@tracer-protocol/pools-js/entities/oracle.js

Javascript library for interacting with Tracer's Perpetual Pools

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;

var _types = require("@tracer-protocol/perpetual-pools-contracts/types");

var _bignumber = _interopRequireDefault(require("bignumber.js"));

var _multicall = require("@0xsequence/multicall");

var _ethers = require("ethers");

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

/**
 * Oracle class for interacting with Chainlink Oracle Wrappers
 * The constructor is private so must be instantiated with {@linkcode Oracle.Create}
 */
class Oracle {
  /**
   * @private
   */
  constructor() {
    this.address = '';
    this.provider = undefined;
    this.multicallProvider = undefined;
  }
  /**
   * Replacement constructor pattern to support async initialisations
   * @param oracleInfo {@link IOracle | IOracle interface props}
   * @returns a Promise containing an initialised Oracle class ready to be used
   */


  static Create = async oracleInfo => {
    const oracle = new Oracle(); // initialise the token;

    await oracle.init(oracleInfo);
    return oracle;
  };
  /**
   * Creates an empty Oracle that can be used as a default
   * @returns default constructed token
   */

  static CreateDefault = () => {
    const oracle = new Oracle();
    return oracle;
  };
  /**
   * Private initialisation function called in {@link Oracle.Create}
   * @private
   * @param oracleInfo {@link IOracle | IOracle interface props}
   */

  init = async oracleInfo => {
    this.provider = oracleInfo.provider;
    this.multicallProvider = new _multicall.providers.MulticallProvider(oracleInfo.provider);
    this.address = oracleInfo.address;

    const contract = _types.ChainlinkOracleWrapper__factory.connect(oracleInfo.address, this.multicallProvider);

    this._contract = contract;
  };
  /**
   * Replaces the provider and connects the contract instance
   * @param provider The new provider to connect to
   */

  connect = provider => {
    if (!provider) {
      throw Error("Failed to connect Oracle: provider cannot be undefined");
    }

    this.provider = provider;
    this.multicallProvider = new _multicall.providers.MulticallProvider(provider);
    this._contract = this._contract?.connect(provider);
  };
  getPrice = async () => {
    if (!this._contract) {
      throw Error("Failed to fetch oracle price: Contract not defined");
    }

    try {
      const price = await this._contract.getPrice();
      return new _bignumber.default(_ethers.ethers.utils.formatEther(price));
    } catch (err) {
      throw Error(`Failed to fetch oracle price: ${err}`);
    }
  };
}

exports.default = Oracle;