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

package/dist/cjs/common-utils/utils/strategies/tokens/is-apy-with-points-exception.js

@@ -0,0 +1,36 @@
+"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 is_apy_with_points_exception_exports = {};
+__export(is_apy_with_points_exception_exports, {
+  RST_ETH_ADDRESS: () => RST_ETH_ADDRESS,
+  isApyWithPointsException: () => isApyWithPointsException
+});
+module.exports = __toCommonJS(is_apy_with_points_exception_exports);
+const RST_ETH_ADDRESS = "0x7a4EffD87C2f3C55CA251080b1343b605f327E3a".toLowerCase();
+const SHOW_APY_FOR_TOKENS_WITH_POINTS = {
+  [RST_ETH_ADDRESS]: RST_ETH_ADDRESS
+};
+function isApyWithPointsException(token) {
+  return !!SHOW_APY_FOR_TOKENS_WITH_POINTS[(token || "").toLowerCase()];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RST_ETH_ADDRESS,
+  isApyWithPointsException
+});

package/dist/cjs/common-utils/utils/strategies/tokens/is-collateral-token.js

@@ -0,0 +1,59 @@
+"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 is_collateral_token_exports = {};
+__export(is_collateral_token_exports, {
+  isCollateralToken: () => isCollateralToken
+});
+module.exports = __toCommonJS(is_collateral_token_exports);
+var import_is_obtainable_token = require("./is-obtainable-token.js");
+var import_is_valid_extra_collateral_token = require("./is-valid-extra-collateral-token.js");
+function isCollateralToken({
+  address,
+  tokensList,
+  creditManager,
+  zeroDebt = false,
+  delayedPhantoms,
+  extraCollateralConfigs,
+  prices
+}) {
+  if (creditManager && address === creditManager.underlyingToken) return true;
+  if (zeroDebt && creditManager) return false;
+  const token = tokensList[address];
+  const cmCheckPassed = (0, import_is_obtainable_token.isObtainableToken)({
+    address,
+    creditManager,
+    delayedPhantoms
+  });
+  const { isPhantom = false } = token || {};
+  const allowedAsMain = !isPhantom && cmCheckPassed;
+  const allowedAsExtra = (0, import_is_valid_extra_collateral_token.isValidExtraCollateralToken)({
+    address,
+    extraCollateralConfigs,
+    creditManager,
+    delayedPhantoms,
+    tokensList,
+    zeroDebt,
+    prices
+  });
+  return allowedAsMain || allowedAsExtra;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isCollateralToken
+});

package/dist/cjs/common-utils/utils/strategies/tokens/is-collateral-token.spec.js

