@pezkuwi/api-derive 16.5.20 → 16.5.22

package/build-deno/balances/all.ts

@@ -1,242 +0,0 @@
-
-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

@@ -1,24 +0,0 @@
-
-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

@@ -1,77 +0,0 @@
-
-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

@@ -1,31 +0,0 @@
-
-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

@@ -1,74 +0,0 @@
-
-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

@@ -1,11 +0,0 @@
-
-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

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

package/build-deno/bundle.ts

@@ -1,135 +0,0 @@
-
-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

@@ -1,19 +0,0 @@
-
-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

@@ -1,20 +0,0 @@
-
-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

@@ -1,31 +0,0 @@
-
-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))
-      )
-    ));
-}