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

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

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

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

@@ -0,0 +1,18 @@
+import { isUsableToken } from "../../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) && isUsableToken({ address, creditManager }) && !delayedPhantoms[address];
+}
+export {
+  isObtainableToken
+};

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

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

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

@@ -0,0 +1,27 @@
+import { isForbiddenToken } from "../../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 = 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;
+}
+export {
+  isValidExtraCollateralToken
+};

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

@@ -0,0 +1,9 @@
+function wrapTokenAddress(tokenAddress, nativeTokenAddress, wrappedNativeTokenAddress) {
+  if (wrappedNativeTokenAddress && tokenAddress === nativeTokenAddress) {
+    return wrappedNativeTokenAddress;
+  }
+  return tokenAddress;
+}
+export {
+  wrapTokenAddress
+};

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

@@ -0,0 +1,12 @@
+import { describe, expect, it } from "vitest";
+import { wrapTokenAddress } from "./wrap-token-address.js";
+describe("wrapTokenAddress", () => {
+  const native = "0xeeee";
+  const wrapped = "0xweth";
+  it("returns wrapped when token matches native", () => {
+    expect(wrapTokenAddress(native, native, wrapped)).toBe(wrapped);
+  });
+  it("returns token when it does not match native", () => {
+    expect(wrapTokenAddress("0xother", native, wrapped)).toBe("0xother");
+  });
+});

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

@@ -6,5 +6,7 @@ export * from "./points-slices.js";
 export * from "./sdk-state.js";
 export * from "./strategies-cm-list.js";
 export * from "./strategy.js";
+export * from "./strategy-data.js";
 export * from "./strategy-data-source.js";
+export * from "./strategy-earnings.js";
 export * from "./targetable.js";

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

@@ -0,0 +1,9 @@
+export * from "./is-zero-balance.js";
+export * from "./validate-balance.js";
+export * from "./validate-balances.js";
+export * from "./validate-credit-manager.js";
+export * from "./validate-hf.js";
+export * from "./validate-open-account.js";
+export * from "./validate-quota.js";
+export * from "./validate-token-to-obtain.js";
+export * from "./validation-types.js";

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

@@ -0,0 +1,6 @@
+function isZeroBalance(balance) {
+  return (balance ?? 0n) <= 10n;
+}
+export {
+  isZeroBalance
+};

package/dist/esm/common-utils/utils/validation/validate-balance.js

@@ -0,0 +1,23 @@
+import { EMPTY_ADDRESS } from "../constants.js";
+import { isZeroBalance } from "./is-zero-balance.js";
+function validateBalance({
+  amount,
+  tokenAddress,
+  maxAmount = 0n,
+  zeroCheck = true,
+  single
+}) {
+  const safeAddress = tokenAddress || EMPTY_ADDRESS;
+  if (!safeAddress) return { message: "unknownToken", token: safeAddress };
+  if (maxAmount < amount)
+    return { message: "insufficientFunds", token: safeAddress };
+  if (zeroCheck && isZeroBalance(amount))
+    return {
+      message: single ? "enterAmount" : "zeroBalance",
+      token: safeAddress
+    };
+  return null;
+}
+export {
+  validateBalance
+};

package/dist/esm/common-utils/utils/validation/validate-balance.spec.js

@@ -0,0 +1,51 @@
+import { describe, expect, it } from "vitest";
+import { mockToken1 } from "../../test-utils/index.js";
+import { validateBalance } from "./validate-balance.js";
+describe("validateBalance", () => {
+  it("returns null when all conditions are met", () => {
+    const result = validateBalance({
+      amount: 1000n,
+      tokenAddress: mockToken1,
+      maxAmount: 2000n,
+      zeroCheck: true,
+      single: false
+    });
+    expect(result).toBeNull();
+  });
+  it("returns error when amount exceeds maxAmount", () => {
+    const result = validateBalance({
+      amount: 3000n,
+      tokenAddress: mockToken1,
+      maxAmount: 2000n,
+      zeroCheck: true,
+      single: false
+    });
+    expect(result).toEqual({
+      message: "insufficientFunds",
+      token: mockToken1
+    });
+  });
+  it("returns error when amount is too small with zeroCheck", () => {
+    const result = validateBalance({
+      amount: 5n,
+      tokenAddress: mockToken1,
+      maxAmount: 2000n,
+      zeroCheck: true,
+      single: false
+    });
+    expect(result).toEqual({
+      message: "zeroBalance",
+      token: mockToken1
+    });
+  });
+  it("returns null when zeroCheck is false and amount is small", () => {
+    const result = validateBalance({
+      amount: 5n,
+      tokenAddress: mockToken1,
+      maxAmount: 2000n,
+      zeroCheck: false,
+      single: false
+    });
+    expect(result).toBeNull();
+  });
+});

package/dist/esm/common-utils/utils/validation/validate-balances.js

