@ocap/util 1.27.15 → 1.28.0

package/lib/curve.d.ts

@@ -1,84 +1,113 @@
-import { BN } from './index';
-export declare enum Direction {
-    Mint = "mint",
-    Burn = "burn"
+import { BN } from "./bn.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/lib/curve.js

@@ -1,158 +1,160 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Direction = void 0;
-exports.calcConstantPrice = calcConstantPrice;
-exports.calcConstantCost = calcConstantCost;
-exports.calcLinearPrice = calcLinearPrice;
-exports.calcLinearCost = calcLinearCost;
-exports.calcQuadraticPrice = calcQuadraticPrice;
-exports.calcQuadraticCost = calcQuadraticCost;
-exports.calcFee = calcFee;
-exports.calcPrice = calcPrice;
-exports.calcCost = calcCost;
-const index_1 = require("./index");
-const ZERO = new index_1.BN(0);
-const TWO = new index_1.BN(2);
-const THREE = new index_1.BN(3);
-const TEN = new index_1.BN(10);
-var Direction;
-(function (Direction) {
-    Direction["Mint"] = "mint";
-    Direction["Burn"] = "burn";
-})(Direction || (exports.Direction = Direction = {}));
+const require_bn = require('./bn.js');
+
+//#region src/curve.ts
+const ZERO = new require_bn.BN(0);
+const TWO = new require_bn.BN(2);
+const THREE = new require_bn.BN(3);
+const TEN = new require_bn.BN(10);
+let Direction = /* @__PURE__ */ function(Direction$1) {
+	Direction$1["Mint"] = "mint";
+	Direction$1["Burn"] = "burn";
+	return Direction$1;
+}({});
 /**
- * Constant Curve
- * Price = fixedPrice
- */
+* Constant Curve
+* Price = fixedPrice
+*/
 function calcConstantPrice({ fixedPrice }) {
-    return new index_1.BN(fixedPrice);
+	return new require_bn.BN(fixedPrice);
 }
 /**
- * Constant Curve
- * Cost = amount * fixedPrice
- */
-function calcConstantCost({ amount, fixedPrice, decimal, }) {
-    const decimalFactor = TEN.pow(new index_1.BN(decimal));
-    return new index_1.BN(amount).mul(new index_1.BN(fixedPrice)).div(decimalFactor);
+* Constant Curve
+* Cost = amount * fixedPrice
+*/
+function calcConstantCost({ amount, fixedPrice, decimal }) {
+	const decimalFactor = TEN.pow(new require_bn.BN(decimal));
+	return new require_bn.BN(amount).mul(new require_bn.BN(fixedPrice)).div(decimalFactor);
 }
 /**
- * linear Curve
- * Price = basePrice + slope * currentSupply
- */
-function calcLinearPrice({ basePrice, slope, currentSupply, decimal, }) {
-    const decimalFactor = TEN.pow(new index_1.BN(decimal));
-    return new index_1.BN(basePrice).add(new index_1.BN(slope).mul(new index_1.BN(currentSupply)).div(decimalFactor));
+* linear Curve
+* Price = basePrice + slope * currentSupply
+*/
+function calcLinearPrice({ basePrice, slope, currentSupply, decimal }) {
+	const decimalFactor = TEN.pow(new require_bn.BN(decimal));
+	return new require_bn.BN(basePrice).add(new require_bn.BN(slope).mul(new require_bn.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;
- */
+* 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 index_1.BN(params.amount);
-    const currentSupply = new index_1.BN(params.currentSupply);
-    const basePrice = new index_1.BN(params.basePrice);
-    const slope = new index_1.BN(params.slope);
-    const decimalFactor = TEN.pow(new index_1.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);
+	const amount = new require_bn.BN(params.amount);
+	const currentSupply = new require_bn.BN(params.currentSupply);
+	const basePrice = new require_bn.BN(params.basePrice);
+	const slope = new require_bn.BN(params.slope);
+	const decimalFactor = TEN.pow(new require_bn.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
- */
+* Quadratic Curve
+* Price = basePrice + currentSupply ** 2 / constant
+*/
 function calcQuadraticPrice(params) {
-    const basePrice = new index_1.BN(params.basePrice);
-    const currentSupply = new index_1.BN(params.currentSupply);
-    const constant = new index_1.BN(params.constant);
-    const decimalFactor = TEN.pow(new index_1.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);
+	const basePrice = new require_bn.BN(params.basePrice);
+	const currentSupply = new require_bn.BN(params.currentSupply);
+	const constant = new require_bn.BN(params.constant);
+	const decimalFactor = TEN.pow(new require_bn.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;
- */
+* 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 index_1.BN(params.amount);
-    const currentSupply = new index_1.BN(params.currentSupply);
-    const basePrice = new index_1.BN(params.basePrice);
-    const constant = new index_1.BN(params.constant);
-    const decimalFactor = TEN.pow(new index_1.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);
+	const amount = new require_bn.BN(params.amount);
+	const currentSupply = new require_bn.BN(params.currentSupply);
+	const basePrice = new require_bn.BN(params.basePrice);
+	const constant = new require_bn.BN(params.constant);
+	const decimalFactor = TEN.pow(new require_bn.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);
 }
 function calcFee({ reserveAmount, feeRate }) {
-    return new index_1.BN(reserveAmount).mul(new index_1.BN(feeRate)).div(new index_1.BN(10000));
+	return new require_bn.BN(reserveAmount).mul(new require_bn.BN(feeRate)).div(new require_bn.BN(1e4));
 }
 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();
+	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 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
+exports.Direction = Direction;
+exports.calcConstantCost = calcConstantCost;
+exports.calcConstantPrice = calcConstantPrice;
+exports.calcCost = calcCost;
+exports.calcFee = calcFee;
+exports.calcLinearCost = calcLinearCost;
+exports.calcLinearPrice = calcLinearPrice;
+exports.calcPrice = calcPrice;
+exports.calcQuadraticCost = calcQuadraticCost;
+exports.calcQuadraticPrice = calcQuadraticPrice;

package/lib/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/lib/error.js

@@ -1,22 +1,26 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PersistError = exports.CustomError = void 0;
-/* eslint-disable max-classes-per-file */
-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 };
-    }
-}
+
+//#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
 exports.CustomError = CustomError;
-class PersistError extends CustomError {
-    constructor(code, message, props = {}) {
-        super(code, message);
-        this.props = { persist: true, ...props };
-    }
-}
-exports.PersistError = PersistError;
+exports.PersistError = PersistError;

package/lib/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/lib/get-list-field.js

@@ -1,9 +1,9 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getListField = void 0;
-const get_1 = __importDefault(require("lodash/get"));
-const getListField = (obj, key) => (0, get_1.default)(obj, `${key}List`) || (0, get_1.default)(obj, key) || [];
-exports.getListField = getListField;
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.js');
+let lodash_get = require("lodash/get");
+lodash_get = require_rolldown_runtime.__toESM(lodash_get);
+
+//#region src/get-list-field.ts
+const getListField = (obj, key) => (0, lodash_get.default)(obj, `${key}List`) || (0, lodash_get.default)(obj, key) || [];
+
+//#endregion
+exports.getListField = getListField;

package/lib/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/lib/get-related-addr.js

@@ -1,5 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRelatedAddresses = void 0;
+
+//#region src/get-related-addr.ts
 const getRelatedAddresses = (state) => [state.address].concat(state.migratedFrom || []).filter(Boolean);
-exports.getRelatedAddresses = getRelatedAddresses;
+
+//#endregion
+exports.getRelatedAddresses = getRelatedAddresses;