@curvefi/api 2.68.41 → 2.68.43

package/lib/pools/PoolTemplate.d.ts

@@ -10,27 +10,27 @@ export declare class PoolTemplate extends CorePool {
     gaugeStatus: () => Promise<any>;
     estimateGas: {
         depositApprove: (amounts: (number | string)[]) => Promise<number | number[]>;
-        deposit: (amounts: (number | string)[]) => Promise<number | number[]>;
+        deposit: (amounts: (number | string)[], slippage?: number) => Promise<number | number[]>;
         depositWrappedApprove: (amounts: (number | string)[]) => Promise<number | number[]>;
-        depositWrapped: (amounts: (number | string)[]) => Promise<number | number[]>;
+        depositWrapped: (amounts: (number | string)[], slippage?: number) => 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[]>;
         depositAndStakeApprove: (amounts: (number | string)[]) => Promise<number | number[]>;
-        depositAndStake: (amounts: (number | string)[]) => Promise<number>;
+        depositAndStake: (amounts: (number | string)[], slippage?: number) => Promise<number>;
         depositAndStakeWrappedApprove: (amounts: (number | string)[]) => Promise<number | number[]>;
-        depositAndStakeWrapped: (amounts: (number | string)[]) => Promise<number | number[]>;
+        depositAndStakeWrapped: (amounts: (number | string)[], slippage?: number) => Promise<number | number[]>;
         withdrawApprove: (lpTokenAmount: number | string) => Promise<number | number[]>;
-        withdraw: (lpTokenAmount: number | string) => Promise<number | number[]>;
-        withdrawWrapped: (lpTokenAmount: number | string) => Promise<number | number[]>;
+        withdraw: (lpTokenAmount: number | string, slippage?: number) => Promise<number | number[]>;
+        withdrawWrapped: (lpTokenAmount: number | string, slippage?: number) => Promise<number | number[]>;
         withdrawImbalanceApprove: (amounts: (number | string)[]) => Promise<number | number[]>;
-        withdrawImbalance: (amounts: (number | string)[]) => Promise<number | number[]>;
-        withdrawImbalanceWrapped: (amounts: (number | string)[]) => Promise<number | number[]>;
+        withdrawImbalance: (amounts: (number | string)[], slippage?: number) => Promise<number | number[]>;
+        withdrawImbalanceWrapped: (amounts: (number | string)[], slippage?: number) => Promise<number | number[]>;
         withdrawOneCoinApprove: (lpTokenAmount: number | string) => Promise<number | number[]>;
-        withdrawOneCoin: (lpTokenAmount: number | string, coin: string | number) => Promise<number | number[]>;
-        withdrawOneCoinWrapped: (lpTokenAmount: number | string, coin: string | number) => Promise<number | number[]>;
+        withdrawOneCoin: (lpTokenAmount: number | string, coin: string | number, slippage?: number) => Promise<number | number[]>;
+        withdrawOneCoinWrapped: (lpTokenAmount: number | string, coin: string | number, slippage?: number) => Promise<number | number[]>;
         swapApprove: (inputCoin: string | number, amount: number | string) => Promise<number | number[]>;
         swap: (inputCoin: string | number, outputCoin: string | number, amount: number | string, slippage: number) => Promise<number | number[]>;
         swapWrappedApprove: (inputCoin: string | number, amount: number | string) => Promise<number | number[]>;

package/lib/pools/PoolTemplate.js

@@ -787,8 +787,8 @@ export class PoolTemplate extends CorePool {
         });
     }
     // OVERRIDE
