@curvefi/api 2.37.0 → 2.39.0

package/README.md

@@ -26,6 +26,7 @@ import curve from "@curvefi/api";
     await curve.factory.fetchPools();
     await curve.crvUSDFactory.fetchPools();
     await curve.cryptoFactory.fetchPools();
+    await curve.tricryptoFactory.fetchPools();
 })()
 ```
 **Note 1.** ```chainId``` parameter is optional, but you must specify it in the case you use Metamask on localhost network, because Metamask has that [bug](https://hardhat.org/metamask-issue.html)
@@ -188,6 +189,7 @@ import curve from "@curvefi/api";
     await curve.factory.fetchPools();
     await curve.crvUSDFactory.fetchPools();
     await curve.cryptoFactory.fetchPools();
+    await curve.tricryptoFactory.fetchPools();
 
     curve.getMainPoolList();
     // [
@@ -264,6 +266,9 @@ import curve from "@curvefi/api";
     //     'factory-crypto-60', 'factory-crypto-61', 'factory-crypto-62'
     // ]
 
+    curve.tricryptoFactory.getPoolList();
+    // ['factory-tricrypto-0', 'factory-tricrypto-1']
+
     curve.getPoolList();
     // [
     //     'compound',      'usdt',          'y',             'busd',
@@ -305,6 +310,7 @@ import curve from "@curvefi/api";
     await curve.factory.fetchPools();
     await curve.crvUSDFactory.fetchPools();
     await curve.cryptoFactory.fetchPools();
+    await curve.tricryptoFactory.fetchPools();
 
     const pool = curve.getPool('factory-v2-11');
 
@@ -1011,6 +1017,7 @@ import curve from "@curvefi/api";
     await curve.factory.fetchPools();
     await curve.crvUSDFactory.fetchPools();
     await curve.cryptoFactory.fetchPools();
+    await curve.tricryptoFactory.fetchPools();
 
     await curve.getBalances(['DAI', 'CRV']);
     // [ '9900.0', '100049.744832225238317557' ]
@@ -1144,6 +1151,42 @@ import curve from "@curvefi/api";
     // 0.0
 })()
 ```
+### Sidechain
+```ts
+import curve from "@curvefi/api";
+
+(async () => {
+
+    // --- SIDECHAIN ---
+
+    await curve.init('JsonRpc', {}, { gasPrice: 0, maxFeePerGas: 0, maxPriorityFeePerGas: 0 });
+
+    await curve.boosting.sidechain.lastBlockhash();
+    // 16931944
+    await curve.boosting.sidechain.checkBlockhash(17377005);
+    // false
+    
+    await curve.boosting.sidechain.getAnycallBalance();
+    // 0.033837278711248954
+    await curve.boosting.sidechain.topUpAnycall(0.1);
+    await curve.boosting.sidechain.getAnycallBalance();
+    // 0.133837278711248954
+
+
+    // --- MAINNET (ETHEREUM) ---
+
+    await curve.init('JsonRpc', {}, { gasPrice: 0, maxFeePerGas: 0, maxPriorityFeePerGas: 0 });
+    await curve.boosting.sidechain.sendBlockhash(17377005, 137); // Polygon
+
+    // --- SIDECHAIN ---
+
+    await curve.init('JsonRpc', {}, { gasPrice: 0, maxFeePerGas: 0, maxPriorityFeePerGas: 0 });
+    await curve.boosting.sidechain.checkBlockhash(17377005);
+    // true
+    await curve.boosting.sidechain.submitProof(17377005, "0x33A4622B82D4c04a53e170c638B944ce27cffce3");
+})()
+```
+
 
 ## CRV. Profit, claim, boosting
 ```ts
@@ -1333,12 +1376,15 @@ import curve from "@curvefi/api";
     // Fetch pools from api (if false arg is not passed)
     await curve.factory.fetchPools();
     await curve.cryptoFactory.fetchPools();
+    await curve.tricryptoFactory.fetchPools();
 
     // Fetch very new pools (that haven't been added to api yet) from blockchain
     await curve.factory.fetchNewPools();
     // [ 'factory-v2-285' ]
     await curve.cryptoFactory.fetchNewPools();
     // [ 'factory-crypto-232' ]
+    await curve.tricryptoFactory.fetchNewPools();
+    // [ 'factory-tricrypto-2' ]
 })()
 ```
 

package/lib/boosting.d.ts

