@gearbox-protocol/sdk 14.10.1 → 14.10.2-next.1

package/dist/cjs/common-utils/utils/validation/validate-open-account-pool-quota-status.js

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var validate_open_account_pool_quota_status_exports = {};
+__export(validate_open_account_pool_quota_status_exports, {
+  validateOpenAccountPoolQuotaStatus: () => validateOpenAccountPoolQuotaStatus
+});
+module.exports = __toCommonJS(validate_open_account_pool_quota_status_exports);
+function validateOpenAccountPoolQuotaStatus(targetToken, creditManager, amountToBorrow) {
+  const quota = creditManager.quotas[targetToken];
+  if (quota) {
+    const realLimit = quota.isActive ? quota.limit : 0n;
+    const quotaLeft = realLimit - quota.totalQuoted;
+    if (quotaLeft < amountToBorrow)
+      return { message: "insufficientQuota", token: targetToken };
+  }
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  validateOpenAccountPoolQuotaStatus
+});

package/dist/cjs/common-utils/utils/validation/validate-open-account-pool-quota-status.spec.js

@@ -0,0 +1,43 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_test_utils = require("../../test-utils/index.js");
+var import_validate_open_account_pool_quota_status = require("./validate-open-account-pool-quota-status.js");
+const mockCreditManager = (0, import_test_utils.buildCreditManager)({
+  quotas: {
+    [import_test_utils.mockToken1]: (0, import_test_utils.buildQuota)({
+      token: import_test_utils.mockToken1,
+      limit: 1000000n,
+      totalQuoted: 500000n,
+      rate: 0n
+    })
+  }
+});
+(0, import_vitest.describe)("validateOpenAccountPoolQuotaStatus", () => {
+  (0, import_vitest.it)("returns null when quota is sufficient", () => {
+    const result = (0, import_validate_open_account_pool_quota_status.validateOpenAccountPoolQuotaStatus)(
+      import_test_utils.mockToken1,
+      mockCreditManager,
+      100000n
+    );
+    (0, import_vitest.expect)(result).toBeNull();
+  });
+  (0, import_vitest.it)("returns error when quota is insufficient", () => {
+    const result = (0, import_validate_open_account_pool_quota_status.validateOpenAccountPoolQuotaStatus)(
+      import_test_utils.mockToken1,
+      mockCreditManager,
+      600000n
+    );
+    (0, import_vitest.expect)(result).toEqual({
+      message: "insufficientQuota",
+      token: import_test_utils.mockToken1
+    });
+  });
+  (0, import_vitest.it)("returns null when token has no quota", () => {
+    const result = (0, import_validate_open_account_pool_quota_status.validateOpenAccountPoolQuotaStatus)(
+      "0x9999999999999999999999999999999999999999",
+      mockCreditManager,
+      100000n
+    );
+    (0, import_vitest.expect)(result).toBeNull();
+  });
+});

package/dist/cjs/common-utils/utils/validation/validate-open-account-pool-status.js

