@gearbox-protocol/sdk 3.0.0-next.5 → 3.0.0-next.50

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,35 +1,43 @@
 import { providers, Signer } from "ethers";
-import { CreditManagerDebtParams, QuotaInfo } from "../../payload/creditManager";
-import { ChartsPoolDataPayload, LinearModel, PoolDataPayload, UserPoolPayload } from "../../payload/pool";
-import { IPoolService } 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 isWETH: boolean;
-    readonly isWSTETH: boolean;
     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: Array<CreditManagerDebtParams>;
-    readonly quotas: Array<QuotaInfo>;
+    readonly creditManagerDebtParams: Record<string, CreditManagerDebtParams>;
+    readonly quotas: Record<string, QuotaInfo>;
+    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);
-    getContractETH(signer: Signer): IPoolService;
+    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;

package/lib/core/{pool/data.js → pool.js}

@@ -2,68 +2,100 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserPoolData = exports.ChartsPoolData = exports.PoolData = void 0;
 const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
-const types_1 = require("../../types");
-const formatter_1 = require("../../utils/formatter");
+const types_1 = require("../types");
+const formatter_1 = require("../utils/formatter");
 class PoolData {
     address;
+    type;
     underlyingToken;
     dieselToken;
-    isWETH;
-    isWSTETH;
     isPaused;
     version;
+    poolQuotaKeeper;
+    gauge;
+    name;
+    symbol;
     // Information
     expectedLiquidity;
     expectedLiquidityLimit;
     availableLiquidity;
-    linearCumulativeIndex;
+    baseInterestIndex;
     totalBorrowed;
     totalDebtLimit;
     creditManagerDebtParams;
     quotas;
+    zappers;
     totalAssets;
     totalSupply;
+    supplyAPY7D;
     depositAPY;
     borrowAPY;
     interestModel;
     dieselRate;
     dieselRateRay;
     withdrawFee;
-    cumulativeIndex_RAY;
+    lastBaseInterestUpdate;
     constructor(payload) {
         this.address = payload.addr.toLowerCase();
-        const underlying = payload.underlying.toLowerCase();
+        this.type = PoolData.getPoolType(payload.name || "");
         this.underlyingToken = payload.underlying.toLowerCase();
         this.dieselToken = payload.dieselToken.toLowerCase();
-        this.isWETH = sdk_gov_1.tokenSymbolByAddress[underlying] === "WETH";
-        this.isWSTETH = sdk_gov_1.tokenSymbolByAddress[underlying] === "wstETH";
         this.isPaused = payload.isPaused;
         this.version = payload.version.toNumber();
+        this.poolQuotaKeeper = payload.poolQuotaKeeper.toLowerCase();
+        this.gauge = payload.gauge.toLowerCase();
+        this.name = payload.name;
+        this.symbol = payload.symbol;
         this.expectedLiquidity = (0, sdk_gov_1.toBigInt)(payload.expectedLiquidity);
         this.availableLiquidity = (0, sdk_gov_1.toBigInt)(payload.availableLiquidity);
         this.expectedLiquidityLimit =
             this.expectedLiquidity + this.availableLiquidity;
-        this.linearCumulativeIndex = (0, sdk_gov_1.toBigInt)(payload.linearCumulativeIndex);
+        this.baseInterestIndex = (0, sdk_gov_1.toBigInt)(payload.baseInterestIndex);
         this.totalBorrowed = (0, sdk_gov_1.toBigInt)(payload.totalBorrowed);
         this.totalDebtLimit = (0, sdk_gov_1.toBigInt)(payload.totalDebtLimit);
-        this.creditManagerDebtParams = payload.creditManagerDebtParams.map(p => ({
-            creditManager: p.creditManager.toLowerCase(),
-            borrowed: (0, sdk_gov_1.toBigInt)(p.borrowed),
-            limit: (0, sdk_gov_1.toBigInt)(p.limit),
-            availableToBorrow: (0, sdk_gov_1.toBigInt)(p.availableToBorrow),
+        this.creditManagerDebtParams = Object.fromEntries(payload.creditManagerDebtParams.map(p => {
+            const creditManager = p.creditManager.toLowerCase();
+            return [
+                creditManager,
+                {
+                    creditManager,
+                    borrowed: (0, sdk_gov_1.toBigInt)(p.borrowed),
+                    limit: (0, sdk_gov_1.toBigInt)(p.limit),
+                    availableToBorrow: (0, sdk_gov_1.toBigInt)(p.availableToBorrow),
+                },
+            ];
         }));
-        this.quotas = payload.quotas.map(q => ({
-            token: q.token.toLowerCase(),
-            rate: q.rate,
-            quotaIncreaseFee: q.quotaIncreaseFee,
-            totalQuoted: (0, sdk_gov_1.toBigInt)(q.totalQuoted),
-            limit: (0, sdk_gov_1.toBigInt)(q.limit),
-            isActive: q.isActive,
+        this.quotas = Object.fromEntries(payload.quotas.map(q => {
+            const token = q.token.toLowerCase();
+            return [
+                token,
+                {
+                    token,
+                    rate: Number((0, sdk_gov_1.toBigInt)(q.rate) * sdk_gov_1.PERCENTAGE_DECIMALS),
+                    quotaIncreaseFee: q.quotaIncreaseFee,
+                    totalQuoted: (0, sdk_gov_1.toBigInt)(q.totalQuoted),
+                    limit: (0, sdk_gov_1.toBigInt)(q.limit),
+                    isActive: q.isActive,
+                },
+            ];
         }));
+        this.zappers = payload.zappers.reduce((acc, z) => {
+            const tokenIn = z.tokenIn.toLowerCase();
+            const tokenOut = z.tokenOut.toLowerCase();
+            const old = acc[tokenIn] || {};
+            return {
+                ...acc,
+                [tokenIn]: {
+                    ...old,
+                    [tokenOut]: { tokenIn, tokenOut, zapper: z.zapper.toLowerCase() },
+                },
+            };
+        }, {});
         this.totalAssets = (0, sdk_gov_1.toBigInt)(payload.totalAssets);
         this.totalSupply = (0, sdk_gov_1.toBigInt)(payload.totalSupply);
         this.depositAPY = (0, formatter_1.rayToNumber)((0, sdk_gov_1.toBigInt)(payload.supplyRate) * sdk_gov_1.PERCENTAGE_DECIMALS);
         this.borrowAPY = (0, formatter_1.rayToNumber)((0, sdk_gov_1.toBigInt)(payload.baseInterestRate) * sdk_gov_1.PERCENTAGE_DECIMALS);
+        this.supplyAPY7D = payload.supplyAPY7D;
         this.interestModel = {
             interestModel: payload.lirm.interestModel.toLowerCase(),
             U_1: payload.lirm.U_1,
@@ -73,20 +105,33 @@ class PoolData {
             R_slope2: payload.lirm.R_slope2,
             R_slope3: payload.lirm.R_slope3,
             version: payload?.lirm?.version?.toNumber(),
+            isBorrowingMoreU2Forbidden: payload?.lirm?.isBorrowingMoreU2Forbidden,
         };
         this.dieselRate = (0, formatter_1.rayToNumber)(payload.dieselRate_RAY);
         this.dieselRateRay = (0, sdk_gov_1.toBigInt)(payload.dieselRate_RAY);
-        this.cumulativeIndex_RAY = (0, sdk_gov_1.toBigInt)(payload.cumulativeIndex_RAY);
+        this.lastBaseInterestUpdate = (0, sdk_gov_1.toBigInt)(payload.lastBaseInterestUpdate);
         this.withdrawFee =
             Number((0, sdk_gov_1.toBigInt)(payload.withdrawFee)) / Number(sdk_gov_1.PERCENTAGE_DECIMALS);
     }
-    getContractETH(signer) {
+    getPoolContractV1(signer) {
         return types_1.IPoolService__factory.connect(this.address, signer);
     }
+    getPoolContractV3(signer) {
+        return types_1.IPoolV3__factory.connect(this.address, signer);
+    }
     async calculateBorrowRate({ provider, expectedLiquidity, availableLiquidity, }) {
         const model = types_1.IInterestRateModel__factory.connect(this.interestModel.interestModel, provider);
         return model.calcBorrowRate(expectedLiquidity, availableLiquidity);
     }
+    static getPoolType(name) {
+        const [identity = ""] = name.split(" ") || [];
+        const lc = identity.toLowerCase();
+        if (lc === "farm")
+            return "farm";
+        if (lc === "trade")
+            return "trade";
+        return "universal";
+    }
 }
 exports.PoolData = PoolData;
 class ChartsPoolData {

package/lib/core/strategy.js

@@ -58,9 +58,9 @@ class Strategy {
         });
         const sorted = ltByCM.sort(([, ltA], [, ltB]) => {
             if (ltA > ltB)
-                return 1;
-            if (ltB > ltA)
                 return -1;
+            if (ltB > ltA)
+                return 1;
             return 0;
         });
         const [cm = "", lt = 0n] = sorted[0] || [];

package/lib/core/trade.d.ts

@@ -1,26 +1,12 @@
 import { SupportedContract } from "@gearbox-protocol/sdk-gov";
-import { Signer } from "ethers";
 import { MultiCall, PathFinderResult, SwapOperation } from "../pathfinder/core";
-import { ICreditFacadeV2 } from "../types";
 import { CreditManagerData } from "./creditManager";
-import { EVMTx } from "./eventOrTx";
 interface Info {
     name: string;
     contractAddress: string;
     creditManager: string;
 }
-export interface TradeProps {
-    adapter: Info;
-    tradePath: PathFinderResult;
-    creditFacade: string;
-    tokenFrom: string;
-    tokenTo: string;
-    sourceAmount: bigint;
-    expectedAmount: bigint;
-    swapType: SwapOperation;
-    swapName: TradeOperations;
-}
-export type TradeOperations = "farmWithdraw" | "farmDeposit" | "swap" | "unknownOperation";
+export type TradeOperations = "farmWithdraw" | "farmDeposit" | "swap";
 export interface GetTradesProps {
     from: string;
     to: string;
@@ -28,11 +14,12 @@ export interface GetTradesProps {
     results: Array<PathFinderResult>;
     creditManager: CreditManagerData;
     currentContracts: Record<SupportedContract, string>;
+    swapType: SwapOperation;
+    swapName: TradeOperations;
 }
 export declare class Trade {
     readonly helper: Info;
     readonly tradePath: PathFinderResult;
-    readonly creditFacade: string;
     readonly swapType: SwapOperation;
     readonly sourceAmount: bigint;
     readonly expectedAmount: bigint;
@@ -40,17 +27,12 @@ export declare class Trade {
     readonly tokenFrom: string;
     readonly tokenTo: string;
     readonly operationName: TradeOperations;
-    constructor(props: TradeProps);
+    private constructor();
     getName(): string;
-    execute(signer: Signer): Promise<EVMTx>;
     toString(): string;
-    static getTrades({ from, to, amount, results, creditManager, currentContracts, }: GetTradesProps): Trade[];
-    static getOperationName(tokenInAddress: string, tokenOutAddress: string): TradeOperations;
+    static getTrades({ from, to, amount, results, creditManager, currentContracts, swapType, swapName, }: GetTradesProps): Trade[];
     static getCallInfo(calls: Array<MultiCall>, creditManager: string, currentContracts: Record<SupportedContract, string>): Info[];
     private static getContractSymbol;
-    static getTradeId(trade: Trade): string;
     static sortTrades(trades: Array<Trade>, swapStrategy: string): Trade[];
-    static executeMulticallPath(creditFacade: string | ICreditFacadeV2, signer: Signer, calls: Array<MultiCall>): Promise<import("ethers").ContractTransaction>;
-    private static executeOnCreditFacade;
 }
 export {};