@pezkuwi/api-derive 16.5.10 → 16.5.13

package/build-deno/balances/all.ts

@@ -0,0 +1,242 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { Option, Vec } from 'https://deno.land/x/pezkuwi/types/mod.ts';
+import type { AccountId, Balance, BalanceLockTo212, BlockNumber, VestingSchedule } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { PezpalletBalancesBalanceLock, PezpalletBalancesReserveData, PezpalletVestingVestingInfo } from 'https://deno.land/x/pezkuwi/types/lookup.ts';
+import type { DeriveApi, DeriveBalancesAccount, DeriveBalancesAccountData, DeriveBalancesAll, DeriveBalancesAllAccountData, DeriveBalancesAllVesting } from '../types.ts';
+
+import { combineLatest, map, of, switchMap } from 'https://esm.sh/rxjs@7.8.1';
+
+import { BN, BN_ZERO, bnMax, bnMin, isFunction, objectSpread } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { memo } from '../util/index.ts';
+
+type ResultBalance = [PezpalletVestingVestingInfo[] | null, ((PezpalletBalancesBalanceLock | BalanceLockTo212)[])[], PezpalletBalancesReserveData[][]];
+type Result = [DeriveBalancesAccount, ResultBalance, BlockNumber];
+
+interface AllLocked {
+  allLocked: boolean,
+  lockedBalance: Balance,
+  lockedBreakdown: (PezpalletBalancesBalanceLock | BalanceLockTo212)[],
+  vestingLocked: Balance
+}
+
+type DeriveCustomLocks = DeriveApi['derive'] & Record<string, {
+  customLocks?: DeriveApi['query']['balances']['locks']
+}>
+
+const VESTING_ID = '0x76657374696e6720';
+
+function calcLocked (api: DeriveApi, bestNumber: BlockNumber, locks: (PezpalletBalancesBalanceLock | BalanceLockTo212)[]): AllLocked {
+  let lockedBalance = api.registry.createType('Balance');
+  let lockedBreakdown: (PezpalletBalancesBalanceLock | BalanceLockTo212)[] = [];
+  let vestingLocked = api.registry.createType('Balance');
+  let allLocked = false;
+
+  if (Array.isArray(locks)) {
+    // only get the locks that are valid until passed the current block
+    lockedBreakdown = (locks as BalanceLockTo212[]).filter(({ until }): boolean => !until || (bestNumber && until.gt(bestNumber)));
+    allLocked = lockedBreakdown.some(({ amount }) => amount && amount.isMax());
+    vestingLocked = api.registry.createType('Balance', lockedBreakdown.filter(({ id }) => id.eq(VESTING_ID)).reduce((result: BN, { amount }) => result.iadd(amount), new BN(0)));
+
+    // get the maximum of the locks according to https://github.com/pezkuwichain/bizinikiwi/blob/master/srml/balances/src/lib.rs#L699
+    const notAll = lockedBreakdown.filter(({ amount }) => amount && !amount.isMax());
+
+    if (notAll.length) {
+      lockedBalance = api.registry.createType('Balance', bnMax(...notAll.map(({ amount }): Balance => amount)));
+    }
+  }
+
+  return { allLocked, lockedBalance, lockedBreakdown, vestingLocked };
+}
+
+function calcShared (api: DeriveApi, bestNumber: BlockNumber, data: DeriveBalancesAccountData, locks: (PezpalletBalancesBalanceLock | BalanceLockTo212)[]): DeriveBalancesAllAccountData {
+  const { allLocked, lockedBalance, lockedBreakdown, vestingLocked } = calcLocked(api, bestNumber, locks);
+  let transferable = null;
+
+  if (data?.frameSystemAccountInfo?.frozen) {
+    const { frameSystemAccountInfo, freeBalance, reservedBalance } = data;
+    const noFrozenReserved = frameSystemAccountInfo.frozen.isZero() && reservedBalance.isZero();
+    const ED = api.consts.balances.existentialDeposit;
+    const maybeED = noFrozenReserved ? new BN(0) : ED;
+    const frozenReserveDif = frameSystemAccountInfo.frozen.sub(reservedBalance);
+
+    transferable = api.registry.createType(
+      'Balance',
+      allLocked
+        ? 0
+        : bnMax(new BN(0), freeBalance.sub(bnMax(maybeED, frozenReserveDif)))
+    );
+  }
+
+  return objectSpread({}, data, {
+    availableBalance: api.registry.createType('Balance', allLocked ? 0 : bnMax(new BN(0), data?.freeBalance ? data.freeBalance.sub(lockedBalance) : new BN(0))),
+    lockedBalance,
+    lockedBreakdown,
+    transferable,
+    vestingLocked
+  });
+}
+
+function calcVesting (bestNumber: BlockNumber, shared: DeriveBalancesAllAccountData, _vesting: PezpalletVestingVestingInfo[] | null): DeriveBalancesAllVesting {
+  // Calculate the vesting balances,
+  //  - offset = balance locked at startingBlock
+  //  - perBlock is the unlock amount
+  const vesting = _vesting || [];
+  const isVesting = !shared.vestingLocked.isZero();
+  const vestedBalances = vesting.map(({ locked, perBlock, startingBlock }) =>
+    bestNumber.gt(startingBlock)
+      ? bnMin(locked, perBlock.mul(bestNumber.sub(startingBlock)))
+      : BN_ZERO
+  );
+  const vestedBalance = vestedBalances.reduce<BN>((all, value) => all.iadd(value), new BN(0));
+  const vestingTotal = vesting.reduce<BN>((all, { locked }) => all.iadd(locked), new BN(0));
+
+  return {
+    isVesting,
+    vestedBalance,
+    vestedClaimable: isVesting
+      ? shared.vestingLocked.sub(vestingTotal.sub(vestedBalance))
+      : BN_ZERO,
+    vesting: vesting
+      .map(({ locked, perBlock, startingBlock }, index) => ({
+        endBlock: locked.div(perBlock).iadd(startingBlock),
+        locked,
+        perBlock,
+        startingBlock,
+        vested: vestedBalances[index]
+      }))
+      .filter(({ locked }) => !locked.isZero()),
+    vestingTotal
+  };
+}
+
+function calcBalances (api: DeriveApi, result: Result): DeriveBalancesAll {
+  const [data, [vesting, allLocks, namedReserves], bestNumber] = result;
+  const shared = calcShared(api, bestNumber, data, allLocks[0]);
+
+  return objectSpread(shared, calcVesting(bestNumber, shared, vesting), {
+    accountId: data.accountId,
+    accountNonce: data.accountNonce,
+    additional: allLocks
+      .slice(1)
+      .map((l, index) => calcShared(api, bestNumber, data.additional[index], l)),
+    namedReserves
+  });
+}
+
+function queryOld (api: DeriveApi, accountId: AccountId | string): Observable<ResultBalance> {
+  return combineLatest([
+    api.query.balances.locks(accountId),
+    api.query.balances['vesting']<Option<VestingSchedule>>(accountId)
+  ]).pipe(
+    map(([locks, optVesting]): ResultBalance => {
+      let vestingNew = null;
+
+      if (optVesting.isSome) {
+        const { offset: locked, perBlock, startingBlock } = optVesting.unwrap();
+
+        vestingNew = api.registry.createType<PezpalletVestingVestingInfo>('VestingInfo', { locked, perBlock, startingBlock });
+      }
+
+      return [
+        vestingNew
+          ? [vestingNew]
+          : null,
+        [locks],
+        []
+      ];
+    })
+  );
+}
+
+const isNonNullable = <T>(nullable: T): nullable is NonNullable<T> => !!nullable;
+
+function createCalls <T> (calls: (((a: unknown) => Observable<T>) | null | undefined)[]): [boolean[], ((a: unknown) => Observable<T>)[]] {
+  return [
+    calls.map((c) => !c),
+    calls.filter(isNonNullable)
+  ];
+}
+
+function queryCurrent (api: DeriveApi, accountId: AccountId | string, balanceInstances: string[] = ['balances']): Observable<ResultBalance> {
+  const [lockEmpty, lockQueries] = createCalls<Vec<PezpalletBalancesBalanceLock>>(
+    balanceInstances.map((m) =>
+      (api.derive as DeriveCustomLocks)[m]?.customLocks || api.query[m as 'balances']?.locks
+    )
+  );
+  const [reserveEmpty, reserveQueries] = createCalls<Vec<PezpalletBalancesReserveData>>(
+    balanceInstances.map((m) =>
+      api.query[m as 'balances']?.reserves
+    )
+  );
+
+  return combineLatest([
+    api.query.vesting?.vesting
+      ? api.query.vesting.vesting(accountId)
+      : of(api.registry.createType('Option<VestingInfo>')),
+    lockQueries.length
+      ? combineLatest(lockQueries.map((c) => c(accountId)))
+      : of([] as Vec<PezpalletBalancesBalanceLock>[]),
+    reserveQueries.length
+      ? combineLatest(reserveQueries.map((c) => c(accountId)))
+      : of([] as Vec<PezpalletBalancesReserveData>[])
+  ]).pipe(
+    map(([opt, locks, reserves]): ResultBalance => {
+      let offsetLock = -1;
+      let offsetReserve = -1;
+      const vesting = opt.unwrapOr(null);
+
+      return [
+        vesting
+          ? Array.isArray(vesting)
+            ? vesting
+            : [vesting as PezpalletVestingVestingInfo]
+          : null,
+        lockEmpty.map((e) =>
+          e ? api.registry.createType<Vec<PezpalletBalancesBalanceLock>>('Vec<BalanceLock>') : locks[++offsetLock]
+        ),
+        reserveEmpty.map((e) =>
+          e ? api.registry.createType<Vec<PezpalletBalancesReserveData>>('Vec<PezpalletBalancesReserveData>') : reserves[++offsetReserve]
+        )
+      ];
+    })
+  );
+}
+
+/**
+ * @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 function all (instanceId: string, api: DeriveApi): (address: AccountId | string) => Observable<DeriveBalancesAll> {
+  const balanceInstances = api.registry.getModuleInstances(api.runtimeVersion.specName, 'balances');
+
+  return memo(instanceId, (address: AccountId | string): Observable<DeriveBalancesAll> =>
+    combineLatest([
+      api.derive.balances.account(address),
+      isFunction(api.query.system?.account) || isFunction(api.query.balances?.account)
+        ? queryCurrent(api, address, balanceInstances)
+        : queryOld(api, address)
+    ]).pipe(
+      switchMap(([account, locks]) =>
+        combineLatest([
+          of(account),
+          of(locks),
+          api.derive.chain.bestNumber()
+        ])
+      ),
+      map((result) => calcBalances(api, result))
+    ));
+}

package/build-deno/balances/index.ts

@@ -0,0 +1,24 @@
+
+import { all } from './all.ts';
+
+export * from './account.ts';
+export * from './votingBalances.ts';
+
+/**
+ * @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.`);
+ * });
+ * ```
+ */
+const votingBalance = all;
+
+export { all, votingBalance };