-    depositEstimateGas(amounts) {
-        return __awaiter(this, void 0, void 0, function* () {
+    depositEstimateGas(amounts_1) {
+        return __awaiter(this, arguments, void 0, function* (amounts, slippage = 0.1) {
             throw Error(`depositEstimateGas method doesn't exist for pool ${this.name} (id: ${this.name})`);
         });
     }
@@ -861,8 +861,8 @@ export class PoolTemplate extends CorePool {
         });
     }
     // OVERRIDE
-    depositWrappedEstimateGas(amounts) {
-        return __awaiter(this, void 0, void 0, function* () {
+    depositWrappedEstimateGas(amounts_1) {
+        return __awaiter(this, arguments, void 0, function* (amounts, slippage = 0.1) {
             throw Error(`depositWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
         });
     }
@@ -1144,12 +1144,12 @@ export class PoolTemplate extends CorePool {
             return approveCoinsTx;
         });
     }
-    depositAndStakeEstimateGas(amounts) {
-        return __awaiter(this, void 0, void 0, function* () {
+    depositAndStakeEstimateGas(amounts_1) {
+        return __awaiter(this, arguments, void 0, function* (amounts, slippage = 1) {
             if (this.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 throw Error(`depositAndStake method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
             }
-            return yield this._depositAndStake(amounts, 1, true, true);
+            return yield this._depositAndStake(amounts, slippage, true, true);
         });
     }
     depositAndStake(amounts_1) {
@@ -1241,14 +1241,14 @@ export class PoolTemplate extends CorePool {
             return approveCoinsTx;
         });
     }
-    depositAndStakeWrappedEstimateGas(amounts) {
-        return __awaiter(this, void 0, void 0, function* () {
+    depositAndStakeWrappedEstimateGas(amounts_1) {
+        return __awaiter(this, arguments, void 0, function* (amounts, slippage = 1) {
             if (this.gauge.address === this.curve.constants.ZERO_ADDRESS) {
                 throw Error(`depositAndStakeWrapped method doesn't exist for pool ${this.name} (id: ${this.name}). There is no gauge`);
             }
             if (this.isPlain || this.isFake)
                 throw Error(`depositAndStakeWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
-            return yield this._depositAndStake(amounts, 1, false, true);
+            return yield this._depositAndStake(amounts, slippage, false, true);
         });
     }
     depositAndStakeWrapped(amounts_1) {
@@ -1349,8 +1349,8 @@ export class PoolTemplate extends CorePool {
         });
     }
     // OVERRIDE
-    withdrawEstimateGas(lpTokenAmount) {
-        return __awaiter(this, void 0, void 0, function* () {
+    withdrawEstimateGas(lpTokenAmount_1) {
+        return __awaiter(this, arguments, void 0, function* (lpTokenAmount, slippage = 0.1) {
             throw Error(`withdraw method doesn't exist for pool ${this.name} (id: ${this.name})`);
         });
     }
@@ -1374,8 +1374,8 @@ export class PoolTemplate extends CorePool {
         });
     }
     // OVERRIDE
-    withdrawWrappedEstimateGas(lpTokenAmount) {
-        return __awaiter(this, void 0, void 0, function* () {
+    withdrawWrappedEstimateGas(lpTokenAmount_1) {
+        return __awaiter(this, arguments, void 0, function* (lpTokenAmount, slippage = 0.1) {
             throw Error(`withdrawWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
         });
     }
@@ -1464,8 +1464,8 @@ export class PoolTemplate extends CorePool {
         });
     }
     // OVERRIDE
-    withdrawImbalanceEstimateGas(amounts) {
-        return __awaiter(this, void 0, void 0, function* () {
+    withdrawImbalanceEstimateGas(amounts_1) {
+        return __awaiter(this, arguments, void 0, function* (amounts, slippage = 0.1) {
             throw Error(`withdrawImbalance method doesn't exist for pool ${this.name} (id: ${this.name})`);
         });
     }
@@ -1494,8 +1494,8 @@ export class PoolTemplate extends CorePool {
         });
     }
     // OVERRIDE
-    withdrawImbalanceWrappedEstimateGas(amounts) {
-        return __awaiter(this, void 0, void 0, function* () {
+    withdrawImbalanceWrappedEstimateGas(amounts_1) {
+        return __awaiter(this, arguments, void 0, function* (amounts, slippage = 0.1) {
             throw Error(`withdrawImbalanceWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
         });
     }
@@ -1583,8 +1583,8 @@ export class PoolTemplate extends CorePool {
         });
     }
     // OVERRIDE
-    withdrawOneCoinEstimateGas(lpTokenAmount, coin) {
-        return __awaiter(this, void 0, void 0, function* () {
+    withdrawOneCoinEstimateGas(lpTokenAmount_1, coin_1) {
+        return __awaiter(this, arguments, void 0, function* (lpTokenAmount, coin, slippage = 0.1) {
             throw Error(`withdrawOneCoin method doesn't exist for pool ${this.name} (id: ${this.name})`);
         });
     }
@@ -1632,8 +1632,8 @@ export class PoolTemplate extends CorePool {
         });
     }
     // OVERRIDE
-    withdrawOneCoinWrappedEstimateGas(lpTokenAmount, coin) {
-        return __awaiter(this, void 0, void 0, function* () {
+    withdrawOneCoinWrappedEstimateGas(lpTokenAmount_1, coin_1) {
+        return __awaiter(this, arguments, void 0, function* (lpTokenAmount, coin, slippage = 0.1) {
             throw Error(`withdrawOneCoinWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
         });
     }

package/lib/pools/mixins/depositMixins.d.ts

@@ -2,31 +2,31 @@ import { PoolTemplate } from "../PoolTemplate.js";
 import { IMethodInfo } from "../../interfaces.js";
 export declare const depositMetaFactoryMixin: {
     _deposit(this: PoolTemplate, _amounts: bigint[], slippage?: number, estimateGas?: boolean, getInfo?: boolean): Promise<string | number | number[] | IMethodInfo>;
-    depositEstimateGas(this: PoolTemplate, amounts: (number | string)[]): Promise<number>;
+    depositEstimateGas(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<number>;
     deposit(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<string>;
     getDepositInfo(this: PoolTemplate): Promise<IMethodInfo>;
 };
 export declare const depositCryptoMetaFactoryMixin: {
     _deposit(this: PoolTemplate, _amounts: bigint[], slippage?: number, estimateGas?: boolean, getInfo?: boolean): Promise<string | number | number[] | IMethodInfo>;
-    depositEstimateGas(this: PoolTemplate, amounts: (number | string)[]): Promise<number | number[]>;
+    depositEstimateGas(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<number | number[]>;
     deposit(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<string>;
     getDepositInfo(this: PoolTemplate): Promise<IMethodInfo>;
 };
 export declare const depositZapMixin: {
     _deposit(this: PoolTemplate, _amounts: bigint[], slippage?: number, estimateGas?: boolean, getInfo?: boolean): Promise<string | number | number[] | IMethodInfo>;
-    depositEstimateGas(this: PoolTemplate, amounts: (number | string)[]): Promise<number | number[]>;
+    depositEstimateGas(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<number | number[]>;
     deposit(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<string>;
     getDepositInfo(this: PoolTemplate): Promise<IMethodInfo>;
 };
 export declare const depositLendingOrCryptoMixin: {
     _deposit(this: PoolTemplate, _amounts: bigint[], slippage?: number, estimateGas?: boolean, getInfo?: boolean): Promise<string | number | number[] | IMethodInfo>;
-    depositEstimateGas(this: PoolTemplate, amounts: (number | string)[]): Promise<number | number[]>;
+    depositEstimateGas(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<number | number[]>;
     deposit(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<string>;
     getDepositInfo(this: PoolTemplate): Promise<IMethodInfo>;
 };
 export declare const depositPlainMixin: {
     _deposit(this: PoolTemplate, _amounts: bigint[], slippage?: number, estimateGas?: boolean, getInfo?: boolean): Promise<string | number | number[] | IMethodInfo>;
-    depositEstimateGas(this: PoolTemplate, amounts: (number | string)[]): Promise<number | number[]>;
+    depositEstimateGas(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<number | number[]>;
     deposit(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<string>;
     getDepositInfo(this: PoolTemplate): Promise<IMethodInfo>;
 };

package/lib/pools/mixins/depositMixins.js

@@ -53,10 +53,10 @@ export const depositMetaFactoryMixin = {
             return (yield contract.add_liquidity(this.address, _amounts, _minMintAmount, Object.assign(Object.assign({}, this.curve.options), { gasLimit, value }))).hash;
         });
     },
-    depositEstimateGas(amounts) {
-        return __awaiter(this, void 0, void 0, function* () {
+    depositEstimateGas(amounts_1) {
+        return __awaiter(this, arguments, void 0, function* (amounts, slippage = 0.1) {
             const _amounts = yield _depositCheck.call(this, amounts, true);
-            return yield depositMetaFactoryMixin._deposit.call(this, _amounts, 0.1, true);
+            return yield depositMetaFactoryMixin._deposit.call(this, _amounts, slippage, true);
         });
     },
     deposit(amounts, slippage) {
@@ -90,10 +90,10 @@ export const depositCryptoMetaFactoryMixin = {
             return (yield contract.add_liquidity(this.address, _amounts, _minMintAmount, true, Object.assign(Object.assign({}, this.curve.options), { gasLimit, value }))).hash;
         });
     },
-    depositEstimateGas(amounts) {
-        return __awaiter(this, void 0, void 0, function* () {
+    depositEstimateGas(amounts_1) {
+        return __awaiter(this, arguments, void 0, function* (amounts, slippage = 0.1) {
             const _amounts = yield _depositCheck.call(this, amounts, true);
-            return yield depositCryptoMetaFactoryMixin._deposit.call(this, _amounts, 0.1, true);
+            return yield depositCryptoMetaFactoryMixin._deposit.call(this, _amounts, slippage, true);
         });
     },
     deposit(amounts, slippage) {
@@ -130,10 +130,10 @@ export const depositZapMixin = {
             return (yield contract.add_liquidity(...args, Object.assign(Object.assign({}, this.curve.options), { gasLimit, value }))).hash;
         });
     },
-    depositEstimateGas(amounts) {
-        return __awaiter(this, void 0, void 0, function* () {
+    depositEstimateGas(amounts_1) {
+        return __awaiter(this, arguments, void 0, function* (amounts, slippage = 0.1) {
             const _amounts = yield _depositCheck.call(this, amounts, true);
-            return yield depositZapMixin._deposit.call(this, _amounts, 0.1, true);
+            return yield depositZapMixin._deposit.call(this, _amounts, slippage, true);
         });
     },
     deposit(amounts, slippage) {
@@ -167,10 +167,10 @@ export const depositLendingOrCryptoMixin = {
             return (yield contract.add_liquidity(_amounts, _minMintAmount, true, Object.assign(Object.assign({}, this.curve.options), { gasLimit, value }))).hash;
         });
     },
-    depositEstimateGas(amounts) {
-        return __awaiter(this, void 0, void 0, function* () {
+    depositEstimateGas(amounts_1) {
+        return __awaiter(this, arguments, void 0, function* (amounts, slippage = 0.1) {
             const _amounts = yield _depositCheck.call(this, amounts, true);
-            return yield depositLendingOrCryptoMixin._deposit.call(this, _amounts, 0.1, true);
+            return yield depositLendingOrCryptoMixin._deposit.call(this, _amounts, slippage, true);
         });
     },
     deposit(amounts, slippage) {
@@ -204,10 +204,10 @@ export const depositPlainMixin = {
             return (yield contract.add_liquidity(_amounts, _minMintAmount, Object.assign(Object.assign({}, this.curve.options), { gasLimit, value }))).hash;
         });
     },
-    depositEstimateGas(amounts) {
-        return __awaiter(this, void 0, void 0, function* () {
+    depositEstimateGas(amounts_1) {
+        return __awaiter(this, arguments, void 0, function* (amounts, slippage = 0.1) {
             const _amounts = yield _depositCheck.call(this, amounts, true);
-            return yield depositPlainMixin._deposit.call(this, _amounts, 0.1, true);
+            return yield depositPlainMixin._deposit.call(this, _amounts, slippage, true);
         });
     },
     deposit(amounts, slippage) {

package/lib/pools/mixins/depositWrappedMixins.d.ts

@@ -2,13 +2,13 @@ import { PoolTemplate } from "../PoolTemplate.js";
 import { IMethodInfo } from "../../interfaces.js";
 export declare const depositWrapped2argsMixin: {
     _depositWrapped(this: PoolTemplate, _amounts: bigint[], slippage?: number, estimateGas?: boolean, getInfo?: boolean): Promise<string | number | number[] | IMethodInfo>;
-    depositWrappedEstimateGas(this: PoolTemplate, amounts: (number | string)[]): Promise<number>;
+    depositWrappedEstimateGas(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<number>;
     depositWrapped(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<string>;
     getDepositWrappedInfo(this: PoolTemplate): Promise<IMethodInfo>;
 };
 export declare const depositWrapped3argsMixin: {
     _depositWrapped(this: PoolTemplate, _amounts: bigint[], slippage?: number, estimateGas?: boolean, getInfo?: boolean): Promise<string | number | number[] | IMethodInfo>;
-    depositWrappedEstimateGas(this: PoolTemplate, amounts: (number | string)[]): Promise<number>;
+    depositWrappedEstimateGas(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<number>;
     depositWrapped(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<string>;
     getDepositWrappedInfo(this: PoolTemplate): Promise<IMethodInfo>;
 };

package/lib/pools/mixins/depositWrappedMixins.js

@@ -56,10 +56,10 @@ export const depositWrapped2argsMixin = {
             return (yield contract.add_liquidity(_amounts, _minMintAmount, Object.assign(Object.assign({}, this.curve.options), { gasLimit, value }))).hash;
         });
     },
-    depositWrappedEstimateGas(amounts) {
-        return __awaiter(this, void 0, void 0, function* () {
+    depositWrappedEstimateGas(amounts_1) {
+        return __awaiter(this, arguments, void 0, function* (amounts, slippage = 0.1) {
             const _amounts = yield _depositWrappedCheck.call(this, amounts, true);
-            return yield depositWrapped2argsMixin._depositWrapped.call(this, _amounts, 0.1, true);
+            return yield depositWrapped2argsMixin._depositWrapped.call(this, _amounts, slippage, true);
         });
     },
     depositWrapped(amounts, slippage) {
@@ -93,10 +93,10 @@ export const depositWrapped3argsMixin = {
             return (yield contract.add_liquidity(_amounts, _minMintAmount, false, Object.assign(Object.assign({}, this.curve.options), { gasLimit, value }))).hash;
         });
     },
-    depositWrappedEstimateGas(amounts) {
-        return __awaiter(this, void 0, void 0, function* () {
+    depositWrappedEstimateGas(amounts_1) {
+        return __awaiter(this, arguments, void 0, function* (amounts, slippage = 0.1) {
             const _amounts = yield _depositWrappedCheck.call(this, amounts, true);
-            return yield depositWrapped3argsMixin._depositWrapped.call(this, _amounts, 0.1, true);
+            return yield depositWrapped3argsMixin._depositWrapped.call(this, _amounts, slippage, true);
         });
     },
     depositWrapped(amounts, slippage) {

package/lib/pools/mixins/swapMixins.d.ts

@@ -2,25 +2,25 @@ import { PoolTemplate } from "../PoolTemplate.js";
 import { IMethodInfo } from "../../interfaces.js";
 export declare const swapTricrypto2Mixin: {
     _swap(this: PoolTemplate, i: number, j: number, _amount: bigint, slippage?: number, estimateGas?: boolean, getInfo?: boolean): Promise<string | number | number[] | IMethodInfo>;
-    swapEstimateGas(this: PoolTemplate, inputCoin: string | number, outputCoin: string | number, amount: number | string): Promise<number>;
+    swapEstimateGas(this: PoolTemplate, inputCoin: string | number, outputCoin: string | number, amount: number | string, slippage?: number): Promise<number>;
     swap(this: PoolTemplate, inputCoin: string | number, outputCoin: string | number, amount: number | string, slippage?: number): Promise<string>;
     getSwapInfo(this: PoolTemplate): Promise<IMethodInfo>;
 };
 export declare const swapMetaFactoryMixin: {
     _swap(this: PoolTemplate, i: number, j: number, _amount: bigint, slippage?: number, estimateGas?: boolean, getInfo?: boolean): Promise<string | number | number[] | IMethodInfo>;
-    swapEstimateGas(this: PoolTemplate, inputCoin: string | number, outputCoin: string | number, amount: number | string): Promise<number>;
+    swapEstimateGas(this: PoolTemplate, inputCoin: string | number, outputCoin: string | number, amount: number | string, slippage?: number): Promise<number>;
     swap(this: PoolTemplate, inputCoin: string | number, outputCoin: string | number, amount: number | string, slippage?: number): Promise<string>;
     getSwapInfo(this: PoolTemplate): Promise<IMethodInfo>;
 };
 export declare const swapCryptoMetaFactoryMixin: {
     _swap(this: PoolTemplate, i: number, j: number, _amount: bigint, slippage?: number, estimateGas?: boolean, getInfo?: boolean): Promise<string | number | number[] | IMethodInfo>;
-    swapEstimateGas(this: PoolTemplate, inputCoin: string | number, outputCoin: string | number, amount: number | string): Promise<number>;
+    swapEstimateGas(this: PoolTemplate, inputCoin: string | number, outputCoin: string | number, amount: number | string, slippage?: number): Promise<number>;
     swap(this: PoolTemplate, inputCoin: string | number, outputCoin: string | number, amount: number | string, slippage?: number): Promise<string>;
     getSwapInfo(this: PoolTemplate): Promise<IMethodInfo>;
 };
 export declare const swapMixin: {
     _swap(this: PoolTemplate, i: number, j: number, _amount: bigint, slippage?: number, estimateGas?: boolean, getInfo?: boolean): Promise<string | number | number[] | IMethodInfo>;
-    swapEstimateGas(this: PoolTemplate, inputCoin: string | number, outputCoin: string | number, amount: number | string): Promise<number>;
+    swapEstimateGas(this: PoolTemplate, inputCoin: string | number, outputCoin: string | number, amount: number | string, slippage?: number): Promise<number>;
     swap(this: PoolTemplate, inputCoin: string | number, outputCoin: string | number, amount: number | string, slippage?: number): Promise<string>;
     getSwapInfo(this: PoolTemplate): Promise<IMethodInfo>;
 };

package/lib/pools/mixins/swapMixins.js

@@ -54,10 +54,10 @@ export const swapTricrypto2Mixin = {
             return (yield contract[exchangeMethod](i, j, _amount, _minRecvAmount, true, Object.assign(Object.assign({}, this.curve.options), { value, gasLimit }))).hash;
         });
     },
-    swapEstimateGas(inputCoin, outputCoin, amount) {
-        return __awaiter(this, void 0, void 0, function* () {
+    swapEstimateGas(inputCoin_1, outputCoin_1, amount_1) {
+        return __awaiter(this, arguments, void 0, function* (inputCoin, outputCoin, amount, slippage = 0.1) {
             const [i, j, _amount] = yield _swapCheck.call(this, inputCoin, outputCoin, amount, true);
-            return yield swapTricrypto2Mixin._swap.call(this, i, j, _amount, 0.1, true);
+            return yield swapTricrypto2Mixin._swap.call(this, i, j, _amount, slippage, true);
         });
     },
     swap(inputCoin, outputCoin, amount, slippage) {
@@ -92,10 +92,10 @@ export const swapMetaFactoryMixin = {
             return (yield contract[exchangeMethod](this.address, i, j, _amount, _minRecvAmount, Object.assign(Object.assign({}, this.curve.options), { value, gasLimit }))).hash;
         });
     },
-    swapEstimateGas(inputCoin, outputCoin, amount) {
-        return __awaiter(this, void 0, void 0, function* () {
+    swapEstimateGas(inputCoin_1, outputCoin_1, amount_1) {
+        return __awaiter(this, arguments, void 0, function* (inputCoin, outputCoin, amount, slippage = 0.1) {
             const [i, j, _amount] = yield _swapCheck.call(this, inputCoin, outputCoin, amount, true);
-            return yield swapMetaFactoryMixin._swap.call(this, i, j, _amount, 0.1, true);
+            return yield swapMetaFactoryMixin._swap.call(this, i, j, _amount, slippage, true);
         });
     },
     swap(inputCoin, outputCoin, amount, slippage) {
@@ -130,10 +130,10 @@ export const swapCryptoMetaFactoryMixin = {
             return (yield contract[exchangeMethod](this.address, i, j, _amount, _minRecvAmount, true, Object.assign(Object.assign({}, this.curve.options), { value, gasLimit }))).hash;
         });
     },
-    swapEstimateGas(inputCoin, outputCoin, amount) {
-        return __awaiter(this, void 0, void 0, function* () {
+    swapEstimateGas(inputCoin_1, outputCoin_1, amount_1) {
+        return __awaiter(this, arguments, void 0, function* (inputCoin, outputCoin, amount, slippage = 0.1) {
             const [i, j, _amount] = yield _swapCheck.call(this, inputCoin, outputCoin, amount, true);
-            return yield swapCryptoMetaFactoryMixin._swap.call(this, i, j, _amount, 0.1, true);
+            return yield swapCryptoMetaFactoryMixin._swap.call(this, i, j, _amount, slippage, true);
         });
     },
     swap(inputCoin, outputCoin, amount, slippage) {
@@ -169,10 +169,10 @@ export const swapMixin = {
             return (yield contract[exchangeMethod](i, j, _amount, _minRecvAmount, Object.assign(Object.assign({}, this.curve.options), { value, gasLimit }))).hash;
         });
     },
-    swapEstimateGas(inputCoin, outputCoin, amount) {
-        return __awaiter(this, void 0, void 0, function* () {
+    swapEstimateGas(inputCoin_1, outputCoin_1, amount_1) {
+        return __awaiter(this, arguments, void 0, function* (inputCoin, outputCoin, amount, slippage = 0.1) {
             const [i, j, _amount] = yield _swapCheck.call(this, inputCoin, outputCoin, amount, true);
-            return yield swapMixin._swap.call(this, i, j, _amount, 0.1, true);
+            return yield swapMixin._swap.call(this, i, j, _amount, slippage, true);
         });
     },
     swap(inputCoin, outputCoin, amount, slippage) {

package/lib/pools/mixins/swapWrappedMixins.d.ts

@@ -2,13 +2,13 @@ import { PoolTemplate } from "../PoolTemplate.js";
 import { IMethodInfo } from "../../interfaces.js";
 export declare const swapWrappedTricrypto2Mixin: {
     _swapWrapped(this: PoolTemplate, i: number, j: number, _amount: bigint, slippage?: number, estimateGas?: boolean, getInfo?: boolean): Promise<string | number | number[] | IMethodInfo>;
-    swapWrappedEstimateGas(this: PoolTemplate, inputCoin: string | number, outputCoin: string | number, amount: number | string): Promise<number>;
+    swapWrappedEstimateGas(this: PoolTemplate, inputCoin: string | number, outputCoin: string | number, amount: number | string, slippage?: number): Promise<number>;
     swapWrapped(this: PoolTemplate, inputCoin: string | number, outputCoin: string | number, amount: number | string, slippage?: number): Promise<string>;
     getSwapWrappedInfo(this: PoolTemplate): Promise<IMethodInfo>;
 };
 export declare const swapWrappedMixin: {
     _swapWrapped(this: PoolTemplate, i: number, j: number, _amount: bigint, slippage?: number, estimateGas?: boolean, getInfo?: boolean): Promise<string | number | number[] | IMethodInfo>;
-    swapWrappedEstimateGas(this: PoolTemplate, inputCoin: string | number, outputCoin: string | number, amount: number | string): Promise<number>;
+    swapWrappedEstimateGas(this: PoolTemplate, inputCoin: string | number, outputCoin: string | number, amount: number | string, slippage?: number): Promise<number>;
     swapWrapped(this: PoolTemplate, inputCoin: string | number, outputCoin: string | number, amount: number | string, slippage?: number): Promise<string>;
     getSwapWrappedInfo(this: PoolTemplate): Promise<IMethodInfo>;
 };

package/lib/pools/mixins/swapWrappedMixins.js

@@ -51,10 +51,10 @@ export const swapWrappedTricrypto2Mixin = {
             return (yield contract.exchange(i, j, _amount, _minRecvAmount, false, Object.assign(Object.assign({}, this.curve.options), { value, gasLimit }))).hash;
         });
     },
-    swapWrappedEstimateGas(inputCoin, outputCoin, amount) {
-        return __awaiter(this, void 0, void 0, function* () {
+    swapWrappedEstimateGas(inputCoin_1, outputCoin_1, amount_1) {
+        return __awaiter(this, arguments, void 0, function* (inputCoin, outputCoin, amount, slippage = 0.1) {
             const [i, j, _amount] = yield _swapWrappedCheck.call(this, inputCoin, outputCoin, amount, true);
-            return yield swapWrappedTricrypto2Mixin._swapWrapped.call(this, i, j, _amount, 0.1, true);
+            return yield swapWrappedTricrypto2Mixin._swapWrapped.call(this, i, j, _amount, slippage, true);
         });
     },
     swapWrapped(inputCoin, outputCoin, amount, slippage) {
@@ -87,10 +87,10 @@ export const swapWrappedMixin = {
             return (yield contract.exchange(i, j, _amount, _minRecvAmount, Object.assign(Object.assign({}, this.curve.options), { value, gasLimit }))).hash;
         });
     },
-    swapWrappedEstimateGas(inputCoin, outputCoin, amount) {
-        return __awaiter(this, void 0, void 0, function* () {
+    swapWrappedEstimateGas(inputCoin_1, outputCoin_1, amount_1) {
+        return __awaiter(this, arguments, void 0, function* (inputCoin, outputCoin, amount, slippage = 0.1) {
             const [i, j, _amount] = yield _swapWrappedCheck.call(this, inputCoin, outputCoin, amount, true);
-            return yield swapWrappedMixin._swapWrapped.call(this, i, j, _amount, 0.1, true);
+            return yield swapWrappedMixin._swapWrapped.call(this, i, j, _amount, slippage, true);
         });
     },
     swapWrapped(inputCoin, outputCoin, amount, slippage) {

package/lib/pools/mixins/withdrawImbalanceMixins.d.ts

@@ -1,21 +1,21 @@
 import { PoolTemplate } from "../PoolTemplate.js";
 export declare const withdrawImbalanceMetaFactoryMixin: {
     _withdrawImbalance(this: PoolTemplate, _amounts: bigint[], slippage?: number, estimateGas?: boolean): Promise<string | number | number[]>;
-    withdrawImbalanceEstimateGas(this: PoolTemplate, amounts: (number | string)[]): Promise<number>;
+    withdrawImbalanceEstimateGas(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<number>;
     withdrawImbalance(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<string>;
 };
 export declare const withdrawImbalanceZapMixin: {
     _withdrawImbalance(this: PoolTemplate, _amounts: bigint[], slippage?: number, estimateGas?: boolean): Promise<string | number | number[]>;
-    withdrawImbalanceEstimateGas(this: PoolTemplate, amounts: (number | string)[]): Promise<number>;
+    withdrawImbalanceEstimateGas(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<number>;
     withdrawImbalance(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<string>;
 };
 export declare const withdrawImbalanceLendingMixin: {
     _withdrawImbalance(this: PoolTemplate, _amounts: bigint[], slippage?: number, estimateGas?: boolean): Promise<string | number | number[]>;
-    withdrawImbalanceEstimateGas(this: PoolTemplate, amounts: (number | string)[]): Promise<number>;
+    withdrawImbalanceEstimateGas(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<number>;
     withdrawImbalance(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<string>;
 };
 export declare const withdrawImbalancePlainMixin: {
     _withdrawImbalance(this: PoolTemplate, _amounts: bigint[], slippage?: number, estimateGas?: boolean): Promise<string | number | number[]>;
-    withdrawImbalanceEstimateGas(this: PoolTemplate, amounts: (number | string)[]): Promise<number>;
+    withdrawImbalanceEstimateGas(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<number>;
     withdrawImbalance(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<string>;
 };

package/lib/pools/mixins/withdrawImbalanceMixins.js

@@ -44,10 +44,10 @@ export const withdrawImbalanceMetaFactoryMixin = {
             return (yield contract.remove_liquidity_imbalance(this.address, _amounts, _maxBurnAmount, Object.assign(Object.assign({}, this.curve.options), { gasLimit }))).hash;
         });
     },
-    withdrawImbalanceEstimateGas(amounts) {
-        return __awaiter(this, void 0, void 0, function* () {
+    withdrawImbalanceEstimateGas(amounts_1) {
+        return __awaiter(this, arguments, void 0, function* (amounts, slippage = 0.1) {
             const _amounts = yield _withdrawImbalanceCheck.call(this, amounts, true);
-            return yield withdrawImbalanceMetaFactoryMixin._withdrawImbalance.call(this, _amounts, 0.1, true);
+            return yield withdrawImbalanceMetaFactoryMixin._withdrawImbalance.call(this, _amounts, slippage, true);
         });
     },
     withdrawImbalance(amounts, slippage) {
@@ -71,10 +71,10 @@ export const withdrawImbalanceZapMixin = {
             return (yield contract.remove_liquidity_imbalance(_amounts, _maxBurnAmount, Object.assign(Object.assign({}, this.curve.options), { gasLimit }))).hash;
         });
     },
-    withdrawImbalanceEstimateGas(amounts) {
-        return __awaiter(this, void 0, void 0, function* () {
+    withdrawImbalanceEstimateGas(amounts_1) {
+        return __awaiter(this, arguments, void 0, function* (amounts, slippage = 0.1) {
             const _amounts = yield _withdrawImbalanceCheck.call(this, amounts, true);
-            return yield withdrawImbalanceZapMixin._withdrawImbalance.call(this, _amounts, 0.1, true);
+            return yield withdrawImbalanceZapMixin._withdrawImbalance.call(this, _amounts, slippage, true);
         });
     },
     withdrawImbalance(amounts, slippage) {
@@ -96,10 +96,10 @@ export const withdrawImbalanceLendingMixin = {
             return (yield contract.remove_liquidity_imbalance(_amounts, _maxBurnAmount, true, Object.assign(Object.assign({}, this.curve.options), { gasLimit }))).hash;
         });
     },
-    withdrawImbalanceEstimateGas(amounts) {
-        return __awaiter(this, void 0, void 0, function* () {
+    withdrawImbalanceEstimateGas(amounts_1) {
+        return __awaiter(this, arguments, void 0, function* (amounts, slippage = 0.1) {
             const _amounts = yield _withdrawImbalanceCheck.call(this, amounts, true);
-            return yield withdrawImbalanceLendingMixin._withdrawImbalance.call(this, _amounts, 0.1, true);
+            return yield withdrawImbalanceLendingMixin._withdrawImbalance.call(this, _amounts, slippage, true);
         });
     },
     withdrawImbalance(amounts, slippage) {
@@ -121,10 +121,10 @@ export const withdrawImbalancePlainMixin = {
             return (yield contract.remove_liquidity_imbalance(_amounts, _maxBurnAmount, Object.assign(Object.assign({}, this.curve.options), { gasLimit }))).hash;
         });
     },
-    withdrawImbalanceEstimateGas(amounts) {
-        return __awaiter(this, void 0, void 0, function* () {
+    withdrawImbalanceEstimateGas(amounts_1) {
+        return __awaiter(this, arguments, void 0, function* (amounts, slippage = 0.1) {
             const _amounts = yield _withdrawImbalanceCheck.call(this, amounts, true);
-            return yield withdrawImbalancePlainMixin._withdrawImbalance.call(this, _amounts, 0.1, true);
+            return yield withdrawImbalancePlainMixin._withdrawImbalance.call(this, _amounts, slippage, true);
         });
     },
     withdrawImbalance(amounts, slippage) {

package/lib/pools/mixins/withdrawImbalanceWrappedMixins.d.ts

@@ -1,11 +1,11 @@
 import { PoolTemplate } from "../PoolTemplate.js";
 export declare const withdrawImbalanceWrapped2argsMixin: {
     _withdrawImbalanceWrapped(this: PoolTemplate, _amounts: bigint[], slippage?: number, estimateGas?: boolean): Promise<string | number | number[]>;
-    withdrawImbalanceWrappedEstimateGas(this: PoolTemplate, amounts: (number | string)[]): Promise<number>;
+    withdrawImbalanceWrappedEstimateGas(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<number>;
     withdrawImbalanceWrapped(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<string>;
 };
 export declare const withdrawImbalanceWrapped3argsMixin: {
     _withdrawImbalanceWrapped(this: PoolTemplate, _amounts: bigint[], slippage?: number, estimateGas?: boolean): Promise<string | number | number[]>;
-    withdrawImbalanceWrappedEstimateGas(this: PoolTemplate, amounts: (number | string)[]): Promise<number>;
+    withdrawImbalanceWrappedEstimateGas(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<number>;
     withdrawImbalanceWrapped(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<string>;
 };

package/lib/pools/mixins/withdrawImbalanceWrappedMixins.js

@@ -38,10 +38,10 @@ export const withdrawImbalanceWrapped2argsMixin = {
             return (yield contract.remove_liquidity_imbalance(_amounts, _maxBurnAmount, Object.assign(Object.assign({}, this.curve.options), { gasLimit }))).hash;
         });
     },
-    withdrawImbalanceWrappedEstimateGas(amounts) {
-        return __awaiter(this, void 0, void 0, function* () {
+    withdrawImbalanceWrappedEstimateGas(amounts_1) {
+        return __awaiter(this, arguments, void 0, function* (amounts, slippage = 0.1) {
             const _amounts = yield _withdrawImbalanceWrappedCheck.call(this, amounts);
-            return yield withdrawImbalanceWrapped2argsMixin._withdrawImbalanceWrapped.call(this, _amounts, 0.1, true);
+            return yield withdrawImbalanceWrapped2argsMixin._withdrawImbalanceWrapped.call(this, _amounts, slippage, true);
         });
     },
     withdrawImbalanceWrapped(amounts, slippage) {
@@ -63,10 +63,10 @@ export const withdrawImbalanceWrapped3argsMixin = {
             return (yield contract.remove_liquidity_imbalance(_amounts, _maxBurnAmount, false, Object.assign(Object.assign({}, this.curve.options), { gasLimit }))).hash;
         });
     },
-    withdrawImbalanceWrappedEstimateGas(amounts) {
-        return __awaiter(this, void 0, void 0, function* () {
+    withdrawImbalanceWrappedEstimateGas(amounts_1) {
+        return __awaiter(this, arguments, void 0, function* (amounts, slippage = 0.1) {
             const _amounts = yield _withdrawImbalanceWrappedCheck.call(this, amounts);
-            return yield withdrawImbalanceWrapped3argsMixin._withdrawImbalanceWrapped.call(this, _amounts, 0.1, true);
+            return yield withdrawImbalanceWrapped3argsMixin._withdrawImbalanceWrapped.call(this, _amounts, slippage, true);
         });
     },
     withdrawImbalanceWrapped(amounts, slippage) {

package/lib/pools/mixins/withdrawMixins.d.ts

@@ -1,26 +1,26 @@
 import { PoolTemplate } from "../PoolTemplate.js";
 export declare const withdrawMetaFactoryMixin: {
     _withdraw(this: PoolTemplate, _lpTokenAmount: bigint, slippage?: number, estimateGas?: boolean): Promise<string | number | number[]>;
-    withdrawEstimateGas(this: PoolTemplate, lpTokenAmount: number | string): Promise<number | number[]>;
+    withdrawEstimateGas(this: PoolTemplate, lpTokenAmount: number | string, slippage?: number): Promise<number | number[]>;
     withdraw(this: PoolTemplate, lpTokenAmount: number | string, slippage?: number): Promise<string>;
 };
 export declare const withdrawCryptoMetaFactoryMixin: {
     _withdraw(this: PoolTemplate, _lpTokenAmount: bigint, slippage?: number, estimateGas?: boolean): Promise<string | number | number[]>;
-    withdrawEstimateGas(this: PoolTemplate, lpTokenAmount: number | string): Promise<number | number[]>;
+    withdrawEstimateGas(this: PoolTemplate, lpTokenAmount: number | string, slippage?: number): Promise<number | number[]>;
     withdraw(this: PoolTemplate, lpTokenAmount: number | string, slippage?: number): Promise<string>;
 };
 export declare const withdrawZapMixin: {
     _withdraw(this: PoolTemplate, _lpTokenAmount: bigint, slippage?: number, estimateGas?: boolean): Promise<string | number | number[]>;
-    withdrawEstimateGas(this: PoolTemplate, lpTokenAmount: number | string): Promise<number | number[]>;
+    withdrawEstimateGas(this: PoolTemplate, lpTokenAmount: number | string, slippage?: number): Promise<number | number[]>;
     withdraw(this: PoolTemplate, lpTokenAmount: number | string, slippage?: number): Promise<string>;
 };
 export declare const withdrawLendingOrCryptoMixin: {
     _withdraw(this: PoolTemplate, _lpTokenAmount: bigint, slippage?: number, estimateGas?: boolean): Promise<string | number | number[]>;
-    withdrawEstimateGas(this: PoolTemplate, lpTokenAmount: number | string): Promise<number | number[]>;
+    withdrawEstimateGas(this: PoolTemplate, lpTokenAmount: number | string, slippage?: number): Promise<number | number[]>;
     withdraw(this: PoolTemplate, lpTokenAmount: number | string, slippage?: number): Promise<string>;
 };
 export declare const withdrawPlainMixin: {
     _withdraw(this: PoolTemplate, _lpTokenAmount: bigint, slippage?: number, estimateGas?: boolean): Promise<string | number | number[]>;
-    withdrawEstimateGas(this: PoolTemplate, lpTokenAmount: number | string): Promise<number | number[]>;
+    withdrawEstimateGas(this: PoolTemplate, lpTokenAmount: number | string, slippage?: number): Promise<number | number[]>;
     withdraw(this: PoolTemplate, lpTokenAmount: number | string, slippage?: number): Promise<string>;
 };

package/lib/pools/mixins/withdrawMixins.js

@@ -44,10 +44,10 @@ export const withdrawMetaFactoryMixin = {
             return (yield contract.remove_liquidity(this.address, _lpTokenAmount, _minAmounts, Object.assign(Object.assign({}, this.curve.options), { gasLimit }))).hash;
         });
     },
-    withdrawEstimateGas(lpTokenAmount) {
-        return __awaiter(this, void 0, void 0, function* () {
+    withdrawEstimateGas(lpTokenAmount_1) {
+        return __awaiter(this, arguments, void 0, function* (lpTokenAmount, slippage = 0.1) {
             const _lpTokenAmount = yield _withdrawCheck.call(this, lpTokenAmount, true);
-            return yield withdrawMetaFactoryMixin._withdraw.call(this, _lpTokenAmount, 0.1, true);
+            return yield withdrawMetaFactoryMixin._withdraw.call(this, _lpTokenAmount, slippage, true);
         });
     },
     withdraw(lpTokenAmount, slippage) {
@@ -71,10 +71,10 @@ export const withdrawCryptoMetaFactoryMixin = {
             return (yield contract.remove_liquidity(this.address, _lpTokenAmount, _minAmounts, true, Object.assign(Object.assign({}, this.curve.options), { gasLimit }))).hash;
         });
     },
-    withdrawEstimateGas(lpTokenAmount) {
-        return __awaiter(this, void 0, void 0, function* () {
+    withdrawEstimateGas(lpTokenAmount_1) {
+        return __awaiter(this, arguments, void 0, function* (lpTokenAmount, slippage = 0.1) {
             const _lpTokenAmount = yield _withdrawCheck.call(this, lpTokenAmount, true);
-            return yield withdrawCryptoMetaFactoryMixin._withdraw.call(this, _lpTokenAmount, 0.1, true);
+            return yield withdrawCryptoMetaFactoryMixin._withdraw.call(this, _lpTokenAmount, slippage, true);
         });
     },
     withdraw(lpTokenAmount, slippage) {
@@ -101,10 +101,10 @@ export const withdrawZapMixin = {
             return (yield contract.remove_liquidity(...args, Object.assign(Object.assign({}, this.curve.options), { gasLimit }))).hash;
         });
     },
-    withdrawEstimateGas(lpTokenAmount) {
-        return __awaiter(this, void 0, void 0, function* () {
+    withdrawEstimateGas(lpTokenAmount_1) {
+        return __awaiter(this, arguments, void 0, function* (lpTokenAmount, slippage = 0.1) {
             const _lpTokenAmount = yield _withdrawCheck.call(this, lpTokenAmount, true);
-            return yield withdrawZapMixin._withdraw.call(this, _lpTokenAmount, 0.1, true);
+            return yield withdrawZapMixin._withdraw.call(this, _lpTokenAmount, slippage, true);
         });
     },
     withdraw(lpTokenAmount, slippage) {
@@ -126,10 +126,10 @@ export const withdrawLendingOrCryptoMixin = {
             return (yield contract.remove_liquidity(_lpTokenAmount, _minAmounts, true, Object.assign(Object.assign({}, this.curve.options), { gasLimit }))).hash;
         });
     },
-    withdrawEstimateGas(lpTokenAmount) {
-        return __awaiter(this, void 0, void 0, function* () {
+    withdrawEstimateGas(lpTokenAmount_1) {
+        return __awaiter(this, arguments, void 0, function* (lpTokenAmount, slippage = 0.1) {
             const _lpTokenAmount = yield _withdrawCheck.call(this, lpTokenAmount, true);
-            return yield withdrawLendingOrCryptoMixin._withdraw.call(this, _lpTokenAmount, 0.1, true);
+            return yield withdrawLendingOrCryptoMixin._withdraw.call(this, _lpTokenAmount, slippage, true);
         });
     },
     withdraw(lpTokenAmount, slippage) {
@@ -151,10 +151,10 @@ export const withdrawPlainMixin = {
             return (yield contract.remove_liquidity(_lpTokenAmount, _minAmounts, Object.assign(Object.assign({}, this.curve.options), { gasLimit }))).hash;
         });
     },
-    withdrawEstimateGas(lpTokenAmount) {
-        return __awaiter(this, void 0, void 0, function* () {
+    withdrawEstimateGas(lpTokenAmount_1) {
+        return __awaiter(this, arguments, void 0, function* (lpTokenAmount, slippage = 0.1) {
             const _lpTokenAmount = yield _withdrawCheck.call(this, lpTokenAmount, true);
-            return yield withdrawPlainMixin._withdraw.call(this, _lpTokenAmount, 0.1, true);
+            return yield withdrawPlainMixin._withdraw.call(this, _lpTokenAmount, slippage, true);
         });
     },
     withdraw(lpTokenAmount, slippage) {

package/lib/pools/mixins/withdrawOneCoinMixins.d.ts

@@ -2,31 +2,31 @@ import { PoolTemplate } from "../PoolTemplate.js";
 import { IMethodInfo } from "../../interfaces.js";
 export declare const withdrawOneCoinMetaFactoryMixin: {
     _withdrawOneCoin(this: PoolTemplate, _lpTokenAmount: bigint, i: number, slippage?: number, estimateGas?: boolean, getInfo?: boolean): Promise<string | number | number[] | IMethodInfo>;
-    withdrawOneCoinEstimateGas(this: PoolTemplate, lpTokenAmount: number | string, coin: string | number): Promise<number | number[]>;
+    withdrawOneCoinEstimateGas(this: PoolTemplate, lpTokenAmount: number | string, coin: string | number, slippage?: number): Promise<number | number[]>;
     withdrawOneCoin(this: PoolTemplate, lpTokenAmount: number | string, coin: string | number, slippage?: number): Promise<string>;
     getWithdrawOneCoinInfo(this: PoolTemplate): Promise<IMethodInfo>;
 };
 export declare const withdrawOneCoinCryptoMetaFactoryMixin: {
     _withdrawOneCoin(this: PoolTemplate, _lpTokenAmount: bigint, i: number, slippage?: number, estimateGas?: boolean, getInfo?: boolean): Promise<string | number | number[] | IMethodInfo>;
-    withdrawOneCoinEstimateGas(this: PoolTemplate, lpTokenAmount: number | string, coin: string | number): Promise<number | number[]>;
+    withdrawOneCoinEstimateGas(this: PoolTemplate, lpTokenAmount: number | string, coin: string | number, slippage?: number): Promise<number | number[]>;
     withdrawOneCoin(this: PoolTemplate, lpTokenAmount: number | string, coin: string | number, slippage?: number): Promise<string>;
     getWithdrawOneCoinInfo(this: PoolTemplate): Promise<IMethodInfo>;
 };
 export declare const withdrawOneCoinZapMixin: {
     _withdrawOneCoin(this: PoolTemplate, _lpTokenAmount: bigint, i: number, slippage?: number, estimateGas?: boolean, getInfo?: boolean): Promise<string | number | number[] | IMethodInfo>;
-    withdrawOneCoinEstimateGas(this: PoolTemplate, lpTokenAmount: number | string, coin: string | number): Promise<number | number[]>;
+    withdrawOneCoinEstimateGas(this: PoolTemplate, lpTokenAmount: number | string, coin: string | number, slippage?: number): Promise<number | number[]>;
     withdrawOneCoin(this: PoolTemplate, lpTokenAmount: number | string, coin: string | number, slippage?: number): Promise<string>;
     getWithdrawOneCoinInfo(this: PoolTemplate): Promise<IMethodInfo>;
 };
 export declare const withdrawOneCoinLendingOrCryptoMixin: {
     _withdrawOneCoin(this: PoolTemplate, _lpTokenAmount: bigint, i: number, slippage?: number, estimateGas?: boolean, getInfo?: boolean): Promise<string | number | number[] | IMethodInfo>;
-    withdrawOneCoinEstimateGas(this: PoolTemplate, lpTokenAmount: number | string, coin: string | number): Promise<number | number[]>;
+    withdrawOneCoinEstimateGas(this: PoolTemplate, lpTokenAmount: number | string, coin: string | number, slippage?: number): Promise<number | number[]>;
     withdrawOneCoin(this: PoolTemplate, lpTokenAmount: number | string, coin: string | number, slippage?: number): Promise<string>;
     getWithdrawOneCoinInfo(this: PoolTemplate): Promise<IMethodInfo>;
 };
 export declare const withdrawOneCoinPlainMixin: {
     _withdrawOneCoin(this: PoolTemplate, _lpTokenAmount: bigint, i: number, slippage?: number, estimateGas?: boolean, getInfo?: boolean): Promise<string | number | number[] | IMethodInfo>;
-    withdrawOneCoinEstimateGas(this: PoolTemplate, lpTokenAmount: number | string, coin: string | number): Promise<number | number[]>;
+    withdrawOneCoinEstimateGas(this: PoolTemplate, lpTokenAmount: number | string, coin: string | number, slippage?: number): Promise<number | number[]>;
     withdrawOneCoin(this: PoolTemplate, lpTokenAmount: number | string, coin: string | number, slippage?: number): Promise<string>;
     getWithdrawOneCoinInfo(this: PoolTemplate): Promise<IMethodInfo>;
 };

package/lib/pools/mixins/withdrawOneCoinMixins.js

@@ -48,10 +48,10 @@ export const withdrawOneCoinMetaFactoryMixin = {
             return (yield contract.remove_liquidity_one_coin(this.address, _lpTokenAmount, i, _minAmount, Object.assign(Object.assign({}, this.curve.options), { gasLimit }))).hash;
         });
     },
-    withdrawOneCoinEstimateGas(lpTokenAmount, coin) {
-        return __awaiter(this, void 0, void 0, function* () {
+    withdrawOneCoinEstimateGas(lpTokenAmount_1, coin_1) {
+        return __awaiter(this, arguments, void 0, function* (lpTokenAmount, coin, slippage = 0.1) {
             const [_lpTokenAmount, i] = yield _withdrawOneCoinCheck.call(this, lpTokenAmount, coin, true);
-            return yield withdrawOneCoinMetaFactoryMixin._withdrawOneCoin.call(this, _lpTokenAmount, i, 0.1, true);
+            return yield withdrawOneCoinMetaFactoryMixin._withdrawOneCoin.call(this, _lpTokenAmount, i, slippage, true);
         });
     },
     withdrawOneCoin(lpTokenAmount, coin, slippage) {
@@ -83,10 +83,10 @@ export const withdrawOneCoinCryptoMetaFactoryMixin = {
             return (yield contract.remove_liquidity_one_coin(this.address, _lpTokenAmount, i, _minAmount, true, Object.assign(Object.assign({}, this.curve.options), { gasLimit }))).hash;
         });
     },
-    withdrawOneCoinEstimateGas(lpTokenAmount, coin) {
-        return __awaiter(this, void 0, void 0, function* () {
+    withdrawOneCoinEstimateGas(lpTokenAmount_1, coin_1) {
+        return __awaiter(this, arguments, void 0, function* (lpTokenAmount, coin, slippage = 0.1) {
             const [_lpTokenAmount, i] = yield _withdrawOneCoinCheck.call(this, lpTokenAmount, coin, true);
-            return yield withdrawOneCoinCryptoMetaFactoryMixin._withdrawOneCoin.call(this, _lpTokenAmount, i, 0.1, true);
+            return yield withdrawOneCoinCryptoMetaFactoryMixin._withdrawOneCoin.call(this, _lpTokenAmount, i, slippage, true);
         });
     },
     withdrawOneCoin(lpTokenAmount, coin, slippage) {
@@ -121,10 +121,10 @@ export const withdrawOneCoinZapMixin = {
             return (yield contract.remove_liquidity_one_coin(...args, Object.assign(Object.assign({}, this.curve.options), { gasLimit }))).hash;
         });
     },
-    withdrawOneCoinEstimateGas(lpTokenAmount, coin) {
-        return __awaiter(this, void 0, void 0, function* () {
+    withdrawOneCoinEstimateGas(lpTokenAmount_1, coin_1) {
+        return __awaiter(this, arguments, void 0, function* (lpTokenAmount, coin, slippage = 0.1) {
             const [_lpTokenAmount, i] = yield _withdrawOneCoinCheck.call(this, lpTokenAmount, coin, true);
-            return yield withdrawOneCoinZapMixin._withdrawOneCoin.call(this, _lpTokenAmount, i, 0.1, true);
+            return yield withdrawOneCoinZapMixin._withdrawOneCoin.call(this, _lpTokenAmount, i, slippage, true);
         });
     },
     withdrawOneCoin(lpTokenAmount, coin, slippage) {
@@ -154,10 +154,10 @@ export const withdrawOneCoinLendingOrCryptoMixin = {
             return (yield contract.remove_liquidity_one_coin(_lpTokenAmount, i, _minAmount, true, Object.assign(Object.assign({}, this.curve.options), { gasLimit }))).hash;
         });
     },
-    withdrawOneCoinEstimateGas(lpTokenAmount, coin) {
-        return __awaiter(this, void 0, void 0, function* () {
+    withdrawOneCoinEstimateGas(lpTokenAmount_1, coin_1) {
+        return __awaiter(this, arguments, void 0, function* (lpTokenAmount, coin, slippage = 0.1) {
             const [_lpTokenAmount, i] = yield _withdrawOneCoinCheck.call(this, lpTokenAmount, coin, true);
-            return yield withdrawOneCoinLendingOrCryptoMixin._withdrawOneCoin.call(this, _lpTokenAmount, i, 0.1, true);
+            return yield withdrawOneCoinLendingOrCryptoMixin._withdrawOneCoin.call(this, _lpTokenAmount, i, slippage, true);
         });
     },
     withdrawOneCoin(lpTokenAmount, coin, slippage) {
@@ -187,10 +187,10 @@ export const withdrawOneCoinPlainMixin = {
             return (yield contract.remove_liquidity_one_coin(_lpTokenAmount, i, _minAmount, Object.assign(Object.assign({}, this.curve.options), { gasLimit }))).hash;
         });
     },
-    withdrawOneCoinEstimateGas(lpTokenAmount, coin) {
-        return __awaiter(this, void 0, void 0, function* () {
+    withdrawOneCoinEstimateGas(lpTokenAmount_1, coin_1) {
+        return __awaiter(this, arguments, void 0, function* (lpTokenAmount, coin, slippage = 0.1) {
             const [_lpTokenAmount, i] = yield _withdrawOneCoinCheck.call(this, lpTokenAmount, coin, true);
-            return yield withdrawOneCoinPlainMixin._withdrawOneCoin.call(this, _lpTokenAmount, i, 0.1, true);
+            return yield withdrawOneCoinPlainMixin._withdrawOneCoin.call(this, _lpTokenAmount, i, slippage, true);
         });
     },
     withdrawOneCoin(lpTokenAmount, coin, slippage) {

package/lib/pools/mixins/withdrawOneCoinWrappedMixins.d.ts

@@ -2,13 +2,13 @@ import { PoolTemplate } from "../PoolTemplate.js";
 import { IMethodInfo } from "../../interfaces.js";
 export declare const withdrawOneCoinWrappedLendingOrCryptoMixin: {
     _withdrawOneCoinWrapped(this: PoolTemplate, _lpTokenAmount: bigint, i: number, slippage?: number, estimateGas?: boolean, getInfo?: boolean): Promise<string | number | number[] | IMethodInfo>;
-    withdrawOneCoinWrappedEstimateGas(this: PoolTemplate, lpTokenAmount: number | string, coin: string | number): Promise<number>;
+    withdrawOneCoinWrappedEstimateGas(this: PoolTemplate, lpTokenAmount: number | string, coin: string | number, slippage?: number): Promise<number>;
     withdrawOneCoinWrapped(this: PoolTemplate, lpTokenAmount: number | string, coin: string | number, slippage?: number): Promise<string>;
     getWithdrawOneCoinWrappedInfo(this: PoolTemplate): Promise<IMethodInfo>;
 };
 export declare const withdrawOneCoinWrappedMixin: {
     _withdrawOneCoinWrapped(this: PoolTemplate, _lpTokenAmount: bigint, i: number, slippage?: number, estimateGas?: boolean, getInfo?: boolean): Promise<string | number | number[] | IMethodInfo>;
-    withdrawOneCoinWrappedEstimateGas(this: PoolTemplate, lpTokenAmount: number | string, coin: string | number): Promise<number>;
+    withdrawOneCoinWrappedEstimateGas(this: PoolTemplate, lpTokenAmount: number | string, coin: string | number, slippage?: number): Promise<number>;
     withdrawOneCoinWrapped(this: PoolTemplate, lpTokenAmount: number | string, coin: string | number, slippage?: number): Promise<string>;
     getWithdrawOneCoinWrappedInfo(this: PoolTemplate): Promise<IMethodInfo>;
 };

package/lib/pools/mixins/withdrawOneCoinWrappedMixins.js

@@ -42,10 +42,10 @@ export const withdrawOneCoinWrappedLendingOrCryptoMixin = {
             return (yield contract.remove_liquidity_one_coin(_lpTokenAmount, i, _minAmount, false, Object.assign(Object.assign({}, this.curve.options), { gasLimit }))).hash;
         });
     },
-    withdrawOneCoinWrappedEstimateGas(lpTokenAmount, coin) {
-        return __awaiter(this, void 0, void 0, function* () {
+    withdrawOneCoinWrappedEstimateGas(lpTokenAmount_1, coin_1) {
+        return __awaiter(this, arguments, void 0, function* (lpTokenAmount, coin, slippage = 0.1) {
             const [_lpTokenAmount, i] = yield _withdrawOneCoinWrappedCheck.call(this, lpTokenAmount, coin);
-            return yield withdrawOneCoinWrappedLendingOrCryptoMixin._withdrawOneCoinWrapped.call(this, _lpTokenAmount, i, 0.1, true);
+            return yield withdrawOneCoinWrappedLendingOrCryptoMixin._withdrawOneCoinWrapped.call(this, _lpTokenAmount, i, slippage, true);
         });
     },
     withdrawOneCoinWrapped(lpTokenAmount, coin, slippage) {
@@ -75,10 +75,10 @@ export const withdrawOneCoinWrappedMixin = {
             return (yield contract.remove_liquidity_one_coin(_lpTokenAmount, i, _minAmount, Object.assign(Object.assign({}, this.curve.options), { gasLimit }))).hash;
         });
     },
-    withdrawOneCoinWrappedEstimateGas(lpTokenAmount, coin) {
-        return __awaiter(this, void 0, void 0, function* () {
+    withdrawOneCoinWrappedEstimateGas(lpTokenAmount_1, coin_1) {
+        return __awaiter(this, arguments, void 0, function* (lpTokenAmount, coin, slippage = 0.1) {
             const [_lpTokenAmount, i] = yield _withdrawOneCoinWrappedCheck.call(this, lpTokenAmount, coin);
-            return yield withdrawOneCoinWrappedMixin._withdrawOneCoinWrapped.call(this, _lpTokenAmount, i, 0.1, true);
+            return yield withdrawOneCoinWrappedMixin._withdrawOneCoinWrapped.call(this, _lpTokenAmount, i, slippage, true);
         });
     },
     withdrawOneCoinWrapped(lpTokenAmount, coin, slippage) {

package/lib/pools/mixins/withdrawWrappedMixins.d.ts

@@ -1,11 +1,11 @@
 import { PoolTemplate } from "../PoolTemplate.js";
 export declare const withdrawWrapped2argsMixin: {
     _withdrawWrapped(this: PoolTemplate, _lpTokenAmount: bigint, slippage?: number, estimateGas?: boolean): Promise<string | number | number[]>;
-    withdrawWrappedEstimateGas(this: PoolTemplate, lpTokenAmount: number | string): Promise<number>;
+    withdrawWrappedEstimateGas(this: PoolTemplate, lpTokenAmount: number | string, slippage?: number): Promise<number>;
     withdrawWrapped(this: PoolTemplate, lpTokenAmount: number | string, slippage?: number): Promise<string>;
 };
 export declare const withdrawWrapped3argsMixin: {
     _withdrawWrapped(this: PoolTemplate, _lpTokenAmount: bigint, slippage?: number, estimateGas?: boolean): Promise<string | number | number[]>;
-    withdrawWrappedEstimateGas(this: PoolTemplate, lpTokenAmount: number | string): Promise<number>;
+    withdrawWrappedEstimateGas(this: PoolTemplate, lpTokenAmount: number | string, slippage?: number): Promise<number>;
     withdrawWrapped(this: PoolTemplate, lpTokenAmount: number | string, slippage?: number): Promise<string>;
 };

package/lib/pools/mixins/withdrawWrappedMixins.js

@@ -38,10 +38,10 @@ export const withdrawWrapped2argsMixin = {
             return (yield contract.remove_liquidity(_lpTokenAmount, _minAmounts, Object.assign(Object.assign({}, this.curve.options), { gasLimit }))).hash;
         });
     },
-    withdrawWrappedEstimateGas(lpTokenAmount) {
-        return __awaiter(this, void 0, void 0, function* () {
+    withdrawWrappedEstimateGas(lpTokenAmount_1) {
+        return __awaiter(this, arguments, void 0, function* (lpTokenAmount, slippage = 0.1) {
             const _lpTokenAmount = yield _withdrawWrappedCheck.call(this, lpTokenAmount);
-            return yield withdrawWrapped2argsMixin._withdrawWrapped.call(this, _lpTokenAmount, 0.1, true);
+            return yield withdrawWrapped2argsMixin._withdrawWrapped.call(this, _lpTokenAmount, slippage, true);
         });
     },
     withdrawWrapped(lpTokenAmount, slippage) {
@@ -63,10 +63,10 @@ export const withdrawWrapped3argsMixin = {
             return (yield contract.remove_liquidity(_lpTokenAmount, _minAmounts, false, Object.assign(Object.assign({}, this.curve.options), { gasLimit }))).hash;
         });
     },
-    withdrawWrappedEstimateGas(lpTokenAmount) {
-        return __awaiter(this, void 0, void 0, function* () {
+    withdrawWrappedEstimateGas(lpTokenAmount_1) {
+        return __awaiter(this, arguments, void 0, function* (lpTokenAmount, slippage = 0.1) {
             const _lpTokenAmount = yield _withdrawWrappedCheck.call(this, lpTokenAmount);
-            return yield withdrawWrapped3argsMixin._withdrawWrapped.call(this, _lpTokenAmount, 0.1, true);
+            return yield withdrawWrapped3argsMixin._withdrawWrapped.call(this, _lpTokenAmount, slippage, true);
         });
     },
     withdrawWrapped(lpTokenAmount, slippage) {

package/package.json

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