@@ -1,4 +1,4 @@
-import { IDict } from "./interfaces";
+import { IDict, IChainId } from "./interfaces";
 export declare const getCrv: (...addresses: string[] | string[][]) => Promise<IDict<string> | string>;
 export declare const getLockedAmountAndUnlockTime: (...addresses: string[] | string[][]) => Promise<IDict<{
     lockedAmount: string;
@@ -24,3 +24,12 @@ export declare const withdrawLockedCrv: () => Promise<string>;
 export declare const claimableFees: (address?: string) => Promise<string>;
 export declare const claimFeesEstimateGas: (address?: string) => Promise<number>;
 export declare const claimFees: (address?: string) => Promise<string>;
+export declare const lastBlockhash: () => Promise<number>;
+export declare const checkBlockhash: (block: number) => Promise<boolean>;
+export declare const getAnycallBalance: () => Promise<string>;
+export declare const topUpAnycallEstimateGas: (amount?: number | string) => Promise<number>;
+export declare const topUpAnycall: (amount?: number | string) => Promise<string>;
+export declare const sendBlockhashEstimateGas: (block: number, chainId: IChainId) => Promise<number>;
+export declare const sendBlockhash: (block: number, chainId: IChainId) => Promise<string>;
+export declare const submitProofEstimateGas: (block: number, address?: string) => Promise<number>;
+export declare const submitProof: (block: number, address?: string) => Promise<string>;

package/lib/boosting.js

@@ -50,6 +50,7 @@ import { curve } from "./curve.js";
 import feeDistributorViewABI from "./constants/abis/fee_distributor_view.json" assert { type: 'json' };
 import { _getBalances, _prepareAddresses, ensureAllowance, ensureAllowanceEstimateGas, hasAllowance, mulBy1_3 } from "./utils.js";
 import { _ensureAllowance, toBN, toStringFromBN, parseUnits } from './utils.js';
+import { _generateBoostingProof } from './external-api.js';
 export var getCrv = function () {
     var addresses = [];
     for (var _i = 0; _i < arguments.length; _i++) {
@@ -400,3 +401,191 @@ export var claimFees = function (address) {
         });
     });
 };
