@gearbox-protocol/sdk 15.0.0-next.2 → 15.0.0-pyth.1

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

package/dist/esm/dev/AccountOpener.js

@@ -490,10 +490,10 @@ class AccountOpener extends SDKConstruct {
       );
       txHash = await this.#anvil.writeContract({
         account: depositor,
-        address: metadata.approveTarget,
+        address: underlying,
         abi: ierc20Abi,
         functionName: "approve",
-        args: [address, allowance],
+        args: [metadata.approveTarget, allowance],
         chain: this.#anvil.chain
       });
       let receipt = await this.#anvil.waitForTransactionReceipt({
@@ -516,12 +516,11 @@ class AccountOpener extends SDKConstruct {
       if (!depositCall) {
         throw new Error(`no deposit call could be created for ${poolName}`);
       }
-      txHash = await this.#anvil.writeContract({
+      txHash = await this.#anvil.sendTransaction({
         account: depositor,
-        address: depositCall.target,
-        abi: depositCall.abi,
-        functionName: depositCall.functionName,
-        args: depositCall.args,
+        to: depositCall.tx.to,
+        data: depositCall.tx.callData,
+        value: BigInt(depositCall.tx.value ?? "0"),
         chain: this.#anvil.chain
       });
       receipt = await this.#anvil.waitForTransactionReceipt({ hash: txHash });