@pezkuwi/api-derive 16.5.6 → 16.5.8

package/build-deno/staking/types.ts

@@ -0,0 +1,172 @@
+
+import type { Option, u32, Vec } from 'https://deno.land/x/pezkuwi/types/mod.ts';
+import type { AccountId, Balance, EraIndex, RewardPoint } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { PezpalletStakingRewardDestination, PezpalletStakingStakingLedger, PezpalletStakingValidatorPrefs, PezspStakingExposure, PezspStakingExposurePage, PezspStakingPagedExposureMetadata } from 'https://deno.land/x/pezkuwi/types/lookup.ts';
+import type { BN } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+import type { DeriveSessionIndexes } from '../session/types.ts';
+
+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;
+  // Legacy Support for erasStakers
+  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-deno/staking/util.ts

@@ -0,0 +1,89 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { ObsInnerType } 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 { EraIndex } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { AnyNumber } from 'https://deno.land/x/pezkuwi/types-codec/types/index.ts';
+import type { ExactDerive } from '../derive.ts';
+import type { DeriveApi } from '../types.ts';
+
+import { BehaviorSubject, combineLatest, map, of, switchMap, tap, toArray } from 'https://esm.sh/rxjs@7.8.1';
+
+import { arrayChunk, arrayFlatten, nextTick } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { memo } from '../util/index.ts';
+
+type ApplyReturn<T extends keyof ExactDerive['staking']> = ReturnType<ExactDerive['staking'][T]>;
+
+const ERA_CHUNK_SIZE = 14;
+
+function chunkEras <T> (eras: EraIndex[], fn: (eras: EraIndex[]) => Observable<T[]>): Observable<T[]> {
+  const chunked = arrayChunk(eras, ERA_CHUNK_SIZE);
+  let index = 0;
+  const subject = new BehaviorSubject<EraIndex[]>(chunked[index]);
+
+  return subject.pipe(
+    switchMap(fn),
+    tap((): void => {
+      nextTick((): void => {
+        index++;
+
+        index === chunked.length
+          ? subject.complete()
+          : subject.next(chunked[index]);
+      });
+    }),
+    toArray(),
+    map(arrayFlatten)
+  );
+}
+
+export function filterEras <T extends { era: EraIndex }> (eras: EraIndex[], list: T[]): EraIndex[] {
+  return eras.filter((e) => !list.some(({ era }) => e.eq(era)));
+}
+
+export function erasHistoricApply <F extends '_erasExposure' | '_erasPoints' | '_erasPrefs' | '_erasRewards' | '_erasSlashes'> (fn: F): (instanceId: string, api: DeriveApi) => (withActive?: boolean) => ApplyReturn<F> {
+  return (instanceId: string, api: DeriveApi) =>
+    // Cannot quite get the typing right, but it is right in the code
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    memo(instanceId, (withActive = false) =>
+      api.derive.staking.erasHistoric(withActive).pipe(
+        switchMap((e) => api.derive.staking[fn](e, withActive))
+      )
+    ) as any;
+}
+
+export function erasHistoricApplyAccount <F extends '_ownExposures' | '_ownSlashes' | '_stakerPoints' | '_stakerPrefs' | '_stakerSlashes'> (fn: F): (instanceId: string, api: DeriveApi) => (accountId: string | Uint8Array, withActive?: boolean) => ApplyReturn<F> {
+  return (instanceId: string, api: DeriveApi) =>
+    // Cannot quite get the typing right, but it is right in the code
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    memo(instanceId, (accountId: string | Uint8Array, withActive = false, page?: u32 | AnyNumber) =>
+      api.derive.staking.erasHistoric(withActive).pipe(
+        switchMap((e) => api.derive.staking[fn](accountId, e, withActive, page || 0))
+      )
+    ) as any;
+}
+
+export function singleEra <F extends '_eraExposure' | '_eraPrefs' | '_eraSlashes'> (fn: F): (instanceId: string, api: DeriveApi) => (era: EraIndex) => ApplyReturn<F> {
+  return (instanceId: string, api: DeriveApi) =>
+    // Cannot quite get the typing right, but it is right in the code
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    memo(instanceId, (era: EraIndex) =>
+      api.derive.staking[fn](era, true)
+    ) as any;
+}
+
+export function combineEras <F extends '_eraExposure' | '_eraPrefs' | '_eraSlashes'> (fn: F): (instanceId: string, api: DeriveApi) => (eras: EraIndex[], withActive: boolean) => Observable<ObsInnerType<ApplyReturn<F>>[]> {
+  return (instanceId: string, api: DeriveApi) =>
+    // Cannot quite get the typing right, but it is right in the code
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+    memo(instanceId, (eras: EraIndex[], withActive: boolean) =>
+      !eras.length
+        ? of([])
+        : chunkEras(eras, (eras) =>
+          combineLatest(
+            eras.map((e) => api.derive.staking[fn](e, withActive))
+          )
+        )
+    ) as any;
+}

