@gearbox-protocol/sdk 3.0.0-next.10 → 3.0.0-next.101

package/lib/core/gaugeMath.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GaugeMath = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
+const math_1 = require("../utils/math");
+class GaugeMath {
+    static vote({ change, ...rest }) {
+        if (change?.type === "remove") {
+            return this.removeVotes({ ...rest, change });
+        }
+        if (change) {
+            return this.addVotes({
+                ...rest,
+                change: { ...change, type: change.type },
+            });
+        }
+        return { ...rest.state, voteCalls: [] };
+    }
+    static addVotes({ state, change }) {
+        const { available, vote } = state;
+        if (!vote) {
+            return {
+                available: available - change.amount,
+                vote: change,
+                voteCalls: [change],
+            };
+        }
+        if (vote.type === change.type) {
+            return {
+                available: available - change.amount,
+                vote: { ...change, amount: vote.amount + change.amount },
+                voteCalls: [change],
+            };
+        }
+        const remove = { type: "remove", amount: vote.amount };
+        return {
+            available: available + vote.amount - change.amount,
+            vote: { ...change, amount: change.amount },
+            voteCalls: [remove, change],
+        };
+    }
+    static removeVotes({ state, change }) {
+        const { available, vote } = state;
+        if (!vote)
+            return { ...state, voteCalls: [] };
+        const safeChange = math_1.BigIntMath.min(vote.amount, change.amount);
+        const afterVote = vote.amount - safeChange;
+        return {
+            available: available + safeChange,
+            vote: { ...vote, amount: afterVote },
+            voteCalls: [{ ...change, amount: safeChange }],
+        };
+    }
+    static revertVote({ balanceAfter, initialVote, nextVoteType, voteAfter, }) {
+        // on vote type change unvote previous vote
+        const prevUnvoted = !initialVote || initialVote.type === nextVoteType
+            ? balanceAfter
+            : balanceAfter + initialVote.amount;
+        if (!voteAfter)
+            return prevUnvoted;
+        // change call is always last, remove is always first
+        const [first, last = first] = voteAfter.voteCalls;
+        const removePart = first?.type === "remove" ? first?.amount || 0n : 0n;
+        const addPart = last?.type !== "remove" ? last?.amount || 0n : 0n;
+        // revert current changes
+        return prevUnvoted + addPart - removePart;
+    }
+    static getBaseVote = (v) => {
+        const voteDown = v.stakerVotesCaSide;
+        const voteUp = v.stakerVotesLpSide;
+        if (!voteDown && !voteUp)
+            return undefined;
+        if (voteDown > 0) {
+            return { type: "lower", amount: voteDown };
+        }
+        if (voteUp > 0) {
+            return { type: "raise", amount: voteUp };
+        }
+        return undefined;
+    };
+    // rate = (minRate *(votesFormin + yourvotesformin) +maxRate*(votesFormax +yourvotesformax)/( votesForMin + votesForMax+yourvotes)
+    static getGaugeApy({ quota, voteAfter, vote }) {
+        if (!quota)
+            return null;
+        const first = voteAfter?.voteCalls?.[0];
+        const last = voteAfter?.voteCalls?.[1] || first;
+        const isRemove = first?.type === "remove";
+        const removeCaPart = isRemove && vote?.type === "lower" ? first?.amount || 0n : 0n;
+        const removeLpPart = isRemove && vote?.type === "raise" ? first?.amount || 0n : 0n;
+        const caPart = last?.type === "lower" ? last?.amount || 0n : 0n;
+        const lpPart = last?.type === "raise" ? last?.amount || 0n : 0n;
+        const caImpact = (0, sdk_gov_1.toBigInt)(quota.minRate) *
+            (quota.totalVotesCaSide + caPart - removeCaPart);
+        const lpImpact = (0, sdk_gov_1.toBigInt)(quota.maxRate) *
+            (quota.totalVotesLpSide + lpPart - removeLpPart);
+        const total = quota.totalVotesCaSide +
+            quota.totalVotesLpSide +
+            caPart +
+            lpPart -
+            removeCaPart -
+            removeLpPart;
+        if (total === 0n)
+            return quota.minRate;
+        const r = (caImpact + lpImpact) / total;
+        return Number(r);
+    }
+}
+exports.GaugeMath = GaugeMath;

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: 12,
+            maxRate: 12345,
+        };
+        const r = gaugeMath_1.GaugeMath.getGaugeApy({
+            quota,
+        });
+        (0, chai_1.expect)(r).to.be.eql(12);
+    });
+    it("should calculate quota without votes", () => {
+        const quota = {
+            totalVotesCaSide: 100n,
+            totalVotesLpSide: 100n,
+            stakerVotesCaSide: 10n,
+            stakerVotesLpSide: 0n,
+            minRate: 0,
+            maxRate: 10000,
+        };
+        const r = gaugeMath_1.GaugeMath.getGaugeApy({
+            quota,
+        });
+        (0, chai_1.expect)(r).to.be.eql(5000);
+    });
+    it("should calculate quota with prev vote", () => {
+        const quota = {
+            totalVotesCaSide: 100n,
+            totalVotesLpSide: 100n,
+            stakerVotesCaSide: 10n,
+            stakerVotesLpSide: 0n,
+            minRate: 0,
+            maxRate: 10000,
+        };
+        const vote = { amount: 10n, type: "lower" };
+        const r = gaugeMath_1.GaugeMath.getGaugeApy({
+            quota,
+            vote,
+        });
+        (0, chai_1.expect)(r).to.be.eql(5000);
+    });
+    it("should calculate quota with same vote increase", () => {
+        const quota = {
+            totalVotesCaSide: 100n,
+            totalVotesLpSide: 100n,
+            stakerVotesCaSide: 10n,
+            stakerVotesLpSide: 0n,
+            minRate: 0,
+            maxRate: 10000,
+        };
+        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(4761);
+    });
+    it("should calculate quota with different vote increase", () => {
+        const quota = {
+            totalVotesCaSide: 100n,
+            totalVotesLpSide: 100n,
+            stakerVotesCaSide: 20n,
+            stakerVotesLpSide: 0n,
+            minRate: 0,
+            maxRate: 10000,
+        };
+        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(6315);
+    });
+    it("should calculate quota with vote remove", () => {
+        const quota = {
+            totalVotesCaSide: 100n,
+            totalVotesLpSide: 100n,
+            stakerVotesCaSide: 20n,
+            stakerVotesLpSide: 0n,
+            minRate: 0,
+            maxRate: 10000,
+        };
+        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(5555);
+    });
+});

