@curvefi/api 2.30.1 → 2.31.1

package/lib/index.d.ts

@@ -1,11 +1,10 @@
-import { ethers } from "ethers";
-import { Networkish } from "@ethersproject/networks";
-import { PoolTemplate } from "./pools";
+import { ethers, Networkish } from "ethers";
+import { PoolTemplate } from "./pools/index.js";
 declare function init(providerType: 'JsonRpc' | 'Web3' | 'Infura' | 'Alchemy', providerSettings: {
     url?: string;
     privateKey?: string;
 } | {
-    externalProvider: ethers.providers.ExternalProvider;
+    externalProvider: ethers.Eip1193Provider;
 } | {
     network?: Networkish;
     apiKey?: string;
@@ -39,8 +38,8 @@ declare const curve: {
     PoolTemplate: typeof PoolTemplate;
     getPool: (poolId: string) => PoolTemplate;
     getUsdRate: (coin: string) => Promise<number>;
-    getTVL: (network?: import("./interfaces").INetworkName | import("./interfaces").IChainId) => Promise<number>;
-    getBalances: (coins: string[], ...addresses: string[] | string[][]) => Promise<string[] | import("./interfaces").IDict<string[]>>;
+    getTVL: (network?: import("./interfaces.js").INetworkName | import("./interfaces.js").IChainId) => Promise<number>;
+    getBalances: (coins: string[], ...addresses: string[] | string[][]) => Promise<string[] | import("./interfaces.js").IDict<string[]>>;
     getAllowance: (coins: string[], address: string, spender: string) => Promise<string[]>;
     hasAllowance: (coins: string[], amounts: (string | number)[], address: string, spender: string) => Promise<boolean>;
     ensureAllowance: (coins: string[], amounts: (string | number)[], spender: string, isMax?: boolean) => Promise<string[]>;
@@ -49,7 +48,7 @@ declare const curve: {
         symbol: string;
         decimals: number;
     }[]>;
-    getVolume: (network?: import("./interfaces").INetworkName | import("./interfaces").IChainId) => Promise<{
+    getVolume: (network?: import("./interfaces.js").INetworkName | import("./interfaces.js").IChainId) => Promise<{
         totalVolume: number;
         cryptoVolume: number;
         cryptoShare: number;
@@ -58,12 +57,12 @@ declare const curve: {
         fetchPools: (useApi?: boolean) => Promise<void>;
         fetchNewPools: () => Promise<string[]>;
         getPoolList: () => string[];
-        deployPlainPool: (name: string, symbol: string, coins: string[], A: string | number, fee: string | number, assetType: 0 | 1 | 2 | 3, implementationIdx: 0 | 1 | 2 | 3) => Promise<ethers.ContractTransaction>;
-        deployMetaPool: (basePool: string, name: string, symbol: string, coin: string, A: string | number, fee: string | number, implementationIdx: 0 | 1) => Promise<ethers.ContractTransaction>;
-        deployGauge: (poolAddress: string) => Promise<ethers.ContractTransaction>;
-        getDeployedPlainPoolAddress: (tx: ethers.ContractTransaction) => Promise<string>;
-        getDeployedMetaPoolAddress: (tx: ethers.ContractTransaction) => Promise<string>;
-        getDeployedGaugeAddress: (tx: ethers.ContractTransaction) => Promise<string>;
+        deployPlainPool: (name: string, symbol: string, coins: string[], A: string | number, fee: string | number, assetType: 0 | 1 | 2 | 3, implementationIdx: 0 | 1 | 2 | 3) => Promise<ethers.ContractTransactionResponse>;
+        deployMetaPool: (basePool: string, name: string, symbol: string, coin: string, A: string | number, fee: string | number, implementationIdx: 0 | 1) => Promise<ethers.ContractTransactionResponse>;
+        deployGauge: (poolAddress: string) => Promise<ethers.ContractTransactionResponse>;
+        getDeployedPlainPoolAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
+        getDeployedMetaPoolAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
+        getDeployedGaugeAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
         fetchRecentlyDeployedPool: (poolAddress: string) => Promise<string>;
         estimateGas: {
             deployPlainPool: (name: string, symbol: string, coins: string[], A: string | number, fee: string | number, assetType: 0 | 1 | 2 | 3, implementationIdx: 0 | 1 | 2 | 3) => Promise<number>;
@@ -75,11 +74,11 @@ declare const curve: {
         fetchPools: (useApi?: boolean) => Promise<void>;
         fetchNewPools: () => Promise<string[]>;
         getPoolList: () => string[];
-        deployPool: (name: string, symbol: string, coins: string[], A: string | number, gamma: string | number, midFee: string | number, outFee: string | number, allowedExtraProfit: string | number, feeGamma: string | number, adjustmentStep: string | number, maHalfTime: string | number, initialPrice: string | number) => Promise<ethers.ContractTransaction>;
-        deployGauge: (poolAddress: string) => Promise<ethers.ContractTransaction>;
-        getDeployed: (tx: ethers.ContractTransaction) => Promise<string>;
-        getDeployedPoolAddress: (tx: ethers.ContractTransaction) => Promise<string>;
-        getDeployedGaugeAddress: (tx: ethers.ContractTransaction) => Promise<string>;
+        deployPool: (name: string, symbol: string, coins: string[], A: string | number, gamma: string | number, midFee: string | number, outFee: string | number, allowedExtraProfit: string | number, feeGamma: string | number, adjustmentStep: string | number, maHalfTime: string | number, initialPrice: string | number) => Promise<ethers.ContractTransactionResponse>;
+        deployGauge: (poolAddress: string) => Promise<ethers.ContractTransactionResponse>;
+        getDeployed: (tx: ethers.ContractTransactionResponse) => Promise<string>;
+        getDeployedPoolAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
+        getDeployedGaugeAddress: (tx: ethers.ContractTransactionResponse) => Promise<string>;
         fetchRecentlyDeployedPool: (poolAddress: string) => Promise<string>;
         estimateGas: {
             deployPool: (name: string, symbol: string, coins: string[], A: string | number, gamma: string | number, midFee: string | number, outFee: string | number, allowedExtraProfit: string | number, feeGamma: string | number, adjustmentStep: string | number, maHalfTime: string | number, initialPrice: string | number) => Promise<number>;
@@ -90,16 +89,16 @@ declare const curve: {
         ensureAllowance: (coins: string[], amounts: (string | number)[], spender: string, isMax?: boolean) => Promise<number>;
     };
     boosting: {
-        getCrv: (...addresses: string[] | string[][]) => Promise<string | import("./interfaces").IDict<string>>;
-        getLockedAmountAndUnlockTime: (...addresses: string[] | string[][]) => Promise<import("./interfaces").IDict<{
+        getCrv: (...addresses: string[] | string[][]) => Promise<string | import("./interfaces.js").IDict<string>>;
+        getLockedAmountAndUnlockTime: (...addresses: string[] | string[][]) => Promise<import("./interfaces.js").IDict<{
             lockedAmount: string;
             unlockTime: number;
         }> | {
             lockedAmount: string;
             unlockTime: number;
         }>;
-        getVeCrv: (...addresses: string[] | string[][]) => Promise<string | import("./interfaces").IDict<string>>;
-        getVeCrvPct: (...addresses: string[] | string[][]) => Promise<string | import("./interfaces").IDict<string>>;
+        getVeCrv: (...addresses: string[] | string[][]) => Promise<string | import("./interfaces.js").IDict<string>>;
+        getVeCrvPct: (...addresses: string[] | string[][]) => Promise<string | import("./interfaces.js").IDict<string>>;
         calcUnlockTime: (days: number, start?: number) => number;
         isApproved: (amount: string | number) => Promise<boolean>;
         approve: (amount: string | number) => Promise<string[]>;
@@ -120,15 +119,15 @@ declare const curve: {
     };
     router: {
         getBestRouteAndOutput: (inputCoin: string, outputCoin: string, amount: string | number) => Promise<{
-            route: import("./interfaces").IRoute;
+            route: import("./interfaces.js").IRoute;
             output: string;
         }>;
         expected: (inputCoin: string, outputCoin: string, amount: string | number) => Promise<string>;
         priceImpact: (inputCoin: string, outputCoin: string, amount: string | number) => Promise<number>;
         isApproved: (inputCoin: string, amount: string | number) => Promise<boolean>;
         approve: (inputCoin: string, amount: string | number) => Promise<string[]>;
-        swap: (inputCoin: string, outputCoin: string, amount: string | number, slippage?: number) => Promise<ethers.ContractTransaction>;
-        getSwappedAmount: (tx: ethers.ContractTransaction, outputCoin: string) => Promise<string>;
+        swap: (inputCoin: string, outputCoin: string, amount: string | number, slippage?: number) => Promise<ethers.ContractTransactionResponse>;
+        getSwappedAmount: (tx: ethers.ContractTransactionResponse, outputCoin: string) => Promise<string>;
         estimateGas: {
             approve: (inputCoin: string, amount: string | number) => Promise<number>;
             swap: (inputCoin: string, outputCoin: string, amount: string | number) => Promise<number>;

package/lib/index.js

@@ -1,167 +1,111 @@
-"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 });
-var pools_1 = require("./pools");
-var utils_1 = require("./pools/utils");
-var router_1 = require("./router");
-var curve_1 = require("./curve");
-var boosting_1 = require("./boosting");
-var utils_2 = require("./utils");
-var deploy_1 = require("./factory/deploy");
-function init(providerType, providerSettings, options) {
-    if (options === void 0) { options = {}; }
-    return __awaiter(this, void 0, void 0, function () {
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, curve_1.curve.init(providerType, providerSettings, options)];
-                case 1:
-                    _a.sent();
-                    // @ts-ignore
-                    this.signerAddress = curve_1.curve.signerAddress;
-                    // @ts-ignore
-                    this.chainId = curve_1.curve.chainId;
-                    return [2 /*return*/];
-            }
-        });
-    });
+import { PoolTemplate, getPool } from "./pools/index.js";
+import { getUserPoolListByLiquidity, getUserPoolListByClaimable, getUserPoolList, getUserLiquidityUSD, getUserClaimable, } from "./pools/utils.js";
+import { getBestRouteAndOutput, swapExpected, swapPriceImpact, swapIsApproved, swapApproveEstimateGas, swapApprove, swapEstimateGas, swap, getSwappedAmount, } from "./router.js";
+import { curve as _curve } from "./curve.js";
+import { getCrv, getLockedAmountAndUnlockTime, getVeCrv, getVeCrvPct, calcUnlockTime, createLockEstimateGas, createLock, isApproved, approveEstimateGas, approve, increaseAmountEstimateGas, increaseAmount, increaseUnlockTimeEstimateGas, increaseUnlockTime, withdrawLockedCrvEstimateGas, withdrawLockedCrv, claimableFees, claimFeesEstimateGas, claimFees, } from "./boosting.js";
+import { getBalances, getAllowance, hasAllowance, ensureAllowanceEstimateGas, ensureAllowance, getUsdRate, getTVL, getCoinsData, getVolume, } from "./utils.js";
+import { deployStablePlainPool, deployStablePlainPoolEstimateGas, deployStableMetaPool, deployStableMetaPoolEstimateGas, deployCryptoPool, deployCryptoPoolEstimateGas, deployGauge, deployGaugeEstimateGas, getDeployedStablePlainPoolAddress, getDeployedStableMetaPoolAddress, getDeployedCryptoPoolAddress, getDeployedGaugeAddress, } from './factory/deploy.js';
+async function init(providerType, providerSettings, options = {}) {
+    await _curve.init(providerType, providerSettings, options);
+    // @ts-ignore
+    this.signerAddress = _curve.signerAddress;
+    // @ts-ignore
+    this.chainId = _curve.chainId;
 }
 function setCustomFeeData(customFeeData) {
-    curve_1.curve.setCustomFeeData(customFeeData);
+    _curve.setCustomFeeData(customFeeData);
 }
-var curve = {
-    init: init,
+const curve = {
+    init,
     chainId: 0,
     signerAddress: '',
-    setCustomFeeData: setCustomFeeData,
-    getPoolList: curve_1.curve.getPoolList,
-    getUserPoolListByLiquidity: utils_1.getUserPoolListByLiquidity,
-    getUserPoolListByClaimable: utils_1.getUserPoolListByClaimable,
-    getUserPoolList: utils_1.getUserPoolList,
-    getUserLiquidityUSD: utils_1.getUserLiquidityUSD,
-    getUserClaimable: utils_1.getUserClaimable,
-    PoolTemplate: pools_1.PoolTemplate,
-    getPool: pools_1.getPool,
-    getUsdRate: utils_2.getUsdRate,
-    getTVL: utils_2.getTVL,
-    getBalances: utils_2.getBalances,
-    getAllowance: utils_2.getAllowance,
-    hasAllowance: utils_2.hasAllowance,
-    ensureAllowance: utils_2.ensureAllowance,
-    getCoinsData: utils_2.getCoinsData,
-    getVolume: utils_2.getVolume,
+    setCustomFeeData,
+    getPoolList: _curve.getPoolList,
+    getUserPoolListByLiquidity,
+    getUserPoolListByClaimable,
+    getUserPoolList,
+    getUserLiquidityUSD,
+    getUserClaimable,
+    PoolTemplate,
+    getPool,
+    getUsdRate,
+    getTVL,
+    getBalances,
+    getAllowance,
+    hasAllowance,
+    ensureAllowance,
+    getCoinsData,
+    getVolume,
     factory: {
-        fetchPools: curve_1.curve.fetchFactoryPools,
-        fetchNewPools: curve_1.curve.fetchNewFactoryPools,
-        getPoolList: curve_1.curve.getFactoryPoolList,
-        deployPlainPool: deploy_1.deployStablePlainPool,
-        deployMetaPool: deploy_1.deployStableMetaPool,
-        deployGauge: function (poolAddress) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
-            return [2 /*return*/, (0, deploy_1.deployGauge)(poolAddress, false)];
-        }); }); },
-        getDeployedPlainPoolAddress: deploy_1.getDeployedStablePlainPoolAddress,
-        getDeployedMetaPoolAddress: deploy_1.getDeployedStableMetaPoolAddress,
-        getDeployedGaugeAddress: deploy_1.getDeployedGaugeAddress,
-        fetchRecentlyDeployedPool: curve_1.curve.fetchRecentlyDeployedFactoryPool,
+        fetchPools: _curve.fetchFactoryPools,
+        fetchNewPools: _curve.fetchNewFactoryPools,
+        getPoolList: _curve.getFactoryPoolList,
+        deployPlainPool: deployStablePlainPool,
+        deployMetaPool: deployStableMetaPool,
+        deployGauge: async (poolAddress) => deployGauge(poolAddress, false),
+        getDeployedPlainPoolAddress: getDeployedStablePlainPoolAddress,
+        getDeployedMetaPoolAddress: getDeployedStableMetaPoolAddress,
+        getDeployedGaugeAddress: getDeployedGaugeAddress,
+        fetchRecentlyDeployedPool: _curve.fetchRecentlyDeployedFactoryPool,
         estimateGas: {
-            deployPlainPool: deploy_1.deployStablePlainPoolEstimateGas,
-            deployMetaPool: deploy_1.deployStableMetaPoolEstimateGas,
-            deployGauge: function (poolAddress) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
-                return [2 /*return*/, (0, deploy_1.deployGaugeEstimateGas)(poolAddress, false)];
-            }); }); },
+            deployPlainPool: deployStablePlainPoolEstimateGas,
+            deployMetaPool: deployStableMetaPoolEstimateGas,
+            deployGauge: async (poolAddress) => deployGaugeEstimateGas(poolAddress, false),
         },
     },
     cryptoFactory: {
-        fetchPools: curve_1.curve.fetchCryptoFactoryPools,
-        fetchNewPools: curve_1.curve.fetchNewCryptoFactoryPools,
-        getPoolList: curve_1.curve.getCryptoFactoryPoolList,
-        deployPool: deploy_1.deployCryptoPool,
-        deployGauge: function (poolAddress) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
-            return [2 /*return*/, (0, deploy_1.deployGauge)(poolAddress, true)];
-        }); }); },
-        getDeployed: deploy_1.getDeployedStablePlainPoolAddress,
-        getDeployedPoolAddress: deploy_1.getDeployedCryptoPoolAddress,
-        getDeployedGaugeAddress: deploy_1.getDeployedGaugeAddress,
-        fetchRecentlyDeployedPool: curve_1.curve.fetchRecentlyDeployedCryptoFactoryPool,
+        fetchPools: _curve.fetchCryptoFactoryPools,
+        fetchNewPools: _curve.fetchNewCryptoFactoryPools,
+        getPoolList: _curve.getCryptoFactoryPoolList,
+        deployPool: deployCryptoPool,
+        deployGauge: async (poolAddress) => deployGauge(poolAddress, true),
+        getDeployed: getDeployedStablePlainPoolAddress,
+        getDeployedPoolAddress: getDeployedCryptoPoolAddress,
+        getDeployedGaugeAddress: getDeployedGaugeAddress,
+        fetchRecentlyDeployedPool: _curve.fetchRecentlyDeployedCryptoFactoryPool,
         estimateGas: {
-            deployPool: deploy_1.deployCryptoPoolEstimateGas,
-            deployGauge: function (poolAddress) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
-                return [2 /*return*/, (0, deploy_1.deployGaugeEstimateGas)(poolAddress, true)];
-            }); }); },
+            deployPool: deployCryptoPoolEstimateGas,
+            deployGauge: async (poolAddress) => deployGaugeEstimateGas(poolAddress, true),
         },
     },
     estimateGas: {
-        ensureAllowance: utils_2.ensureAllowanceEstimateGas,
+        ensureAllowance: ensureAllowanceEstimateGas,
     },
     boosting: {
-        getCrv: boosting_1.getCrv,
-        getLockedAmountAndUnlockTime: boosting_1.getLockedAmountAndUnlockTime,
-        getVeCrv: boosting_1.getVeCrv,
-        getVeCrvPct: boosting_1.getVeCrvPct,
-        calcUnlockTime: boosting_1.calcUnlockTime,
-        isApproved: boosting_1.isApproved,
-        approve: boosting_1.approve,
-        createLock: boosting_1.createLock,
-        increaseAmount: boosting_1.increaseAmount,
-        increaseUnlockTime: boosting_1.increaseUnlockTime,
-        withdrawLockedCrv: boosting_1.withdrawLockedCrv,
-        claimableFees: boosting_1.claimableFees,
-        claimFees: boosting_1.claimFees,
+        getCrv,
+        getLockedAmountAndUnlockTime,
+        getVeCrv,
+        getVeCrvPct,
+        calcUnlockTime,
+        isApproved,
+        approve,
+        createLock,
+        increaseAmount,
+        increaseUnlockTime,
+        withdrawLockedCrv,
+        claimableFees,
+        claimFees,
         estimateGas: {
-            approve: boosting_1.approveEstimateGas,
-            createLock: boosting_1.createLockEstimateGas,
-            increaseAmount: boosting_1.increaseAmountEstimateGas,
-            increaseUnlockTime: boosting_1.increaseUnlockTimeEstimateGas,
-            withdrawLockedCrv: boosting_1.withdrawLockedCrvEstimateGas,
-            claimFees: boosting_1.claimFeesEstimateGas,
+            approve: approveEstimateGas,
+            createLock: createLockEstimateGas,
+            increaseAmount: increaseAmountEstimateGas,
+            increaseUnlockTime: increaseUnlockTimeEstimateGas,
+            withdrawLockedCrv: withdrawLockedCrvEstimateGas,
+            claimFees: claimFeesEstimateGas,
         },
     },
     router: {
-        getBestRouteAndOutput: router_1.getBestRouteAndOutput,
-        expected: router_1.swapExpected,
-        priceImpact: router_1.swapPriceImpact,
-        isApproved: router_1.swapIsApproved,
-        approve: router_1.swapApprove,
-        swap: router_1.swap,
-        getSwappedAmount: router_1.getSwappedAmount,
+        getBestRouteAndOutput,
+        expected: swapExpected,
+        priceImpact: swapPriceImpact,
+        isApproved: swapIsApproved,
+        approve: swapApprove,
+        swap,
+        getSwappedAmount,
         estimateGas: {
-            approve: router_1.swapApproveEstimateGas,
-            swap: router_1.swapEstimateGas,
+            approve: swapApproveEstimateGas,
+            swap: swapEstimateGas,
         },
     },
 };
