@gearbox-protocol/sdk 2.1.37 → 3.0.0-draft.2

package/lib/core/gaugeMath.spec.js

@@ -0,0 +1,388 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const chai_1 = require("chai");
+const gaugeMath_1 = require("./gaugeMath");
+describe("GaugeMath vote() test", () => {
+    it("with empty state and with no changes", () => {
+        const s = { available: 0n, voteCalls: [] };
+        const v = { state: s };
+        const r = gaugeMath_1.GaugeMath.vote(v);
+        const res = { ...s, voteCalls: [] };
+        (0, chai_1.expect)(r).to.be.eql(res);
+    });
+    it("remove with no prev vote", () => {
+        const s = { available: 0n, voteCalls: [] };
+        const v = { state: s, change: { type: "remove", amount: 10n } };
+        const r = gaugeMath_1.GaugeMath.vote(v);
+        const res = { ...s, voteCalls: [] };
+        (0, chai_1.expect)(r).to.be.eql(res);
+    });
+    it("remove with prev vote - more than available", () => {
+        const s = {
+            available: 0n,
+            vote: { type: "lower", amount: 5n },
+            voteCalls: [],
+        };
+        const v = { state: s, change: { type: "remove", amount: 10n } };
+        const r = gaugeMath_1.GaugeMath.vote(v);
+        const res = {
+            available: 5n,
+            vote: { type: "lower", amount: 0n },
+            voteCalls: [{ type: "remove", amount: 5n }],
+        };
+        (0, chai_1.expect)(r).to.be.eql(res);
+    });
+    it("remove with prev vote - eq than available", () => {
+        const s = {
+            available: 0n,
+            vote: { type: "lower", amount: 5n },
+            voteCalls: [],
+        };
+        const v = { state: s, change: { type: "remove", amount: 5n } };
+        const r = gaugeMath_1.GaugeMath.vote(v);
+        const res = {
+            available: 5n,
+            vote: { type: "lower", amount: 0n },
+            voteCalls: [{ type: "remove", amount: 5n }],
+        };
+        (0, chai_1.expect)(r).to.be.eql(res);
+    });
+    it("remove with prev vote - more than available", () => {
+        const s = {
+            available: 0n,
+            vote: { type: "lower", amount: 10n },
+            voteCalls: [],
+        };
+        const v = { state: s, change: { type: "remove", amount: 5n } };
+        const r = gaugeMath_1.GaugeMath.vote(v);
+        const res = {
+            available: 5n,
+            vote: { type: "lower", amount: 5n },
+            voteCalls: [{ type: "remove", amount: 5n }],
+        };
+        (0, chai_1.expect)(r).to.be.eql(res);
+    });
+    it("add to zero", () => {
+        const s = { available: 10n, voteCalls: [] };
+        const v = { state: s, change: { type: "lower", amount: 10n } };
+        const r = gaugeMath_1.GaugeMath.vote(v);
+        const res = {
+            available: 0n,
+            vote: { type: "lower", amount: 10n },
+            voteCalls: [{ type: "lower", amount: 10n }],
+        };
+        (0, chai_1.expect)(r).to.be.eql(res);
+    });
+    it("add to same type", () => {
+        const s = {
+            available: 10n,
+            vote: { type: "lower", amount: 5n },
+            voteCalls: [],
+        };
+        const v = { state: s, change: { type: "lower", amount: 10n } };
+        const r = gaugeMath_1.GaugeMath.vote(v);
+        const res = {
+            available: 0n,
+            vote: { type: "lower", amount: 15n },
+            voteCalls: [{ type: "lower", amount: 10n }],
+        };
+        (0, chai_1.expect)(r).to.be.eql(res);
+    });
+    it("add different type", () => {
+        const s = {
+            available: 10n,
+            vote: { type: "lower", amount: 10n },
+            voteCalls: [],
+        };
+        const v = { state: s, change: { type: "raise", amount: 5n } };
+        const r = gaugeMath_1.GaugeMath.vote(v);
+        const res = {
+            available: 15n,
+            vote: { type: "raise", amount: 5n },
+            voteCalls: [
+                { type: "remove", amount: 10n },
+                { type: "raise", amount: 5n },
+            ],
+        };
+        (0, chai_1.expect)(r).to.be.eql(res);
+    });
+    it("available can be negative after add", () => {
+        const s = {
+            available: 5n,
+            vote: { type: "lower", amount: 5n },
+            voteCalls: [],
+        };
+        const v = { state: s, change: { type: "raise", amount: 15n } };
+        const r = gaugeMath_1.GaugeMath.vote(v);
+        const res = {
+            available: -5n,
+            vote: { type: "raise", amount: 15n },
+            voteCalls: [
+                { type: "remove", amount: 5n },
+                { type: "raise", amount: 15n },
+            ],
+        };
+        (0, chai_1.expect)(r).to.be.eql(res);
+    });
+});
+describe("GaugeMath revertVote() test", () => {
+    it("if no votes before & after, should return initial amount", () => {
+        const initialBalance = 21n;
+        const r = gaugeMath_1.GaugeMath.revertVote({
+            balanceAfter: initialBalance,
+            nextVoteType: "lower",
+        });
+        (0, chai_1.expect)(r).to.be.eql(initialBalance);
+    });
+    it("if no vote after and next expected type is not changed, should return initial amount", () => {
+        const initialBalance = 27n;
+        const initialVote = {
+            type: "lower",
+            amount: 99n,
+        };
+        const r = gaugeMath_1.GaugeMath.revertVote({
+            balanceAfter: initialBalance,
+            initialVote,
+            nextVoteType: "lower",
+        });
+        (0, chai_1.expect)(r).to.be.eql(initialBalance);
+    });
+    it("if no vote after and next expected type is changed, should revert initial vote", () => {
+        const initialBalance = 27n;
+        const initialVote = {
+            type: "lower",
+            amount: 99n,
+        };
+        const r = gaugeMath_1.GaugeMath.revertVote({
+            balanceAfter: initialBalance,
+            initialVote,
+            nextVoteType: "raise",
+        });
+        (0, chai_1.expect)(r).to.be.eql(initialBalance + initialVote.amount);
+    });
+    it("if no vote before, should revert vote after", () => {
+        const initialBalance = 26n;
+        const voteBy = 5n;
+        const voteAfter = {
+            available: initialBalance - voteBy,
+            vote: { type: "lower", amount: voteBy },
+            voteCalls: [{ type: "lower", amount: voteBy }],
+        };
+        const balanceAfter = voteAfter.available;
+        const r = gaugeMath_1.GaugeMath.revertVote({
+            balanceAfter,
+            nextVoteType: "lower",
+            voteAfter: voteAfter,
+        });
+        (0, chai_1.expect)(r).to.be.eql(initialBalance);
+    });
+    it("if vote before type matches expected type, should revert vote after", () => {
+        const initialBalance = 10n;
+        const voteBy = 6n;
+        const initialVote = {
+            type: "lower",
+            amount: 20n,
+        };
+        const voteAfter = {
+            available: initialBalance - voteBy,
+            vote: { type: "lower", amount: initialVote.amount + voteBy },
+            voteCalls: [{ type: "lower", amount: voteBy }],
+        };
+        const balanceAfter = voteAfter.available;
+        const r = gaugeMath_1.GaugeMath.revertVote({
+            initialVote,
+            balanceAfter,
+            nextVoteType: "lower",
+            voteAfter: voteAfter,
+        });
+        (0, chai_1.expect)(r).to.be.eql(initialBalance);
+    });
+    it("if vote before type doesn't match expected type, should revert vote before", () => {
+        const initialBalance = 10n;
+        const voteBy = 20n;
+        const initialVote = {
+            type: "raise",
+            amount: 61n,
+        };
+        const voteAfter = {
+            available: initialBalance + initialVote.amount - voteBy,
+            vote: { type: "lower", amount: voteBy },
+            voteCalls: [
+                { type: "remove", amount: initialVote.amount },
+                { type: "lower", amount: voteBy },
+            ],
+        };
+        const r = gaugeMath_1.GaugeMath.revertVote({
+            initialVote,
+            balanceAfter: voteAfter.available,
+            nextVoteType: "lower",
+            voteAfter: voteAfter,
+        });
+        (0, chai_1.expect)(r).to.be.eql(initialBalance + initialVote.amount);
+    });
+    it("on remove, if vote before type matches expected type, should revert removal", () => {
+        const initialBalance = 100n;
+        const voteBy = 13n;
+        const initialVote = {
+            type: "lower",
+            amount: 30n,
+        };
+        const voteAfter = {
+            available: initialBalance + voteBy,
+            vote: { type: "lower", amount: initialVote.amount - voteBy },
+            voteCalls: [{ type: "remove", amount: voteBy }],
+        };
+        const r = gaugeMath_1.GaugeMath.revertVote({
+            initialVote,
+            balanceAfter: voteAfter.available,
+            nextVoteType: "lower",
+            voteAfter: voteAfter,
+        });
+        (0, chai_1.expect)(r).to.be.eql(initialBalance);
+    });
+    it("on remove, if vote before type doesn't match expected type, should revert vote before", () => {
+        const initialBalance = 100n;
+        const voteBy = 13n;
+        const initialVote = {
+            type: "raise",
+            amount: 30n,
+        };
+        const voteAfter = {
+            available: initialBalance + voteBy,
+            vote: { type: "raise", amount: initialVote.amount - voteBy },
+            voteCalls: [{ type: "remove", amount: voteBy }],
+        };
+        const r = gaugeMath_1.GaugeMath.revertVote({
+            initialVote,
+            balanceAfter: voteAfter.available,
+            nextVoteType: "lower",
+            voteAfter: voteAfter,
+        });
+        (0, chai_1.expect)(r).to.be.eql(initialBalance + initialVote.amount);
+    });
+});
+describe("GaugeMath getGaugeApy() test", () => {
+    it("should return null if no quota", () => {
+        const vote = { amount: 0n, type: "lower" };
+        const voteAfter = {
+            vote: { amount: 5n, type: "lower" },
+            voteCalls: [{ amount: 5n, type: "lower" }],
+        };
+        const r = gaugeMath_1.GaugeMath.getGaugeApy({
+            quota: undefined,
+            vote,
+            voteAfter,
+        });
+        (0, chai_1.expect)(r).to.be.eql(null);
+    });
+    it("should return min rate if total is zero", () => {
+        const quota = {
+            totalVotesCaSide: 0n,
+            totalVotesLpSide: 0n,
+            stakerVotesCaSide: 0n,
+            stakerVotesLpSide: 0n,
+            minRate: 12n,
+            maxRate: 12345n,
+        };
+        const r = gaugeMath_1.GaugeMath.getGaugeApy({
+            quota,
+        });
+        (0, chai_1.expect)(r).to.be.eql(12n);
+    });
+    it("should calculate quota without votes", () => {
+        const quota = {
+            totalVotesCaSide: 100n,
+            totalVotesLpSide: 100n,
+            stakerVotesCaSide: 10n,
+            stakerVotesLpSide: 0n,
+            minRate: 0n,
+            maxRate: 10000n,
+        };
+        const r = gaugeMath_1.GaugeMath.getGaugeApy({
+            quota,
+        });
+        (0, chai_1.expect)(r).to.be.eql(5000n);
+    });
+    it("should calculate quota with prev vote", () => {
+        const quota = {
+            totalVotesCaSide: 100n,
+            totalVotesLpSide: 100n,
+            stakerVotesCaSide: 10n,
+            stakerVotesLpSide: 0n,
+            minRate: 0n,
+            maxRate: 10000n,
+        };
+        const vote = { amount: 10n, type: "lower" };
+        const r = gaugeMath_1.GaugeMath.getGaugeApy({
+            quota,
+            vote,
+        });
+        (0, chai_1.expect)(r).to.be.eql(5000n);
+    });
+    it("should calculate quota with same vote increase", () => {
+        const quota = {
+            totalVotesCaSide: 100n,
+            totalVotesLpSide: 100n,
+            stakerVotesCaSide: 10n,
+            stakerVotesLpSide: 0n,
+            minRate: 0n,
+            maxRate: 10000n,
+        };
+        const vote = { amount: 10n, type: "lower" };
+        const voteAfter = {
+            vote: { amount: 20n, type: "lower" },
+            voteCalls: [{ amount: 10n, type: "lower" }],
+        };
+        const r = gaugeMath_1.GaugeMath.getGaugeApy({
+            quota,
+            vote,
+            voteAfter,
+        });
+        (0, chai_1.expect)(r).to.be.eql(4761n);
+    });
+    it("should calculate quota with different vote increase", () => {
+        const quota = {
+            totalVotesCaSide: 100n,
+            totalVotesLpSide: 100n,
+            stakerVotesCaSide: 20n,
+            stakerVotesLpSide: 0n,
+            minRate: 0n,
+            maxRate: 10000n,
+        };
+        const vote = { amount: 30n, type: "lower" };
+        const voteAfter = {
+            vote: { amount: 20n, type: "raise" },
+            voteCalls: [
+                { amount: 30n, type: "remove" },
+                { amount: 20n, type: "raise" },
+            ],
+        };
+        const r = gaugeMath_1.GaugeMath.getGaugeApy({
+            quota,
+            vote,
+            voteAfter,
+        });
+        (0, chai_1.expect)(r).to.be.eql(6315n);
+    });
+    it("should calculate quota with vote remove", () => {
+        const quota = {
+            totalVotesCaSide: 100n,
+            totalVotesLpSide: 100n,
+            stakerVotesCaSide: 20n,
+            stakerVotesLpSide: 0n,
+            minRate: 0n,
+            maxRate: 10000n,
+        };
+        const vote = { amount: 20n, type: "lower" };
+        const voteAfter = {
+            vote: { amount: 0n, type: "lower" },
+            voteCalls: [{ amount: 20n, type: "remove" }],
+        };
+        const r = gaugeMath_1.GaugeMath.getGaugeApy({
+            quota,
+            vote,
+            voteAfter,
+        });
+        (0, chai_1.expect)(r).to.be.eql(5555n);
+    });
+});

