@tracer-protocol/pools-js/utils/helpers.js

Javascript library for interacting with Tracer's Perpetual Pools

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.pendingCommitsToBN = exports.movingAveragePriceTransformer = exports.ethersBNtoBN = exports.encodeCommitParams = exports.attemptPromiseRecursively = void 0;

var _ethers = require("ethers");

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

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

const NUM_PADDING_REQUIRED = 26;

const encodeCommitParams = (payForClaim, fromAggregateBalances, commitType, parsedAmount) => {
  let expectedResult = _ethers.ethers.utils.solidityPack(['bool', 'bool', 'uint8', 'uint128'], [payForClaim, fromAggregateBalances, commitType, parsedAmount]); // Pad with 0s


  expectedResult = '0x' + '0'.repeat(NUM_PADDING_REQUIRED) + expectedResult.slice(2);
  return expectedResult;
};

exports.encodeCommitParams = encodeCommitParams;

const ethersBNtoBN = (ethersBN, decimals) => {
  return new _bignumber.default(_ethers.ethers.utils.formatUnits(ethersBN, decimals ?? 0));
};

exports.ethersBNtoBN = ethersBNtoBN;

const movingAveragePriceTransformer = (lastPrice, currentPrice) => {
  return lastPrice.plus(currentPrice).div(2);
};

exports.movingAveragePriceTransformer = movingAveragePriceTransformer;

const pendingCommitsToBN = (pendingCommits, decimals) => {
  return {
    longBurnPoolTokens: ethersBNtoBN(pendingCommits.longBurnPoolTokens, decimals),
    longMintSettlement: ethersBNtoBN(pendingCommits.longMintSettlement, decimals),
    longBurnShortMintPoolTokens: ethersBNtoBN(pendingCommits.longBurnShortMintPoolTokens, decimals),
    shortBurnPoolTokens: ethersBNtoBN(pendingCommits.shortBurnPoolTokens, decimals),
    shortMintSettlement: ethersBNtoBN(pendingCommits.shortMintSettlement, decimals),
    shortBurnLongMintPoolTokens: ethersBNtoBN(pendingCommits.shortBurnLongMintPoolTokens, decimals)
  };
};
/**
 * attempt promise until it succeeds or the maximum number of allowed attempts is reached
 *
 * @returns a promise that will eventually error or resolve to the same type as the original promise
 */


exports.pendingCommitsToBN = pendingCommitsToBN;

const attemptPromiseRecursively = async ({
  promise,
  retryCheck,
  maxAttempts = 3,
  interval = 1000,
  attemptCount = 1
}) => {
  try {
    const result = await promise();
    return result;
  } catch (error) {
    if (attemptCount >= maxAttempts) {
      throw error;
    }

    await new Promise(resolve => setTimeout(resolve, interval));

    if (!retryCheck || retryCheck && (await retryCheck(error))) {
      return attemptPromiseRecursively({
        promise,
        retryCheck,
        interval,
        maxAttempts,
        attemptCount: attemptCount + 1
      });
    } else {
      throw error;
    }
  }
};

exports.attemptPromiseRecursively = attemptPromiseRecursively;