@gearbox-protocol/sdk 3.0.0-next.29 → 3.0.0-next.290

package/lib/pathfinder/utils.d.ts

@@ -0,0 +1,34 @@
+import { Address, PublicClient } from "viem";
+import { MultiCall } from "./core";
+export interface FeeInfo {
+    type: KnownFeeTypes;
+    value: bigint;
+}
+type KnownFeeTypes = "curve" | "lido" | "uniswap_v2" | "uniswap_v3" | "balancer";
+export declare const BALANCER_VAULT_ABI: readonly [{
+    readonly inputs: readonly [];
+    readonly name: "getSwapFeePercentage";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];
+export interface FindPathFeesProps {
+    calls: Array<MultiCall>;
+    provider: PublicClient;
+    contractsByAdapter: Record<Address, Address>;
+}
+export declare class PathFinderUtils {
+    static findPathFees({ calls, provider, contractsByAdapter, }: FindPathFeesProps): Promise<FeeInfo[]>;
+    private static getUniswapV2Fee;
+    private static getUniswapV3Fee;
+    private static getCurveFeeCall;
+    private static getCurveFee;
+    private static getBalancerFeeCall;
+    private static getBalancerFee;
+    private static getLidoFee;
+}
+export {};

package/lib/pathfinder/utils.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathFinderUtils = exports.BALANCER_VAULT_ABI = void 0;
+const sdk_gov_1 = require("@gearbox-protocol/sdk-gov");
+const balancerV2VaultParser_1 = require("../parsers/balancerV2VaultParser");
+const curveAdapterParser_1 = require("../parsers/curveAdapterParser");
+const lidoAdapterParser_1 = require("../parsers/lidoAdapterParser");
+const txParser_1 = require("../parsers/txParser");
+const uniV2AdapterParser_1 = require("../parsers/uniV2AdapterParser");
+const uniV3AdapterParser_1 = require("../parsers/uniV3AdapterParser");
+const types_1 = require("../types");
+const balancerVault_1 = require("./balancerVault");
+const CURVE_FEE_DECIMALS = 100000000n;
+const BALANCER_FEE_DECIMALS = 10000000000000000n;
+exports.BALANCER_VAULT_ABI = [
+    {
+        inputs: [],
+        name: "getSwapFeePercentage",
+        outputs: [
+            {
+                internalType: "uint256",
+                name: "",
+                type: "uint256",
+            },
+        ],
+        stateMutability: "view",
+        type: "function",
+    },
+];
+class PathFinderUtils {
+    static async findPathFees({ calls, provider, contractsByAdapter, }) {
+        const pathObjects = txParser_1.TxParser.parseToObjectMultiCall(calls);
+        const { simpleFees, curve, balancer } = pathObjects.reduce((acc, pathSegment) => {
+            if (!pathSegment)
+                return acc;
+            const { callObject, parser } = pathSegment;
+            switch (true) {
+                case parser instanceof uniV2AdapterParser_1.UniswapV2AdapterParser: {
+                    const f = this.getUniswapV2Fee(callObject);
+                    if (f)
+                        acc.simpleFees.push(f);
+                    break;
+                }
+                case parser instanceof uniV3AdapterParser_1.UniswapV3AdapterParser: {
+                    const f = this.getUniswapV3Fee(callObject);
+                    if (f)
+                        acc.simpleFees.push(f);
+                    break;
+                }
+                case parser instanceof lidoAdapterParser_1.LidoAdapterParser: {
+                    const f = this.getLidoFee();
+                    if (f)
+                        acc.simpleFees.push(f);
+                    break;
+                }
+                case parser instanceof curveAdapterParser_1.CurveAdapterParser: {
+                    const call = this.getCurveFeeCall(callObject, contractsByAdapter);
+                    if (call)
+                        acc.curve.push(call);
+                    break;
+                }
+                case parser instanceof balancerV2VaultParser_1.BalancerV2VaultParser: {
+                    const call = this.getBalancerFeeCall(callObject);
+                    if (call)
+                        acc.balancer.push(call);
+                    break;
+                }
+            }
+            return acc;
+        }, {
+            simpleFees: [],
+            curve: [],
+            balancer: [],
+        });
+        const response = (await provider.multicall({
+            allowFailure: true,
+            multicallAddress: sdk_gov_1.MULTICALL_ADDRESS,
+            contracts: [...curve, ...balancer],
+        }));
+        const curveEnds = curve.length;
+        const curveResponse = response.slice(0, curveEnds);
+        const balancerEnds = balancer.length;
+        const balancerResponse = response.slice(curveEnds, balancerEnds);
+        const curveFees = curveResponse.map(r => this.getCurveFee(r));
+        const balancerFees = balancerResponse.map(r => this.getBalancerFee(r));
+        const fees = [...simpleFees, ...curveFees, ...balancerFees];
+        return fees;
+    }
+    static getUniswapV2Fee(callObject) {
+        const { functionName } = callObject;
+        switch (functionName) {
+            case "swapExactTokensForTokens":
+            case "swapTokensForExactTokens":
+            case "swapDiffTokensForTokens": {
+                // 0.3%
+                return {
+                    type: "uniswap_v2",
+                    value: 3000n,
+                };
+            }
+            default:
+                return null;
+        }
+    }
+    static getUniswapV3Fee(callObject) {
+        const { functionName, args } = callObject;
+        switch (functionName) {
+            case "exactInputSingle":
+            case "exactDiffInputSingle":
+            case "exactOutputSingle": {
+                const [first] = args;
+                const { fee = 0 } = first || {};
+                return {
+                    type: "uniswap_v3",
+                    value: (0, sdk_gov_1.toBigInt)(fee),
+                };
+            }
+            default:
+                return null;
+        }
+    }
+    static getCurveFeeCall(callObject, contractsByAdapter) {
+        const { functionName } = callObject;
+        switch (functionName) {
+            case "exchange":
+            case "exchange_underlying":
+            case "exchange_diff":
+            case "exchange_diff_underlying": {
+                const adapter = (callObject.address || "").toLowerCase();
+                const contract = contractsByAdapter[adapter];
+                return contract
+                    ? {
+                        address: contract,
+                        abi: types_1.iCurvePoolAbi,
+                        functionName: "fee",
+                        args: [],
+                    }
+                    : null;
+            }
+            default:
+                return null;
+        }
+    }
+    static getCurveFee({ result }) {
+        const feeOriginal = result || 0n;
+        return {
+            type: "curve",
+            value: (feeOriginal * sdk_gov_1.PERCENTAGE_FACTOR) / CURVE_FEE_DECIMALS,
+        };
+    }
+    static getBalancerFeeCall(callObject) {
+        const { functionName } = callObject;
+        switch (functionName) {
+            case "swapDiff":
+            case "swap": {
+                const [first] = callObject.args;
+                const { poolId = "" } = first || {};
+                const { address } = (0, balancerVault_1.splitPoolId)(poolId);
+                return address
+                    ? {
+                        address: address,
+                        abi: exports.BALANCER_VAULT_ABI,
+                        functionName: "getSwapFeePercentage",
+                        args: [],
+                    }
+                    : null;
+            }
+            default:
+                return null;
+        }
+    }
+    static getBalancerFee({ result }) {
+        const feeOriginal = result || 0n;
+        return {
+            type: "balancer",
+            value: (feeOriginal * sdk_gov_1.PERCENTAGE_FACTOR) / BALANCER_FEE_DECIMALS,
+        };
+    }
+    static getLidoFee() {
+        return {
+            type: "lido",
+            value: 0n,
+        };
+    }
+}
+exports.PathFinderUtils = PathFinderUtils;

package/lib/payload/bot.d.ts

@@ -0,0 +1,13 @@
+import { Address } from "viem";
+export type BotBaseType = "liquidationProtection";
+export type LiquidationBotType = "deleverageBotPegged" | "deleverageBotLV" | "deleverageBotHV";
+export type BotDetailedType = LiquidationBotType;
+export interface BotDataPayload {
+    baseType: BotBaseType;
+    detailedType: BotDetailedType;
+    address: Address;
+    minHealthFactor: number;
+    maxHealthFactor: number;
+    premiumScaleFactor: number;
+    feeScaleFactor: number;
+}

package/lib/payload/creditAccount.d.ts

@@ -1,6 +1,41 @@
-import { ExcludeArrayProps } from "@gearbox-protocol/sdk-gov";
-import { CreditAccountDataStructOutput, ScheduledWithdrawalStructOutput, TokenBalanceStructOutput } from "../types/IDataCompressorV3_00";
-import { BigintifyProps, PartialKeys } from "../utils/types";
-export type CaTokenBalance = BigintifyProps<ExcludeArrayProps<TokenBalanceStructOutput>>;
-export type ScheduledWithdrawal = BigintifyProps<ExcludeArrayProps<ScheduledWithdrawalStructOutput>>;
-export type CreditAccountDataPayload = PartialKeys<ExcludeArrayProps<CreditAccountDataStructOutput>, "accruedInterest" | "accruedFees" | "healthFactor" | "totalValue">;
+import { Address } from "viem";
+export interface CaTokenBalance {
+    token: Address;
+    balance: bigint;
+    isForbidden: boolean;
+    isEnabled: boolean;
+    isQuoted: boolean;
+    quota: bigint;
+    quotaRate: bigint;
+}
+export interface CreditAccountDataPayload {
+    isSuccessful: boolean;
+    priceFeedsNeeded: readonly Address[];
+    addr: Address;
+    borrower: Address;
+    creditManager: Address;
+    creditFacade: Address;
+    underlying: Address;
+    debt: bigint;
+    accruedInterest: bigint;
+    accruedFees: bigint;
+    totalDebtUSD: bigint;
+    totalValue: bigint;
+    totalValueUSD: bigint;
+    twvUSD: bigint;
+    enabledTokensMask: bigint;
+    healthFactor: bigint;
+    baseBorrowRate: bigint;
+    balances: readonly {
+        token: Address;
+        balance: bigint;
+        isForbidden: boolean;
+        isEnabled: boolean;
+        isQuoted: boolean;
+        quota: bigint;
+        quotaRate: number;
+    }[];
+    cfVersion: bigint;
+    expirationDate: number;
+    activeBots: readonly Address[];
+}

package/lib/payload/creditManager.d.ts

@@ -1,21 +1,62 @@
-import { ExcludeArrayProps } from "@gearbox-protocol/sdk-gov";
-import { BigNumberish } from "ethers";
-import { ICreditFacadeV2 } from "../types";
-import { CreditManagerDataStructOutput, CreditManagerDebtParamsStructOutput, QuotaInfoStructOutput } from "../types/IDataCompressorV3_00";
-import { BigintifyProps } from "../utils/types";
-export type CreditManagerDebtParams = BigintifyProps<ExcludeArrayProps<CreditManagerDebtParamsStructOutput>>;
-export type QuotaInfo = BigintifyProps<ExcludeArrayProps<QuotaInfoStructOutput>>;
-export interface AdapterPayload {
-    allowedContract: string;
-    adapter: string;
+import { Address } from "viem";
+import { BigNumberish } from "../utils/formatter";
+import { PoolDataPayload } from "./pool";
+export interface CreditManagerDebtParamsSDK {
+    creditManager: Address;
+    borrowed: bigint;
+    limit: bigint;
+    availableToBorrow: bigint;
+}
+export interface QuotaInfo {
+    token: Address;
+    rate: bigint;
+    quotaIncreaseFee: bigint;
+    totalQuoted: bigint;
+    limit: bigint;
+    isActive: boolean;
+}
+export interface CreditManagerDataPayload {
+    addr: Address;
+    name: string;
+    cfVersion: bigint;
+    creditFacade: Address;
+    creditConfigurator: Address;
+    underlying: Address;
+    pool: Address;
+    totalDebt: bigint;
+    totalDebtLimit: bigint;
+    baseBorrowRate: bigint;
+    minDebt: bigint;
+    maxDebt: bigint;
+    availableToBorrow: bigint;
+    isDegenMode: boolean;
+    degenNFT: Address;
+    forbiddenTokenMask: bigint;
+    isPaused: boolean;
+    collateralTokens: readonly Address[];
+    adapters: readonly {
+        targetContract: Address;
+        adapter: Address;
+    }[];
+    liquidationThresholds: readonly bigint[];
+    maxEnabledTokensLength: number;
+    feeInterest: number;
+    feeLiquidation: number;
+    liquidationDiscount: number;
+    feeLiquidationExpired: number;
+    liquidationDiscountExpired: number;
+    quotas: PoolDataPayload["quotas"];
+    lirm: PoolDataPayload["lirm"];
+    isBorrowingForbidden: boolean;
 }
-export type TotalDebt = ExcludeArrayProps<Awaited<ReturnType<ICreditFacadeV2["totalDebt"]>>>;
-export type CreditManagerDataPayload = ExcludeArrayProps<CreditManagerDataStructOutput>;
 export interface ChartsCreditManagerPayload {
-    addr: string;
-    underlyingToken: string;
+    addr: Address;
+    underlyingToken: Address;
+    configurator: Address;
+    creditFacade: Address;
     isWeth: boolean;
-    poolAddress: string;
+    poolAddress: Address;
+    name: string;
     maxAmount: BigNumberish;
     minAmount: BigNumberish;
     maxLeverageFactor: number;
@@ -52,5 +93,6 @@ export interface ChartsCreditManagerPayload {
     totalClosedAccounts: number;
     totalClosedAccountsChange: number;
     totalRepaidAccounts: number;
-    liquidityThresholds: Record<string, number>;
+    liquidityThresholds: Record<Address, number>;
+    totalDebtLimit: BigNumberish;
 }

package/lib/payload/creditSession.d.ts

@@ -1,31 +1,38 @@
-import { BigNumberish } from "ethers";
+import { Address } from "viem";
+import { BigNumberish } from "../utils/formatter";
 export interface CreditSessionBalancePayload {
     BI: string;
     F: number;
     ind: number;
-    isAllowed: boolean;
+    isForbidden: boolean;
     isEnabled: boolean;
+    quota?: BigNumberish;
+    quotaIndexLU?: BigNumberish;
+    isQuoted?: boolean;
 }
 interface CreditSessionReward {
     bi: BigNumberish;
     f: number;
-    pool: string;
+    pool: Address;
     symbol: string;
 }
+export interface SecondaryStatus {
+    secStatus: Array<[block: number, status: number]>;
+}
 export interface CreditSessionPayload {
     id: string;
     status: number;
-    borrower: string;
-    account: string;
-    creditManager: string;
-    underlyingToken: string;
+    borrower: Address;
+    account: Address;
+    creditManager: Address;
+    underlyingToken: Address;
     version: number;
     borrowAPY_RAY: BigNumberish;
     borrowAPY7DAverage: number;
     entryPrice?: number;
     closePrice?: number;
-    quoteToken?: string;
-    tradingToken?: string;
+    quoteToken?: Address;
+    tradingToken?: Address;
     healthFactor: BigNumberish;
     leverage: number;
     tfIndex: number;
@@ -50,16 +57,21 @@ export interface CreditSessionPayload {
     roi: number;
     currentBlock: number;
     currentTimestamp: number;
-    cvxUnclaimedRewards: Record<string, CreditSessionReward>;
-    balances: Record<string, CreditSessionBalancePayload>;
+    cvxUnclaimedRewards: Record<Address, CreditSessionReward>;
+    balances: Record<Address, CreditSessionBalancePayload>;
+    baseBorrowAPY7DAverage: number;
+    baseBorrowAPY_RAY: string;
+    baseToken: Address;
+    pool: Address;
+    teritaryStatus: null | SecondaryStatus;
 }
 export interface CreditSessionFilteredPayload {
-    balances: Record<string, CreditSessionBalancePayload>;
+    balances: Record<Address, CreditSessionBalancePayload>;
     id: string;
-    borrower: string;
-    account: string;
-    creditManager: string;
-    underlyingToken: string;
+    borrower: Address;
+    account: Address;
+    creditManager: Address;
+    underlyingToken: Address;
     status: number;
     closedAt: number;
     since: number;
@@ -72,6 +84,9 @@ export interface CreditSessionFilteredPayload {
     pnl: number;
     pnlUSD: number;
     tfIndex: number;
+    closedAtTimestamp: number;
+    sinceTimestamp: number;
+    teritaryStatus: null | SecondaryStatus;
 }
 export interface CreditSessionsAggregatedStatsPayload {
     healthFactor: BigNumberish;

package/lib/payload/gauge.d.ts

@@ -1,5 +1,40 @@
-import { ExcludeArrayProps } from "@gearbox-protocol/sdk-gov";
-import { GaugeInfoStructOutput, GaugeQuotaParamsStructOutput } from "../types/IDataCompressorV3_00";
-import { BigintifyProps } from "../utils/types";
-export type GaugeQuotaParams = BigintifyProps<ExcludeArrayProps<GaugeQuotaParamsStructOutput>>;
-export type GaugeDataPayload = ExcludeArrayProps<GaugeInfoStructOutput>;
+import { Address } from "viem";
+export interface MultiVote {
+    votingContract: Address;
+    voteAmount: bigint;
+    isIncrease: boolean;
+    extraData: Address;
+}
+export interface GaugeQuotaParams {
+    token: Address;
+    minRate: number;
+    maxRate: number;
+    totalVotesLpSide: bigint;
+    totalVotesCaSide: bigint;
+    rate: number;
+    quotaIncreaseFee: number;
+    totalQuoted: bigint;
+    limit: bigint;
+    isActive: boolean;
+    stakerVotesLpSide: bigint;
+    stakerVotesCaSide: bigint;
+}
+export interface GaugeDataPayload {
+    addr: Address;
+    pool: Address;
+    symbol: string;
+    name: string;
+    underlying: Address;
+    currentEpoch: number;
+    epochFrozen: boolean;
+    quotaParams: readonly GaugeQuotaParams[];
+}
+export interface GaugeStakingDataPayload {
+    availableBalance: bigint;
+    totalBalance: bigint;
+    epoch: number;
+    withdrawableAmounts: {
+        withdrawableNow: bigint;
+        withdrawableInEpochs: readonly [bigint, bigint, bigint, bigint];
+    };
+}

package/lib/payload/graphPayload.d.ts

@@ -1,9 +1,10 @@
-export interface GraphData {
+interface GraphPointPayload {
     time: number;
     value: number;
 }
 export interface GraphPayload {
     id: string;
     title: string;
-    data: Array<GraphData>;
+    data: Array<GraphPointPayload>;
 }
+export {};