@gearbox-protocol/sdk 1.22.4 → 1.23.1

package/lib/core/rewardClaimer.d.ts

@@ -1,4 +1,4 @@
-import { BigNumber, providers } from "ethers";
+import { providers } from "ethers";
 import { SupportedContract } from "../contracts/contracts";
 import { MultiCall } from "../pathfinder/core";
 import { SupportedToken } from "../tokens/token";
@@ -7,11 +7,11 @@ import { CreditAccountData } from "./creditAccount";
 import { CreditManagerData } from "./creditManager";
 export interface Rewards {
     contract: SupportedContract;
-    rewards: Partial<Record<SupportedToken, BigNumber>>;
+    rewards: Partial<Record<SupportedToken, bigint>>;
     calls: Array<MultiCall>;
 }
 export interface AdapterWithType {
-    adapter: string;
+    contractAddress: string;
     contract: SupportedContract;
 }
 export declare class RewardClaimer {

package/lib/core/rewardClaimer.js

@@ -1,53 +1,10 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RewardClaimer = void 0;
-var rewardConvex_1 = require("./rewardConvex");
-var RewardClaimer = /** @class */ (function () {
-    function RewardClaimer() {
+const rewardConvex_1 = require("./rewardConvex");
+class RewardClaimer {
+    static async findRewards(ca, cm, network, provider) {
+        return rewardConvex_1.RewardConvex.findRewards(ca, cm, network, provider);
     }
-    RewardClaimer.findRewards = function (ca, cm, network, provider) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, rewardConvex_1.RewardConvex.findRewards(ca, cm, network, provider)];
-            });
-        });
-    };
-    return RewardClaimer;
-}());
+}
 exports.RewardClaimer = RewardClaimer;

package/lib/core/rewardConvex.d.ts

@@ -8,7 +8,7 @@ import { CreditAccountData } from "./creditAccount";
 import { CreditManagerData } from "./creditManager";
 import { AdapterWithType, Rewards } from "./rewardClaimer";
 export interface RewardDistribution {
-    adapter: string;
+    contractAddress: string;
     contract: SupportedContract;
     token: SupportedToken;
 }

package/lib/core/rewardConvex.js