package/build-deno/staking/validators.ts

@@ -0,0 +1,80 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { AccountId } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { DeriveApi, DeriveStakingValidators } from '../types.ts';
+
+import { combineLatest, map, of, switchMap } from 'https://esm.sh/rxjs@7.8.1';
+
+import { memo } from '../util/index.ts';
+
+/**
+ * @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 function nextElected (instanceId: string, api: DeriveApi): () => Observable<AccountId[]> {
+  return memo(instanceId, (): Observable<AccountId[]> =>
+    // Compatibility for future generation changes in staking.
+    api.query.staking.erasStakersOverview
+      ? api.derive.session.indexes().pipe(
+        // only populate for next era in the last session, so track both here - entries are not
+        // subscriptions, so we need a trigger - currentIndex acts as that trigger to refresh
+        switchMap(({ currentEra }) => api.query.staking.erasStakersOverview.keys(currentEra)),
+        // Dedupe any duplicates
+        map((keys) => [...new Set(keys.map(({ args: [, accountId] }) => accountId.toString()))].map((a) => api.registry.createType('AccountId', a)))
+      )
+      : api.query.staking.erasStakers
+        ? api.derive.session.indexes().pipe(
+          // only populate for next era in the last session, so track both here - entries are not
+          // subscriptions, so we need a trigger - currentIndex acts as that trigger to refresh
+          switchMap(({ currentEra }) => api.query.staking.erasStakers.keys(currentEra)),
+          // Dedupe any duplicates
+          map((keys) => [...new Set(keys.map(({ args: [, accountId] }) => accountId.toString()))].map((a) => api.registry.createType('AccountId', a)))
+        )
+        : api.query.staking['currentElected']<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 function validators (instanceId: string, api: DeriveApi): () => Observable<DeriveStakingValidators> {
+  return memo(instanceId, (): Observable<DeriveStakingValidators> =>
+    // Sadly the node-template is (for some obscure reason) not comprehensive, so while the derive works
+    // in all actual real-world deployed chains, it does create some confusion for limited template chains
+    combineLatest([
+      api.query.session
+        ? api.query.session.validators()
+        : of([]),
+      api.query.staking
+        ? api.derive.staking.nextElected()
+        : of([])
+    ]).pipe(
+      map(([validators, nextElected]): DeriveStakingValidators => ({
+        nextElected: nextElected.length
+          ? nextElected
+          : validators,
+        validators
+      }))
+    ));
+}

package/build-deno/staking/waitingInfo.ts

@@ -0,0 +1,43 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { DeriveApi, DeriveStakingWaiting, StakingQueryFlags } from '../types.ts';
+
+import { combineLatest, map, switchMap } from 'https://esm.sh/rxjs@7.8.1';
+
+import { memo } from '../util/index.ts';
+
+const DEFAULT_FLAGS = { withController: true, withPrefs: true };
+
+/**
+ * @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 function waitingInfo (instanceId: string, api: DeriveApi): (flags?: StakingQueryFlags) => Observable<DeriveStakingWaiting> {
+  return memo(instanceId, (flags: StakingQueryFlags = DEFAULT_FLAGS): Observable<DeriveStakingWaiting> =>
+    combineLatest([
+      api.derive.staking.validators(),
+      api.derive.staking.stashes()
+    ]).pipe(
+      switchMap(([{ nextElected }, stashes]): Observable<DeriveStakingWaiting> => {
+        const elected = nextElected.map((a) => a.toString());
+        const waiting = stashes.filter((v) => !elected.includes(v.toString()));
+
+        return api.derive.staking.queryMulti(waiting, flags).pipe(
+          map((info): DeriveStakingWaiting => ({
+            info,
+            waiting
+          }))
+        );
+      })
+    )
+  );
+}

package/build-deno/technicalCommittee/index.ts

@@ -0,0 +1,74 @@
+
+import { hasProposals as collectiveHasProposals, members as collectiveMembers, prime as collectivePrime, proposal as collectiveProposal, proposalCount as collectiveProposalCount, proposalHashes as collectiveProposalHashes, proposals as collectiveProposals } from '../collective/index.ts';
+
+/**
+ * @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 const members = /*#__PURE__*/ collectiveMembers('technicalCommittee');
+
+/**
+ * @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 const hasProposals = /*#__PURE__*/ collectiveHasProposals('technicalCommittee');
+/**
+ * @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 const proposal = /*#__PURE__*/ collectiveProposal('technicalCommittee');
+/**
+ * @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 const proposalCount = /*#__PURE__*/ collectiveProposalCount('technicalCommittee');
+/**
+ * @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 const proposalHashes = /*#__PURE__*/ collectiveProposalHashes('technicalCommittee');
+/**
+ * @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 const proposals = /*#__PURE__*/ collectiveProposals('technicalCommittee');
+/**
+ * @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 const prime = /*#__PURE__*/ collectivePrime('technicalCommittee');

