@ocap/util 1.27.16 → 1.28.1

package/esm/bn.d.ts

@@ -1,7 +1,9 @@
-import BaseBN from 'bn.js';
-export interface BN extends BaseBN {
+import BaseBN from "bn.js";
+
+//#region src/bn.d.ts
+interface BN extends BaseBN {}
+declare class BN extends BaseBN {
+  constructor(value: number | string | number[] | Uint8Array | Buffer | BaseBN | null | undefined, base?: number | 'hex', endian?: BaseBN.Endianness);
 }
-export declare class BN extends BaseBN {
-    constructor(value: number | string | number[] | Uint8Array | Buffer | BaseBN | null | undefined, base?: number | 'hex', endian?: BaseBN.Endianness);
-}
-export { BaseBN };
+//#endregion
+export { BN, BaseBN };

package/esm/bn.js

@@ -1,7 +1,11 @@
-import BaseBN from 'bn.js';
-export class BN extends BaseBN {
-    constructor(value, base, endian) {
-        super(value === null ? '0' : value, base, endian);
-    }
-}
-export { BaseBN };
+import BaseBN from "bn.js";
+
+//#region src/bn.ts
+var BN = class extends BaseBN {
+	constructor(value, base, endian) {
+		super(value === null ? "0" : value, base, endian);
+	}
+};
+
+//#endregion
+export { BN, BaseBN };

package/esm/constant.d.ts

@@ -1 +1,4 @@
-export declare const DEFAULT_TOKEN_DECIMAL = 18;
+//#region src/constant.d.ts
+declare const DEFAULT_TOKEN_DECIMAL = 18;
+//#endregion
+export { DEFAULT_TOKEN_DECIMAL };

package/esm/constant.js

@@ -1 +1,5 @@
-export const DEFAULT_TOKEN_DECIMAL = 18;
+//#region src/constant.ts
+const DEFAULT_TOKEN_DECIMAL = 18;
+
+//#endregion
+export { DEFAULT_TOKEN_DECIMAL };

package/esm/create-sorted-list.d.ts

@@ -1 +1,4 @@
-export declare const createSortedList: (list: $TSFixMe) => any;
+//#region src/create-sorted-list.d.ts
+declare const createSortedList: (list: $TSFixMe) => unknown[];
+//#endregion
+export { createSortedList };

package/esm/create-sorted-list.js

@@ -1,3 +1,8 @@
-import uniq from 'lodash/uniq';
-import flatten from 'lodash/flatten';
-export const createSortedList = (list) => uniq(flatten(list)).filter(Boolean).sort();
+import uniq from "lodash/uniq.js";
+import flatten from "lodash/flatten.js";
+
+//#region src/create-sorted-list.ts
+const createSortedList = (list) => uniq(flatten(list)).filter(Boolean).sort();
+
+//#endregion
+export { createSortedList };

package/esm/curve.d.ts

@@ -1,84 +1,114 @@
-import { BN } from './index';
-export declare enum Direction {
-    Mint = "mint",
-    Burn = "burn"
+import { BN } from "./bn.js";
+import "./index.js";
+import * as bn_js0 from "bn.js";
+
+//#region src/curve.d.ts
+declare enum Direction {
+  Mint = "mint",
+  Burn = "burn",
 }
 /**
  * Constant Curve
  * Price = fixedPrice
  */
-export declare function calcConstantPrice({ fixedPrice }: {
-    fixedPrice: string;
+declare function calcConstantPrice({
+  fixedPrice
+}: {
+  fixedPrice: string;
 }): BN;
 /**
  * Constant Curve
  * Cost = amount * fixedPrice
  */
-export declare function calcConstantCost({ amount, fixedPrice, decimal, }: {
-    amount: string;
-    fixedPrice: string;
-    decimal: number;
-}): import("bn.js");
+declare function calcConstantCost({
+  amount,
+  fixedPrice,
+  decimal
+}: {
+  amount: string;
+  fixedPrice: string;
+  decimal: number;
+}): bn_js0;
 /**
  * linear Curve
  * Price = basePrice + slope * currentSupply
  */
-export declare function calcLinearPrice({ basePrice, slope, currentSupply, decimal, }: {
-    basePrice: string;
-    slope: string;
-    currentSupply: string;
-    decimal: number;
-}): import("bn.js");
+declare function calcLinearPrice({
+  basePrice,
+  slope,
+  currentSupply,
+  decimal
+}: {
+  basePrice: string;
+  slope: string;
+  currentSupply: string;
+  decimal: number;
+}): bn_js0;
 /**
  * Linear Curve
  * mint Cost = (slope / 2) * ( (currentSupply + amount) ** 2 - currentSupply ** 2 ) + basePrice * amount;
  * burn Cost = (slope / 2) * ( currentSupply ** 2 - (currentSupply - amount) ** 2 ) + basePrice * amount;
  */
-export declare function calcLinearCost(params: {
-    amount: string;
-    currentSupply: string;
-    basePrice: string;
-    slope: string;
-    decimal: number;
-    direction: Direction;
-}): import("bn.js");
+declare function calcLinearCost(params: {
+  amount: string;
+  currentSupply: string;
+  basePrice: string;
+  slope: string;
+  decimal: number;
+  direction: Direction;
+}): bn_js0;
 /**
  * Quadratic Curve
  * Price = basePrice + currentSupply ** 2 / constant
  */
-export declare function calcQuadraticPrice(params: {
-    basePrice: string;
-    currentSupply: string;
-    constant: string;
-    decimal: number;
-}): import("bn.js");
+declare function calcQuadraticPrice(params: {
+  basePrice: string;
+  currentSupply: string;
+  constant: string;
+  decimal: number;
+}): bn_js0;
 /**
  * Quadratic Curve
  * Price = basePrice + currentSupply ** 2 / constant
  * mint Cost = ( (currentSupply + amount)^3 / 3 - currentSupply^3 / 3 ) / constant + basePrice * amount;
  * burn Cost = ( currentSupply^3 / 3 - (currentSupply - amount)^3 / 3 ) / constant + basePrice * amount;
  */
-export declare function calcQuadraticCost(params: {
-    amount: string;
-    currentSupply: string;
-    basePrice: string;
-    constant: string;
-    decimal: number;
-    direction: Direction;
-}): import("bn.js");
-export declare function calcFee({ reserveAmount, feeRate }: {
-    reserveAmount: string;
-    feeRate: string;
-}): import("bn.js");
-export declare function calcPrice({ currentSupply, decimal, curve }: {
-    currentSupply: string;
-    decimal: number;
-    curve: any;
-}): import("bn.js");
-export declare function calcCost({ amount, decimal, currentSupply, direction, curve, }: {
-    amount: string;
-    decimal: number;
-    currentSupply: string;
-    curve: any;
-    direction: Direction;
-}): import("bn.js");
+declare function calcQuadraticCost(params: {
+  amount: string;
+  currentSupply: string;
+  basePrice: string;
+  constant: string;
+  decimal: number;
+  direction: Direction;
+}): bn_js0;
+declare function calcFee({
+  reserveAmount,
+  feeRate
+}: {
+  reserveAmount: string;
+  feeRate: string;
+}): bn_js0;
+declare function calcPrice({
+  currentSupply,
+  decimal,
+  curve
+}: {
+  currentSupply: string;
+  decimal: number;
+  curve: any;
+}): bn_js0;
+declare function calcCost({
+  amount,
+  decimal,
+  currentSupply,
+  direction,
+  curve
+}: {
+  amount: string;
+  decimal: number;
+  currentSupply: string;
+  curve: any;
+  direction: Direction;
+}): bn_js0;
+//#endregion
+export { Direction, calcConstantCost, calcConstantPrice, calcCost, calcFee, calcLinearCost, calcLinearPrice, calcPrice, calcQuadraticCost, calcQuadraticPrice };

package/esm/curve.js

@@ -1,146 +1,151 @@
-import { BN } from './index';
+import { BN } from "./bn.js";
+
+//#region src/curve.ts
 const ZERO = new BN(0);
 const TWO = new BN(2);
 const THREE = new BN(3);
 const TEN = new BN(10);
-export var Direction;
-(function (Direction) {
-    Direction["Mint"] = "mint";
-    Direction["Burn"] = "burn";
-})(Direction || (Direction = {}));
+let Direction = /* @__PURE__ */ function(Direction$1) {
+	Direction$1["Mint"] = "mint";
+	Direction$1["Burn"] = "burn";
+	return Direction$1;
+}({});
 /**
- * Constant Curve
- * Price = fixedPrice
- */
-export function calcConstantPrice({ fixedPrice }) {
-    return new BN(fixedPrice);
+* Constant Curve
+* Price = fixedPrice
+*/
+function calcConstantPrice({ fixedPrice }) {
+	return new BN(fixedPrice);
 }
 /**
- * Constant Curve
- * Cost = amount * fixedPrice
- */
-export function calcConstantCost({ amount, fixedPrice, decimal, }) {
-    const decimalFactor = TEN.pow(new BN(decimal));
-    return new BN(amount).mul(new BN(fixedPrice)).div(decimalFactor);
+* Constant Curve
+* Cost = amount * fixedPrice
+*/
+function calcConstantCost({ amount, fixedPrice, decimal }) {
+	const decimalFactor = TEN.pow(new BN(decimal));
+	return new BN(amount).mul(new BN(fixedPrice)).div(decimalFactor);
 }
 /**
- * linear Curve
- * Price = basePrice + slope * currentSupply
- */
-export function calcLinearPrice({ basePrice, slope, currentSupply, decimal, }) {
-    const decimalFactor = TEN.pow(new BN(decimal));
-    return new BN(basePrice).add(new BN(slope).mul(new BN(currentSupply)).div(decimalFactor));
+* linear Curve
+* Price = basePrice + slope * currentSupply
+*/
+function calcLinearPrice({ basePrice, slope, currentSupply, decimal }) {
+	const decimalFactor = TEN.pow(new BN(decimal));
+	return new BN(basePrice).add(new BN(slope).mul(new BN(currentSupply)).div(decimalFactor));
 }
 /**
- * Linear Curve
- * mint Cost = (slope / 2) * ( (currentSupply + amount) ** 2 - currentSupply ** 2 ) + basePrice * amount;
- * burn Cost = (slope / 2) * ( currentSupply ** 2 - (currentSupply - amount) ** 2 ) + basePrice * amount;
- */
-export function calcLinearCost(params) {
-    const amount = new BN(params.amount);
-    const currentSupply = new BN(params.currentSupply);
-    const basePrice = new BN(params.basePrice);
-    const slope = new BN(params.slope);
-    const decimalFactor = TEN.pow(new BN(params.decimal));
-    if (slope.lte(ZERO))
-        throw new Error('INVALID_SLOPE');
-    if (amount.lt(ZERO))
-        throw new Error('INVALID_AMOUNT');
-    if (currentSupply.lt(ZERO))
-        throw new Error('INVALID_CURRENT_SUPPLY');
-    if (basePrice.lt(ZERO))
-        throw new Error('INVALID_BASE_PRICE');
-    if (decimalFactor.lte(ZERO))
-        throw new Error('INVALID_DECIMAL_FACTOR');
-    if (params.direction === Direction.Burn && amount.gt(currentSupply)) {
-        throw new Error('SUPPLY_INSUFFICIENT');
-    }
-    const integralDelta = params.direction === Direction.Mint
-        ? amount.mul(currentSupply.mul(TWO).add(amount)) // (currentSupply + amount) ** 2 - currentSupply ** 2 = amount * (2 * currentSupply + amount)
-        : amount.mul(currentSupply.mul(TWO).sub(amount)); // currentSupply ** 2 - (currentSupply - amount) ** 2 = amount * (2 * currentSupply - amount)
-    const linearTerm = basePrice.mul(amount).div(decimalFactor);
-    const integralTerm = slope.mul(integralDelta).div(TWO.mul(decimalFactor.sqr()));
-    return linearTerm.add(integralTerm);
+* Linear Curve
+* mint Cost = (slope / 2) * ( (currentSupply + amount) ** 2 - currentSupply ** 2 ) + basePrice * amount;
+* burn Cost = (slope / 2) * ( currentSupply ** 2 - (currentSupply - amount) ** 2 ) + basePrice * amount;
+*/
+function calcLinearCost(params) {
+	const amount = new BN(params.amount);
+	const currentSupply = new BN(params.currentSupply);
+	const basePrice = new BN(params.basePrice);
+	const slope = new BN(params.slope);
+	const decimalFactor = TEN.pow(new BN(params.decimal));
+	if (slope.lte(ZERO)) throw new Error("INVALID_SLOPE");
+	if (amount.lt(ZERO)) throw new Error("INVALID_AMOUNT");
+	if (currentSupply.lt(ZERO)) throw new Error("INVALID_CURRENT_SUPPLY");
+	if (basePrice.lt(ZERO)) throw new Error("INVALID_BASE_PRICE");
+	if (decimalFactor.lte(ZERO)) throw new Error("INVALID_DECIMAL_FACTOR");
+	if (params.direction === Direction.Burn && amount.gt(currentSupply)) throw new Error("SUPPLY_INSUFFICIENT");
+	const integralDelta = params.direction === Direction.Mint ? amount.mul(currentSupply.mul(TWO).add(amount)) : amount.mul(currentSupply.mul(TWO).sub(amount));
+	const linearTerm = basePrice.mul(amount).div(decimalFactor);
+	const integralTerm = slope.mul(integralDelta).div(TWO.mul(decimalFactor.sqr()));
+	return linearTerm.add(integralTerm);
 }
 /**
- * Quadratic Curve
- * Price = basePrice + currentSupply ** 2 / constant
- */
-export function calcQuadraticPrice(params) {
-    const basePrice = new BN(params.basePrice);
-    const currentSupply = new BN(params.currentSupply);
-    const constant = new BN(params.constant);
-    const decimalFactor = TEN.pow(new BN(params.decimal)); // 10^decimal
-    if (constant.lte(ZERO))
-        throw new Error('INVALID_CONSTANT');
-    if (currentSupply.lt(ZERO))
-        throw new Error('INVALID_CURRENT_SUPPLY');
-    if (basePrice.lt(ZERO))
-        throw new Error('INVALID_BASE_PRICE');
-    if (decimalFactor.lte(ZERO))
-        throw new Error('INVALID_DECIMAL_FACTOR');
-    // Single division to reduce double-flooring error
-    const denom = constant.mul(decimalFactor);
-    const a = currentSupply.sqr().div(denom);
-    return basePrice.add(a);
+* Quadratic Curve
+* Price = basePrice + currentSupply ** 2 / constant
+*/
+function calcQuadraticPrice(params) {
+	const basePrice = new BN(params.basePrice);
+	const currentSupply = new BN(params.currentSupply);
+	const constant = new BN(params.constant);
+	const decimalFactor = TEN.pow(new BN(params.decimal));
+	if (constant.lte(ZERO)) throw new Error("INVALID_CONSTANT");
+	if (currentSupply.lt(ZERO)) throw new Error("INVALID_CURRENT_SUPPLY");
+	if (basePrice.lt(ZERO)) throw new Error("INVALID_BASE_PRICE");
+	if (decimalFactor.lte(ZERO)) throw new Error("INVALID_DECIMAL_FACTOR");
+	const denom = constant.mul(decimalFactor);
+	const a = currentSupply.sqr().div(denom);
+	return basePrice.add(a);
 }
 /**
- * Quadratic Curve
- * Price = basePrice + currentSupply ** 2 / constant
- * mint Cost = ( (currentSupply + amount)^3 / 3 - currentSupply^3 / 3 ) / constant + basePrice * amount;
- * burn Cost = ( currentSupply^3 / 3 - (currentSupply - amount)^3 / 3 ) / constant + basePrice * amount;
- */
-export function calcQuadraticCost(params) {
-    const amount = new BN(params.amount);
-    const currentSupply = new BN(params.currentSupply);
-    const basePrice = new BN(params.basePrice);
-    const constant = new BN(params.constant);
-    const decimalFactor = TEN.pow(new BN(params.decimal)); // M = 10^decimal
-    // Basic validations
-    if (constant.lte(ZERO))
-        throw new Error('INVALID_CONSTANT');
-    if (amount.lt(ZERO))
-        throw new Error('INVALID_AMOUNT');
-    if (amount.isZero())
-        return ZERO;
-    // Compute new supply with direction guard
-    const newSupply = params.direction === Direction.Mint ? currentSupply.add(amount) : currentSupply.sub(amount);
-    if (params.direction === Direction.Burn && newSupply.lt(ZERO)) {
-        throw new Error('SUPPLY_INSUFFICIENT');
-    }
-    // cubicDelta = |S1^3 - S0^3| = (S1 - S0) * (S1^2 + S1 * S0 + S0^2)
-    const diff = params.direction === Direction.Mint ? newSupply.sub(currentSupply) : currentSupply.sub(newSupply);
-    const sumSquaresAndProduct = newSupply.sqr().add(newSupply.mul(currentSupply)).add(currentSupply.sqr());
-    const cubicDelta = diff.mul(sumSquaresAndProduct);
-    // integral term: (S1^3 - S0^3) / (3 * constant * M^2)
-    const denom = THREE.mul(constant).mul(decimalFactor.sqr());
-    const cubicCost = cubicDelta.div(denom);
-    // linear term: basePrice * amount / M
-    const linearCost = basePrice.mul(amount).div(decimalFactor);
-    return cubicCost.add(linearCost);
+* Quadratic Curve
+* Price = basePrice + currentSupply ** 2 / constant
+* mint Cost = ( (currentSupply + amount)^3 / 3 - currentSupply^3 / 3 ) / constant + basePrice * amount;
+* burn Cost = ( currentSupply^3 / 3 - (currentSupply - amount)^3 / 3 ) / constant + basePrice * amount;
+*/
+function calcQuadraticCost(params) {
+	const amount = new BN(params.amount);
+	const currentSupply = new BN(params.currentSupply);
+	const basePrice = new BN(params.basePrice);
+	const constant = new BN(params.constant);
+	const decimalFactor = TEN.pow(new BN(params.decimal));
+	if (constant.lte(ZERO)) throw new Error("INVALID_CONSTANT");
+	if (amount.lt(ZERO)) throw new Error("INVALID_AMOUNT");
+	if (amount.isZero()) return ZERO;
+	const newSupply = params.direction === Direction.Mint ? currentSupply.add(amount) : currentSupply.sub(amount);
+	if (params.direction === Direction.Burn && newSupply.lt(ZERO)) throw new Error("SUPPLY_INSUFFICIENT");
+	const diff = params.direction === Direction.Mint ? newSupply.sub(currentSupply) : currentSupply.sub(newSupply);
+	const sumSquaresAndProduct = newSupply.sqr().add(newSupply.mul(currentSupply)).add(currentSupply.sqr());
+	const cubicDelta = diff.mul(sumSquaresAndProduct);
+	const denom = THREE.mul(constant).mul(decimalFactor.sqr());
+	const cubicCost = cubicDelta.div(denom);
+	const linearCost = basePrice.mul(amount).div(decimalFactor);
+	return cubicCost.add(linearCost);
 }
-export function calcFee({ reserveAmount, feeRate }) {
-    return new BN(reserveAmount).mul(new BN(feeRate)).div(new BN(10000));
+function calcFee({ reserveAmount, feeRate }) {
+	return new BN(reserveAmount).mul(new BN(feeRate)).div(new BN(1e4));
 }
-export function calcPrice({ currentSupply, decimal, curve }) {
-    const calculator = {
-        constant: () => calcConstantPrice({ currentSupply, decimal, ...curve }),
-        linear: () => calcLinearPrice({ currentSupply, decimal, ...curve }),
-        quadratic: () => calcQuadraticPrice({ currentSupply, decimal, ...curve }),
-    }[curve.type];
-    if (!calculator) {
-        throw new Error('INVALID_CURVE_TYPE');
-    }
-    return calculator();
+function calcPrice({ currentSupply, decimal, curve }) {
+	const calculator = {
+		constant: () => calcConstantPrice({
+			currentSupply,
+			decimal,
+			...curve
+		}),
+		linear: () => calcLinearPrice({
+			currentSupply,
+			decimal,
+			...curve
+		}),
+		quadratic: () => calcQuadraticPrice({
+			currentSupply,
+			decimal,
+			...curve
+		})
+	}[curve.type];
+	if (!calculator) throw new Error("INVALID_CURVE_TYPE");
+	return calculator();
 }
-export function calcCost({ amount, decimal, currentSupply, direction, curve, }) {
-    const calculator = {
-        constant: () => calcConstantCost({ amount, decimal, ...curve }),
-        linear: () => calcLinearCost({ amount, decimal, currentSupply, direction, ...curve }),
-        quadratic: () => calcQuadraticCost({ amount, decimal, currentSupply, direction, ...curve }),
-    }[curve.type];
-    if (!calculator) {
-        throw new Error('INVALID_CURVE_TYPE');
-    }
-    return calculator();
+function calcCost({ amount, decimal, currentSupply, direction, curve }) {
+	const calculator = {
+		constant: () => calcConstantCost({
+			amount,
+			decimal,
+			...curve
+		}),
+		linear: () => calcLinearCost({
+			amount,
+			decimal,
+			currentSupply,
+			direction,
+			...curve
+		}),
+		quadratic: () => calcQuadraticCost({
+			amount,
+			decimal,
+			currentSupply,
+			direction,
+			...curve
+		})
+	}[curve.type];
+	if (!calculator) throw new Error("INVALID_CURVE_TYPE");
+	return calculator();
 }
+
+//#endregion
+export { Direction, calcConstantCost, calcConstantPrice, calcCost, calcFee, calcLinearCost, calcLinearPrice, calcPrice, calcQuadraticCost, calcQuadraticPrice };

package/esm/error.d.ts

@@ -1,11 +1,14 @@
-export declare class CustomError extends Error {
-    code: string;
-    props: {
-        persist: boolean;
-        [prop: string]: $TSFixMe;
-    };
-    constructor(code: string, message: string, props?: {});
+//#region src/error.d.ts
+declare class CustomError extends Error {
+  code: string;
+  props: {
+    persist: boolean;
+    [prop: string]: $TSFixMe;
+  };
+  constructor(code: string, message: string, props?: {});
 }
-export declare class PersistError extends CustomError {
-    constructor(code: string, message: string, props?: {});
+declare class PersistError extends CustomError {
+  constructor(code: string, message: string, props?: {});
 }
+//#endregion
+export { CustomError, PersistError };

package/esm/error.js

@@ -1,17 +1,24 @@
-/* eslint-disable max-classes-per-file */
-export class CustomError extends Error {
-    constructor(code, message, props = {}) {
-        super(message);
-        if (Error.captureStackTrace) {
-            Error.captureStackTrace(this, CustomError);
-        }
-        this.code = code;
-        this.props = { persist: false, ...props };
-    }
-}
-export class PersistError extends CustomError {
-    constructor(code, message, props = {}) {
-        super(code, message);
-        this.props = { persist: true, ...props };
-    }
-}
+//#region src/error.ts
+var CustomError = class CustomError extends Error {
+	constructor(code, message, props = {}) {
+		super(message);
+		if (Error.captureStackTrace) Error.captureStackTrace(this, CustomError);
+		this.code = code;
+		this.props = {
+			persist: false,
+			...props
+		};
+	}
+};
+var PersistError = class extends CustomError {
+	constructor(code, message, props = {}) {
+		super(code, message);
+		this.props = {
+			persist: true,
+			...props
+		};
+	}
+};
+
+//#endregion
+export { CustomError, PersistError };

package/esm/get-list-field.d.ts

@@ -1 +1,4 @@
-export declare const getListField: (obj: $TSFixMe, key: string) => any;
+//#region src/get-list-field.d.ts
+declare const getListField: (obj: $TSFixMe, key: string) => any;
+//#endregion
+export { getListField };

package/esm/get-list-field.js

@@ -1,2 +1,7 @@
-import get from 'lodash/get';
-export const getListField = (obj, key) => get(obj, `${key}List`) || get(obj, key) || [];
+import get from "lodash/get.js";
+
+//#region src/get-list-field.ts
+const getListField = (obj, key) => get(obj, `${key}List`) || get(obj, key) || [];
+
+//#endregion
+export { getListField };

package/esm/get-related-addr.d.ts

@@ -1 +1,4 @@
-export declare const getRelatedAddresses: (state: $TSFixMe) => any[];
+//#region src/get-related-addr.d.ts
+declare const getRelatedAddresses: (state: $TSFixMe) => any[];
+//#endregion
+export { getRelatedAddresses };

package/esm/get-related-addr.js

@@ -1 +1,5 @@
-export const getRelatedAddresses = (state) => [state.address].concat(state.migratedFrom || []).filter(Boolean);
+//#region src/get-related-addr.ts
+const getRelatedAddresses = (state) => [state.address].concat(state.migratedFrom || []).filter(Boolean);
+
+//#endregion
+export { getRelatedAddresses };