@@ -0,0 +1,135 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_test_utils = require("../../../test-utils/index.js");
+var import_is_collateral_token = require("./is-collateral-token.js");
+const buildAllPrices = (_, token, value = 100n) => {
+  return {
+    [token]: value
+  };
+};
+(0, import_vitest.describe)("isCollateralToken", () => {
+  const underlying = "0xunderlying";
+  const token = "0xtoken";
+  const tokensList = {
+    [token]: (0, import_test_utils.buildTokenData)(token, "TOKEN")
+  };
+  const baseCM = (0, import_test_utils.buildCreditManager)({
+    underlyingToken: underlying,
+    quotas: {}
+  });
+  (0, import_vitest.it)("returns true for underlying token", () => {
+    const result = (0, import_is_collateral_token.isCollateralToken)({
+      address: underlying,
+      tokensList,
+      creditManager: baseCM,
+      zeroDebt: false,
+      delayedPhantoms: {},
+      extraCollateralConfigs: void 0,
+      prices: void 0
+    });
+    (0, import_vitest.expect)(result).toBe(true);
+  });
+  (0, import_vitest.it)("returns false when zeroDebt is true", () => {
+    const result = (0, import_is_collateral_token.isCollateralToken)({
+      address: token,
+      tokensList,
+      creditManager: baseCM,
+      zeroDebt: true,
+      delayedPhantoms: {},
+      extraCollateralConfigs: void 0,
+      prices: void 0
+    });
+    (0, import_vitest.expect)(result).toBe(false);
+  });
+  (0, import_vitest.it)("returns false when cm check fails", () => {
+    const result = (0, import_is_collateral_token.isCollateralToken)({
+      address: token,
+      tokensList,
+      creditManager: baseCM,
+      zeroDebt: false,
+      delayedPhantoms: {},
+      extraCollateralConfigs: void 0,
+      prices: void 0
+    });
+    (0, import_vitest.expect)(result).toBe(false);
+  });
+  (0, import_vitest.it)("returns true when not obtainable but listed as extra collateral for cm and has price", () => {
+    const result = (0, import_is_collateral_token.isCollateralToken)({
+      address: token,
+      tokensList,
+      creditManager: baseCM,
+      zeroDebt: false,
+      delayedPhantoms: {},
+      extraCollateralConfigs: [{ token, cm: baseCM.address }],
+      prices: buildAllPrices(baseCM, token)
+    });
+    (0, import_vitest.expect)(result).toBe(true);
+  });
+  (0, import_vitest.it)("returns false when not obtainable but listed as extra collateral for cm and has no price", () => {
+    const zeroPriceResult = (0, import_is_collateral_token.isCollateralToken)({
+      address: token,
+      tokensList,
+      creditManager: baseCM,
+      zeroDebt: false,
+      delayedPhantoms: {},
+      extraCollateralConfigs: [{ token, cm: baseCM.address }],
+      prices: buildAllPrices(baseCM, token, 0n)
+    });
+    (0, import_vitest.expect)(zeroPriceResult).toBe(false);
+    const undefinedPriceResult = (0, import_is_collateral_token.isCollateralToken)({
+      address: token,
+      tokensList,
+      creditManager: baseCM,
+      zeroDebt: false,
+      delayedPhantoms: {},
+      extraCollateralConfigs: [{ token, cm: baseCM.address }],
+      prices: void 0
+    });
+    (0, import_vitest.expect)(undefinedPriceResult).toBe(false);
+  });
+  (0, import_vitest.it)("returns false when extra collateral config targets different credit manager", () => {
+    const result = (0, import_is_collateral_token.isCollateralToken)({
+      address: token,
+      tokensList,
+      creditManager: baseCM,
+      zeroDebt: false,
+      delayedPhantoms: {},
+      extraCollateralConfigs: [{ token, cm: "0xother" }],
+      prices: buildAllPrices(baseCM, token)
+    });
+    (0, import_vitest.expect)(result).toBe(false);
+  });
+  (0, import_vitest.it)("returns false when token is phantom", () => {
+    const phantomTokenList = {
+      [token]: (0, import_test_utils.buildTokenData)(token, "TOKEN", 18, true)
+    };
+    const result = (0, import_is_collateral_token.isCollateralToken)({
+      address: token,
+      tokensList: phantomTokenList,
+      creditManager: baseCM,
+      zeroDebt: false,
+      delayedPhantoms: {},
+      extraCollateralConfigs: void 0,
+      prices: void 0
+    });
+    (0, import_vitest.expect)(result).toBe(false);
+  });
+  (0, import_vitest.it)("returns true when obtainable, non-phantom, not underlying", () => {
+    const cmWithSupportedToken = (0, import_test_utils.buildCreditManager)({
+      underlyingToken: underlying,
+      supportedTokens: { [token]: true },
+      liquidationThresholds: { [token]: 8000n },
+      quotas: {}
+    });
+    const result = (0, import_is_collateral_token.isCollateralToken)({
+      address: token,
+      tokensList,
+      creditManager: cmWithSupportedToken,
+      zeroDebt: false,
+      delayedPhantoms: {},
+      extraCollateralConfigs: void 0,
+      prices: void 0
+    });
+    (0, import_vitest.expect)(result).toBe(true);
+  });
+});

package/dist/cjs/common-utils/utils/strategies/tokens/is-obtainable-token.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 is_obtainable_token_exports = {};
+__export(is_obtainable_token_exports, {
+  isObtainableToken: () => isObtainableToken
+});
+module.exports = __toCommonJS(is_obtainable_token_exports);
+var import_is_usable_token = require("../../strategies/tokens/is-usable-token.js");
+function isObtainableToken({
+  address,
+  creditManager,
+  delayedPhantoms
+}) {
+  const {
+    isActive,
+    limit = 0n,
+    totalQuoted = 0n
+  } = creditManager.quotas[address] || {};
+  const realLimit = isActive ? limit || 0n : 0n;
+  const quotaLeft = realLimit - totalQuoted;
+  return (creditManager.isQuoted(address) ? quotaLeft > 0 : true) && (0, import_is_usable_token.isUsableToken)({ address, creditManager }) && !delayedPhantoms[address];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isObtainableToken
+});