@@ -0,0 +1,76 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var validate_open_account_pool_status_exports = {};
+__export(validate_open_account_pool_status_exports, {
+  validateOpenAccountPoolStatus: () => validateOpenAccountPoolStatus
+});
+module.exports = __toCommonJS(validate_open_account_pool_status_exports);
+var import_bigint_math = require("../bigint-math.js");
+var import_validate_open_account_pool_quota_status = require("./validate-open-account-pool-quota-status.js");
+function validateOpenAccountPoolStatus(props) {
+  const { debt, creditManager, pool, targetToken } = props;
+  const effectiveDebt = import_bigint_math.BigIntMath.max(creditManager.minDebt, debt);
+  const hasDebtLimit = creditManager.totalDebtLimit >= 0n;
+  const debtLimitLeft = import_bigint_math.BigIntMath.max(
+    creditManager.totalDebtLimit - creditManager.totalDebt,
+    0n
+  );
+  const { totalDebtLimit = 0n, totalBorrowed = 0n } = pool || {};
+  const hasPoolDebtLimit = totalDebtLimit > 0n;
+  const poolDebtLimitLeft = totalDebtLimit - totalBorrowed;
+  const canOpenMinDebt = creditManager.minDebt <= debtLimitLeft && creditManager.minDebt <= poolDebtLimitLeft && creditManager.minDebt <= creditManager.availableToBorrow;
+  const minPositionSize = import_bigint_math.BigIntMath.min(
+    import_bigint_math.BigIntMath.min(debtLimitLeft, poolDebtLimitLeft),
+    creditManager.availableToBorrow
+  );
+  if (hasDebtLimit && effectiveDebt > debtLimitLeft) {
+    return {
+      message: "insufficientDebtLimit",
+      amount: debtLimitLeft,
+      solutionAmount: canOpenMinDebt ? minPositionSize : void 0
+    };
+  }
+  if (hasPoolDebtLimit && effectiveDebt > poolDebtLimitLeft) {
+    return {
+      message: "insufficientPoolDebtLimit",
+      amount: poolDebtLimitLeft,
+      solutionAmount: canOpenMinDebt ? minPositionSize : void 0
+    };
+  }
+  if (effectiveDebt > creditManager.availableToBorrow) {
+    return {
+      message: "insufficientPoolLiquidity",
+      amount: creditManager.availableToBorrow,
+      solutionAmount: canOpenMinDebt ? minPositionSize : void 0
+    };
+  }
+  if (targetToken !== null) {
+    const quotaError = (0, import_validate_open_account_pool_quota_status.validateOpenAccountPoolQuotaStatus)(
+      targetToken,
+      creditManager,
+      effectiveDebt
+    );
+    if (quotaError) return quotaError;
+  }
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  validateOpenAccountPoolStatus
+});

package/dist/cjs/common-utils/utils/validation/validate-open-account-pool-status.spec.js

@@ -0,0 +1,98 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_test_utils = require("../../test-utils/index.js");
+var import_validate_open_account_pool_status = require("./validate-open-account-pool-status.js");
+const mockCreditManager = (0, import_test_utils.buildCreditManager)({
+  minDebt: 1000n,
+  maxDebt: 1000000n,
+  totalDebtLimit: 5000000n,
+  totalDebt: 2000000n,
+  availableToBorrow: 3000000n,
+  quotas: {
+    [import_test_utils.mockToken1]: (0, import_test_utils.buildQuota)({
+      token: import_test_utils.mockToken1,
+      limit: 1000000n,
+      totalQuoted: 500000n,
+      rate: 0n
+    })
+  }
+});
+const mockPool = (0, import_test_utils.buildPool)({
+  totalDebtLimit: 10000000n,
+  totalBorrowed: 5000000n
+});
+(0, import_vitest.describe)("validateOpenAccountPoolStatus", () => {
+  (0, import_vitest.it)("returns null when all conditions are met", () => {
+    const result = (0, import_validate_open_account_pool_status.validateOpenAccountPoolStatus)({
+      debt: 50000n,
+      creditManager: mockCreditManager,
+      pool: mockPool,
+      targetToken: import_test_utils.mockToken1
+    });
+    (0, import_vitest.expect)(result).toBeNull();
+  });
+  (0, import_vitest.it)("returns error when debt exceeds debt limit", () => {
+    const result = (0, import_validate_open_account_pool_status.validateOpenAccountPoolStatus)({
+      debt: 4000000n,
+      creditManager: mockCreditManager,
+      pool: mockPool,
+      targetToken: import_test_utils.mockToken1
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      message: "insufficientDebtLimit",
+      amount: 3000000n,
+      solutionAmount: 3000000n
+    });
+  });
+  (0, import_vitest.it)("returns error when debt exceeds pool debt limit", () => {
+    const result = (0, import_validate_open_account_pool_status.validateOpenAccountPoolStatus)({
+      debt: 6000000n,
+      creditManager: (0, import_test_utils.buildCreditManager)({
+        ...mockCreditManager,
+        totalDebtLimit: -1n
+      }),
+      pool: mockPool,
+      targetToken: import_test_utils.mockToken1
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      message: "insufficientPoolDebtLimit",
+      amount: 5000000n
+    });
+  });
+  (0, import_vitest.it)("returns error when debt exceeds available liquidity", () => {
+    const result = (0, import_validate_open_account_pool_status.validateOpenAccountPoolStatus)({
+      debt: 4000000n,
+      creditManager: (0, import_test_utils.buildCreditManager)({
+        ...mockCreditManager,
+        totalDebtLimit: -1n
+      }),
+      pool: (0, import_test_utils.buildPool)({ totalDebtLimit: -1n }),
+      targetToken: import_test_utils.mockToken1
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      message: "insufficientPoolLiquidity",
+      amount: 3000000n
+    });
+  });
+  (0, import_vitest.it)("returns error when quota is insufficient", () => {
+    const result = (0, import_validate_open_account_pool_status.validateOpenAccountPoolStatus)({
+      debt: 600000n,
+      creditManager: mockCreditManager,
+      pool: mockPool,
+      targetToken: import_test_utils.mockToken1
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      message: "insufficientQuota",
+      token: import_test_utils.mockToken1
+    });
+  });
+  (0, import_vitest.it)("returns null when targetToken is null", () => {
+    const result = (0, import_validate_open_account_pool_status.validateOpenAccountPoolStatus)({
+      debt: 50000n,
+      creditManager: mockCreditManager,
+      pool: mockPool,
+      targetToken: null
+    });
+    (0, import_vitest.expect)(result).toBeNull();
+  });
+});