package/lib/core/{pool/data.d.ts → pool.d.ts}

@@ -1,37 +1,44 @@
 import { providers, Signer } from "ethers";
-import { CreditManagerDebtParams, QuotaInfo } from "../../payload/creditManager";
-import { ChartsPoolDataPayload, LinearModel, PoolDataPayload, PoolZapper, UserPoolPayload } from "../../payload/pool";
-import { IPoolService, IPoolV3 } from "../../types";
+import { CreditManagerDebtParams, QuotaInfo } from "../payload/creditManager";
+import { ChartsPoolDataPayload, LinearModel, PoolDataPayload, PoolZapper, UserPoolPayload } from "../payload/pool";
+import { IPoolService, IPoolV3 } from "../types";
+export type PoolType = "universal" | "trade" | "farm";
 export declare class PoolData {
     readonly address: string;
+    readonly type: PoolType;
     readonly underlyingToken: string;
     readonly dieselToken: string;
+    readonly stakedDieselToken: Array<string>;
     readonly isPaused: boolean;
     readonly version: number;
     readonly poolQuotaKeeper: string;
     readonly gauge: string;
+    readonly name: string;
+    readonly symbol: string;
     readonly expectedLiquidity: bigint;
     readonly expectedLiquidityLimit: bigint;
     readonly availableLiquidity: bigint;
-    readonly linearCumulativeIndex: bigint;
+    readonly baseInterestIndex: bigint;
     readonly totalBorrowed: bigint;
     readonly totalDebtLimit: bigint;
     readonly creditManagerDebtParams: Record<string, CreditManagerDebtParams>;
     readonly quotas: Record<string, QuotaInfo>;
-    readonly zappers: Record<string, PoolZapper>;
+    readonly zappers: Record<string, Record<string, PoolZapper>>;
     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 cumulativeIndex_RAY: bigint;
+    readonly lastBaseInterestUpdate: bigint;
     constructor(payload: PoolDataPayload);
     getPoolContractV1(signer: Signer): IPoolService;
     getPoolContractV3(signer: Signer): IPoolV3;
     calculateBorrowRate({ provider, expectedLiquidity, availableLiquidity, }: CalculateBorrowRateProps): Promise<import("ethers").BigNumber>;
+    static getPoolType(name: string): PoolType;
 }
 interface CalculateBorrowRateProps {
     provider: providers.Provider;
@@ -39,11 +46,12 @@ interface CalculateBorrowRateProps {
     availableLiquidity: bigint;
 }
 export declare class ChartsPoolData {
-    readonly id: string;
     readonly address: string;
     readonly underlyingToken: string;
     readonly dieselToken: string;
-    readonly isWETH: boolean;
+    readonly type: PoolType;
+    readonly version: number;
+    readonly name: string;
     readonly addLiqCount: number;
     readonly addedLiquidity: number;
     readonly removeLiqCount: number;