split chaindata into multiple files

packages/common/src/chaindata/chaindata.ts

@@ -0,0 +1,276 @@
+import { ApiPromise } from "@polkadot/api";
+import ApiHandler from "../ApiHandler";
+import logger from "../logger";
+import { NumberResult, StringResult } from "../types";
+import { sleep } from "../util";
+import {
+  getApiAt,
+  getBlock,
+  getBlockHash,
+  getChainType,
+  getDenom,
+  getLatestBlock,
+  getLatestBlockHash,
+} from "./queries/ChainMeta";
+import { getSession, getSessionAt } from "./queries/Session";
+import {
+  findEraBlockHash,
+  getActiveEraIndex,
+  getCurrentEra,
+  getEraAt,
+  getErasMinStakeAt,
+  getTotalEraPoints,
+} from "./queries/Era";
+import {
+  getBalance,
+  getBlocked,
+  getBondedAmount,
+  getCommission,
+  getCommissionInEra,
+  getControllerFromStash,
+  getExposure,
+  getExposureAt,
+  getNextKeys,
+  getQueuedKeys,
+  getRewardDestination,
+  getRewardDestinationAt,
+} from "./queries/ValidatorPref";
+import {
+  currentValidators,
+  getActiveValidatorsInPeriod,
+  getAssociatedValidatorAddresses,
+  getValidators,
+  getValidatorsAt,
+} from "./queries/Validators";
+import {
+  getFormattedIdentity,
+  getIdentity,
+  hasIdentity,
+} from "./queries/Identity";
+import { getProxyAnnouncements } from "./queries/Proxy";
+import { getNominatorAddresses, getNominators } from "./queries/Nomination";
+
+type JSON = any;
+
+export const chaindataLabel = { label: "Chaindata" };
+
+export class ChainData {
+  public api: ApiPromise;
+
+  constructor(handler: ApiHandler) {
+    this.api = handler.getApi();
+
+    logger.info(
+      `{Chaindata::API::Info} API connected: ${this.api?.isConnected}`,
+    );
+  }
+
+  checkApiConnection = async () => {
+    if (!this.api?.isConnected) {
+      while (!this.api?.isConnected) {
+        logger.warn(`{Chaindata::API::Warn} API is not connected, waiting...`);
+        await sleep(1000);
+      }
+    }
+  };
+
+  getChainType = async (): Promise<string> => {
+    return getChainType(this);
+  };
+
+  // Returns the denomination of the chain. Used for formatting planck denomianted amounts
+  getDenom = async (): Promise<number> => {
+    return await getDenom(this);
+  };
+
+  getApiAt = async (blockNumber: number): Promise<any> => {
+    return await getApiAt(this, blockNumber);
+  };
+
+  getBlockHash = async (blockNumber: number): Promise<string> => {
+    return await getBlockHash(this, blockNumber);
+  };
+
+  getBlock = async (blockNumber): Promise<any> => {
+    return await getBlock(this, blockNumber);
+  };
+
+  getLatestBlock = async () => {
+    return await getLatestBlock(this);
+  };
+
+  getLatestBlockHash = async () => {
+    return await getLatestBlockHash(this);
+  };
+
+  /**
+   * Gets the current session
+   * @returns session as number
+   */
+  getSession = async () => {
+    return getSession(this);
+  };
+  getSessionAt = async (apiAt: ApiPromise) => {
+    return getSessionAt(this, apiAt);
+  };
+
+  getEraAt = async (apiAt: ApiPromise) => {
+    return await getEraAt(this, apiAt);
+  };
+
+  getTotalEraPoints = async (era: number) => {
+    return await getTotalEraPoints(this, era);
+  };
+
+  getErasMinStakeAt = async (apiAt: any, era: number) => {
+    return await getErasMinStakeAt(this, apiAt, era);
+  };
+
+  // Gets the active era index
+  getActiveEraIndex = async (): Promise<NumberResult> => {
+    return await getActiveEraIndex(this);
+  };
+
+  // Gets the curent era
+  getCurrentEra = async () => {
+    return getCurrentEra(this);
+  };
+
+  /**
+   * Finds the block hash for a particular era index. Used to determine the
+   * active validators within an era in `getActiveValidators`.
+   *
+   * @param chainType: either 'Polkadot', 'Kusama', or 'Local Testnet'
+   */
+  findEraBlockHash = async (
+    era: number,
+    chainType: string,
+  ): Promise<StringResult> => {
+    return await findEraBlockHash(this, era, chainType);
+  };
+
+  // Gets the commision for a given validator
+  getCommission = async (validator: string): Promise<NumberResult> => {
+    return await getCommission(this, validator);
+  };
+
+  // Gets the validator preferences, and whether or not they block external nominations
+  getBlocked = async (validator: string): Promise<any> => {
+    return await getBlocked(this, validator);
+  };
+
+  getCommissionInEra = async (
+    apiAt: any,
+    eraIndex: number,
+    validator: string,
+  ): Promise<NumberResult> => {
+    return await getCommissionInEra(this, apiAt, eraIndex, validator);
+  };
+
+  getBondedAmount = async (stash: string): Promise<NumberResult> => {
+    return await getBondedAmount(this, stash);
+  };
+
+  getControllerFromStash = async (stash: string): Promise<string | null> => {
+    return await getControllerFromStash(this, stash);
+  };
+
+  getRewardDestination = async (stash: string): Promise<string | null> => {
+    return await getRewardDestination(this, stash);
+  };
+
+  getRewardDestinationAt = async (
+    apiAt: any,
+    stash: string,
+  ): Promise<string | null> => {
+    return await getRewardDestinationAt(this, apiAt, stash);
+  };
+
+  getQueuedKeys = async (): Promise<any> => {
+    return await getQueuedKeys(this);
+  };
+
+  getNextKeys = async (stash: string): Promise<any> => {
+    return await getNextKeys(this, stash);
+  };
+
+  getBalance = async (address: string) => {
+    return await getBalance(this, address);
+  };
+
+  getExposure = async (eraIndex: number, validator: string): Promise<any> => {
+    return await getExposure(this, eraIndex, validator);
+  };
+
+  getExposureAt = async (
+    apiAt: any,
+    eraIndex: number,
+    validator: string,
+  ): Promise<any> => {
+    return await getExposureAt(this, apiAt, eraIndex, validator);
+  };
+
+  activeValidatorsInPeriod = async (
+    startEra: number,
+    endEra: number,
+    chainType: string,
+  ): Promise<[string[] | null, string | null]> => {
+    return await getActiveValidatorsInPeriod(this, startEra, endEra, chainType);
+  };
+
+  currentValidators = async (): Promise<any> => {
+    return await currentValidators(this);
+  };
+
+  getValidatorsAt = async (apiAt: ApiPromise): Promise<any> => {
+    return await getValidatorsAt(this, apiAt);
+  };
+
+  /**
+   * Gets list of validators that have `validate` intentions
+   * @returns list of all validators
+   */
+  getValidators = async () => {
+    return await getValidators(this);
+  };
+
+  getAssociatedValidatorAddresses = async () => {
+    return await getAssociatedValidatorAddresses(this);
+  };
+
+  /**
+   * Checks if an account has an identity set.
+   * @param account The account to check.
+   * @returns [hasIdentity, verified]
+   */
+  hasIdentity = async (account: string): Promise<[boolean, boolean]> => {
+    return await hasIdentity(this, account);
+  };
+
+  /**
+   * Gets the identity root for an account.
+   * @param account The account to check.
+   * @returns The identity root string.
+   */
+  getIdentity = async (account: string): Promise<string | null> => {
+    return await getIdentity(this, account);
+  };
+
+  getFormattedIdentity = async (addr) => {
+    return await getFormattedIdentity(this, addr);
+  };
+
+  getProxyAnnouncements = async (address: string) => {
+    return await getProxyAnnouncements(this, address);
+  };
+
+  getNominatorAddresses = async () => {
+    return await getNominatorAddresses(this);
+  };
+
+  getNominators = async (): Promise<any> => {
+    return await getNominators(this);
+  };
+}
+
+export default ChainData;

