@curvefi/api 2.59.1 → 2.60.1

package/lib/constants/abis/gauge_factory.json

@@ -875,5 +875,29 @@
             }
         ],
         "gas": "3648"
+    },
+    {
+        "stateMutability": "view",
+        "type": "function",
+        "name": "manager",
+        "inputs": [],
+        "outputs": [
+            {
+                "name": "",
+                "type": "address"
+            }
+        ]
+    },
+    {
+        "stateMutability": "view",
+        "type": "function",
+        "name": "version",
+        "inputs": [],
+        "outputs": [
+            {
+                "name": "",
+                "type": "string"
+            }
+        ]
     }
 ]

package/lib/factory/deploy.js

@@ -384,8 +384,6 @@ implementationIdx, methodName, oracleAddress, estimateGas) {
                         throw Error("Max name length = 32");
                     if (symbol.length > 10)
                         throw Error("Max symbol length = 10");
-                    if (BN(fee).lt(0.04))
-                        throw Error("fee must be >= 0.04%. Passed fee = ".concat(fee));
                     if (BN(fee).gt(1))
                         throw Error("fee must be <= 1%. Passed fee = ".concat(fee));
                     if (![0, 1].includes(implementationIdx))

package/lib/pools/PoolTemplate.d.ts

@@ -34,16 +34,22 @@ export declare class PoolTemplate {
     inApi: boolean;
     isGaugeKilled: () => Promise<boolean>;
     gaugeStatus: () => Promise<any>;
+    gaugeManager: () => Promise<string>;
+    gaugeDistributors: () => Promise<IDict<string>>;
+    gaugeVersion: () => Promise<string | null>;
     estimateGas: {
         depositApprove: (amounts: (number | string)[]) => Promise<number | number[]>;
         deposit: (amounts: (number | string)[]) => Promise<number | number[]>;
+        depositRewardApprove: (rewardToken: string, amount: number | string) => Promise<number | number[]>;
         depositWrappedApprove: (amounts: (number | string)[]) => Promise<number | number[]>;
+        depositReward: (rewardToken: string, amount: string | number, epoch: number) => Promise<number | number[]>;
         depositWrapped: (amounts: (number | string)[]) => Promise<number | number[]>;
         stakeApprove: (lpTokenAmount: number | string) => Promise<number | number[]>;
         stake: (lpTokenAmount: number | string) => Promise<number | number[]>;
         unstake: (lpTokenAmount: number | string) => Promise<number | number[]>;
         claimCrv: () => Promise<number | number[]>;
         claimRewards: () => Promise<number | number[]>;
+        addReward: (rewardToken: string, distributor: string) => Promise<number | number[]>;
         depositAndStakeApprove: (amounts: (number | string)[]) => Promise<number | number[]>;
         depositAndStake: (amounts: (number | string)[]) => Promise<number>;
         depositAndStakeWrappedApprove: (amounts: (number | string)[]) => Promise<number | number[]>;
@@ -263,5 +269,18 @@ export declare class PoolTemplate {
     private _underlyingPrices;
     private _wrappedPrices;
     private getGaugeStatus;
+    private _addReward;
+    addRewardEstimateGas(rewardToken: string, distributor: string): Promise<number | number[]>;
+    addReward(rewardToken: string, distributor: string): Promise<string>;
+    private getGaugeManager;
+    private getGaugeVersion;
+    isDepositRewardAvailable(): Promise<boolean>;
+    getGaugeDistributors(): Promise<IDict<string>>;
+    depositRewardIsApproved(rewardToken: string, amount: number | string): Promise<boolean>;
+    private depositRewardApproveEstimateGas;
+    depositRewardApprove(rewardToken: string, amount: number | string): Promise<string[]>;
+    private _depositReward;
+    depositRewardEstimateGas(rewardToken: string, amount: string | number, epoch: number): Promise<number | number[]>;
+    depositReward(rewardToken: string, amount: string | number, epoch: number): Promise<string>;
     private getIsGaugeKilled;
 }

package/lib/pools/PoolTemplate.js

@@ -1182,16 +1182,23 @@ var PoolTemplate = /** @class */ (function () {
         this.inApi = (_d = poolData.in_api) !== null && _d !== void 0 ? _d : false;
         this.isGaugeKilled = this.getIsGaugeKilled.bind(this);
         this.gaugeStatus = this.getGaugeStatus.bind(this);
+        this.gaugeManager = this.getGaugeManager.bind(this);
+        this.gaugeDistributors = this.getGaugeDistributors.bind(this);
+        this.gaugeVersion = this.getGaugeVersion.bind(this);
+        this.addReward = this.addReward.bind(this);
         this.estimateGas = {
             depositApprove: this.depositApproveEstimateGas.bind(this),
             deposit: this.depositEstimateGas.bind(this),
             depositWrappedApprove: this.depositWrappedApproveEstimateGas.bind(this),
+            depositReward: this.depositRewardEstimateGas.bind(this),
             depositWrapped: this.depositWrappedEstimateGas.bind(this),
+            depositRewardApprove: this.depositRewardApproveEstimateGas.bind(this),
             stakeApprove: this.stakeApproveEstimateGas.bind(this),
             stake: this.stakeEstimateGas.bind(this),
             unstake: this.unstakeEstimateGas.bind(this),
             claimCrv: this.claimCrvEstimateGas.bind(this),
             claimRewards: this.claimRewardsEstimateGas.bind(this),
+            addReward: this.addRewardEstimateGas.bind(this),
             depositAndStakeApprove: this.depositAndStakeApproveEstimateGas.bind(this),
             depositAndStake: this.depositAndStakeEstimateGas.bind(this),
             depositAndStakeWrappedApprove: this.depositAndStakeWrappedApproveEstimateGas.bind(this),
@@ -3367,6 +3374,224 @@ var PoolTemplate = /** @class */ (function () {
             });
         });
     };
+    PoolTemplate.prototype._addReward = function (_reward_token, _distributor, estimateGas) {
+        if (estimateGas === void 0) { estimateGas = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var gas, gasLimit;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!(this.gauge !== curve.constants.ZERO_ADDRESS && this.gauge)) return [3 /*break*/, 3];
+                        return [4 /*yield*/, curve.contracts[this.gauge].contract.add_reward.estimateGas(_reward_token, _distributor, __assign({}, curve.constantOptions))];
+                    case 1:
+                        gas = _c.sent();
+                        if (estimateGas)
+                            return [2 /*return*/, smartNumber(gas)];
+                        gasLimit = mulBy1_3(DIGas(gas));
+                        return [4 /*yield*/, curve.contracts[this.gauge].contract.add_reward(_reward_token, _distributor, __assign(__assign({}, curve.options), { gasLimit: gasLimit }))];
+                    case 2: return [2 /*return*/, (_c.sent()).hash];
+                    case 3: throw Error("Pool ".concat(this.name, " does not have gauge"));
+                }
+            });
+        });
+    };
+    PoolTemplate.prototype.addRewardEstimateGas = function (rewardToken, distributor) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this._addReward(rewardToken, distributor, true)];
+                    case 1: 
+                    // @ts-ignore
+                    return [2 /*return*/, _c.sent()];
+                }
+            });
+        });
+    };
+    PoolTemplate.prototype.addReward = function (rewardToken, distributor) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this._addReward(rewardToken, distributor)];
+                    case 1: 
+                    // @ts-ignore
+                    return [2 /*return*/, _c.sent()];
+                }
+            });
+        });
+    };
+    PoolTemplate.prototype.getGaugeManager = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var e_4;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!(!this.gauge || this.gauge === curve.constants.ZERO_ADDRESS)) return [3 /*break*/, 1];
+                        return [2 /*return*/, curve.constants.ZERO_ADDRESS];
+                    case 1:
+                        _c.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, curve.contracts[this.gauge].contract.manager()];
+                    case 2: return [2 /*return*/, _c.sent()];
+                    case 3:
+                        e_4 = _c.sent();
+                        return [2 /*return*/, curve.constants.ZERO_ADDRESS];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    PoolTemplate.prototype.getGaugeVersion = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var e_5;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!(!this.gauge || this.gauge === curve.constants.ZERO_ADDRESS)) return [3 /*break*/, 1];
+                        return [2 /*return*/, null];
+                    case 1:
+                        _c.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, curve.contracts[this.gauge].contract.version()];
+                    case 2: return [2 /*return*/, _c.sent()];
+                    case 3:
+                        e_5 = _c.sent();
+                        return [2 /*return*/, null];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    PoolTemplate.prototype.isDepositRewardAvailable = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var versionsWithDepositReward, version;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        versionsWithDepositReward = ['v6.1.0'];
+                        return [4 /*yield*/, this.getGaugeVersion()];
+                    case 1:
+                        version = _c.sent();
+                        return [2 /*return*/, version ? versionsWithDepositReward.includes(version) : Boolean(version)];
+                }
+            });
+        });
+    };
+    PoolTemplate.prototype.getGaugeDistributors = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var gaugeContract, gaugeMulticallContract, rewardCount, _c, _d, _e, calls, i, rewardTokens, i, rewardData, gaugeDistributors, i;
+            return __generator(this, function (_f) {
+                switch (_f.label) {
+                    case 0: return [4 /*yield*/, curve.contracts[this.gauge].contract];
+                    case 1:
+                        gaugeContract = _f.sent();
+                        return [4 /*yield*/, curve.contracts[this.gauge].multicallContract];
+                    case 2:
+                        gaugeMulticallContract = _f.sent();
+                        _c = Number;
+                        _e = (_d = curve).formatUnits;
+                        return [4 /*yield*/, gaugeContract.reward_count(curve.constantOptions)];
+                    case 3:
+                        rewardCount = _c.apply(void 0, [_e.apply(_d, [_f.sent(), 0])]);
+                        calls = [];
+                        for (i = 0; i < rewardCount; i++) {
+                            calls.push(gaugeMulticallContract.reward_tokens(i));
+                        }
+                        return [4 /*yield*/, curve.multicallProvider.all(calls)];
+                    case 4:
+                        rewardTokens = _f.sent();
+                        for (i = 0; i < rewardCount; i++) {
+                            calls.push(gaugeMulticallContract.reward_data(rewardTokens[i]));
+                        }
+                        return [4 /*yield*/, curve.multicallProvider.all(calls)];
+                    case 5:
+                        rewardData = _f.sent();
+                        gaugeDistributors = {};
+                        for (i = 0; i < rewardCount; i++) {
+                            gaugeDistributors[rewardTokens[i]] = rewardData[i];
+                        }
+                        return [2 /*return*/, gaugeDistributors];
+                }
+            });
+        });
+    };
+    PoolTemplate.prototype.depositRewardIsApproved = function (rewardToken, amount) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, hasAllowance([rewardToken], [amount], curve.signerAddress, this.gauge)];
+                    case 1: return [2 /*return*/, _c.sent()];
+                }
+            });
+        });
+    };
+    PoolTemplate.prototype.depositRewardApproveEstimateGas = function (rewardToken, amount) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, ensureAllowanceEstimateGas([rewardToken], [amount], this.gauge)];
+                    case 1: return [2 /*return*/, _c.sent()];
+                }
+            });
+        });
+    };
+    PoolTemplate.prototype.depositRewardApprove = function (rewardToken, amount) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, ensureAllowance([rewardToken], [amount], this.gauge)];
+                    case 1: return [2 /*return*/, _c.sent()];
+                }
+            });
+        });
+    };
+    PoolTemplate.prototype._depositReward = function (rewardToken, amount, epoch, estimateGas) {
+        if (estimateGas === void 0) { estimateGas = false; }
+        return __awaiter(this, void 0, void 0, function () {
+            var contract, gas, gasLimit;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        if (!!estimateGas) return [3 /*break*/, 2];
+                        return [4 /*yield*/, ensureAllowance([rewardToken], [amount], this.gauge)];
+                    case 1:
+                        _c.sent();
+                        _c.label = 2;
+                    case 2:
+                        contract = curve.contracts[this.gauge].contract;
+                        return [4 /*yield*/, contract.deposit_reward_token.estimateGas(rewardToken, amount, __assign({}, curve.constantOptions))];
+                    case 3:
+                        gas = _c.sent();
+                        if (estimateGas)
+                            return [2 /*return*/, smartNumber(gas)];
+                        gasLimit = mulBy1_3(DIGas(gas));
+                        return [4 /*yield*/, contract.deposit_reward_token(rewardToken, amount, __assign(__assign({}, curve.options), { gasLimit: gasLimit }))];
+                    case 4: return [2 /*return*/, (_c.sent()).hash];
+                }
+            });
+        });
+    };
+    PoolTemplate.prototype.depositRewardEstimateGas = function (rewardToken, amount, epoch) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this._depositReward(rewardToken, amount, epoch, true)];
+                    case 1: 
+                    // @ts-ignore
+                    return [2 /*return*/, _c.sent()];
+                }
+            });
+        });
+    };
+    PoolTemplate.prototype.depositReward = function (rewardToken, amount, epoch) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0: return [4 /*yield*/, this._depositReward(rewardToken, amount, epoch)];
+                    case 1: 
+                    // @ts-ignore
+                    return [2 /*return*/, _c.sent()];
+                }
+            });
+        });
+    };
     PoolTemplate.prototype.getIsGaugeKilled = function () {
         return __awaiter(this, void 0, void 0, function () {
             var gaugeData;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@curvefi/api",
-  "version": "2.59.1",
+  "version": "2.60.1",
   "description": "JavaScript library for curve.fi",
   "main": "lib/index.js",
   "author": "Macket",