package/dist/cjs/common-utils/utils/validation/validate-open-account.js

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var validate_open_account_exports = {};
+__export(validate_open_account_exports, {
+  validateOpenAccount: () => validateOpenAccount
+});
+module.exports = __toCommonJS(validate_open_account_exports);
+var import_validate_quota = require("./validate-quota.js");
+function validateOpenAccount(props) {
+  const { debt, creditManager, loading } = props;
+  if (loading) {
+    return { message: "loading" };
+  }
+  if (debt < creditManager.minDebt) {
+    return { message: "amountLessMin", amount: creditManager.minDebt };
+  }
+  if (debt > creditManager.maxDebt) {
+    return { message: "debtGreaterMax", amount: creditManager.maxDebt };
+  }
+  return (0, import_validate_quota.validateQuota)(props);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  validateOpenAccount
+});

package/dist/cjs/common-utils/utils/validation/validate-open-account.spec.js

@@ -0,0 +1,54 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_test_utils = require("../../test-utils/index.js");
+var import_validate_open_account = require("./validate-open-account.js");
+const mockCreditManager = (0, import_test_utils.buildCreditManager)({
+  minDebt: 1000n,
+  maxDebt: 1000000n,
+  underlyingToken: import_test_utils.mockUnderlyingToken
+});
+(0, import_vitest.describe)("validateOpenAccount", () => {
+  (0, import_vitest.it)("returns null when all conditions are met", () => {
+    const result = (0, import_validate_open_account.validateOpenAccount)({
+      debt: 50000n,
+      creditManager: mockCreditManager,
+      desiredQuota: {},
+      quotaUpdate: []
+    });
+    (0, import_vitest.expect)(result).toBeNull();
+  });
+  (0, import_vitest.it)("returns loading error when loading is true", () => {
+    const result = (0, import_validate_open_account.validateOpenAccount)({
+      debt: 50000n,
+      creditManager: mockCreditManager,
+      desiredQuota: {},
+      quotaUpdate: [],
+      loading: true
+    });
+    (0, import_vitest.expect)(result).toEqual({ message: "loading" });
+  });
+  (0, import_vitest.it)("returns error when debt is less than min", () => {
+    const result = (0, import_validate_open_account.validateOpenAccount)({
+      debt: 500n,
+      creditManager: mockCreditManager,
+      desiredQuota: {},
+      quotaUpdate: []
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      message: "amountLessMin",
+      amount: 1000n
+    });
+  });
+  (0, import_vitest.it)("returns error when debt is greater than max", () => {
+    const result = (0, import_validate_open_account.validateOpenAccount)({
+      debt: 2000000n,
+      creditManager: mockCreditManager,
+      desiredQuota: {},
+      quotaUpdate: []
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      message: "debtGreaterMax",
+      amount: 1000000n
+    });
+  });
+});

package/dist/cjs/common-utils/utils/validation/validate-quota.js

