@gearbox-protocol/sdk 1.22.4 → 1.23.1

package/lib/strategies/convex.js

@@ -1,64 +1,56 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConvexStrategies = exports.ConvexClaimZapMulticaller = exports.ConvexPoolMulticaller = exports.ConvexBoosterMulticaller = exports.ConvexClaimZapCalls = exports.ConvexPoolCalls = exports.ConvexBoosterCalls = void 0;
-var contracts_1 = require("../contracts/contracts");
-var token_1 = require("../tokens/token");
-var types_1 = require("../types");
-var curve_1 = require("./curve");
-var uniswapV2_1 = require("./uniswapV2");
-var ConvexBoosterCalls = /** @class */ (function () {
-    function ConvexBoosterCalls() {
-    }
-    ConvexBoosterCalls.deposit = function (pid, amount, stake) {
+const contracts_1 = require("../contracts/contracts");
+const token_1 = require("../tokens/token");
+const types_1 = require("../types");
+const curve_1 = require("./curve");
+const uniswapV2_1 = require("./uniswapV2");
+class ConvexBoosterCalls {
+    static deposit(pid, amount, stake) {
         return types_1.IBooster__factory.createInterface().encodeFunctionData("deposit", [
             pid,
             amount,
             stake,
         ]);
-    };
-    ConvexBoosterCalls.depositAll = function (pid, stake) {
+    }
+    static depositAll(pid, stake) {
         return types_1.IBooster__factory.createInterface().encodeFunctionData("depositAll", [pid, stake]);
-    };
-    ConvexBoosterCalls.withdraw = function (pid, amount) {
+    }
+    static withdraw(pid, amount) {
         return types_1.IBooster__factory.createInterface().encodeFunctionData("withdraw", [
             pid,
             amount,
         ]);
-    };
-    ConvexBoosterCalls.withdrawAll = function (pid) {
+    }
+    static withdrawAll(pid) {
         return types_1.IBooster__factory.createInterface().encodeFunctionData("withdrawAll", [pid]);
-    };
-    return ConvexBoosterCalls;
-}());
-exports.ConvexBoosterCalls = ConvexBoosterCalls;
-var ConvexPoolCalls = /** @class */ (function () {
-    function ConvexPoolCalls() {
     }
-    ConvexPoolCalls.stake = function (amount) {
+}
+exports.ConvexBoosterCalls = ConvexBoosterCalls;
+class ConvexPoolCalls {
+    static stake(amount) {
         return types_1.IConvexV1BaseRewardPoolAdapter__factory.createInterface().encodeFunctionData("stake", [amount]);
-    };
-    ConvexPoolCalls.stakeAll = function () {
+    }
+    static stakeAll() {
         return types_1.IConvexV1BaseRewardPoolAdapter__factory.createInterface().encodeFunctionData("stakeAll");
-    };
-    ConvexPoolCalls.withdraw = function (amount, claim) {
+    }
+    static withdraw(amount, claim) {
         return types_1.IConvexV1BaseRewardPoolAdapter__factory.createInterface().encodeFunctionData("withdraw", [amount, claim]);
-    };
-    ConvexPoolCalls.withdrawAll = function (claim) {
+    }
+    static withdrawAll(claim) {
         return types_1.IConvexV1BaseRewardPoolAdapter__factory.createInterface().encodeFunctionData("withdrawAll", [claim]);
-    };
-    ConvexPoolCalls.withdrawAndUnwrap = function (amount, claim) {
+    }
+    static withdrawAndUnwrap(amount, claim) {
         return types_1.IConvexV1BaseRewardPoolAdapter__factory.createInterface().encodeFunctionData("withdrawAndUnwrap", [amount, claim]);
-    };
-    ConvexPoolCalls.withdrawAllAndUnwrap = function (claim) {
+    }
+    static withdrawAllAndUnwrap(claim) {
         return types_1.IConvexV1BaseRewardPoolAdapter__factory.createInterface().encodeFunctionData("withdrawAllAndUnwrap", [claim]);
-    };
-    return ConvexPoolCalls;
-}());
-exports.ConvexPoolCalls = ConvexPoolCalls;
-var ConvexClaimZapCalls = /** @class */ (function () {
-    function ConvexClaimZapCalls() {
     }
-    ConvexClaimZapCalls.claimRewards = function (rewardContracts, extraRewardContracts, tokenRewardContracts, tokenRewardTokens, depositCrvMaxAmount, minAmountOut, depositCvxMaxAmount, spendCvxAmount, options) {
+}
+exports.ConvexPoolCalls = ConvexPoolCalls;
+class ConvexClaimZapCalls {
+    static claimRewards(rewardContracts, extraRewardContracts, tokenRewardContracts, tokenRewardTokens, depositCrvMaxAmount, minAmountOut, depositCvxMaxAmount, spendCvxAmount, options) {
         return types_1.IClaimZap__factory.createInterface().encodeFunctionData("claimRewards", [
             rewardContracts,
             extraRewardContracts,
@@ -70,163 +62,159 @@ var ConvexClaimZapCalls = /** @class */ (function () {
             spendCvxAmount,
             options,
         ]);
-    };
-    return ConvexClaimZapCalls;
-}());
+    }
+}
 exports.ConvexClaimZapCalls = ConvexClaimZapCalls;
-var ConvexBoosterMulticaller = /** @class */ (function () {
-    function ConvexBoosterMulticaller(address) {
+class ConvexBoosterMulticaller {
+    _address;
+    constructor(address) {
         this._address = address;
     }
-    ConvexBoosterMulticaller.connect = function (address) {
+    static connect(address) {
         return new ConvexBoosterMulticaller(address);
-    };
-    ConvexBoosterMulticaller.prototype.deposit = function (pid, amount, stake) {
+    }
+    deposit(pid, amount, stake) {
         return {
             target: this._address,
             callData: ConvexBoosterCalls.deposit(pid, amount, stake),
         };
-    };
-    ConvexBoosterMulticaller.prototype.depositAll = function (pid, stake) {
+    }
+    depositAll(pid, stake) {
         return {
             target: this._address,
             callData: ConvexBoosterCalls.depositAll(pid, stake),
         };
-    };
-    ConvexBoosterMulticaller.prototype.withdraw = function (pid, amount) {
+    }
+    withdraw(pid, amount) {
         return {
             target: this._address,
             callData: ConvexBoosterCalls.withdraw(pid, amount),
         };
-    };
-    ConvexBoosterMulticaller.prototype.withdrawAll = function (pid) {
+    }
+    withdrawAll(pid) {
         return {
             target: this._address,
             callData: ConvexBoosterCalls.withdrawAll(pid),
         };
-    };
-    return ConvexBoosterMulticaller;
-}());
+    }
+}
 exports.ConvexBoosterMulticaller = ConvexBoosterMulticaller;
-var ConvexPoolMulticaller = /** @class */ (function () {
-    function ConvexPoolMulticaller(address) {
+class ConvexPoolMulticaller {
+    _address;
+    constructor(address) {
         this._address = address;
     }
-    ConvexPoolMulticaller.connect = function (address) {
+    static connect(address) {
         return new ConvexPoolMulticaller(address);
-    };
-    ConvexPoolMulticaller.prototype.stake = function (amount) {
+    }
+    stake(amount) {
         return {
             target: this._address,
             callData: ConvexPoolCalls.stake(amount),
         };
-    };
-    ConvexPoolMulticaller.prototype.stakeAll = function () {
+    }
+    stakeAll() {
         return {
             target: this._address,
             callData: ConvexPoolCalls.stakeAll(),
         };
-    };
-    ConvexPoolMulticaller.prototype.withdraw = function (amount, claim) {
+    }
+    withdraw(amount, claim) {
         return {
             target: this._address,
             callData: ConvexPoolCalls.withdraw(amount, claim),
         };
-    };
-    ConvexPoolMulticaller.prototype.withdrawAll = function (claim) {
+    }
+    withdrawAll(claim) {
         return {
             target: this._address,
             callData: ConvexPoolCalls.withdrawAll(claim),
         };
-    };
-    ConvexPoolMulticaller.prototype.withdrawAndUnwrap = function (amount, claim) {
+    }
+    withdrawAndUnwrap(amount, claim) {
         return {
             target: this._address,
             callData: ConvexPoolCalls.withdrawAndUnwrap(amount, claim),
         };
-    };
-    ConvexPoolMulticaller.prototype.withdrawAllAndUnwrap = function (claim) {
+    }
+    withdrawAllAndUnwrap(claim) {
         return {
             target: this._address,
             callData: ConvexPoolCalls.withdrawAllAndUnwrap(claim),
         };
-    };
-    return ConvexPoolMulticaller;
-}());
+    }
+}
 exports.ConvexPoolMulticaller = ConvexPoolMulticaller;
-var ConvexClaimZapMulticaller = /** @class */ (function () {
-    function ConvexClaimZapMulticaller(address) {
+class ConvexClaimZapMulticaller {
+    _address;
+    constructor(address) {
         this._address = address;
     }
-    ConvexClaimZapMulticaller.connect = function (address) {
+    static connect(address) {
         return new ConvexClaimZapMulticaller(address);
-    };
-    ConvexClaimZapMulticaller.prototype.claimRewards = function (rewardContracts, extraRewardContracts, tokenRewardContracts, tokenRewardTokens, depositCrvMaxAmount, minAmountOut, depositCvxMaxAmount, spendCvxAmount, options) {
+    }
+    claimRewards(rewardContracts, extraRewardContracts, tokenRewardContracts, tokenRewardTokens, depositCrvMaxAmount, minAmountOut, depositCvxMaxAmount, spendCvxAmount, options) {
         return {
             target: this._address,
             callData: ConvexClaimZapCalls.claimRewards(rewardContracts, extraRewardContracts, tokenRewardContracts, tokenRewardTokens, depositCrvMaxAmount, minAmountOut, depositCvxMaxAmount, spendCvxAmount, options),
         };
-    };
-    return ConvexClaimZapMulticaller;
-}());
+    }
+}
 exports.ConvexClaimZapMulticaller = ConvexClaimZapMulticaller;
-var ConvexStrategies = /** @class */ (function () {
-    function ConvexStrategies() {
-    }
-    ConvexStrategies.underlyingToStakedConvex = function (data, network, convexPool, underlyingAmount) {
-        var calls = [];
-        var convexParams = contracts_1.contractParams[convexPool];
-        var stakedToken = convexParams.stakedToken;
-        var stakedTokenParams = token_1.supportedTokens[stakedToken];
-        var curveLpToken = stakedTokenParams.underlying;
-        var curveLpTokenData = token_1.supportedTokens[curveLpToken];
-        var curvePool = curveLpTokenData.pool;
+class ConvexStrategies {
+    static underlyingToStakedConvex(data, network, convexPool, underlyingAmount) {
+        let calls = [];
+        const convexParams = contracts_1.contractParams[convexPool];
+        const { stakedToken } = convexParams;
+        const stakedTokenParams = token_1.supportedTokens[stakedToken];
+        const curveLpToken = stakedTokenParams.underlying;
+        const curveLpTokenData = token_1.supportedTokens[curveLpToken];
+        const curvePool = curveLpTokenData.pool;
         calls = curve_1.CurveStrategies.underlyingToCurveLP(data, network, curvePool, underlyingAmount);
         calls.push(ConvexBoosterMulticaller.connect(data.adapters[contracts_1.contractsByNetwork[network].CONVEX_BOOSTER.toLowerCase()]).depositAll(stakedTokenParams.pid, true));
         return calls;
-    };
-    ConvexStrategies.stakedConvexToUnderlying = function (data, network, convexPool, convexLpAmount, sellRewards) {
-        var calls = [];
-        var convexParams = contracts_1.contractParams[convexPool];
-        var stakedToken = convexParams.stakedToken;
-        var stakedTokenParams = token_1.supportedTokens[stakedToken];
-        var curveLpToken = stakedTokenParams.underlying;
-        var curveLpTokenData = token_1.supportedTokens[curveLpToken];
-        var curvePool = curveLpTokenData.pool;
+    }
+    static stakedConvexToUnderlying(data, network, convexPool, convexLpAmount, sellRewards) {
+        const calls = [];
+        const convexParams = contracts_1.contractParams[convexPool];
+        const { stakedToken } = convexParams;
+        const stakedTokenParams = token_1.supportedTokens[stakedToken];
+        const curveLpToken = stakedTokenParams.underlying;
+        const curveLpTokenData = token_1.supportedTokens[curveLpToken];
+        const curvePool = curveLpTokenData.pool;
         calls.push(ConvexPoolMulticaller.connect(data.adapters[contracts_1.contractsByNetwork[network][convexPool].toLowerCase()]).withdrawAndUnwrap(convexLpAmount, true));
-        calls.push.apply(calls, curve_1.CurveStrategies.allCurveLPToUnderlying(data, network, curvePool));
+        calls.push(...curve_1.CurveStrategies.allCurveLPToUnderlying(data, network, curvePool));
         if (sellRewards) {
-            calls.push.apply(calls, ConvexStrategies.sellRewards(data, network, convexPool));
+            calls.push(...ConvexStrategies.sellRewards(data, network, convexPool));
         }
         return calls;
-    };
-    ConvexStrategies.allStakedConvexToUnderlying = function (data, network, convexPool, sellRewards) {
-        var calls = [];
-        var convexParams = contracts_1.contractParams[convexPool];
-        var stakedToken = convexParams.stakedToken;
-        var stakedTokenParams = token_1.supportedTokens[stakedToken];
-        var curveLpToken = stakedTokenParams.underlying;
-        var curveLpTokenData = token_1.supportedTokens[curveLpToken];
-        var curvePool = curveLpTokenData.pool;
+    }
+    static allStakedConvexToUnderlying(data, network, convexPool, sellRewards) {
+        const calls = [];
+        const convexParams = contracts_1.contractParams[convexPool];
+        const { stakedToken } = convexParams;
+        const stakedTokenParams = token_1.supportedTokens[stakedToken];
+        const curveLpToken = stakedTokenParams.underlying;
+        const curveLpTokenData = token_1.supportedTokens[curveLpToken];
+        const curvePool = curveLpTokenData.pool;
         calls.push(ConvexPoolMulticaller.connect(data.adapters[contracts_1.contractsByNetwork[network][convexPool].toLowerCase()]).withdrawAllAndUnwrap(true));
-        calls.push.apply(calls, curve_1.CurveStrategies.allCurveLPToUnderlying(data, network, curvePool));
+        calls.push(...curve_1.CurveStrategies.allCurveLPToUnderlying(data, network, curvePool));
         if (sellRewards) {
-            calls.push.apply(calls, ConvexStrategies.sellRewards(data, network, convexPool));
+            calls.push(...ConvexStrategies.sellRewards(data, network, convexPool));
         }
         return calls;
-    };
-    ConvexStrategies.sellRewards = function (data, network, convexPool) {
-        var calls = [];
-        var convexParams = contracts_1.contractParams[convexPool];
+    }
+    static sellRewards(data, network, convexPool) {
+        const calls = [];
+        const convexParams = contracts_1.contractParams[convexPool];
         calls.push(uniswapV2_1.UniswapV2Multicaller.connect(data.adapters[contracts_1.contractsByNetwork[network].UNISWAP_V2_ROUTER.toLowerCase()]).swapAllTokensForTokens(0, [token_1.tokenDataByNetwork[network].CRV, data.underlyingToken], Math.floor(new Date().getTime() / 1000) + 3600), uniswapV2_1.UniswapV2Multicaller.connect(data.adapters[contracts_1.contractsByNetwork[network].UNISWAP_V2_ROUTER.toLowerCase()]).swapAllTokensForTokens(0, [token_1.tokenDataByNetwork[network].CVX, data.underlyingToken], Math.floor(new Date().getTime() / 1000) + 3600));
-        convexParams.extraRewards.forEach(function (extraReward) {
+        convexParams.extraRewards.forEach(extraReward => {
             uniswapV2_1.UniswapV2Multicaller.connect(data.adapters[contracts_1.contractsByNetwork[network].UNISWAP_V2_ROUTER.toLowerCase()]).swapAllTokensForTokens(0, [
                 token_1.tokenDataByNetwork[network][extraReward.rewardToken],
                 data.underlyingToken,
             ], Math.floor(new Date().getTime() / 1000) + 3600);
         });
         return calls;
-    };
-    return ConvexStrategies;
-}());
+    }
+}
 exports.ConvexStrategies = ConvexStrategies;

package/lib/strategies/creditFacade.js

@@ -1,74 +1,71 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CreditFacadeMulticaller = exports.CreditFacadeCalls = void 0;
-var types_1 = require("../types");
-var CreditFacadeCalls = /** @class */ (function () {
-    function CreditFacadeCalls() {
-    }
-    CreditFacadeCalls.addCollateral = function (onBehalfOf, token, amount) {
+const types_1 = require("../types");
+class CreditFacadeCalls {
+    static addCollateral(onBehalfOf, token, amount) {
         return types_1.ICreditFacade__factory.createInterface().encodeFunctionData("addCollateral", [onBehalfOf, token, amount]);
-    };
-    CreditFacadeCalls.increaseDebt = function (amount) {
+    }
+    static increaseDebt(amount) {
         return types_1.ICreditFacade__factory.createInterface().encodeFunctionData("increaseDebt", [amount]);
-    };
-    CreditFacadeCalls.decreaseDebt = function (amount) {
+    }
+    static decreaseDebt(amount) {
         return types_1.ICreditFacade__factory.createInterface().encodeFunctionData("decreaseDebt", [amount]);
-    };
-    CreditFacadeCalls.revertIfBalanceLessThan = function (token, minBalance) {
-        return types_1.ICreditFacadeExtended__factory.createInterface().encodeFunctionData("revertIfReceivedLessThan", [[{ token: token, balance: minBalance }]]);
-    };
-    CreditFacadeCalls.disableToken = function (token) {
+    }
+    static revertIfBalanceLessThan(token, minBalance) {
+        return types_1.ICreditFacadeExtended__factory.createInterface().encodeFunctionData("revertIfReceivedLessThan", [[{ token, balance: minBalance }]]);
+    }
+    static disableToken(token) {
         return types_1.ICreditFacadeExtended__factory.createInterface().encodeFunctionData("disableToken", [token]);
-    };
-    CreditFacadeCalls.enableToken = function (token) {
+    }
+    static enableToken(token) {
         return types_1.ICreditFacade__factory.createInterface().encodeFunctionData("enableToken", [token]);
-    };
-    return CreditFacadeCalls;
-}());
+    }
+}
 exports.CreditFacadeCalls = CreditFacadeCalls;
-var CreditFacadeMulticaller = /** @class */ (function () {
-    function CreditFacadeMulticaller(address) {
+class CreditFacadeMulticaller {
+    _address;
+    constructor(address) {
         this._address = address;
     }
-    CreditFacadeMulticaller.connect = function (address) {
+    static connect(address) {
         return new CreditFacadeMulticaller(address);
-    };
-    CreditFacadeMulticaller.prototype.addCollateral = function (onBehalfOf, token, amount) {
+    }
+    addCollateral(onBehalfOf, token, amount) {
         return {
             target: this._address,
             callData: CreditFacadeCalls.addCollateral(onBehalfOf, token, amount),
         };
-    };
-    CreditFacadeMulticaller.prototype.increaseDebt = function (amount) {
+    }
+    increaseDebt(amount) {
         return {
             target: this._address,
             callData: CreditFacadeCalls.increaseDebt(amount),
         };
-    };
-    CreditFacadeMulticaller.prototype.decreaseDebt = function (amount) {
+    }
+    decreaseDebt(amount) {
         return {
             target: this._address,
             callData: CreditFacadeCalls.decreaseDebt(amount),
         };
-    };
-    CreditFacadeMulticaller.prototype.revertIfBalanceLessThan = function (token, minBalance) {
+    }
+    revertIfBalanceLessThan(token, minBalance) {
         return {
             target: this._address,
             callData: CreditFacadeCalls.revertIfBalanceLessThan(token, minBalance),
         };
-    };
-    CreditFacadeMulticaller.prototype.disableToken = function (token) {
+    }
+    disableToken(token) {
         return {
             target: this._address,
             callData: CreditFacadeCalls.disableToken(token),
         };
-    };
-    CreditFacadeMulticaller.prototype.enableToken = function (token) {
+    }
+    enableToken(token) {
         return {
             target: this._address,
             callData: CreditFacadeCalls.enableToken(token),
         };
-    };
-    return CreditFacadeMulticaller;
-}());
+    }
+}
 exports.CreditFacadeMulticaller = CreditFacadeMulticaller;