-exports.default = curve;
+export default curve;

package/lib/interfaces.d.ts

@@ -25,6 +25,7 @@ export interface IPoolData {
     is_fake?: boolean;
     is_factory?: boolean;
     base_pool?: string;
+    meta_coin_idx?: number;
     underlying_coins: string[];
     wrapped_coins: string[];
     underlying_coin_addresses: string[];
@@ -39,7 +40,7 @@ export interface IPoolData {
     in_api?: boolean;
 }
 export interface ICurve {
-    provider: ethers.providers.Web3Provider | ethers.providers.JsonRpcProvider;
+    provider: ethers.BrowserProvider | ethers.JsonRpcProvider;
     multicallProvider: MulticallProvider;
     signer: ethers.Signer | null;
     signerAddress: string;
@@ -59,9 +60,9 @@ export interface ICurve {
         gasLimit: number;
     };
     options: {
-        gasPrice?: number | ethers.BigNumber;
-        maxFeePerGas?: number | ethers.BigNumber;
-        maxPriorityFeePerGas?: number | ethers.BigNumber;
+        gasPrice?: number | bigint;
+        maxFeePerGas?: number | bigint;
+        maxPriorityFeePerGas?: number | bigint;
     };
     constants: {
         NATIVE_TOKEN: {
@@ -148,7 +149,7 @@ export interface IRouteTvl {
 }
 export interface IRouteOutputAndCost {
     route: IRoute;
-    _output: ethers.BigNumber;
+    _output: bigint;
     outputUsd: number;
     txCostUsd: number;
 }

package/lib/interfaces.js

@@ -1,2 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
+export {};

package/lib/pools/PoolTemplate.d.ts

@@ -20,6 +20,7 @@ export declare class PoolTemplate {
     isFactory: boolean;
     isMetaFactory: boolean;
     basePool: string;
+    metaCoinIdx: number;
     underlyingCoins: string[];
     wrappedCoins: string[];
     underlyingCoinAddresses: string[];