package/dist/cjs/common-utils/utils/strategies/tokens/is-obtainable-token.spec.js

@@ -0,0 +1,162 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_test_utils = require("../../../test-utils/index.js");
+var import_is_usable_token = require("../../strategies/tokens/is-usable-token.js");
+var import_is_obtainable_token = require("./is-obtainable-token.js");
+import_vitest.vi.mock("../../utils/strategies/tokens/is-usable-token.js", async () => {
+  const actual = await import_vitest.vi.importActual(
+    "../../utils/strategies/tokens/is-usable-token.js"
+  );
+  return {
+    ...actual,
+    isUsableToken: import_vitest.vi.fn(
+      actual.isUsableToken
+    )
+  };
+});
+const mockIsUsableToken = import_vitest.vi.mocked(import_is_usable_token.isUsableToken);
+(0, import_vitest.describe)("isObtainableToken", () => {
+  const tokenAddr = "0xtoken";
+  (0, import_vitest.beforeEach)(async () => {
+    mockIsUsableToken.mockReset();
+    const actual = await import_vitest.vi.importActual(
+      "../../utils/strategies/tokens/is-usable-token.js"
+    );
+    mockIsUsableToken.mockImplementation(
+      actual.isUsableToken
+    );
+  });
+  (0, import_vitest.it)("returns true when usable, not delayed phantom, and quota has room", () => {
+    const cm = (0, import_test_utils.buildCreditManager)({
+      quotas: {
+        [tokenAddr]: {
+          token: tokenAddr,
+          rate: 0n,
+          limit: 100n,
+          totalQuoted: 0n,
+          isActive: true,
+          quotaIncreaseFee: 0n
+        }
+      },
+      isQuoted: import_vitest.vi.fn().mockReturnValue(true)
+    });
+    mockIsUsableToken.mockReturnValue(true);
+    const result = (0, import_is_obtainable_token.isObtainableToken)({
+      address: tokenAddr,
+      creditManager: {
+        quotas: cm.quotas,
+        isQuoted: cm.isQuoted.bind(cm),
+        forbiddenTokens: cm.forbiddenTokens,
+        liquidationThresholds: cm.liquidationThresholds,
+        supportedTokens: cm.supportedTokens
+      },
+      delayedPhantoms: {}
+    });
+    (0, import_vitest.expect)(cm.isQuoted).toHaveBeenCalledWith(tokenAddr);
+    (0, import_vitest.expect)(result).toBe(true);
+  });
+  (0, import_vitest.it)("returns true when usable, not delayed phantom, and not quoted", () => {
+    const cm = (0, import_test_utils.buildCreditManager)({
+      quotas: {},
+      isQuoted: import_vitest.vi.fn().mockReturnValue(false)
+    });
+    mockIsUsableToken.mockReturnValue(true);
+    const result = (0, import_is_obtainable_token.isObtainableToken)({
+      address: tokenAddr,
+      creditManager: {
+        quotas: cm.quotas,
+        isQuoted: cm.isQuoted.bind(cm),
+        forbiddenTokens: cm.forbiddenTokens,
+        liquidationThresholds: cm.liquidationThresholds,
+        supportedTokens: cm.supportedTokens
+      },
+      delayedPhantoms: {}
+    });
+    (0, import_vitest.expect)(cm.isQuoted).toHaveBeenCalledWith(tokenAddr);
+    (0, import_vitest.expect)(result).toBe(true);
+  });
+  (0, import_vitest.it)("returns false when isUsableToken is false", () => {
+    const cm = (0, import_test_utils.buildCreditManager)({
+      quotas: {
+        [tokenAddr]: {
+          token: tokenAddr,
+          rate: 0n,
+          limit: 100n,
+          totalQuoted: 0n,
+          isActive: true,
+          quotaIncreaseFee: 0n
+        }
+      },
+      isQuoted: import_vitest.vi.fn().mockReturnValue(true)
+    });
+    mockIsUsableToken.mockReturnValue(false);
+    const result = (0, import_is_obtainable_token.isObtainableToken)({
+      address: tokenAddr,
+      creditManager: {
+        quotas: cm.quotas,
+        isQuoted: cm.isQuoted.bind(cm),
+        forbiddenTokens: cm.forbiddenTokens,
+        liquidationThresholds: cm.liquidationThresholds,
+        supportedTokens: cm.supportedTokens
+      },
+      delayedPhantoms: {}
+    });
+    (0, import_vitest.expect)(result).toBe(false);
+  });
+  (0, import_vitest.it)("returns false when quotaLeft is zero or negative", () => {
+    const cm = (0, import_test_utils.buildCreditManager)({
+      quotas: {
+        [tokenAddr]: {
+          token: tokenAddr,
+          rate: 0n,
+          limit: 0n,
+          totalQuoted: 10n,
+          isActive: true,
+          quotaIncreaseFee: 0n
+        }
+      },
+      isQuoted: import_vitest.vi.fn().mockReturnValue(true)
+    });
+    mockIsUsableToken.mockReturnValue(true);
+    const result = (0, import_is_obtainable_token.isObtainableToken)({
+      address: tokenAddr,
+      creditManager: {
+        quotas: cm.quotas,
+        isQuoted: cm.isQuoted.bind(cm),
+        forbiddenTokens: cm.forbiddenTokens,
+        liquidationThresholds: cm.liquidationThresholds,
+        supportedTokens: cm.supportedTokens
+      },
+      delayedPhantoms: {}
+    });
+    (0, import_vitest.expect)(result).toBe(false);
+  });
+  (0, import_vitest.it)("returns false when token is delayed phantom", () => {
+    const cm = (0, import_test_utils.buildCreditManager)({
+      quotas: {
+        [tokenAddr]: {
+          token: tokenAddr,
+          rate: 0n,
+          limit: 100n,
+          totalQuoted: 0n,
+          isActive: true,
+          quotaIncreaseFee: 0n
+        }
+      },
+      isQuoted: import_vitest.vi.fn().mockReturnValue(true)
+    });
+    mockIsUsableToken.mockReturnValue(true);
+    const result = (0, import_is_obtainable_token.isObtainableToken)({
+      address: tokenAddr,
+      creditManager: {
+        quotas: cm.quotas,
+        isQuoted: cm.isQuoted.bind(cm),
+        forbiddenTokens: cm.forbiddenTokens,
+        liquidationThresholds: cm.liquidationThresholds,
+        supportedTokens: cm.supportedTokens
+      },
+      delayedPhantoms: { [tokenAddr]: true }
+    });
+    (0, import_vitest.expect)(result).toBe(false);
+  });
+});