@@ -0,0 +1,49 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var validate_quota_exports = {};
+__export(validate_quota_exports, {
+  validateQuota: () => validateQuota
+});
+module.exports = __toCommonJS(validate_quota_exports);
+function validateQuota(props) {
+  const desiredQuotasList = Object.values(props.desiredQuota).filter(
+    (a) => a.balance > 0n
+  );
+  if (desiredQuotasList.length > props.creditManager.maxEnabledTokensLength)
+    return {
+      message: "maxQuotasLengthReached",
+      count: desiredQuotasList.length,
+      max: props.creditManager.maxEnabledTokensLength
+    };
+  if (props.quotaUpdate.length === 0 && props.throwOnZeroQuotaUpdate)
+    return { message: "quotaShouldBeUpdated" };
+  for (const { token, balance: updateBy } of props.quotaUpdate) {
+    const quota = props.creditManager.quotas[token];
+    if (updateBy > 0 && quota) {
+      const realLimit = quota.isActive ? quota.limit : 0n;
+      const quotaLeft = realLimit - quota.totalQuoted;
+      if (quotaLeft < updateBy) return { message: "insufficientQuota", token };
+    }
+  }
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  validateQuota
+});

package/dist/cjs/common-utils/utils/validation/validate-quota.spec.js

@@ -0,0 +1,79 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_test_utils = require("../../test-utils/index.js");
+var import_validate_quota = require("./validate-quota.js");
+const mockCreditManager = (0, import_test_utils.buildCreditManager)({
+  minDebt: 1000n,
+  maxDebt: 1000000n,
+  totalDebtLimit: 5000000n,
+  totalDebt: 2000000n,
+  availableToBorrow: 3000000n,
+  quotas: {
+    [import_test_utils.mockToken1]: (0, import_test_utils.buildQuota)({
+      token: import_test_utils.mockToken1,
+      limit: 1000000n,
+      totalQuoted: 500000n,
+      rate: 0n
+    }),
+    [import_test_utils.mockToken2]: (0, import_test_utils.buildQuota)({
+      token: import_test_utils.mockToken2,
+      limit: 2000000n,
+      totalQuoted: 1000000n,
+      rate: 0n
+    })
+  },
+  maxEnabledTokensLength: 2
+});
+(0, import_vitest.describe)("validateQuota", () => {
+  (0, import_vitest.it)("returns null when all conditions are met", () => {
+    const result = (0, import_validate_quota.validateQuota)({
+      desiredQuota: {},
+      quotaUpdate: [],
+      creditManager: mockCreditManager,
+      throwOnZeroQuotaUpdate: false
+    });
+    (0, import_vitest.expect)(result).toBeNull();
+  });
+  (0, import_vitest.it)("returns error when max quotas length is reached", () => {
+    const result = (0, import_validate_quota.validateQuota)({
+      desiredQuota: {
+        [import_test_utils.mockToken1]: { token: import_test_utils.mockToken1, balance: 1000n },
+        [import_test_utils.mockToken2]: { token: import_test_utils.mockToken2, balance: 1000n }
+      },
+      quotaUpdate: [],
+      creditManager: (0, import_test_utils.buildCreditManager)({
+        ...mockCreditManager,
+        maxEnabledTokensLength: 1
+      }),
+      throwOnZeroQuotaUpdate: false
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      message: "maxQuotasLengthReached",
+      count: 2,
+      max: 1
+    });
+  });
+  (0, import_vitest.it)("returns error when quota update is empty and throwOnZeroQuotaUpdate is true", () => {
+    const result = (0, import_validate_quota.validateQuota)({
+      desiredQuota: {},
+      quotaUpdate: [],
+      creditManager: mockCreditManager,
+      throwOnZeroQuotaUpdate: true
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      message: "quotaShouldBeUpdated"
+    });
+  });
+  (0, import_vitest.it)("returns error when quota is insufficient", () => {
+    const result = (0, import_validate_quota.validateQuota)({
+      desiredQuota: {},
+      quotaUpdate: [{ token: import_test_utils.mockToken1, balance: 600000n }],
+      creditManager: mockCreditManager,
+      throwOnZeroQuotaUpdate: false
+    });
+    (0, import_vitest.expect)(result).toEqual({
+      message: "insufficientQuota",
+      token: import_test_utils.mockToken1
+    });
+  });
+});

package/dist/cjs/common-utils/utils/validation/validate-token-to-obtain.js