package/build-deno/test/bountyFactory.ts

@@ -0,0 +1,37 @@
+
+import type { ApiPromise } from 'https://deno.land/x/pezkuwi/api/mod.ts';
+import type { Bounty, BountyIndex } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { Codec, CodecClass, InterfaceTypes, Registry } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
+
+import { Option, StorageKey } from 'https://deno.land/x/pezkuwi/types/mod.ts';
+
+export class BountyFactory {
+  readonly #api: ApiPromise;
+  readonly #registry: Registry;
+
+  constructor (api: ApiPromise) {
+    this.#api = api;
+    this.#registry = this.#api.registry;
+  }
+
+  public storageKey = (index: number): StorageKey => {
+    const key = new StorageKey(this.#registry, this.#api.query.bounties.bounties.key(this.bountyIndex(index)));
+
+    return key.setMeta(this.#api.query.bounties.bounties.creator.meta);
+  };
+
+  public bountyIndex = (index: number): BountyIndex =>
+    this.#registry.createType('BountyIndex', index);
+
+  public defaultBounty = (): Bounty =>
+    this.#registry.createType('Bounty');
+
+  public optionOf = <T extends Codec>(value: T): Option<T> => {
+    const typeName = this.#registry.getClassName(value.constructor as CodecClass<T>);
+
+    return new Option<T>(this.#registry, typeName as keyof InterfaceTypes, value);
+  };
+
+  public emptyOption = <T extends Codec>(typeName: keyof InterfaceTypes): Option<T> =>
+    new Option<T>(this.#registry, typeName);
+}

package/build-deno/test/bytesFactory.ts

@@ -0,0 +1,13 @@
+
+import type { Bytes } from 'https://deno.land/x/pezkuwi/types/mod.ts';
+import type { Registry } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
+
+export class BytesFactory {
+  #registry: Registry;
+
+  constructor (registry: Registry) {
+    this.#registry = registry;
+  }
+
+  public bytes = (value: string): Bytes => this.#registry.createType('Bytes', value);
+}

package/build-deno/test/helpers.ts

@@ -0,0 +1,21 @@
+
+import { ApiPromise, WsProvider } from 'https://deno.land/x/pezkuwi/api/mod.ts';
+import { Metadata, TypeRegistry } from 'https://deno.land/x/pezkuwi/types/mod.ts';
+import metaStatic from 'https://deno.land/x/pezkuwi/types-support/metadata/static-bizinikiwi.ts';
+
+export function createApiWithAugmentations (): ApiPromise {
+  const registry = new TypeRegistry();
+  const metadata = new Metadata(registry, metaStatic);
+
+  registry.setMetadata(metadata);
+
+  const api = new ApiPromise({
+    provider: new WsProvider('ws://', false),
+    registry
+  });
+
+  // eslint-disable-next-line deprecation/deprecation
+  api.injectMetadata(metadata, true, registry);
+
+  return api;
+}

package/build-deno/test/proposalFactory.ts

@@ -0,0 +1,23 @@
+
+import type { ApiPromise } from 'https://deno.land/x/pezkuwi/api/mod.ts';
+import type { SubmittableExtrinsic } from 'https://deno.land/x/pezkuwi/api-base/types/index.ts';
+import type { Proposal, ProposalIndex } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { Registry } from 'https://deno.land/x/pezkuwi/types/types/index.ts';
+
+export class ProposalFactory {
+  readonly #api: ApiPromise;
+  readonly #registry: Registry;
+
+  constructor (api: ApiPromise) {
+    this.#api = api;
+    this.#registry = this.#api.registry;
+  }
+
+  public createProposal = (method: SubmittableExtrinsic<'promise'>): Proposal => {
+    return this.#registry.createType('Proposal', method);
+  };
+
+  public proposalIndex = (index: number): ProposalIndex => {
+    return this.#registry.createType('ProposalIndex', index);
+  };
+}

package/build-deno/teyrchains/index.ts

@@ -0,0 +1,3 @@
+
+export * from './info.ts';
+export * from './overview.ts';

package/build-deno/teyrchains/info.ts

@@ -0,0 +1,109 @@
+
+import type { Observable } from 'https://esm.sh/rxjs@7.8.1';
+import type { CollatorId, ParaId } from 'https://deno.land/x/pezkuwi/types/interfaces/index.ts';
+import type { DeriveApi, DeriveTeyrchainActive, DeriveTeyrchainFull, DeriveTeyrchainInfo } from '../types.ts';
+import type { Active, DidUpdate, Heads, ParaInfoResult, PendingSwap, RelayDispatchQueue, RetryQueue, SelectedThreads } from './types.ts';
+
+import { map, of } from 'https://esm.sh/rxjs@7.8.1';
+
+import { objectSpread } from 'https://deno.land/x/pezkuwi/util/mod.ts';
+
+import { memo } from '../util/index.ts';
+import { didUpdateToBool } from './util.ts';
+
+type Result = [
+  Active,
+  RetryQueue,
+  SelectedThreads,
+  DidUpdate,
+  ParaInfoResult,
+  PendingSwap,
+  Heads,
+  RelayDispatchQueue
+];
+
+function parseActive (id: ParaId, active: Active): DeriveTeyrchainActive | null {
+  const found = active.find(([paraId]) => paraId === id);
+
+  if (found && found[1].isSome) {
+    const [collatorId, retriable] = found[1].unwrap();
+
+    return objectSpread<DeriveTeyrchainActive>(
+      { collatorId },
+      retriable.isWithRetries
+        ? {
+          isRetriable: true,
+          retries: retriable.asWithRetries.toNumber()
+        }
+        : {
+          isRetriable: false,
+          retries: 0
+        }
+    );
+  }
+
+  return null;
+}
+
+function parseCollators (id: ParaId, collatorQueue: SelectedThreads | RetryQueue): (CollatorId | null)[] {
+  return collatorQueue.map((queue): CollatorId | null => {
+    const found = queue.find(([paraId]) => paraId === id);
+
+    return found ? found[1] : null;
+  });
+}
+
+function parse (id: ParaId, [active, retryQueue, selectedThreads, didUpdate, info, pendingSwap, heads, relayDispatchQueue]: Result): DeriveTeyrchainFull | null {
+  if (info.isNone) {
+    return null;
+  }
+
+  return {
+    active: parseActive(id, active),
+    didUpdate: didUpdateToBool(didUpdate, id),
+    heads,
+    id,
+    info: objectSpread<DeriveTeyrchainInfo>({ id }, info.unwrap()),
+    pendingSwapId: pendingSwap.unwrapOr(null),
+    relayDispatchQueue,
+    retryCollators: parseCollators(id, retryQueue),
+    selectedCollators: parseCollators(id, selectedThreads)
+  };
+}
+
+/**
+ * @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 function info (instanceId: string, api: DeriveApi): (id: ParaId | number) => Observable<DeriveTeyrchainFull | null> {
+  return memo(instanceId, (id: ParaId | number): Observable<DeriveTeyrchainFull | null> =>
+    api.query['registrar'] && api.query['teyrchains']
+      ? api.queryMulti<Result>([
+        api.query['registrar']['active'],
+        api.query['registrar']['retryQueue'],
+        api.query['registrar']['selectedThreads'],
+        api.query['teyrchains']['didUpdate'],
+        [api.query['registrar']['paras'], id],
+        [api.query['registrar']['pendingSwap'], id],
+        [api.query['teyrchains']['heads'], id],
+        [api.query['teyrchains']['relayDispatchQueue'], id]
+      ])
+        .pipe(
+          map((result: Result): DeriveTeyrchainFull | null =>
+            parse(api.registry.createType('ParaId', id), result)
+          )
+        )
+      : of(null)
+  );
+}