package/lib/core/pool.d.ts

@@ -0,0 +1,150 @@
+import { Address, PublicClient } from "viem";
+import { ChartsPoolDataPayload, LinearModel, PoolDataExtraPayload, PoolDataPayload, UserPoolPayload } from "../payload/pool";
+export type PoolType = "universal" | "trade" | "farm";
+export declare class PoolData {
+    readonly address: Address;
+    readonly type: PoolType;
+    readonly underlyingToken: Address;
+    readonly dieselToken: Address;
+    readonly stakedDieselToken: Array<Address>;
+    readonly stakedDieselToken_old: Array<Address>;
+    readonly isPaused: boolean;
+    readonly version: number;
+    readonly poolQuotaKeeper: Address;
+    readonly gauge: Address;
+    readonly name: string;
+    readonly symbol: string;
+    readonly expectedLiquidity: bigint;
+    readonly expectedLiquidityLimit: bigint;
+    readonly availableLiquidity: bigint;
+    readonly baseInterestIndex: bigint;
+    readonly utilization: number;
+    readonly totalBorrowed: bigint;
+    readonly totalDebtLimit: bigint;
+    readonly creditManagerDebtParams: Record<Address, {
+        creditManager: Address;
+        borrowed: bigint;
+        limit: bigint;
+        availableToBorrow: bigint;
+    }>;
+    readonly quotas: Record<Address, {
+        token: Address;
+        rate: bigint;
+        quotaIncreaseFee: bigint;
+        totalQuoted: bigint;
+        limit: bigint;
+        isActive: boolean;
+    }>;
+    readonly zappers: Record<Address, Record<Address, {
+        zapper: Address;
+        tokenIn: Address;
+        tokenOut: Address;
+    }>>;
+    readonly totalAssets: bigint;
+    readonly totalSupply: bigint;
+    readonly supplyAPY7D: number | undefined;
+    readonly depositAPY: number;
+    readonly borrowAPY: number;
+    readonly interestModel: LinearModel;
+    readonly dieselRate: number;
+    readonly dieselRateRay: bigint;
+    readonly withdrawFee: number;
+    readonly lastBaseInterestUpdate: bigint;
+    constructor(payload: PoolDataPayload, extra: PoolDataExtraPayload);
+    calculateBorrowRate({ provider, expectedLiquidity, availableLiquidity, }: CalculateBorrowRateProps): Promise<bigint>;
+    static getPoolType(name: string): PoolType;
+    static calculateUtilization(expected: bigint, available: bigint): number;
+}
+interface CalculateBorrowRateProps {
+    provider: PublicClient;
+    expectedLiquidity: bigint;
+    availableLiquidity: bigint;
+}
+export declare class ChartsPoolData {
+    readonly address: Address;
+    readonly underlyingToken: Address;
+    readonly dieselToken: Address;
+    readonly type: PoolType;
+    readonly version: number;
+    readonly name: string;
+    readonly addLiqCount: number;
+    readonly addedLiquidity: number;
+    readonly removeLiqCount: number;
+    readonly removedLiquidity: number;
+    readonly earned7D: number;
+    readonly earned7DInUSD: number;
+    readonly utilization: number;
+    readonly dieselRate: number;
+    readonly dieselRateRay: bigint;
+    readonly depositAPY: number;
+    readonly depositAPYRay: bigint;
+    readonly borrowAPY: number;
+    readonly borrowAPYRay: bigint;
+    readonly lmAPY: number;
+    readonly lmRewardAll: Array<{
+        apy: number;
+        token: Address;
+    }>;
+    readonly availableLiquidity: bigint;
+    readonly availableLiquidityChange: number;
+    readonly availableLiquidityInUSD: number;
+    readonly caLockedValue: number;
+    readonly caLockedValueChange: number;
+    readonly caLockedValueInUSD: number;
+    readonly expectedLiquidity: bigint;
+    readonly expectedLiquidityChange: number;
+    readonly expectedLiquidityInUSD: number;
+    readonly expectedLiqWeekAgo: number;
+    readonly expectedLiquidityLimit: bigint;
+    readonly expectedLiquidityLimitInUSD: number;
+    readonly totalBorrowed: bigint;
+    readonly totalBorrowedChange: number;
+    readonly totalBorrowedInUSD: number;
+    readonly debtWithInterest: bigint;
+    readonly debtWithInterestChange: number;
+    readonly debtWithInterestInUSD: number;
+    readonly debtWithInterestOld: bigint;
+    readonly oldAvailableLiquidity: bigint;
+    readonly oldCALockedValue: number;
+    readonly oldExpectedLiquidity: bigint;
+    readonly oldTotalBorrowed: bigint;
+    readonly withdrawFee: number;
+    readonly depositAPY1DAverage: number;
+    readonly depositAPY1DAverageChange: number;
+    readonly depositAPY7DAverage: number;
+    readonly depositAPY30DAverage: number;
+    readonly oldUniqueLPs: number;
+    readonly uniqueLPs: number;
+    readonly uniqueLPsChange: number;
+    constructor(payload: ChartsPoolDataPayload);
+}
+export declare class UserPoolData {
+    readonly id: string;
+    readonly address: Address;
+    readonly dieselToken: Address;
+    readonly underlyingToken: Address;
+    readonly depositAPY: number;
+    readonly depositAPYRay: bigint;
+    readonly lmRewardAll: Array<{
+        apy: number;
+        token: Address;
+    }>;
+    readonly providedLiquidity: bigint;
+    readonly providedLiquidityInUSD: number;
+    readonly dieselBalance: bigint;
+    readonly dieselBalanceInUSD: number;
+    readonly userRewards: Array<{
+        token: Address;
+        pool: Address;
+        lmRewards: bigint;
+        lmRewardsInUSD: number;
+    }>;
+    readonly pnlInNativeToken: number;
+    readonly pnlInUSD: number;
+    readonly addedLiq: number;
+    readonly addLiqCount: number;
+    readonly removeLiqCount: number;
+    readonly removedLiq: number;
+    constructor(payload: UserPoolPayload);
+}
+export {};