package/dist/cjs/common-utils/utils/strategies/tokens/is-valid-extra-collateral-token.js

@@ -0,0 +1,51 @@
+"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 is_valid_extra_collateral_token_exports = {};
+__export(is_valid_extra_collateral_token_exports, {
+  isValidExtraCollateralToken: () => isValidExtraCollateralToken
+});
+module.exports = __toCommonJS(is_valid_extra_collateral_token_exports);
+var import_is_forbidden_token = require("../../strategies/tokens/is-forbidden-token.js");
+function isValidExtraCollateralToken({
+  address,
+  extraCollateralConfigs,
+  prices,
+  creditManager,
+  tokensList,
+  delayedPhantoms,
+  zeroDebt
+}) {
+  if (!extraCollateralConfigs || extraCollateralConfigs.length === 0 || !prices || !creditManager)
+    return false;
+  if (creditManager && address === creditManager.underlyingToken) return true;
+  if (zeroDebt && creditManager) return false;
+  const forbidden = (0, import_is_forbidden_token.isForbiddenToken)({ address, creditManager });
+  const delayed = !!delayedPhantoms[address];
+  const { isPhantom = false } = tokensList[address] || {};
+  const isCMValid = extraCollateralConfigs.some((config) => {
+    const targetCM = typeof config === "string" ? creditManager.address : config.cm;
+    const price = prices?.[address] || 0n;
+    return targetCM === creditManager.address && price > 0n;
+  });
+  return !isPhantom && !forbidden && !delayed && isCMValid;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isValidExtraCollateralToken
+});

package/dist/cjs/common-utils/utils/strategies/tokens/wrap-token-address.js