@@ -0,0 +1,42 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var validate_token_to_obtain_exports = {};
+__export(validate_token_to_obtain_exports, {
+  validateTokenToObtain: () => validateTokenToObtain
+});
+module.exports = __toCommonJS(validate_token_to_obtain_exports);
+function validateTokenToObtain({
+  creditManager,
+  targetToken
+}) {
+  if (Array.isArray(targetToken)) {
+    for (const asset of targetToken) {
+      if (creditManager.forbiddenTokens[asset.token])
+        return { message: "tokenIsForbidden", token: asset.token };
+    }
+    return null;
+  }
+  if (targetToken !== null && creditManager.forbiddenTokens[targetToken])
+    return { message: "tokenIsForbidden", token: targetToken };
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  validateTokenToObtain
+});

package/dist/cjs/common-utils/utils/validation/validate-token-to-obtain.spec.js

@@ -0,0 +1,35 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_test_utils = require("../../test-utils/index.js");
+var import_validate_token_to_obtain = require("./validate-token-to-obtain.js");
+const mockCreditManager = (0, import_test_utils.buildCreditManager)({
+  forbiddenTokens: {}
+});
+(0, import_vitest.describe)("validateTokenToObtain", () => {
+  (0, import_vitest.it)("returns null when targetToken is null", () => {
+    const result = (0, import_validate_token_to_obtain.validateTokenToObtain)({
+      targetToken: null,
+      creditManager: mockCreditManager
+    });
+    (0, import_vitest.expect)(result).toBeNull();
+  });
+  (0, import_vitest.it)("returns null when targetToken is not forbidden", () => {
+    const result = (0, import_validate_token_to_obtain.validateTokenToObtain)({
+      targetToken: import_test_utils.mockToken1,
+      creditManager: mockCreditManager
+    });
+    (0, import_vitest.expect)(result).toBeNull();
+  });
+  (0, import_vitest.it)("returns error when targetToken is forbidden", () => {
+    const result = (0, import_validate_token_to_obtain.validateTokenToObtain)({
+      targetToken: import_test_utils.mockToken1,
+      creditManager: (0, import_test_utils.buildCreditManager)({
+        ...mockCreditManager,
+        forbiddenTokens: {
+          [import_test_utils.mockToken1]: true
+        }
+      })
+    });
+    (0, import_vitest.expect)(result).toEqual({ message: "tokenIsForbidden", token: import_test_utils.mockToken1 });
+  });
+});

package/dist/cjs/common-utils/utils/validation/validation-types.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var validation_types_exports = {};
+module.exports = __toCommonJS(validation_types_exports);

package/dist/cjs/sdk/constants/math.js

@@ -25,6 +25,7 @@ __export(math_exports, {
   MIN_INT96: () => MIN_INT96,
   PERCENTAGE_DECIMALS: () => PERCENTAGE_DECIMALS,
   PERCENTAGE_FACTOR: () => PERCENTAGE_FACTOR,
+  PERCENTAGE_FACTOR_1KK: () => PERCENTAGE_FACTOR_1KK,
   PRICE_DECIMALS: () => PRICE_DECIMALS,
   PRICE_DECIMALS_POW: () => PRICE_DECIMALS_POW,
   RAY: () => RAY,
@@ -52,6 +53,7 @@ const PRICE_DECIMALS = 10n ** BigInt(PRICE_DECIMALS_POW);
 const SECONDS_PER_YEAR = 365 * 24 * 3600;
 const PERCENTAGE_DECIMALS = 100n;
 const PERCENTAGE_FACTOR = 10000n;
+const PERCENTAGE_FACTOR_1KK = PERCENTAGE_FACTOR * PERCENTAGE_DECIMALS;
 const LEVERAGE_DECIMALS = 100n;
 const SLIPPAGE_DECIMALS = 100n;
 // Annotate the CommonJS export names for ESM import in node:
@@ -63,6 +65,7 @@ const SLIPPAGE_DECIMALS = 100n;
   MIN_INT96,
   PERCENTAGE_DECIMALS,
   PERCENTAGE_FACTOR,
+  PERCENTAGE_FACTOR_1KK,
   PRICE_DECIMALS,
   PRICE_DECIMALS_POW,
   RAY,