@curvefi/api 2.69.2 → 2.69.4

package/lib/curve.d.ts

@@ -38,6 +38,7 @@ export declare class Curve implements ICurve {
     constants: INetworkConstants;
     nativeTokenAddress: string;
     poolAddressMapCache: IDict<string> | null;
+    routerBlacklist: string[];
     constructor();
     init(providerType: 'JsonRpc' | 'Web3' | 'Infura' | 'Alchemy' | 'NoRPC', providerSettings: {
         url?: string;
@@ -59,14 +60,14 @@ export declare class Curve implements ICurve {
     initContract: (address: string, abi: any, provider: BrowserProvider | JsonRpcProvider | Signer) => Contract;
     initMulticallContract: (address: string, abi: any) => MulticallContract;
     setContract(address: string | undefined, abi: any): void;
-    _filterHiddenPools(pools: IDict<IPoolData>): Promise<IDict<IPoolData>>;
+    _filterHiddenPools(pools: IDict<IPoolData>, isFiltered?: boolean): Promise<IDict<IPoolData>>;
     _updateDecimalsAndGauges(pools: IDict<IPoolData>): void;
-    fetchFactoryPools: (useApi?: boolean) => Promise<void>;
-    fetchCrvusdFactoryPools: (useApi?: boolean) => Promise<void>;
-    fetchCryptoFactoryPools: (useApi?: boolean) => Promise<void>;
-    fetchStableNgFactoryPools: (useApi?: boolean) => Promise<void>;
-    fetchTworyptoFactoryPools: (useApi?: boolean) => Promise<void>;
-    fetchTricryptoFactoryPools: (useApi?: boolean) => Promise<void>;
+    fetchFactoryPools: (useApi?: boolean, isFiltered?: boolean) => Promise<void>;
+    fetchCrvusdFactoryPools: (useApi?: boolean, isFiltered?: boolean) => Promise<void>;
+    fetchCryptoFactoryPools: (useApi?: boolean, isFiltered?: boolean) => Promise<void>;
+    fetchStableNgFactoryPools: (useApi?: boolean, isFiltered?: boolean) => Promise<void>;
+    fetchTworyptoFactoryPools: (useApi?: boolean, isFiltered?: boolean) => Promise<void>;
+    fetchTricryptoFactoryPools: (useApi?: boolean, isFiltered?: boolean) => Promise<void>;
     fetchNewFactoryPools: () => Promise<string[]>;
     fetchNewCryptoFactoryPools: () => Promise<string[]>;
     fetchNewStableNgFactoryPools: () => Promise<string[]>;

package/lib/curve.js

@@ -49,7 +49,7 @@ import circulatingSupplyABI from './constants/abis/circulating_supply.json' with
 import rootGaugeFactoryABI from "./constants/abis/gauge_factory/root_gauge_factory.json" with { type: "json" };
 import fastBridgeABI from './constants/abis/fastBridge.json' with { type: 'json' };
 import { extractDecimals, extractGauges, formatUnits, lowerCasePoolDataAddresses, parseUnits, } from "./constants/utils.js";
-import { _getHiddenPools } from "./external-api.js";
+import { _getHiddenPools, _getPoolFilters } from "./external-api.js";
 import { L2Networks } from "./constants/L2Networks.js";
 import { getTwocryptoFactoryPoolData } from "./factory/factory-twocrypto.js";
 import { applyFeeDataOverride, computeEip1559Fees, computeLegacyOrFallback, fetchFeeHistory, getNetworkConstants, } from "./utils.js";
@@ -85,7 +85,7 @@ export class Curve {
     constructor() {
         this.initContract = memoizedContract();
         this.initMulticallContract = memoizedMulticallContract();
-        this.fetchFactoryPools = (...args_1) => __awaiter(this, [...args_1], void 0, function* (useApi = true) {
+        this.fetchFactoryPools = (...args_1) => __awaiter(this, [...args_1], void 0, function* (useApi = true, isFiltered = false) {
             if (!("factory" in this.constants.ALIASES))
                 return;
             if (useApi) {
@@ -94,11 +94,11 @@ export class Curve {
             else {
                 this.constants.FACTORY_POOLS_DATA = lowerCasePoolDataAddresses(yield getFactoryPoolData.call(this));
             }
-            this.constants.FACTORY_POOLS_DATA = yield this._filterHiddenPools(this.constants.FACTORY_POOLS_DATA);
+            this.constants.FACTORY_POOLS_DATA = yield this._filterHiddenPools(this.constants.FACTORY_POOLS_DATA, isFiltered);
             this._updateDecimalsAndGauges(this.constants.FACTORY_POOLS_DATA);
             this.constants.FACTORY_GAUGE_IMPLEMENTATIONS["factory"] = this.isNoRPC ? null : yield this.contracts[this.constants.ALIASES.factory].contract.gauge_implementation(this.constantOptions);
         });
-        this.fetchCrvusdFactoryPools = (...args_1) => __awaiter(this, [...args_1], void 0, function* (useApi = true) {
+        this.fetchCrvusdFactoryPools = (...args_1) => __awaiter(this, [...args_1], void 0, function* (useApi = true, isFiltered = false) {
             if (!("crvusd_factory" in this.constants.ALIASES))
                 return;
             if (useApi) {
@@ -110,10 +110,10 @@ export class Curve {
                 }
                 this.constants.CRVUSD_FACTORY_POOLS_DATA = lowerCasePoolDataAddresses(yield getFactoryPoolData.call(this, 0, undefined, this.constants.ALIASES.crvusd_factory));
             }
-            this.constants.CRVUSD_FACTORY_POOLS_DATA = yield this._filterHiddenPools(this.constants.CRVUSD_FACTORY_POOLS_DATA);
+            this.constants.CRVUSD_FACTORY_POOLS_DATA = yield this._filterHiddenPools(this.constants.CRVUSD_FACTORY_POOLS_DATA, isFiltered);
             this._updateDecimalsAndGauges(this.constants.CRVUSD_FACTORY_POOLS_DATA);
         });
-        this.fetchCryptoFactoryPools = (...args_1) => __awaiter(this, [...args_1], void 0, function* (useApi = true) {
+        this.fetchCryptoFactoryPools = (...args_1) => __awaiter(this, [...args_1], void 0, function* (useApi = true, isFiltered = false) {
             if (!("crypto_factory" in this.constants.ALIASES))
                 return;
             if (useApi) {
@@ -125,11 +125,11 @@ export class Curve {
                 }
                 this.constants.CRYPTO_FACTORY_POOLS_DATA = lowerCasePoolDataAddresses(yield getCryptoFactoryPoolData.call(this));
             }
-            this.constants.CRYPTO_FACTORY_POOLS_DATA = yield this._filterHiddenPools(this.constants.CRYPTO_FACTORY_POOLS_DATA);
+            this.constants.CRYPTO_FACTORY_POOLS_DATA = yield this._filterHiddenPools(this.constants.CRYPTO_FACTORY_POOLS_DATA, isFiltered);
             this._updateDecimalsAndGauges(this.constants.CRYPTO_FACTORY_POOLS_DATA);
             this.constants.FACTORY_GAUGE_IMPLEMENTATIONS["factory-crypto"] = this.isNoRPC ? null : yield this.contracts[this.constants.ALIASES.crypto_factory].contract.gauge_implementation(this.constantOptions);
         });
-        this.fetchStableNgFactoryPools = (...args_1) => __awaiter(this, [...args_1], void 0, function* (useApi = true) {
+        this.fetchStableNgFactoryPools = (...args_1) => __awaiter(this, [...args_1], void 0, function* (useApi = true, isFiltered = false) {
             if (!("stable_ng_factory" in this.constants.ALIASES))
                 return;
             if (useApi) {
@@ -141,10 +141,10 @@ export class Curve {
                 }
                 this.constants.STABLE_NG_FACTORY_POOLS_DATA = lowerCasePoolDataAddresses(yield getFactoryPoolData.call(this, 0, undefined, this.constants.ALIASES.stable_ng_factory));
             }
-            this.constants.STABLE_NG_FACTORY_POOLS_DATA = yield this._filterHiddenPools(this.constants.STABLE_NG_FACTORY_POOLS_DATA);
+            this.constants.STABLE_NG_FACTORY_POOLS_DATA = yield this._filterHiddenPools(this.constants.STABLE_NG_FACTORY_POOLS_DATA, isFiltered);
             this._updateDecimalsAndGauges(this.constants.STABLE_NG_FACTORY_POOLS_DATA);
         });
-        this.fetchTworyptoFactoryPools = (...args_1) => __awaiter(this, [...args_1], void 0, function* (useApi = true) {
+        this.fetchTworyptoFactoryPools = (...args_1) => __awaiter(this, [...args_1], void 0, function* (useApi = true, isFiltered = false) {
             if (!("twocrypto_factory" in this.constants.ALIASES))
                 return;
             if (useApi) {
@@ -156,7 +156,7 @@ export class Curve {
                 }
                 this.constants.TWOCRYPTO_FACTORY_POOLS_DATA = lowerCasePoolDataAddresses(yield getTwocryptoFactoryPoolData.call(this));
             }
-            this.constants.TWOCRYPTO_FACTORY_POOLS_DATA = yield this._filterHiddenPools(this.constants.TWOCRYPTO_FACTORY_POOLS_DATA);
+            this.constants.TWOCRYPTO_FACTORY_POOLS_DATA = yield this._filterHiddenPools(this.constants.TWOCRYPTO_FACTORY_POOLS_DATA, isFiltered);
             this._updateDecimalsAndGauges(this.constants.TWOCRYPTO_FACTORY_POOLS_DATA);
             if (this.chainId === 1) {
                 this.constants.FACTORY_GAUGE_IMPLEMENTATIONS["factory-twocrypto"] = this.isNoRPC ? null :
@@ -167,7 +167,7 @@ export class Curve {
                     yield this.contracts[this.constants.ALIASES.child_gauge_factory].contract.get_implementation(this.constantOptions);
             }
         });
-        this.fetchTricryptoFactoryPools = (...args_1) => __awaiter(this, [...args_1], void 0, function* (useApi = true) {
+        this.fetchTricryptoFactoryPools = (...args_1) => __awaiter(this, [...args_1], void 0, function* (useApi = true, isFiltered = false) {
             if (!("tricrypto_factory" in this.constants.ALIASES))
                 return;
             if (useApi) {
@@ -179,7 +179,7 @@ export class Curve {
                 }
                 this.constants.TRICRYPTO_FACTORY_POOLS_DATA = lowerCasePoolDataAddresses(yield getTricryptoFactoryPoolData.call(this));
             }
-            this.constants.TRICRYPTO_FACTORY_POOLS_DATA = yield this._filterHiddenPools(this.constants.TRICRYPTO_FACTORY_POOLS_DATA);
+            this.constants.TRICRYPTO_FACTORY_POOLS_DATA = yield this._filterHiddenPools(this.constants.TRICRYPTO_FACTORY_POOLS_DATA, isFiltered);
             this._updateDecimalsAndGauges(this.constants.TRICRYPTO_FACTORY_POOLS_DATA);
             if (this.chainId === 1) {
                 this.constants.FACTORY_GAUGE_IMPLEMENTATIONS["factory-tricrypto"] = this.isNoRPC ? null :
@@ -326,6 +326,7 @@ export class Curve {
         this.options = {};
         this.nativeTokenAddress = NETWORK_CONSTANTS[1].NATIVE_COIN.address;
         this.poolAddressMapCache = null;
+        this.routerBlacklist = [];
         this.constants = {
             NATIVE_TOKEN: NETWORK_CONSTANTS[1].NATIVE_COIN,
             NETWORK_NAME: 'ethereum',
@@ -364,6 +365,7 @@ export class Curve {
             this.constantOptions = { gasLimit: 12000000 };
             this.options = {};
             this.nativeTokenAddress = NETWORK_CONSTANTS[1].NATIVE_COIN.address;
+            this.routerBlacklist = [];
             this.constants = {
                 NATIVE_TOKEN: NETWORK_CONSTANTS[1].NATIVE_COIN,
                 NETWORK_NAME: 'ethereum',
@@ -662,10 +664,16 @@ export class Curve {
         };
         this.contracts[address] = new Proxy(coreContract, proxyHandler);
     }
-    _filterHiddenPools(pools) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const hiddenPools = (yield _getHiddenPools(this.isLiteChain))[this.constants.NETWORK_NAME] || [];
-            return Object.fromEntries(Object.entries(pools).filter(([id]) => !hiddenPools.includes(id)));
+    _filterHiddenPools(pools_1) {
+        return __awaiter(this, arguments, void 0, function* (pools, isFiltered = false) {
+            const hiddenPoolsAll = yield _getHiddenPools(this.isLiteChain);
+            const hiddenPools = hiddenPoolsAll[this.constants.NETWORK_NAME];
+            let filteredAddresses;
+            if (isFiltered) {
+                const poolFilters = yield _getPoolFilters();
+                filteredAddresses = new Set(poolFilters[this.constants.NETWORK_NAME]);
+            }
+            return Object.fromEntries(Object.entries(pools).filter(([id, pool]) => !(hiddenPools === null || hiddenPools === void 0 ? void 0 : hiddenPools.includes(id)) && !(filteredAddresses === null || filteredAddresses === void 0 ? void 0 : filteredAddresses.has(pool.swap_address))));
         });
     }
     _updateDecimalsAndGauges(pools) {

package/lib/external-api.d.ts

@@ -9,6 +9,7 @@ export declare const _getFactoryAPYs: ((network: string) => Promise<IVolumeAndAP
 export declare const _getAllGauges: (() => Promise<IDict<IGaugesDataFromApi>>) & memoize.Memoized<() => Promise<IDict<IGaugesDataFromApi>>>;
 export declare const _getAllGaugesFormatted: (() => Promise<IDict<any>>) & memoize.Memoized<() => Promise<IDict<any>>>;
 export declare const _getHiddenPools: ((isLiteChain: boolean) => Promise<IDict<string[]>>) & memoize.Memoized<(isLiteChain: boolean) => Promise<IDict<string[]>>>;
+export declare const _getPoolFilters: (() => Promise<IDict<string[]>>) & memoize.Memoized<() => Promise<IDict<string[]>>>;
 export declare const _generateBoostingProof: ((block: number, address: string) => Promise<{
     block_header_rlp: string;
     proof_rlp: string;

package/lib/external-api.js

@@ -190,6 +190,19 @@ export const _getHiddenPools = memoize((isLiteChain) => fetchData(`https://${isL
     promise: true,
     maxAge: 5 * 60 * 1000, // 5m
 });
+export const _getPoolFilters = memoize(() => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { data } = yield fetchJson("https://prices.curve.finance/v1/chains/pool_filters");
+        return Object.fromEntries((data !== null && data !== void 0 ? data : []).map(({ chain, pools }) => [chain, pools.map((pool) => pool.address.toLowerCase())]));
+    }
+    catch (error) {
+        console.error('Error fetching pool filters:', error);
+        return {};
+    }
+}), {
+    promise: true,
+    maxAge: 5 * 60 * 1000, // 5m
+});
 export const _generateBoostingProof = memoize((block, address) => __awaiter(void 0, void 0, void 0, function* () {
     const url = `https://prices.curve.finance/v1/general/get_merkle_proof?block=${block}&account_address=${address}`;
     const { block_header_rlp, proof_rlp } = yield fetchJson(url);

package/lib/index.d.ts

@@ -72,7 +72,7 @@ export declare const createCurve: () => {
     getIsLiteChain: () => boolean;
     isNoRPC: boolean;
     factory: {
-        fetchPools: (useApi?: boolean) => Promise<void>;
+        fetchPools: (useApi?: boolean, isFiltered?: 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 | 4 | 5, emaTime?: number | undefined, oracleAddress?: string | undefined, methodName?: string | undefined) => Promise<ethers.ContractTransactionResponse>;
@@ -98,11 +98,11 @@ export declare const createCurve: () => {
         };
     };
     crvUSDFactory: {
-        fetchPools: (useApi?: boolean) => Promise<void>;
+        fetchPools: (useApi?: boolean, isFiltered?: boolean) => Promise<void>;
         getPoolList: () => string[];
     };
     stableNgFactory: {
-        fetchPools: (useApi?: boolean) => Promise<void>;
+        fetchPools: (useApi?: boolean, isFiltered?: boolean) => Promise<void>;
         fetchNewPools: () => Promise<string[]>;
         getPoolList: () => string[];
         deployPlainPool: (name: string, symbol: string, coins: string[], A: string | number, fee: string | number, offpegFeeMultiplier: string | number, assetTypes: (0 | 1 | 2 | 3)[], implementationIdx: 0, emaTime: number, oracleAddresses: string[], methodNames: string[]) => Promise<ethers.ContractTransactionResponse>;
@@ -122,7 +122,7 @@ export declare const createCurve: () => {
         };
     };
     cryptoFactory: {
-        fetchPools: (useApi?: boolean) => Promise<void>;
+        fetchPools: (useApi?: boolean, isFiltered?: 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: number, initialPrice: string | number) => Promise<ethers.ContractTransactionResponse>;
@@ -143,7 +143,7 @@ export declare const createCurve: () => {
         };
     };
     twocryptoFactory: {
-        fetchPools: (useApi?: boolean) => Promise<void>;
+        fetchPools: (useApi?: boolean, isFiltered?: 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: number, initialPrice: string | number, implementationIdx?: import("./constants/twoCryptoImplementations.js").TwoCryptoImplementation | undefined) => Promise<ethers.ContractTransactionResponse>;
@@ -165,7 +165,7 @@ export declare const createCurve: () => {
         };
     };
     tricryptoFactory: {
-        fetchPools: (useApi?: boolean) => Promise<void>;
+        fetchPools: (useApi?: boolean, isFiltered?: 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, emaTime: number, initialPrices: (string | number)[]) => Promise<ethers.ContractTransactionResponse>;
@@ -249,6 +249,7 @@ export declare const createCurve: () => {
             _secondBasePools?: string[];
             _secondBaseTokens?: string[];
         };
+        setBlacklist: (blacklist: string[]) => void;
         expected: (inputCoin: string, outputCoin: string, amount: string | number) => Promise<string>;
         required: (inputCoin: string, outputCoin: string, outAmount: string | number) => Promise<string>;
         priceImpact: (inputCoin: string, outputCoin: string, amount: string | number) => Promise<number>;
@@ -404,7 +405,7 @@ declare const _default: {
     getIsLiteChain: () => boolean;
     isNoRPC: boolean;
     factory: {
-        fetchPools: (useApi?: boolean) => Promise<void>;
+        fetchPools: (useApi?: boolean, isFiltered?: 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 | 4 | 5, emaTime?: number | undefined, oracleAddress?: string | undefined, methodName?: string | undefined) => Promise<ethers.ContractTransactionResponse>;
@@ -430,11 +431,11 @@ declare const _default: {
         };
     };
     crvUSDFactory: {
-        fetchPools: (useApi?: boolean) => Promise<void>;
+        fetchPools: (useApi?: boolean, isFiltered?: boolean) => Promise<void>;
         getPoolList: () => string[];
     };
     stableNgFactory: {
-        fetchPools: (useApi?: boolean) => Promise<void>;
+        fetchPools: (useApi?: boolean, isFiltered?: boolean) => Promise<void>;
         fetchNewPools: () => Promise<string[]>;
         getPoolList: () => string[];
         deployPlainPool: (name: string, symbol: string, coins: string[], A: string | number, fee: string | number, offpegFeeMultiplier: string | number, assetTypes: (0 | 1 | 2 | 3)[], implementationIdx: 0, emaTime: number, oracleAddresses: string[], methodNames: string[]) => Promise<ethers.ContractTransactionResponse>;
@@ -454,7 +455,7 @@ declare const _default: {
         };
     };
     cryptoFactory: {
-        fetchPools: (useApi?: boolean) => Promise<void>;
+        fetchPools: (useApi?: boolean, isFiltered?: 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: number, initialPrice: string | number) => Promise<ethers.ContractTransactionResponse>;
@@ -475,7 +476,7 @@ declare const _default: {
         };
     };
     twocryptoFactory: {
-        fetchPools: (useApi?: boolean) => Promise<void>;
+        fetchPools: (useApi?: boolean, isFiltered?: 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: number, initialPrice: string | number, implementationIdx?: import("./constants/twoCryptoImplementations.js").TwoCryptoImplementation | undefined) => Promise<ethers.ContractTransactionResponse>;
@@ -497,7 +498,7 @@ declare const _default: {
         };
     };
     tricryptoFactory: {
-        fetchPools: (useApi?: boolean) => Promise<void>;
+        fetchPools: (useApi?: boolean, isFiltered?: 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, emaTime: number, initialPrices: (string | number)[]) => Promise<ethers.ContractTransactionResponse>;
@@ -581,6 +582,7 @@ declare const _default: {
             _secondBasePools?: string[];
             _secondBaseTokens?: string[];
         };
+        setBlacklist: (blacklist: string[]) => void;
         expected: (inputCoin: string, outputCoin: string, amount: string | number) => Promise<string>;
         required: (inputCoin: string, outputCoin: string, outAmount: string | number) => Promise<string>;
         priceImpact: (inputCoin: string, outputCoin: string, amount: string | number) => Promise<number>;

package/lib/index.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { PoolTemplate, getPool } from "./pools/index.js";
 import { getUserPoolListByLiquidity, getUserPoolListByClaimable, getUserPoolList, getUserLiquidityUSD, getUserClaimable, } from "./pools/utils.js";
-import { getBestRouteAndOutput, getArgs, swapExpected, swapRequired, swapPriceImpact, swapIsApproved, swapApproveEstimateGas, swapApprove, swapPopulateApprove, swapEstimateGas, swap, populateSwap, getSwappedAmount, approveFromCalldata, approveFromCalldataEstimateGas, swapFromCalldata, swapFromCalldataEstimateGas, } from "./router.js";
+import { getBestRouteAndOutput, getArgs, swapExpected, swapRequired, swapPriceImpact, swapIsApproved, swapApproveEstimateGas, swapApprove, swapPopulateApprove, swapEstimateGas, swap, populateSwap, getSwappedAmount, approveFromCalldata, approveFromCalldataEstimateGas, swapFromCalldata, swapFromCalldataEstimateGas, setRouterBlacklist, } from "./router.js";
 import { isSupported, assertIsSupported, allowedToBridge, bridgeCost, bridgeIsApproved, bridgeApproveEstimateGas, bridgeApprove, bridgeEstimateGas, bridge, getSupportedNetworks, } from "./bridge.js";
 import { Curve } from "./curve.js";
 import { getCrv, getLockedAmountAndUnlockTime, getVeCrv, getVeCrvPct, calcUnlockTime, createLockEstimateGas, createLock, isApproved, approveEstimateGas, approve, increaseAmountEstimateGas, increaseAmount, increaseUnlockTimeEstimateGas, increaseUnlockTime, withdrawLockedCrvEstimateGas, withdrawLockedCrv, claimableFees, claimFeesEstimateGas, claimFees, lastEthBlock, getAnycallBalance, topUpAnycall, topUpAnycallEstimateGas, lastBlockSent, blockToSend, sendBlockhash, sendBlockhashEstimateGas, submitProof, submitProofEstimateGas, claimFeesCrvUSDEstimateGas, claimableFeesCrvUSD, claimFeesCrvUSD, calculateVeCrv, } from "./boosting.js";
@@ -222,6 +222,7 @@ export const createCurve = () => {
         router: {
             getBestRouteAndOutput: getBestRouteAndOutput.bind(_curve),
             getArgs: getArgs.bind(_curve),
+            setBlacklist: setRouterBlacklist.bind(_curve),
             expected: swapExpected.bind(_curve),
             required: swapRequired.bind(_curve),
             priceImpact: swapPriceImpact.bind(_curve),

package/lib/route-graph.worker.d.ts

@@ -7,6 +7,7 @@ export type IRouteGraphInput = {
     allPools: [string, IPoolData][];
     amplificationCoefficientDict: IDict<number>;
     poolTvlDict: IDict<number>;
+    blacklist?: string[];
 };
-export declare function routeGraphWorker(): (({ constants, chainId, isLiteChain, allPools, amplificationCoefficientDict, poolTvlDict }: IRouteGraphInput) => IDict<IDict<IRouteStep[]>>) | undefined;
+export declare function routeGraphWorker(): (({ constants, chainId, isLiteChain, allPools, amplificationCoefficientDict, poolTvlDict, blacklist }: IRouteGraphInput) => IDict<IDict<IRouteStep[]>>) | undefined;
 export declare const routeGraphWorkerCode: string;

package/lib/route-graph.worker.js

@@ -4,9 +4,11 @@ export function routeGraphWorker() {
     const EXCLUDED_POOLS_FROM_ROUTER = {
         1: ['usdt'], // Ethereum mainnet
     };
-    const createRouteGraph = ({ constants, chainId, isLiteChain, allPools, amplificationCoefficientDict, poolTvlDict }) => {
+    const createRouteGraph = ({ constants, chainId, isLiteChain, allPools, amplificationCoefficientDict, poolTvlDict, blacklist }) => {
         var _a, _b, _c, _d;
         const routerGraph = {};
+        // Pool addresses we don't want to index when building routes
+        const blacklistedPools = new Set((blacklist !== null && blacklist !== void 0 ? blacklist : []).map((a) => a.toLowerCase()));
         // ETH <-> WETH (exclude Celo)
         if (chainId !== 42220) {
             const wrapperAddress = constants.NATIVE_TOKEN.wrapperAddress || constants.NATIVE_TOKEN.wrappedAddress;
@@ -263,6 +265,9 @@ export function routeGraphWorker() {
             // Skip excluded pools from router
             if ((_d = EXCLUDED_POOLS_FROM_ROUTER[chainId]) === null || _d === void 0 ? void 0 : _d.includes(poolId))
                 continue;
+            // Skip blacklisted pools
+            if (blacklistedPools.has(poolAddress))
+                continue;
             const excludedUnderlyingSwaps = (poolId === 'ib' && chainId === 1) ||
                 (poolId === 'geist' && chainId === 250) ||
                 (poolId === 'saave' && chainId === 1);

package/lib/router.d.ts

@@ -1,6 +1,7 @@
 import { ethers, TransactionLike } from "ethers";
 import { type Curve } from "./curve.js";
 import { IRoute } from "./interfaces";
+export declare function setRouterBlacklist(this: Curve, blacklist: string[]): void;
 export declare function getBestRouteAndOutput(this: Curve, inputCoin: string, outputCoin: string, amount: number | string): Promise<{
     route: IRoute;
     output: string;

package/lib/router.js

@@ -19,6 +19,12 @@ import { memoizeMethod } from "./constants/utils.js";
 import { YB_ASSETS } from "./constants/ybPools.js";
 const MAX_STEPS = 5;
 const ROUTE_LENGTH = (MAX_STEPS * 2) + 1;
+export function setRouterBlacklist(blacklist) {
+    this.routerBlacklist = (blacklist !== null && blacklist !== void 0 ? blacklist : []).map((a) => a.toLowerCase());
+    // Drop the memoized route graph / routes so they get rebuilt with the new blacklist
+    delete this._buildRouteGraph;
+    delete this._getBestRoute;
+}
 function _getTVL(poolId) {
     return __awaiter(this, void 0, void 0, function* () { return Number(yield getPool.call(this, poolId).stats.totalLiquidityMemoized()); });
 }
@@ -40,7 +46,7 @@ function _buildRouteGraphImpl(chainId, isLiteChain) {
         const allPools = Object.entries(this.getPoolsData()).filter(([id]) => !["crveth", "y", "busd", "pax", "susd", "aave"].includes(id));
         const amplificationCoefficientDict = yield _getAmplificationCoefficientsFromApi.call(this);
         const poolTvlDict = yield entriesToDictAsync(allPools, _getTVL.bind(this));
-        const input = { constants, chainId, isLiteChain, allPools, amplificationCoefficientDict, poolTvlDict };
+        const input = { constants, chainId, isLiteChain, allPools, amplificationCoefficientDict, poolTvlDict, blacklist: this.routerBlacklist };
         return runWorker(routeGraphWorkerCode, routeGraphWorker, Object.assign({ type: 'createRouteGraph' }, input));
     });
 }

package/package.json

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