@@ -0,0 +1,33 @@
+"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 wrap_token_address_exports = {};
+__export(wrap_token_address_exports, {
+  wrapTokenAddress: () => wrapTokenAddress
+});
+module.exports = __toCommonJS(wrap_token_address_exports);
+function wrapTokenAddress(tokenAddress, nativeTokenAddress, wrappedNativeTokenAddress) {
+  if (wrappedNativeTokenAddress && tokenAddress === nativeTokenAddress) {
+    return wrappedNativeTokenAddress;
+  }
+  return tokenAddress;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  wrapTokenAddress
+});

package/dist/cjs/common-utils/utils/strategies/tokens/wrap-token-address.spec.js

@@ -0,0 +1,13 @@
+"use strict";
+var import_vitest = require("vitest");
+var import_wrap_token_address = require("./wrap-token-address.js");
+(0, import_vitest.describe)("wrapTokenAddress", () => {
+  const native = "0xeeee";
+  const wrapped = "0xweth";
+  (0, import_vitest.it)("returns wrapped when token matches native", () => {
+    (0, import_vitest.expect)((0, import_wrap_token_address.wrapTokenAddress)(native, native, wrapped)).toBe(wrapped);
+  });
+  (0, import_vitest.it)("returns token when it does not match native", () => {
+    (0, import_vitest.expect)((0, import_wrap_token_address.wrapTokenAddress)("0xother", native, wrapped)).toBe("0xother");
+  });
+});

package/dist/cjs/common-utils/utils/strategies/types/index.js

@@ -23,7 +23,9 @@ __reExport(types_exports, require("./points-slices.js"), module.exports);
 __reExport(types_exports, require("./sdk-state.js"), module.exports);
 __reExport(types_exports, require("./strategies-cm-list.js"), module.exports);
 __reExport(types_exports, require("./strategy.js"), module.exports);
+__reExport(types_exports, require("./strategy-data.js"), module.exports);
 __reExport(types_exports, require("./strategy-data-source.js"), module.exports);
+__reExport(types_exports, require("./strategy-earnings.js"), module.exports);
 __reExport(types_exports, require("./targetable.js"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -35,6 +37,8 @@ __reExport(types_exports, require("./targetable.js"), module.exports);
   ...require("./sdk-state.js"),
   ...require("./strategies-cm-list.js"),
   ...require("./strategy.js"),
+  ...require("./strategy-data.js"),
   ...require("./strategy-data-source.js"),
+  ...require("./strategy-earnings.js"),
   ...require("./targetable.js")
 });

package/dist/cjs/common-utils/utils/strategies/types/strategy-data.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 strategy_data_exports = {};
+module.exports = __toCommonJS(strategy_data_exports);

package/dist/cjs/common-utils/utils/strategies/types/strategy-earnings.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 strategy_earnings_exports = {};
+module.exports = __toCommonJS(strategy_earnings_exports);

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

@@ -0,0 +1,38 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var validation_exports = {};
+module.exports = __toCommonJS(validation_exports);
+__reExport(validation_exports, require("./is-zero-balance.js"), module.exports);
+__reExport(validation_exports, require("./validate-balance.js"), module.exports);
+__reExport(validation_exports, require("./validate-balances.js"), module.exports);
+__reExport(validation_exports, require("./validate-credit-manager.js"), module.exports);
+__reExport(validation_exports, require("./validate-hf.js"), module.exports);
+__reExport(validation_exports, require("./validate-open-account.js"), module.exports);
+__reExport(validation_exports, require("./validate-quota.js"), module.exports);
+__reExport(validation_exports, require("./validate-token-to-obtain.js"), module.exports);
+__reExport(validation_exports, require("./validation-types.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./is-zero-balance.js"),
+  ...require("./validate-balance.js"),
+  ...require("./validate-balances.js"),
+  ...require("./validate-credit-manager.js"),
+  ...require("./validate-hf.js"),
+  ...require("./validate-open-account.js"),
+  ...require("./validate-quota.js"),
+  ...require("./validate-token-to-obtain.js"),
+  ...require("./validation-types.js")
+});

package/dist/cjs/common-utils/utils/validation/is-zero-balance.js

@@ -0,0 +1,30 @@
+"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 is_zero_balance_exports = {};
+__export(is_zero_balance_exports, {
+  isZeroBalance: () => isZeroBalance
+});
+module.exports = __toCommonJS(is_zero_balance_exports);
+function isZeroBalance(balance) {
+  return (balance ?? 0n) <= 10n;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isZeroBalance
+});