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

package/lib/core/strategy.js

@@ -1,56 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Strategy = void 0;
-const decimals_1 = require("../tokens/decimals");
-const token_1 = require("../tokens/token");
-const price_1 = require("../utils/price");
-const constants_1 = require("./constants");
-class Strategy {
-    apy;
-    name;
-    lpToken;
-    baseAssets;
-    unleveragableCollateral;
-    leveragableCollateral;
-    creditManagers;
-    constructor(payload) {
-        this.apy = payload.apy;
-        this.name = payload.name;
-        this.lpToken = payload.lpToken.toLowerCase();
-        this.creditManagers = payload.creditManagers.map(addr => addr.toLowerCase());
-        this.baseAssets = payload.baseAssets.map(addr => addr.toLowerCase());
-        this.unleveragableCollateral = payload.unleveragableCollateral.map(addr => addr.toLowerCase());
-        this.leveragableCollateral = payload.leveragableCollateral.map(addr => addr.toLowerCase());
-    }
+exports.PositionUtils = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
+class PositionUtils {
     static maxLeverage(lpToken, cms) {
-        const [maxThreshold] = Strategy.maxLeverageThreshold(lpToken, cms);
-        const maxLeverage = (constants_1.PERCENTAGE_FACTOR * constants_1.LEVERAGE_DECIMALS) /
-            (constants_1.PERCENTAGE_FACTOR - maxThreshold);
-        return Number(maxLeverage - constants_1.LEVERAGE_DECIMALS);
-    }
-    maxAPY(baseAPY, maxLeverage, borrowAPY) {
-        return (baseAPY +
-            ((baseAPY - borrowAPY) * (maxLeverage - Number(constants_1.LEVERAGE_DECIMALS))) /
-                Number(constants_1.LEVERAGE_DECIMALS));
+        const [maxThreshold] = this.maxLeverageThreshold(lpToken, cms);
+        const maxLeverage = (sdk_gov_1.PERCENTAGE_FACTOR * sdk_gov_1.LEVERAGE_DECIMALS) /
+            (sdk_gov_1.PERCENTAGE_FACTOR - maxThreshold);
+        return Number(maxLeverage - sdk_gov_1.LEVERAGE_DECIMALS);
     }
-    static liquidationPrice({ prices, liquidationThresholds, borrowed, underlyingToken, lpAmount, lpToken, }) {
-        const underlyingTokenAddressLC = underlyingToken.toLowerCase();
-        const underlyingTokenSymbol = token_1.tokenSymbolByAddress[underlyingTokenAddressLC];
-        const underlyingTokenDecimals = decimals_1.decimals[underlyingTokenSymbol];
-        const underlyingPrice = prices[underlyingTokenAddressLC] || constants_1.PRICE_DECIMALS;
-        const borrowedMoney = price_1.PriceUtils.calcTotalPrice(underlyingPrice, borrowed, underlyingTokenDecimals);
-        const lpTokenAddressLC = lpToken.toLowerCase();
-        const lpTokenSymbol = token_1.tokenSymbolByAddress[lpTokenAddressLC];
-        const lpTokenDecimals = decimals_1.decimals[lpTokenSymbol];
-        const lpLT = liquidationThresholds[lpTokenAddressLC] || 0n;
-        const lpPrice = prices[lpTokenAddressLC] || constants_1.PRICE_DECIMALS;
-        const lpMoney = price_1.PriceUtils.calcTotalPrice(lpPrice, lpAmount, lpTokenDecimals);
-        const lpLTMoney = (lpMoney * lpLT) / constants_1.PERCENTAGE_FACTOR;
-        if (lpLTMoney > 0) {
-            const lqPrice = (borrowedMoney * constants_1.WAD) / lpLTMoney;
-            return lqPrice >= 0 ? lqPrice : 0n;
-        }
-        return 0n;
+    static maxAPY({ apy, leverage, baseRateWithFee, quotaRateWithFee, }) {
+        const collateralTerm = apy - quotaRateWithFee;
+        const debtTerm = ((apy - baseRateWithFee - quotaRateWithFee) *
+            (leverage - Number(sdk_gov_1.LEVERAGE_DECIMALS))) /
+            Number(sdk_gov_1.LEVERAGE_DECIMALS);
+        return collateralTerm + Math.floor(debtTerm);
     }
     static maxLeverageThreshold(lpToken, cms) {
         const lpTokenLC = lpToken.toLowerCase();
@@ -60,13 +24,23 @@ 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] || [];
         return [lt, cm];
     }
+    static isStrategyReleased(releaseAt, currentTimestamp, network) {
+        if (releaseAt === undefined)
+            return true;
+        if (typeof releaseAt === "number")
+            return currentTimestamp > releaseAt;
+        const releaseAtNetwork = releaseAt[network];
+        if (releaseAtNetwork === undefined)
+            return true;
+        return currentTimestamp > releaseAtNetwork;
+    }
 }
-exports.Strategy = Strategy;
+exports.PositionUtils = PositionUtils;

package/lib/core/trade.d.ts

@@ -1,56 +1,38 @@
-import { Signer } from "ethers";
-import { SupportedContract } from "../contracts/contracts";
+import { Address } from "viem";
 import { MultiCall, PathFinderResult, SwapOperation } from "../pathfinder/core";
-import { ICreditFacade } from "../types";
 import { CreditManagerData } from "./creditManager";
-import { EVMTx } from "./eventOrTx";
 interface Info {
     name: string;
-    contractAddress: string;
-    creditManager: string;
+    creditManager: Address;
+    creditManagerName: 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;
+    tokenIn: Address;
+    tokenOut: Address;
     amount: bigint;
     results: Array<PathFinderResult>;
     creditManager: CreditManagerData;
-    currentContracts: Record<SupportedContract, string>;
+    swapOperation: SwapOperation;
+    swapName: TradeOperations;
 }
 export declare class Trade {
     readonly helper: Info;
     readonly tradePath: PathFinderResult;
-    readonly creditFacade: string;
-    readonly swapType: SwapOperation;
+    readonly swapOperation: SwapOperation;
     readonly sourceAmount: bigint;
-    readonly expectedAmount: bigint;
+    readonly minExpectedAmount: bigint;
+    readonly averageExpectedAmount: bigint;
     readonly rate: bigint;
-    readonly tokenFrom: string;
-    readonly tokenTo: string;
+    readonly tokenIn: Address;
+    readonly tokenOut: Address;
     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 getCallInfo(calls: Array<MultiCall>, creditManager: string, currentContracts: Record<SupportedContract, string>): Info[];
+    static getTrades({ tokenIn, tokenOut, amount, results, creditManager, swapOperation, swapName, }: GetTradesProps): Trade[];
+    static getCallInfo(calls: Array<MultiCall>, creditManager: Address, creditManagerName: string): Info[];
     private static getContractSymbol;
-    static getTradeId(trade: Trade): string;
     static sortTrades(trades: Array<Trade>, swapStrategy: string): Trade[];
-    static executeMulticallPath(creditFacade: string | ICreditFacade, signer: Signer, calls: Array<MultiCall>): Promise<import("ethers").ContractTransaction>;
-    private static executeOnCreditFacade;
 }
 export {};

package/lib/core/trade.js

@@ -1,120 +1,82 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Trade = void 0;
-const contracts_1 = require("../contracts/contracts");
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
 const txParser_1 = require("../parsers/txParser");
 const core_1 = require("../pathfinder/core");
-const decimals_1 = require("../tokens/decimals");
-const token_1 = require("../tokens/token");
-const types_1 = require("../types");
-const formatter_1 = require("../utils/formatter");
-const constants_1 = require("./constants");
-const transactions_1 = require("./transactions");
-const OPERATION_NAMES = {
-    farmWithdraw: "Farm withdraw",
-    farmDeposit: "Farm deposit",
-    swap: "Swap",
-    unknownOperation: "Unknown operation",
-};
 class Trade {
     helper;
     tradePath;
-    creditFacade;
-    swapType;
+    swapOperation;
     sourceAmount;
-    expectedAmount;
+    minExpectedAmount;
+    averageExpectedAmount;
     rate;
-    tokenFrom;
-    tokenTo;
+    tokenIn;
+    tokenOut;
     operationName;
     constructor(props) {
         this.helper = props.adapter;
         this.tradePath = props.tradePath;
-        this.creditFacade = props.creditFacade;
-        this.swapType = props.swapType;
+        this.swapOperation = props.swapOperation;
         this.sourceAmount = props.sourceAmount;
-        this.expectedAmount = props.expectedAmount;
-        this.rate = (constants_1.WAD * props.expectedAmount) / props.sourceAmount;
-        this.tokenFrom = props.tokenFrom;
-        this.tokenTo = props.tokenTo;
+        this.minExpectedAmount = props.minExpectedAmount;
+        this.averageExpectedAmount = props.averageExpectedAmount;
+        this.rate = (sdk_gov_1.WAD * props.minExpectedAmount) / props.sourceAmount;
+        this.tokenIn = props.tokenIn;
+        this.tokenOut = props.tokenOut;
         this.operationName = props.swapName;
     }
     getName() {
         return this.helper.name;
     }
-    async execute(signer) {
-        const receipt = await Trade.executeMulticallPath(this.creditFacade, signer, this.tradePath.calls);
-        return new transactions_1.TXSwap({
-            txHash: receipt.hash,
-            protocol: this.helper.contractAddress,
-            operation: OPERATION_NAMES[this.operationName],
-            amountFrom: this.sourceAmount,
-            amountTo: this.expectedAmount,
-            tokenFrom: this.tokenFrom,
-            tokenTo: this.tokenTo,
-            creditManager: this.helper.creditManager,
-            timestamp: 0,
-        });
-    }
     toString() {
-        const symbolFrom = token_1.tokenSymbolByAddress[this.tokenFrom.toLowerCase()];
-        const symbolTo = token_1.tokenSymbolByAddress[this.tokenTo.toLowerCase()];
+        const symbolFrom = sdk_gov_1.tokenSymbolByAddress[this.tokenIn.toLowerCase()];
+        const symbolTo = sdk_gov_1.tokenSymbolByAddress[this.tokenOut.toLowerCase()];
         if (!symbolFrom)
-            throw new Error(`Unknown token: ${this.tokenFrom}`);
+            throw new Error(`Unknown token: ${this.tokenIn}`);
         if (!symbolTo)
-            throw new Error(`Unknown token: ${this.tokenTo}`);
-        const decimalsFrom = decimals_1.decimals[symbolFrom];
-        const decimalsTo = decimals_1.decimals[symbolTo];
-        return `${this.operationName} ${(0, formatter_1.formatBN)(this.sourceAmount, decimalsFrom)} ${symbolFrom} ⇒ ${(0, formatter_1.formatBN)(this.expectedAmount, decimalsTo)} ${symbolTo} on ${this.helper.name}`;
+            throw new Error(`Unknown token: ${this.tokenOut}`);
+        const decimalsFrom = sdk_gov_1.decimals[symbolFrom];
+        const decimalsTo = sdk_gov_1.decimals[symbolTo];
+        return `${this.operationName} ${(0, sdk_gov_1.formatBN)(this.sourceAmount, decimalsFrom)} ${symbolFrom} ⇒ ${(0, sdk_gov_1.formatBN)(this.minExpectedAmount, decimalsTo)} ${symbolTo} on ${this.helper.name}`;
     }
-    static getTrades({ from, to, amount, results, creditManager, currentContracts, }) {
+    static getTrades({ tokenIn, tokenOut, amount, results, creditManager, swapOperation, swapName, }) {
         const trades = results.reduce((acc, tradePath) => {
             const { calls } = tradePath;
-            const callInfo = Trade.getCallInfo(calls, creditManager.address, currentContracts);
+            const callInfo = Trade.getCallInfo(calls, creditManager.address, creditManager.name);
             const trade = new Trade({
                 tradePath,
-                creditFacade: creditManager.creditFacade,
-                adapter: callInfo[0],
-                swapType: core_1.SwapOperation.EXACT_INPUT,
+                adapter: callInfo[0] || {
+                    name: "unknown",
+                    contractAddress: calls[0]?.target || "",
+                    creditManager: creditManager.address,
+                    creditManagerName: creditManager.name,
+                },
+                swapOperation,
                 sourceAmount: amount,
-                expectedAmount: tradePath.amount,
-                tokenFrom: from,
-                tokenTo: to,
-                swapName: Trade.getOperationName(from, to),
+                minExpectedAmount: tradePath.minAmount,
+                averageExpectedAmount: tradePath.amount,
+                tokenIn,
+                tokenOut,
+                swapName,
             });
             acc.push(trade);
             return acc;
         }, []);
         return trades;
     }
-    static getOperationName(tokenInAddress, tokenOutAddress) {
-        const tokenInSymbol = token_1.tokenSymbolByAddress[tokenInAddress];
-        const tokenOutSymbol = token_1.tokenSymbolByAddress[tokenOutAddress];
-        const tokenInIsLp = (0, token_1.isLPToken)(tokenInSymbol);
-        const tokenOutIsLp = (0, token_1.isLPToken)(tokenOutSymbol);
-        if (!tokenInSymbol)
-            throw new Error(`Unknown token: ${tokenInAddress}`);
-        if (!tokenOutSymbol)
-            throw new Error(`Unknown token: ${tokenOutAddress}`);
-        if (tokenInIsLp && !tokenOutIsLp)
-            return "farmWithdraw";
-        if (!tokenInIsLp && tokenOutIsLp)
-            return "farmDeposit";
-        if (!tokenInIsLp && !tokenOutIsLp)
-            return "swap";
-        return "unknownOperation";
-    }
-    static getCallInfo(calls, creditManager, currentContracts) {
+    static getCallInfo(calls, creditManager, creditManagerName) {
         const callAdapters = calls.reduce((acc, call) => {
             const contractSymbol = this.getContractSymbol(call.target.toLowerCase());
-            if (!(0, contracts_1.isSupportedContract)(contractSymbol))
+            if (!(0, sdk_gov_1.isSupportedContract)(contractSymbol)) {
                 return acc;
-            const { name } = contracts_1.contractParams[contractSymbol];
-            const contractAddress = currentContracts[contractSymbol];
+            }
+            const { name } = sdk_gov_1.contractParams[contractSymbol];
             acc.push({
                 name,
-                contractAddress,
                 creditManager,
+                creditManagerName,
             });
             return acc;
         }, []);
@@ -129,34 +91,20 @@ class Trade {
             return undefined;
         }
     }
-    static getTradeId(trade) {
-        return `${trade.getName()}:${trade.expectedAmount.toString()}`;
-    }
     static sortTrades(trades, swapStrategy) {
         if (trades.length === 0)
             return [];
-        const { swapType } = trades[0];
+        const { swapOperation } = trades[0];
         const sorted = [...trades].sort((a, b) => {
             const aSelected = a.getName().toLowerCase().search(swapStrategy.toLowerCase()) >= 0;
             const bSelected = b.getName().toLowerCase().search(swapStrategy.toLowerCase()) >= 0;
             if ((aSelected && bSelected) || (!aSelected && !bSelected)) {
-                const sign = a.expectedAmount > b.expectedAmount ? -1 : 1;
-                return swapType === core_1.SwapOperation.EXACT_INPUT ? sign : -sign;
+                const sign = a.minExpectedAmount > b.minExpectedAmount ? -1 : 1;
+                return swapOperation === core_1.SwapOperation.EXACT_INPUT ? sign : -sign;
             }
             return aSelected ? -1 : 1;
         });
         return sorted;
     }
-    static async executeMulticallPath(creditFacade, signer, calls) {
-        if (calls.length < 1)
-            throw new Error("No path to execute");
-        const safeCreditFacade = typeof creditFacade === "string"
-            ? types_1.ICreditFacade__factory.connect(creditFacade, signer)
-            : creditFacade;
-        return this.executeOnCreditFacade(calls, safeCreditFacade);
-    }
-    static async executeOnCreditFacade(calls, creditFacade) {
-        return creditFacade.multicall(calls);
-    }
 }
 exports.Trade = Trade;