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

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/validation/validate-open-account-pool-quota-status.js

@@ -0,0 +1,13 @@
+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;
+}
+export {
+  validateOpenAccountPoolQuotaStatus
+};

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();
+  });
+});

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

@@ -0,0 +1,54 @@
+import { BigIntMath } from "../bigint-math.js";
+import {
+  validateOpenAccountPoolQuotaStatus
+} from "./validate-open-account-pool-quota-status.js";
+function validateOpenAccountPoolStatus(props) {
+  const { debt, creditManager, pool, targetToken } = props;
+  const effectiveDebt = BigIntMath.max(creditManager.minDebt, debt);
+  const hasDebtLimit = creditManager.totalDebtLimit >= 0n;
+  const debtLimitLeft = 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 = BigIntMath.min(
+    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 = validateOpenAccountPoolQuotaStatus(
+      targetToken,
+      creditManager,
+      effectiveDebt
+    );
+    if (quotaError) return quotaError;
+  }
+  return null;
+}
+export {
+  validateOpenAccountPoolStatus
+};

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

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

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

@@ -0,0 +1,17 @@
+import { validateQuota } from "./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 validateQuota(props);
+}
+export {
+  validateOpenAccount
+};

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

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

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

@@ -0,0 +1,25 @@
+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;
+}
+export {
+  validateQuota
+};

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

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

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

@@ -0,0 +1,18 @@
+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;
+}
+export {
+  validateTokenToObtain
+};

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

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