@@ -0,0 +1,20 @@
+import { validateBalance } from "./validate-balance.js";
+function validateBalances({
+  balances,
+  assets,
+  zeroCheck = true
+}) {
+  for (const { token: tokenAddress, balance: amount } of assets) {
+    const e = validateBalance({
+      tokenAddress,
+      amount,
+      maxAmount: balances[(tokenAddress || "").toLowerCase()] || 0n,
+      zeroCheck
+    });
+    if (e !== null) return e;
+  }
+  return null;
+}
+export {
+  validateBalances
+};

package/dist/esm/common-utils/utils/validation/validate-balances.spec.js

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import { mockToken1, mockToken2 } from "../../test-utils/index.js";
+import { validateBalances } from "./validate-balances.js";
+describe("validateBalances", () => {
+  it("returns null when all balances are valid", () => {
+    const result = validateBalances({
+      balances: {
+        [mockToken1]: 2000n,
+        [mockToken2]: 3000n
+      },
+      assets: [
+        { token: mockToken1, balance: 1000n },
+        { token: mockToken2, balance: 2000n }
+      ],
+      zeroCheck: true
+    });
+    expect(result).toBeNull();
+  });
+  it("returns error when any balance is invalid", () => {
+    const result = validateBalances({
+      balances: {
+        [mockToken1]: 500n,
+        [mockToken2]: 3000n
+      },
+      assets: [
+        { token: mockToken1, balance: 1000n },
+        { token: mockToken2, balance: 2000n }
+      ],
+      zeroCheck: true
+    });
+    expect(result).toEqual({
+      message: "insufficientFunds",
+      token: mockToken1
+    });
+  });
+});

package/dist/esm/common-utils/utils/validation/validate-credit-manager.js

@@ -0,0 +1,10 @@
+function validateCreditManager({
+  creditManager,
+  allowPausedCm
+}) {
+  if (creditManager.isPaused && !allowPausedCm) return { message: "paused" };
+  return null;
+}
+export {
+  validateCreditManager
+};

package/dist/esm/common-utils/utils/validation/validate-credit-manager.spec.js

@@ -0,0 +1,35 @@
+import { describe, expect, it } from "vitest";
+import { buildCreditManager } from "../../test-utils/index.js";
+import { validateCreditManager } from "./validate-credit-manager.js";
+const mockCreditManager = buildCreditManager({
+  isPaused: false
+});
+describe("validateCreditManager", () => {
+  it("returns null when credit manager is not paused", () => {
+    const result = validateCreditManager({
+      creditManager: mockCreditManager,
+      allowPausedCm: false
+    });
+    expect(result).toBeNull();
+  });
+  it("returns null when credit manager is paused but allowed", () => {
+    const result = validateCreditManager({
+      creditManager: buildCreditManager({
+        ...mockCreditManager,
+        isPaused: true
+      }),
+      allowPausedCm: true
+    });
+    expect(result).toBeNull();
+  });
+  it("returns error when credit manager is paused and not allowed", () => {
+    const result = validateCreditManager({
+      creditManager: buildCreditManager({
+        ...mockCreditManager,
+        isPaused: true
+      }),
+      allowPausedCm: false
+    });
+    expect(result).toEqual({ message: "paused" });
+  });
+});

package/dist/esm/common-utils/utils/validation/validate-hf.js

@@ -0,0 +1,13 @@
+const MIN_HF_LIMITED = 10100n;
+function validateHF({
+  hf,
+  hfCheck = true
+}) {
+  if (hfCheck && (hf === void 0 || hf <= MIN_HF_LIMITED))
+    return { message: "hfTooLow" };
+  return null;
+}
+export {
+  MIN_HF_LIMITED,
+  validateHF
+};

package/dist/esm/common-utils/utils/validation/validate-hf.spec.js

@@ -0,0 +1,23 @@
+import { describe, expect, it } from "vitest";
+import { MIN_HF_LIMITED, validateHF } from "./validate-hf.js";
+describe("validateHF", () => {
+  it("returns null when HF is above minimum", () => {
+    const result = validateHF({ hf: 15e3 });
+    expect(result).toBeNull();
+  });
+  it("returns error when HF is undefined", () => {
+    const result = validateHF({ hf: void 0 });
+    expect(result).toEqual({ message: "hfTooLow" });
+  });
+  it("returns error when HF is too low", () => {
+    const result = validateHF({ hf: Number(MIN_HF_LIMITED) });
+    expect(result).toEqual({ message: "hfTooLow" });
+  });
+  it("returns null when hfCheck is false and HF is too low", () => {
+    const result = validateHF({
+      hf: Number(MIN_HF_LIMITED - 1n),
+      hfCheck: false
+    });
+    expect(result).toBeNull();
+  });
+});

package/dist/esm/common-utils/utils/{strategies/availability → validation}/validate-open-account-pool-quota-status.js

@@ -4,10 +4,7 @@ function validateOpenAccountPoolQuotaStatus(targetToken, creditManager, amountTo
     const realLimit = quota.isActive ? quota.limit : 0n;
     const quotaLeft = realLimit - quota.totalQuoted;
     if (quotaLeft < amountToBorrow)
-      return {
-        message: "insufficientQuota",
-        token: targetToken
-      };
+      return { message: "insufficientQuota", token: targetToken };
   }
   return null;
 }

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

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