packages/common/src/chaindata/queries/ChainMeta.ts

@@ -0,0 +1,96 @@
+/**
+ * Chaindata querying related to chain metadata, blocks, and other chain-specific data.
+ *
+ * @function ChainMeta
+ */
+
+import { ChainData, chaindataLabel } from "../chaindata";
+import { logger } from "../../index";
+
+export const getChainType = async (chaindata: ChainData): Promise<string> => {
+  try {
+    await chaindata.checkApiConnection();
+
+    const chainType = await chaindata.api.rpc.system.chain();
+    return chainType.toString();
+  } catch (e) {
+    logger.error(`Error getting chain type: ${e}`, chaindataLabel);
+  }
+};
+
+export const getDenom = async (chaindata: ChainData): Promise<number> => {
+  try {
+    await chaindata.checkApiConnection();
+
+    const chainType = await chaindata.api.rpc.system.chain();
+    const denom =
+      chainType.toString() == "Polkadot" ? 10000000000 : 1000000000000;
+    return denom;
+  } catch (e) {
+    logger.error(`Error getting chain denom: ${e}`, chaindataLabel);
+  }
+};
+
+export const getApiAt = async (
+  chaindata: ChainData,
+  blockNumber: number,
+): Promise<any> => {
+  try {
+    await chaindata.checkApiConnection();
+
+    const hash = await chaindata.getBlockHash(blockNumber);
+    return await chaindata.api.at(hash);
+  } catch (e) {
+    logger.error(`Error getting api at block: ${e}`, chaindataLabel);
+  }
+};
+
+export const getBlockHash = async (
+  chaindata: ChainData,
+  blockNumber: number,
+): Promise<string> => {
+  try {
+    await chaindata.checkApiConnection();
+
+    return (await chaindata.api.rpc.chain.getBlockHash(blockNumber)).toString();
+  } catch (e) {
+    logger.error(`Error getting block hash: ${e}`, chaindataLabel);
+  }
+};
+
+export const getBlock = async (
+  chaindata: ChainData,
+  blockNumber: number,
+): Promise<any> => {
+  try {
+    await chaindata.checkApiConnection();
+    const hash = await chaindata.getBlockHash(blockNumber);
+    return await chaindata.api.rpc.chain.getBlock(hash);
+  } catch (e) {
+    logger.error(`Error getting block: ${e}`, chaindataLabel);
+  }
+};
+
+export const getLatestBlock = async (chaindata: ChainData): Promise<number> => {
+  try {
+    await chaindata.checkApiConnection();
+    return (
+      await chaindata.api.rpc.chain.getBlock()
+    ).block.header.number.toNumber();
+  } catch (e) {
+    logger.error(`Error getting latest block: ${e}`, chaindataLabel);
+  }
+};
+
+export const getLatestBlockHash = async (
+  chaindata: ChainData,
+): Promise<string> => {
+  try {
+    await chaindata.checkApiConnection();
+    return (
+      await chaindata.api.rpc.chain.getBlock()
+    ).block.header.hash.toString();
+  } catch (e) {
+    logger.error(`Error getting latest block hash: ${e}`, chaindataLabel);
+  }
+};