package/build-deno/balances/types.ts

@@ -0,0 +1,77 @@
+
+import type { AccountId, Balance, BalanceLockTo212, Index } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { PezpalletBalancesBalanceLock, PezpalletBalancesReserveData } from 'https://deno.land/x/pezkuwi/types/lookup.ts';
+import type { BN } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+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-deno/balances/votingBalances.ts

@@ -0,0 +1,31 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { AccountId, AccountIndex, Address } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { DeriveApi, DeriveBalancesAccount } from '../types.ts';
+
+import { combineLatest, of } from 'https://esm.sh/rxjs@7.8.1';
+
+import { memo } from '../util/index.ts';
+
+/**
+ * @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 function votingBalances (instanceId: string, api: DeriveApi): (addresses?: (AccountId | AccountIndex | Address | string)[]) => Observable<DeriveBalancesAccount[]> {
+  return memo(instanceId, (addresses?: (AccountId | AccountIndex | Address | string)[]): Observable<DeriveBalancesAccount[]> =>
+    !addresses?.length
+      ? of([] as DeriveBalancesAccount[])
+      : combineLatest(
+        addresses.map((accountId): Observable<DeriveBalancesAccount> =>
+          api.derive.balances.account(accountId)
+        )
+      )
+  );
+}

package/build-deno/bounties/bounties.ts

@@ -0,0 +1,74 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { Bytes, Option } from 'https://deno.land/x/pezkuwi/types/mod.ts';
+import type { BountyIndex } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { PezpalletBountiesBounty } from 'https://deno.land/x/pezkuwi/types/lookup.ts';
+import type { DeriveApi, DeriveBounties, DeriveCollectiveProposal } from '../types.ts';
+
+import { combineLatest, map, of, switchMap } from 'https://esm.sh/rxjs@7.8.1';
+
+import { memo } from '../util/index.ts';
+import { filterBountiesProposals } from './helpers/filterBountyProposals.ts';
+
+type Result = [Option<PezpalletBountiesBounty>[], Option<Bytes>[], BountyIndex[], DeriveCollectiveProposal[]];
+
+function parseResult ([maybeBounties, maybeDescriptions, ids, bountyProposals]: Result): DeriveBounties {
+  const bounties: DeriveBounties = [];
+
+  maybeBounties.forEach((bounty, index) => {
+    if (bounty.isSome) {
+      bounties.push({
+        bounty: bounty.unwrap(),
+        description: maybeDescriptions[index].unwrapOrDefault().toUtf8(),
+        index: ids[index],
+        proposals: bountyProposals.filter((bountyProposal) =>
+          bountyProposal.proposal && ids[index].eq(bountyProposal.proposal.args[0])
+        )
+      });
+    }
+  });
+
+  return bounties;
+}
+
+/**
+ * @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 function bounties (instanceId: string, api: DeriveApi): () => Observable<DeriveBounties> {
+  const bountyBase = api.query.bounties || api.query.treasury;
+
+  return memo(instanceId, (): Observable<DeriveBounties> =>
+    bountyBase.bounties
+      ? combineLatest([
+        bountyBase.bountyCount(),
+        api.query.council
+          ? api.query.council.proposalCount()
+          : of(0)
+      ]).pipe(
+        switchMap(() => combineLatest([
+          bountyBase.bounties.keys(),
+          api.derive.council
+            ? api.derive.council.proposals()
+            : of([])
+        ])),
+        switchMap(([keys, proposals]): Observable<Result> => {
+          const ids = keys.map(({ args: [id] }) => id);
+
+          return combineLatest([
+            bountyBase.bounties.multi(ids),
+            bountyBase.bountyDescriptions.multi(ids),
+            of(ids),
+            of(filterBountiesProposals(api, proposals))
+          ]);
+        }),
+        map(parseResult)
+      )
+      : of(parseResult([[], [], [], []]))
+  );
+}

package/build-deno/bounties/helpers/filterBountyProposals.ts

@@ -0,0 +1,11 @@
+
+import type { DeriveApi, DeriveCollectiveProposal } from '../../types.ts';
+
+export function filterBountiesProposals (api: DeriveApi, allProposals: DeriveCollectiveProposal[]): DeriveCollectiveProposal[] {
+  const bountyTxBase = api.tx.bounties ? api.tx.bounties : api.tx.treasury;
+  const bountyProposalCalls = [bountyTxBase.approveBounty, bountyTxBase.closeBounty, bountyTxBase.proposeCurator, bountyTxBase.unassignCurator];
+
+  return allProposals.filter((proposal) => bountyProposalCalls.find((bountyCall) =>
+    proposal.proposal && bountyCall.is(proposal.proposal))
+  );
+}

package/build-deno/bounties/index.ts

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

package/build-deno/bundle.ts

@@ -0,0 +1,135 @@
+
+import type { DeriveCustom } from 'https://deno.land/x/pezkuwi/api-base/types/index.ts';
+import type { AnyFunction, AnyString } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
+import type { ExactDerive } from './derive.ts';
+import type { DeriveApi } from './types.ts';
+
+import { lazyDeriveSection } from './util/index.ts';
+import { derive } from './derive.ts';
+
+export * from './derive.ts';
+export * from './type/index.ts';
+
+interface Avail {
+  instances: string[];
+  methods: string[];
+  withDetect?: boolean;
+}
+
+export { lazyDeriveSection };
+
+const checks: Record<string, Avail> = {
+  allianceMotion: {
+    instances: ['allianceMotion'],
+    methods: []
+  },
+  bagsList: {
+    instances: ['voterBagsList', 'voterList', 'bagsList'],
+    methods: [],
+    withDetect: true
+  },
+  contracts: {
+    instances: ['contracts'],
+    methods: []
+  },
+  council: {
+    instances: ['council'],
+    methods: [],
+    withDetect: true
+  },
+  crowdloan: {
+    instances: ['crowdloan'],
+    methods: []
+  },
+  democracy: {
+    instances: ['democracy'],
+    methods: []
+  },
+  elections: {
+    instances: ['phragmenElection', 'electionsPhragmen', 'elections', 'council'],
+    methods: [],
+    withDetect: true
+  },
+  imOnline: {
+    instances: ['imOnline'],
+    methods: []
+  },
+  membership: {
+    instances: ['membership'],
+    methods: []
+  },
+  teyrchains: {
+    instances: ['teyrchains', 'registrar'],
+    methods: []
+  },
+  session: {
+    instances: ['session'],
+    methods: []
+  },
+  society: {
+    instances: ['society'],
+    methods: []
+  },
+  staking: {
+    instances: ['staking'],
+    methods: ['erasRewardPoints']
+  },
+  technicalCommittee: {
+    instances: ['technicalCommittee'],
+    methods: [],
+    withDetect: true
+  },
+  treasury: {
+    instances: ['treasury'],
+    methods: []
+  }
+};
+
+function getModuleInstances (api: DeriveApi, specName: AnyString, moduleName: string): string[] {
+  return api.registry.getModuleInstances(specName, moduleName) || [];
+}
+
+/**
+ * Returns an object that will inject `api` into all the functions inside
+ * `allSections`, and keep the object architecture of `allSections`.
+ */
+/** @internal */
+function injectFunctions (instanceId: string, api: DeriveApi, derives: DeriveCustom): ExactDerive {
+  const result: Record<string, Record<string, AnyFunction>> = {};
+  const names = Object.keys(derives);
+  const keys = Object.keys(api.query);
+  const specName = api.runtimeVersion.specName;
+
+  const filterKeys = (q: string) => keys.includes(q);
+  const filterInstances = (q: string) => getModuleInstances(api, specName, q).some(filterKeys);
+  const filterMethods = (all: string[]) => (m: string) => all.some((q) => keys.includes(q) && api.query[q][m]);
+  const getKeys = (s: string) => Object.keys(derives[s]);
+  const creator = (s: string, m: string) => derives[s][m](instanceId, api);
+  const isIncluded = (c: string) => (!checks[c] || (
+    (checks[c].instances.some(filterKeys) && (
+      !checks[c].methods.length ||
+      checks[c].methods.every(filterMethods(checks[c].instances))
+    )) ||
+    (
+      checks[c].withDetect &&
+      checks[c].instances.some(filterInstances)
+    )
+  ));
+
+  for (let i = 0, count = names.length; i < count; i++) {
+    const name = names[i];
+
+    isIncluded(name) &&
+      lazyDeriveSection(result, name, getKeys, creator);
+  }
+
+  return result as ExactDerive;
+}
+
+/** @internal */
+export function getAvailableDerives (instanceId: string, api: DeriveApi, custom: DeriveCustom = {}): ExactDerive {
+  return {
+    ...injectFunctions(instanceId, api, derive as DeriveCustom),
+    ...injectFunctions(instanceId, api, custom)
+  };
+}

package/build-deno/chain/bestNumber.ts

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

package/build-deno/chain/bestNumberFinalized.ts

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

package/build-deno/chain/bestNumberLag.ts

@@ -0,0 +1,31 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { BlockNumber } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { DeriveApi } from '../types.ts';
+
+import { combineLatest, map } from 'https://esm.sh/rxjs@7.8.1';
+
+import { memo } from '../util/index.ts';
+
+/**
+ * @name bestNumberLag
+ * @returns A number of blocks
+ * @description Calculates the lag between finalized head and best head
+ * @examplew
+ * ```javascript
+ * api.derive.chain.bestNumberLag((lag) => {
+ *   console.log(`finalized is ${lag} blocks behind head`);
+ * });
+ * ```
+ */
+export function bestNumberLag (instanceId: string, api: DeriveApi): () => Observable<BlockNumber> {
+  return memo(instanceId, (): Observable<BlockNumber> =>
+    combineLatest([
+      api.derive.chain.bestNumber(),
+      api.derive.chain.bestNumberFinalized()
+    ]).pipe(
+      map(([bestNumber, bestNumberFinalized]): BlockNumber =>
+        api.registry.createType('BlockNumber', bestNumber.sub(bestNumberFinalized))
+      )
+    ));
+}