@xlink-network/xlink-sdk/lib/chunk-KHTJNOQE.mjs

XLINK js SDK

import {
  last,
  reduce
} from "./chunk-PRLWYSC3.mjs";

// src/utils/BigNumber.ts
import { Big } from "big.js";
Big.PE = 21;
Big.NE = -21;
var toBig = (num) => {
  if (num instanceof Big) {
    return num;
  }
  return new Big(num);
};
var fromBig = (num) => {
  return num;
};
var BigNumber;
((BigNumber2) => {
  ({ roundUp: BigNumber2.roundUp, roundDown: BigNumber2.roundDown, roundHalfUp: BigNumber2.roundHalfUp, roundHalfEven: BigNumber2.roundHalfEven } = Big);
  let defaultRoundingMode = BigNumber2.roundHalfUp;
  BigNumber2.setDefaultRoundingMode = (roundingMode) => {
    defaultRoundingMode = roundingMode;
  };
  BigNumber2.isBigNumber = (num) => {
    return num instanceof Big;
  };
  BigNumber2.safeFrom = (value) => {
    try {
      return (0, BigNumber2.from)(value);
    } catch (e) {
      return void 0;
    }
  };
  BigNumber2.from = (value) => {
    return fromBig(toBig(value));
  };
  BigNumber2.toString = (value) => {
    return toBig(value).toString();
  };
  BigNumber2.toNumber = (value) => {
    return toBig(value).toNumber();
  };
  BigNumber2.toBigInt = curry2(
    (options, value) => {
      return BigInt(
        (0, BigNumber2.toFixed)(
          {
            precision: 0,
            roundingMode: options.roundingMode ?? defaultRoundingMode
          },
          toBig(value)
        )
      );
    }
  );
  BigNumber2.toFixed = curry2(
    (options, value) => {
      return toBig(value).toFixed(
        options.precision,
        options.roundingMode ?? defaultRoundingMode
      );
    }
  );
  BigNumber2.toExponential = curry2(
    (options, value) => {
      return toBig(value).toExponential(
        options.precision,
        options.roundingMode ?? defaultRoundingMode
      );
    }
  );
  BigNumber2.isNegative = (value) => {
    return toBig(value).lt(0);
  };
  BigNumber2.isGtZero = (value) => {
    return toBig(value).gt(0);
  };
  BigNumber2.isZero = (value) => {
    return toBig(value).eq(0);
  };
  BigNumber2.isEq = curry2(
    (value, a) => {
      return toBig(value).eq(toBig(a));
    }
  );
  BigNumber2.isGt = curry2(
    (value, a) => {
      return toBig(value).gt(toBig(a));
    }
  );
  BigNumber2.isGte = curry2(
    (value, a) => {
      return toBig(value).gte(toBig(a));
    }
  );
  BigNumber2.isLt = curry2(
    (value, a) => {
      return toBig(value).lt(toBig(a));
    }
  );
  BigNumber2.isLte = curry2(
    (value, a) => {
      return toBig(value).lte(toBig(a));
    }
  );
  BigNumber2.setPrecision = curry2(
    (options, value) => {
      return fromBig(
        toBig(
          toBig(value).toPrecision(
            options.precision,
            options.roundingMode ?? defaultRoundingMode
          )
        )
      );
    }
  );
  BigNumber2.getPrecision = (value) => {
    return toBig(value).c.length - (toBig(value).e + 1);
  };
  BigNumber2.getIntegerLength = (value) => {
    return toBig(value).e + 1;
  };
  BigNumber2.leftMoveDecimals = curry2(
    (distance, value) => (0, BigNumber2.moveDecimals)({ distance }, value)
  );
  BigNumber2.rightMoveDecimals = curry2(
    (distance, value) => (0, BigNumber2.moveDecimals)({ distance: -distance }, value)
  );
  BigNumber2.moveDecimals = curry2(
    (options, value) => {
      if (options.distance > 0) {
        return fromBig(toBig(value).div(10 ** options.distance));
      }
      if (options.distance < 0) {
        return fromBig(toBig(value).mul(10 ** -options.distance));
      }
      return (0, BigNumber2.from)(value);
    }
  );
  BigNumber2.getDecimalPart = curry2(
    (options, value) => {
      const formatted = (0, BigNumber2.toFixed)(
        {
          precision: Math.min((0, BigNumber2.getPrecision)(value), options.precision),
          roundingMode: BigNumber2.roundDown
        },
        value
      );
      const [, decimals] = formatted.split(".");
      if (decimals == null) return void 0;
      return decimals;
    }
  );
  BigNumber2.abs = (value) => {
    return fromBig(toBig(value).abs());
  };
  BigNumber2.neg = (value) => {
    return fromBig(toBig(value).neg());
  };
  BigNumber2.sqrt = (value) => {
    return fromBig(toBig(value).sqrt());
  };
  BigNumber2.add = curry2(
    (value, a) => {
      return fromBig(toBig(value).add(toBig(a)));
    }
  );
  BigNumber2.minus = curry2(
    (value, a) => {
      return fromBig(toBig(value).minus(toBig(a)));
    }
  );
  BigNumber2.mul = curry2(
    (value, a) => {
      return fromBig(toBig(value).mul(toBig(a)));
    }
  );
  BigNumber2.cumulativeMul = curry2(
    (value, as) => {
      return reduce(
        (acc, currentRate) => [
          ...acc,
          BigNumber2.mul(last(acc), currentRate)
        ],
        [(0, BigNumber2.from)(value)],
        as
      );
    }
  );
  BigNumber2.div = curry2(
    (value, a) => {
      return fromBig(toBig(value).div(toBig(a)));
    }
  );
  BigNumber2.pow = curry2((value, a) => {
    return fromBig(toBig(value).pow(a));
  });
  BigNumber2.round = curry2(
    (options, value) => {
      return fromBig(
        toBig(value).round(
          options.precision,
          options.roundingMode ?? defaultRoundingMode
        )
      );
    }
  );
  BigNumber2.toPrecision = curry2(
    (options, value) => {
      return toBig(value).toPrecision(
        options.precision,
        options.roundingMode ?? defaultRoundingMode
      );
    }
  );
  BigNumber2.ascend = curry2(
    (a, b) => (0, BigNumber2.isLt)(a, b) ? -1 : (0, BigNumber2.isGt)(a, b) ? 1 : 0
  );
  BigNumber2.descend = curry2(
    (a, b) => (0, BigNumber2.isLt)(a, b) ? 1 : (0, BigNumber2.isGt)(a, b) ? -1 : 0
  );
  BigNumber2.sort = (comparator, numbers) => {
    const _numbers = numbers.map((a) => fromBig(toBig(a)));
    _numbers.sort(comparator);
    return _numbers;
  };
  BigNumber2.max = (numbers) => {
    return (0, BigNumber2.from)((0, BigNumber2.sort)(BigNumber2.descend, numbers)[0]);
  };
  BigNumber2.min = (numbers) => {
    return (0, BigNumber2.from)((0, BigNumber2.sort)(BigNumber2.ascend, numbers)[0]);
  };
  BigNumber2.clamp = (range, n) => {
    const [min2, max2] = range;
    if ((0, BigNumber2.isGte)(n, max2)) return max2;
    if ((0, BigNumber2.isLte)(n, min2)) return min2;
    return n;
  };
  BigNumber2.sum = (numbers) => {
    return numbers.map((n) => fromBig(toBig(n))).reduce((acc, n) => (0, BigNumber2.add)(acc, n), BigNumber2.ZERO);
  };
  BigNumber2.ZERO = BigNumber2.from(0);
  BigNumber2.ONE = BigNumber2.from(1);
})(BigNumber || (BigNumber = {}));
function curry2(fn) {
  return function(a, b) {
    if (arguments.length > 1) {
      return fn(a, b);
    }
    return (b2) => fn(a, b2);
  };
}

export {
  BigNumber
};
//# sourceMappingURL=chunk-KHTJNOQE.mjs.map