@@ -1,118 +1,60 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RewardConvex = void 0;
-var ethers_1 = require("ethers");
-var apy_1 = require("../apy");
-var adapters_1 = require("../contracts/adapters");
-var contracts_1 = require("../contracts/contracts");
-var token_1 = require("../tokens/token");
-var types_1 = require("../types");
-var multicall_1 = require("../utils/multicall");
-var RewardConvex = /** @class */ (function () {
-    function RewardConvex() {
-    }
-    RewardConvex.findRewards = function (ca, cm, network, provider) {
-        return __awaiter(this, void 0, void 0, function () {
-            var _a, calls, distribution, mcalls, rewards, totalSupply, results;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _a = RewardConvex.prepareMultiCalls(ca.addr, cm, network), calls = _a.calls, distribution = _a.distribution;
-                        mcalls = calls;
-                        mcalls.push({
-                            address: token_1.tokenDataByNetwork[network].CVX,
-                            interface: types_1.IConvexToken__factory.createInterface(),
-                            method: "totalSupply()",
-                        });
-                        return [4 /*yield*/, (0, multicall_1.multicall)(mcalls, provider)];
-                    case 1:
-                        rewards = _b.sent();
-                        totalSupply = rewards.pop();
-                        results = RewardConvex.parseResults(ca.addr, rewards, distribution);
-                        results.forEach(function (r) {
-                            r.rewards.CVX = (0, apy_1.getCVXMintAmount)(r.rewards.CRV || ethers_1.BigNumber.from(0), totalSupply);
-                        });
-                        return [2 /*return*/, results];
-                }
-            });
+const apy_1 = require("../apy");
+const adapters_1 = require("../contracts/adapters");
+const contracts_1 = require("../contracts/contracts");
+const token_1 = require("../tokens/token");
+const types_1 = require("../types");
+const formatter_1 = require("../utils/formatter");
+const multicall_1 = require("../utils/multicall");
+class RewardConvex {
+    static poolInterface = types_1.IConvexV1BaseRewardPoolAdapter__factory.createInterface();
+    static async findRewards(ca, cm, network, provider) {
+        const { calls, distribution } = RewardConvex.prepareMultiCalls(ca.addr, cm, network);
+        const mcalls = calls;
+        mcalls.push({
+            address: token_1.tokenDataByNetwork[network].CVX,
+            interface: types_1.IConvexToken__factory.createInterface(),
+            method: "totalSupply()",
         });
-    };
-    RewardConvex.findAdapters = function (cm) {
-        var convexPools = Object.entries(contracts_1.contractParams)
-            .filter(function (_a) {
-            var _ = _a[0], params = _a[1];
-            return params.type === adapters_1.AdapterInterface.CONVEX_V1_BASE_REWARD_POOL;
-        })
-            .map(function (_a) {
-            var contract = _a[0];
-            return contract;
+        const rewards = await (0, multicall_1.multicall)(mcalls, provider);
+        const totalSupply = rewards.pop();
+        const results = RewardConvex.parseResults(ca.addr, rewards, distribution);
+        results.forEach(r => {
+            r.rewards.CVX = (0, apy_1.getCVXMintAmount)(r.rewards.CRV || 0n, (0, formatter_1.toBigInt)(totalSupply));
         });
+        return results;
+    }
+    static findAdapters(cm) {
+        const convexPools = Object.entries(contracts_1.contractParams)
+            .filter(([_, params]) => params.type === adapters_1.AdapterInterface.CONVEX_V1_BASE_REWARD_POOL)
+            .map(([contract]) => contract);
         return Object.entries(cm.adapters)
-            .map(function (_a) {
-            var contract = _a[0], adapter = _a[1];
-            return ({
-                adapter: adapter,
-                contract: contracts_1.contractsByAddress[contract.toLowerCase()],
-            });
-        })
-            .filter(function (a) { return convexPools.includes(a.contract); });
-    };
-    RewardConvex.prepareMultiCalls = function (creditAccount, cm, network) {
-        var calls = [];
-        var distribution = [];
-        var adapters = this.findAdapters(cm);
-        for (var _i = 0, adapters_2 = adapters; _i < adapters_2.length; _i++) {
-            var a = adapters_2[_i];
+            .map(([contract]) => ({
+            contractAddress: contract,
+            contract: contracts_1.contractsByAddress[contract.toLowerCase()],
+        }))
+            .filter(a => convexPools.includes(a.contract));
+    }
+    static prepareMultiCalls(creditAccount, cm, network) {
+        const calls = [];
+        const distribution = [];
+        const adapters = this.findAdapters(cm);
+        for (let a of adapters) {
             calls.push({
-                address: a.adapter,
+                address: a.contractAddress,
                 interface: RewardConvex.poolInterface,
                 method: "earned(address)",
                 params: [creditAccount],
             });
             distribution.push({
-                adapter: a.adapter,
+                contractAddress: a.contractAddress,
                 contract: a.contract,
                 token: "CRV",
             });
-            var params = contracts_1.contractParams[a.contract];
-            for (var _a = 0, _b = params.extraRewards; _a < _b.length; _a++) {
-                var er = _b[_a];
+            const params = contracts_1.contractParams[a.contract];
+            for (let er of params.extraRewards) {
                 calls.push({
                     address: er.poolAddress[network],
                     interface: RewardConvex.poolInterface,
@@ -120,42 +62,40 @@ var RewardConvex = /** @class */ (function () {
                     params: [creditAccount],
                 });
                 distribution.push({
-                    adapter: a.adapter,
+                    contractAddress: a.contractAddress,
                     contract: a.contract,
                     token: er.rewardToken,
                 });
             }
         }
         return {
-            calls: calls,
-            distribution: distribution,
+            calls,
+            distribution,
         };
-    };
-    RewardConvex.parseResults = function (creditAccount, rewards, distribution) {
-        var result = {};
-        var callData = RewardConvex.poolInterface.encodeFunctionData("getReward(address,bool)", [creditAccount, true]);
-        for (var i = 0; i < rewards.length; i++) {
-            var _a = distribution[i], contract = _a.contract, adapter = _a.adapter, token = _a.token;
-            var reward = rewards[i];
+    }
+    static parseResults(creditAccount, rewards, distribution) {
+        const result = {};
+        const callData = RewardConvex.poolInterface.encodeFunctionData("getReward(address,bool)", [creditAccount, true]);
+        for (let i = 0; i < rewards.length; i++) {
+            const { contract, contractAddress, token } = distribution[i];
+            const reward = rewards[i];
             if (!reward.isZero()) {
                 if (!result[contract]) {
                     result[contract] = {
-                        contract: contract,
+                        contract,
                         rewards: {},
                         calls: [
                             {
-                                target: adapter,
-                                callData: callData,
+                                target: contractAddress,
+                                callData,
                             },
                         ],
                     };
                 }
-                result[contract].rewards[token] = reward;
+                result[contract].rewards[token] = BigInt(reward.toString());
             }
         }
         return Object.values(result);
-    };
-    RewardConvex.poolInterface = types_1.IConvexV1BaseRewardPoolAdapter__factory.createInterface();
-    return RewardConvex;
-}());
+    }
+}
 exports.RewardConvex = RewardConvex;

package/lib/core/rewardConvex.spec.js

@@ -1,55 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var chai_1 = require("chai");
-var ethers_1 = require("ethers");
-var contracts_1 = require("../contracts/contracts");
-var constants_1 = require("./constants");
-var rewardConvex_1 = require("./rewardConvex");
-var ADAPTER_CONVEX_3CRV_POOL = constants_1.DUMB_ADDRESS;
-var ADAPTER_CURVE_FRAX_POOL = constants_1.DUMB_ADDRESS2;
-var ADAPTER_CONVEX_FRAX3CRV_POOL = constants_1.DUMB_ADDRESS3;
-var CREDIT_ACCOUNT = constants_1.DUMB_ADDRESS4;
-describe("RewardConvex test", function () {
-    it("findAdapters find convex adapters correctly", function () {
-        var _a;
-        var cm = {
-            adapters: (_a = {},
-                _a[contracts_1.contractsByNetwork.Mainnet.CONVEX_3CRV_POOL] = ADAPTER_CONVEX_3CRV_POOL,
-                _a[contracts_1.contractsByNetwork.Mainnet.CURVE_FRAX_POOL] = ADAPTER_CURVE_FRAX_POOL,
-                _a[contracts_1.contractsByNetwork.Goerli.CONVEX_FRAX3CRV_POOL] = ADAPTER_CONVEX_FRAX3CRV_POOL,
-                _a),
+const chai_1 = require("chai");
+const ethers_1 = require("ethers");
+const contracts_1 = require("../contracts/contracts");
+const constants_1 = require("./constants");
+const rewardConvex_1 = require("./rewardConvex");
+const ADAPTER_CONVEX_3CRV_POOL = constants_1.DUMB_ADDRESS;
+const ADAPTER_CURVE_FRAX_POOL = constants_1.DUMB_ADDRESS2;
+const ADAPTER_CONVEX_FRAX3CRV_POOL = constants_1.DUMB_ADDRESS3;
+const CREDIT_ACCOUNT = constants_1.DUMB_ADDRESS4;
+describe("RewardConvex test", () => {
+    it("findAdapters find convex adapters correctly", () => {
+        const cm = {
+            adapters: {
+                [contracts_1.contractsByNetwork.Mainnet.CONVEX_3CRV_POOL]: ADAPTER_CONVEX_3CRV_POOL,
+                [contracts_1.contractsByNetwork.Mainnet.CURVE_FRAX_POOL]: ADAPTER_CURVE_FRAX_POOL,
+                [contracts_1.contractsByNetwork.Goerli.CONVEX_FRAX3CRV_POOL]: ADAPTER_CONVEX_FRAX3CRV_POOL,
+            },
         };
-        var expectedResult = [
+        const expectedResult = [
             {
-                adapter: ADAPTER_CONVEX_3CRV_POOL,
                 contract: "CONVEX_3CRV_POOL",
+                contractAddress: contracts_1.contractsByNetwork.Mainnet.CONVEX_3CRV_POOL,
             },
             {
-                adapter: ADAPTER_CONVEX_FRAX3CRV_POOL,
                 contract: "CONVEX_FRAX3CRV_POOL",
+                contractAddress: contracts_1.contractsByNetwork.Goerli.CONVEX_FRAX3CRV_POOL,
             },
         ];
-        var result = rewardConvex_1.RewardConvex.findAdapters(cm);
+        const result = rewardConvex_1.RewardConvex.findAdapters(cm);
         (0, chai_1.expect)(result).to.be.eql(expectedResult);
     });
-    it("prepareMultiCalls prepares multicall data correctly", function () {
-        var _a;
-        var cm = {
-            adapters: (_a = {},
-                _a[contracts_1.contractsByNetwork.Mainnet.CONVEX_3CRV_POOL] = ADAPTER_CONVEX_3CRV_POOL,
-                _a[contracts_1.contractsByNetwork.Mainnet.CURVE_FRAX_POOL] = ADAPTER_CURVE_FRAX_POOL,
-                _a[contracts_1.contractsByNetwork.Goerli.CONVEX_FRAX3CRV_POOL] = ADAPTER_CONVEX_FRAX3CRV_POOL,
-                _a),
+    it("prepareMultiCalls prepares multicall data correctly", () => {
+        const cm = {
+            adapters: {
+                [contracts_1.contractsByNetwork.Mainnet.CONVEX_3CRV_POOL]: ADAPTER_CONVEX_3CRV_POOL,
+                [contracts_1.contractsByNetwork.Mainnet.CURVE_FRAX_POOL]: ADAPTER_CURVE_FRAX_POOL,
+                [contracts_1.contractsByNetwork.Goerli.CONVEX_FRAX3CRV_POOL]: ADAPTER_CONVEX_FRAX3CRV_POOL,
+            },
         };
-        var calls = [
+        const calls = [
             {
-                address: ADAPTER_CONVEX_3CRV_POOL,
+                address: contracts_1.contractsByNetwork.Mainnet.CONVEX_3CRV_POOL,
                 interface: rewardConvex_1.RewardConvex.poolInterface,
                 method: "earned(address)",
                 params: [CREDIT_ACCOUNT],
             },
             {
-                address: ADAPTER_CONVEX_FRAX3CRV_POOL,
+                address: contracts_1.contractsByNetwork.Goerli.CONVEX_FRAX3CRV_POOL,
                 interface: rewardConvex_1.RewardConvex.poolInterface,
                 method: "earned(address)",
                 params: [CREDIT_ACCOUNT],
@@ -62,74 +60,74 @@ describe("RewardConvex test", function () {
                 params: [CREDIT_ACCOUNT],
             },
         ];
-        var distribution = [
+        const distribution = [
             {
-                adapter: ADAPTER_CONVEX_3CRV_POOL,
+                contractAddress: contracts_1.contractsByNetwork.Mainnet.CONVEX_3CRV_POOL,
                 contract: "CONVEX_3CRV_POOL",
                 token: "CRV",
             },
             {
-                adapter: ADAPTER_CONVEX_FRAX3CRV_POOL,
+                contractAddress: contracts_1.contractsByNetwork.Goerli.CONVEX_FRAX3CRV_POOL,
                 contract: "CONVEX_FRAX3CRV_POOL",
                 token: "CRV",
             },
             {
-                adapter: ADAPTER_CONVEX_FRAX3CRV_POOL,
+                contractAddress: contracts_1.contractsByNetwork.Goerli.CONVEX_FRAX3CRV_POOL,
                 contract: "CONVEX_FRAX3CRV_POOL",
                 token: "FXS",
             },
         ];
-        var result = rewardConvex_1.RewardConvex.prepareMultiCalls(CREDIT_ACCOUNT, cm, "Mainnet");
-        (0, chai_1.expect)(result).to.be.eql({ calls: calls, distribution: distribution });
+        const result = rewardConvex_1.RewardConvex.prepareMultiCalls(CREDIT_ACCOUNT, cm, "Mainnet");
+        (0, chai_1.expect)(result).to.be.eql({ calls, distribution });
     });
-    it("parseResults parse data correctly", function () {
-        var rewards = [
-            ethers_1.BigNumber.from(1000),
-            ethers_1.BigNumber.from(2000),
-            ethers_1.BigNumber.from(4000),
+    it("parseResults parse data correctly", () => {
+        const rewards = [
+            ethers_1.BigNumber.from(1000n),
+            ethers_1.BigNumber.from(2000n),
+            ethers_1.BigNumber.from(4000n),
         ];
-        var distribution = [
+        const distribution = [
             {
-                adapter: ADAPTER_CONVEX_3CRV_POOL,
+                contractAddress: contracts_1.contractsByNetwork.Mainnet.CONVEX_3CRV_POOL,
                 contract: "CONVEX_3CRV_POOL",
                 token: "CRV",
             },
             {
-                adapter: ADAPTER_CONVEX_FRAX3CRV_POOL,
+                contractAddress: contracts_1.contractsByNetwork.Goerli.CONVEX_FRAX3CRV_POOL,
                 contract: "CONVEX_FRAX3CRV_POOL",
                 token: "CRV",
             },
             {
-                adapter: ADAPTER_CONVEX_FRAX3CRV_POOL,
+                contractAddress: contracts_1.contractsByNetwork.Goerli.CONVEX_FRAX3CRV_POOL,
                 contract: "CONVEX_FRAX3CRV_POOL",
                 token: "FXS",
             },
         ];
-        var parsed = rewardConvex_1.RewardConvex.parseResults(CREDIT_ACCOUNT, rewards, distribution);
-        var callData = rewardConvex_1.RewardConvex.poolInterface.encodeFunctionData("getReward(address,bool)", [CREDIT_ACCOUNT, true]);
-        var expected = [
+        const parsed = rewardConvex_1.RewardConvex.parseResults(CREDIT_ACCOUNT, rewards, distribution);
+        const callData = rewardConvex_1.RewardConvex.poolInterface.encodeFunctionData("getReward(address,bool)", [CREDIT_ACCOUNT, true]);
+        const expected = [
             {
                 contract: "CONVEX_3CRV_POOL",
                 rewards: {
-                    CRV: ethers_1.BigNumber.from(1000),
+                    CRV: 1000n,
                 },
                 calls: [
                     {
-                        target: ADAPTER_CONVEX_3CRV_POOL,
-                        callData: callData,
+                        target: contracts_1.contractsByNetwork.Mainnet.CONVEX_3CRV_POOL,
+                        callData,
                     },
                 ],
             },
             {
                 contract: "CONVEX_FRAX3CRV_POOL",
                 rewards: {
-                    CRV: ethers_1.BigNumber.from(2000),
-                    FXS: ethers_1.BigNumber.from(4000),
+                    CRV: 2000n,
+                    FXS: 4000n,
                 },
                 calls: [
                     {
-                        target: ADAPTER_CONVEX_FRAX3CRV_POOL,
-                        callData: callData,
+                        target: contracts_1.contractsByNetwork.Goerli.CONVEX_FRAX3CRV_POOL,
+                        callData,
                     },
                 ],
             },

package/lib/core/strategy.d.ts

@@ -1,4 +1,3 @@
-import { BigNumber } from "ethers";
 import { CreditManagerData } from "./creditManager";
 export interface StrategyPayload {
     apy?: number;
@@ -10,11 +9,11 @@ export interface StrategyPayload {
     baseAssets: Array<string>;
 }
 interface LiquidationPriceProps {
-    prices: Record<string, BigNumber>;
-    liquidationThresholds: Record<string, BigNumber>;
-    borrowed: BigNumber;
+    prices: Record<string, bigint>;
+    liquidationThresholds: Record<string, bigint>;
+    borrowed: bigint;
     underlyingToken: string;
-    lpAmount: BigNumber;
+    lpAmount: bigint;
     lpToken: string;
 }
 export declare class Strategy {
@@ -29,7 +28,7 @@ export declare class Strategy {
     static maxLeverage(lpToken: string, cms: Array<PartialCM>): number;
     maxAPY(baseAPY: number, maxLeverage: number, borrowAPY: number): number;
     overallAPY(apy: number, leverage: number, depositCollateral: string, borrowAPY: number): number;
-    static liquidationPrice({ prices, liquidationThresholds, borrowed, underlyingToken, lpAmount, lpToken, }: LiquidationPriceProps): BigNumber;
+    static liquidationPrice({ prices, liquidationThresholds, borrowed, underlyingToken, lpAmount, lpToken, }: LiquidationPriceProps): bigint;
     protected farmLev(leverage: number, depositCollateral: string): number;
     protected inBaseAssets(depositCollateral: string): boolean;
     protected inLeveragableAssets(depositCollateral: string): boolean;