+//  ------------ SIDECHAIN ------------
+export var lastBlockhash = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var veOracleContract, _a;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                if (curve.chainId === 1)
+                    throw Error("There is no lastBlock method on ethereum network");
+                veOracleContract = curve.contracts[curve.constants.ALIASES.voting_escrow_oracle].contract;
+                _a = Number;
+                return [4 /*yield*/, veOracleContract.last_eth_block_number(curve.constantOptions)];
+            case 1: return [2 /*return*/, _a.apply(void 0, [_b.sent()])];
+        }
+    });
+}); };
+export var checkBlockhash = function (block) { return __awaiter(void 0, void 0, void 0, function () {
+    var veOracleContract, e_1;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (curve.chainId === 1)
+                    throw Error("There is no checkBlockhash method on ethereum network");
+                veOracleContract = curve.contracts[curve.constants.ALIASES.voting_escrow_oracle].contract;
+                _a.label = 1;
+            case 1:
+                _a.trys.push([1, 3, , 4]);
+                return [4 /*yield*/, veOracleContract.get_eth_blockhash(block, curve.constantOptions)];
+            case 2:
+                _a.sent();
+                return [2 /*return*/, true];
+            case 3:
+                e_1 = _a.sent();
+                return [2 /*return*/, false];
+            case 4: return [2 /*return*/];
+        }
+    });
+}); };
+export var getAnycallBalance = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var anycallContract, _balance;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (curve.chainId === 1)
+                    throw Error("There is no getAnycallBalance method on ethereum network");
+                anycallContract = curve.contracts[curve.constants.ALIASES.anycall].contract;
+                return [4 /*yield*/, anycallContract.executionBudget(curve.constants.ALIASES.voting_escrow_oracle, curve.constantOptions)];
+            case 1:
+                _balance = _a.sent();
+                return [2 /*return*/, curve.formatUnits(_balance)];
+        }
+    });
+}); };
+var DEFAULT_AMOUNT = (curve.chainId === 42161 || curve.chainId === 10) ? 0.00001 : 0.1;
+var _topUpAnycall = function (amount, estimateGas) { return __awaiter(void 0, void 0, void 0, function () {
+    var anycallContract, value, gas, gasLimit;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (curve.chainId === 1)
+                    throw Error("There is no topUpAnycall method on ethereum network");
+                anycallContract = curve.contracts[curve.constants.ALIASES.anycall].contract;
+                value = curve.parseUnits(String(amount));
+                return [4 /*yield*/, anycallContract.deposit.estimateGas(curve.constants.ALIASES.voting_escrow_oracle, __assign(__assign({}, curve.constantOptions), { value: value }))];
+            case 1:
+                gas = _a.sent();
+                if (estimateGas)
+                    return [2 /*return*/, Number(gas)];
+                return [4 /*yield*/, curve.updateFeeData()];
+            case 2:
+                _a.sent();
+                gasLimit = mulBy1_3(gas);
+                return [4 /*yield*/, anycallContract.deposit(curve.constants.ALIASES.voting_escrow_oracle, __assign(__assign({}, curve.options), { gasLimit: gasLimit, value: value }))];
+            case 3: return [2 /*return*/, (_a.sent()).hash];
+        }
+    });
+}); };
+export var topUpAnycallEstimateGas = function (amount) {
+    if (amount === void 0) { amount = DEFAULT_AMOUNT; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, _topUpAnycall(amount, true)];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
+};
+export var topUpAnycall = function (amount) {
+    if (amount === void 0) { amount = DEFAULT_AMOUNT; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, _topUpAnycall(amount, false)];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
+};
+var _sendBlockhash = function (block, chainId, estimateGas) { return __awaiter(void 0, void 0, void 0, function () {
+    var veOracleContract, gas, gasLimit;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                if (curve.chainId !== 1)
+                    throw Error("sendBlockhash method is on ethereum network only");
+                veOracleContract = curve.contracts[curve.constants.ALIASES.voting_escrow_oracle].contract;
+                return [4 /*yield*/, veOracleContract.send_blockhash.estimateGas(block, chainId, curve.constantOptions)];
+            case 1:
+                gas = _a.sent();
+                if (estimateGas)
+                    return [2 /*return*/, Number(gas)];
+                return [4 /*yield*/, curve.updateFeeData()];
+            case 2:
+                _a.sent();
+                gasLimit = mulBy1_3(gas);
+                return [4 /*yield*/, veOracleContract.deposit(curve.constants.ALIASES.voting_escrow_oracle, __assign(__assign({}, curve.options), { gasLimit: gasLimit }))];
+            case 3: return [2 /*return*/, (_a.sent()).hash];
+        }
+    });
+}); };
+export var sendBlockhashEstimateGas = function (block, chainId) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, _sendBlockhash(block, chainId, true)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+export var sendBlockhash = function (block, chainId) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, _sendBlockhash(block, chainId, false)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+var _submitProof = function (block, address, estimateGas) {
+    if (address === void 0) { address = curve.signerAddress; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        var proof, veOracleContract, gas, gasLimit;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    if (curve.chainId === 1)
+                        throw Error("submitProof method is on ethereum network only");
+                    if (address === "")
+                        throw Error("Pass address you want to submit proof for");
+                    return [4 /*yield*/, _generateBoostingProof(block, address)];
+                case 1:
+                    proof = _a.sent();
+                    veOracleContract = curve.contracts[curve.constants.ALIASES.voting_escrow_oracle].contract;
+                    return [4 /*yield*/, veOracleContract.submit_state.estimateGas(address, "0x" + proof.block_header_rlp, "0x" + proof.proof_rlp, curve.constantOptions)];
+                case 2:
+                    gas = _a.sent();
+                    if (estimateGas)
+                        return [2 /*return*/, Number(gas)];
+                    return [4 /*yield*/, curve.updateFeeData()];
+                case 3:
+                    _a.sent();
+                    gasLimit = mulBy1_3(gas);
+                    return [4 /*yield*/, veOracleContract.submit_state(address, "0x" + proof.block_header_rlp, "0x" + proof.proof_rlp, __assign(__assign({}, curve.options), { gasLimit: gasLimit }))];
+                case 4: return [2 /*return*/, (_a.sent()).hash];
+            }
+        });
+    });
+};
+export var submitProofEstimateGas = function (block, address) {
+    if (address === void 0) { address = curve.signerAddress; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, _submitProof(block, address, true)];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
+};
+export var submitProof = function (block, address) {
+    if (address === void 0) { address = curve.signerAddress; }
+    return __awaiter(void 0, void 0, void 0, function () {
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, _submitProof(block, address, false)];
+                case 1: return [2 /*return*/, _a.sent()];
+            }
+        });
+    });
+};