@curvefi/api 2.68.32 → 2.68.34

package/README.md

@@ -983,13 +983,100 @@ import curve from "@curvefi/api";
 })()
 ```
 
-### Getting swap ABI metadata
+### BigInt methods
+
+- `pool.swapExpectedBigInt(inputCoin, outputCoin, amount: bigint): Promise<bigint>`
+- `pool.swapWrappedExpectedBigInt(inputCoin, outputCoin, amount: bigint): Promise<bigint>`
+- `pool.depositExpectedBigInt(amounts: bigint[]): Promise<bigint>`
+- `pool.depositWrappedExpectedBigInt(amounts: bigint[]): Promise<bigint>`
+- `pool.withdrawExpectedBigInt(lpTokenAmount: bigint): Promise<bigint[]>`
+- `pool.withdrawWrappedExpectedBigInt(lpTokenAmount: bigint): Promise<bigint[]>`
+- `pool.withdrawOneCoinExpectedBigInt(lpTokenAmount: bigint, coin: string | number): Promise<bigint>`
+- `pool.withdrawOneCoinWrappedExpectedBigInt(lpTokenAmount: bigint, coin: string | number): Promise<bigint>`
+
+### Getting method ABI metadata
 ```ts
 (async () => {
     await curve.init('JsonRpc', {}, { gasPrice: 0, maxFeePerGas: 0, maxPriorityFeePerGas: 0 });
 
     const pool = curve.getPool('mim');
 
+    // Get exact ABI information for deposit (underlying) without executing the transaction
+    const depositInfo = await pool.abi.deposit();
+    console.log(depositInfo);
+    // {
+    //     address: '0xa79828df1850e8a3a3064576f380d90aecdd3359',  // Contract address (zap or pool)
+    //     method: 'add_liquidity',                                 // Method name
+    //     abi: {
+    //         type: 'function',
+    //         name: 'add_liquidity',
+    //         inputs: [
+    //             { name: '_pool', type: 'address' },
+    //             { name: '_deposit_amounts', type: 'uint256[4]' },
+    //             { name: '_min_mint_amount', type: 'uint256' }
+    //         ],
+    //         outputs: [ { name: '', type: 'uint256' } ],
+    //         stateMutability: 'nonpayable'
+    //     }
+    // }
+
+    // Get exact ABI information for deposit wrapped without executing the transaction
+    const depositWrappedInfo = await pool.abi.depositWrapped();
+    console.log(depositWrappedInfo);
+    // {
+    //     address: '0x5a6a4d54456819380173272a5e8e9b9904bdf41b',  // Contract address (pool)
+    //     method: 'add_liquidity',                                 // Method name
+    //     abi: {
+    //         type: 'function',
+    //         name: 'add_liquidity',
+    //         inputs: [
+    //             { name: 'amounts', type: 'uint256[2]' },
+    //             { name: 'min_mint_amount', type: 'uint256' }
+    //         ],
+    //         outputs: [ { name: '', type: 'uint256' } ],
+    //         stateMutability: 'nonpayable'
+    //     }
+    // }
+
+    // Get exact ABI information for withdrawOneCoin (underlying) without executing the transaction
+    const withdrawOneCoinInfo = await pool.abi.withdrawOneCoin();
+    console.log(withdrawOneCoinInfo);
+    // {
+    //     address: '0xa79828df1850e8a3a3064576f380d90aecdd3359',  // Contract address (zap or pool)
+    //     method: 'remove_liquidity_one_coin',                     // Method name
+    //     abi: {
+    //         type: 'function',
+    //         name: 'remove_liquidity_one_coin',
+    //         inputs: [
+    //             { name: '_pool', type: 'address' },
+    //             { name: '_burn_amount', type: 'uint256' },
+    //             { name: 'i', type: 'int128' },
+    //             { name: '_min_amount', type: 'uint256' }
+    //         ],
+    //         outputs: [ { name: '', type: 'uint256' } ],
+    //         stateMutability: 'nonpayable'
+    //     }
+    // }
+
+    // Get exact ABI information for withdrawOneCoin wrapped without executing the transaction
+    const withdrawOneCoinWrappedInfo = await pool.abi.withdrawOneCoinWrapped();
+    console.log(withdrawOneCoinWrappedInfo);
+    // {
+    //     address: '0x5a6a4d54456819380173272a5e8e9b9904bdf41b',  // Contract address (pool)
+    //     method: 'remove_liquidity_one_coin',                     // Method name
+    //     abi: {
+    //         type: 'function',
+    //         name: 'remove_liquidity_one_coin',
+    //         inputs: [
+    //             { name: '_token_amount', type: 'uint256' },
+    //             { name: 'i', type: 'int128' },
+    //             { name: '_min_amount', type: 'uint256' }
+    //         ],
+    //         outputs: [ { name: '', type: 'uint256' } ],
+    //         stateMutability: 'nonpayable'
+    //     }
+    // }
+
     // Get exact ABI information for swap (underlying) without executing the transaction
     const swapInfo = await pool.abi.swap();
     console.log(swapInfo);

package/lib/interfaces.d.ts

@@ -349,7 +349,7 @@ export type AbiError = {
     name: string;
 };
 export type Abi = (AbiConstructor | AbiError | AbiEvent | AbiFallback | AbiFunction | AbiReceive)[];
-export interface ISwapMethodInfo {
+export interface IMethodInfo {
     address: string;
     method: string;
     abi: any;

package/lib/pools/PoolTemplate.d.ts

@@ -1,6 +1,6 @@
 import BigNumber from 'bignumber.js';
 import memoize from "memoizee";
-import { IDict, IProfit, ISwapMethodInfo } from '../interfaces';
+import { IDict, IProfit, IMethodInfo } from '../interfaces';
 import { Curve } from "../curve.js";
 import { CorePool } from "./subClasses/corePool.js";
 import { StatsPool } from "./subClasses/statsPool.js";
@@ -37,8 +37,12 @@ export declare class PoolTemplate extends CorePool {
         swapWrapped: (inputCoin: string | number, outputCoin: string | number, amount: number | string, slippage: number) => Promise<number | number[]>;
     };
     abi: {
-        swap: () => Promise<ISwapMethodInfo>;
-        swapWrapped: () => Promise<ISwapMethodInfo>;
+        deposit: () => Promise<IMethodInfo>;
+        depositWrapped: () => Promise<IMethodInfo>;
+        withdrawOneCoin: () => Promise<IMethodInfo>;
+        withdrawOneCoinWrapped: () => Promise<IMethodInfo>;
+        swap: () => Promise<IMethodInfo>;
+        swapWrapped: () => Promise<IMethodInfo>;
     };
     stats: StatsPool;
     wallet: WalletPool;
@@ -49,10 +53,13 @@ export declare class PoolTemplate extends CorePool {
     private _pureCalcLpTokenAmount;
     _calcLpTokenAmount: ((_amounts: bigint[], isDeposit?: any, useUnderlying?: any) => Promise<bigint>) & memoize.Memoized<(_amounts: bigint[], isDeposit?: any, useUnderlying?: any) => Promise<bigint>>;
     private calcLpTokenAmount;
+    private calcLpTokenAmountBigInt;
     private calcLpTokenAmountWrapped;
+    private calcLpTokenAmountWrappedBigInt;
     getSeedAmounts(amount1: number | string, useUnderlying?: boolean): Promise<string[]>;
     depositBalancedAmounts(): Promise<string[]>;
     depositExpected(amounts: (number | string)[]): Promise<string>;
+    depositExpectedBigInt(amounts: bigint[]): Promise<bigint>;
     private _balancedAmountsWithSameValue;
     depositBonus(amounts: (number | string)[]): Promise<string>;
     depositIsApproved(amounts: (number | string)[]): Promise<boolean>;
@@ -60,14 +67,17 @@ export declare class PoolTemplate extends CorePool {
     depositApprove(amounts: (number | string)[], isMax?: boolean): Promise<string[]>;
     private depositEstimateGas;
     deposit(amounts: (number | string)[], slippage?: number): Promise<string>;
+    getDepositInfo(): Promise<IMethodInfo>;
     depositWrappedBalancedAmounts(): Promise<string[]>;
     depositWrappedExpected(amounts: (number | string)[]): Promise<string>;
+    depositWrappedExpectedBigInt(amounts: bigint[]): Promise<bigint>;
     depositWrappedBonus(amounts: (number | string)[]): Promise<string>;
     depositWrappedIsApproved(amounts: (number | string)[]): Promise<boolean>;
     private depositWrappedApproveEstimateGas;
     depositWrappedApprove(amounts: (number | string)[]): Promise<string[]>;
     private depositWrappedEstimateGas;
     depositWrapped(amounts: (number | string)[], slippage?: number): Promise<string>;
+    getDepositWrappedInfo(): Promise<IMethodInfo>;
     stakeIsApproved(lpTokenAmount: number | string): Promise<boolean>;
     private stakeApproveEstimateGas;
     stakeApprove(lpTokenAmount: number | string): Promise<string[]>;
@@ -118,12 +128,14 @@ export declare class PoolTemplate extends CorePool {
     depositAndStakeWrapped(amounts: (number | string)[], slippage?: number): Promise<string>;
     private _depositAndStake;
     withdrawExpected(lpTokenAmount: number | string): Promise<string[]>;
+    withdrawExpectedBigInt(lpTokenAmount: bigint): Promise<bigint[]>;
     withdrawIsApproved(lpTokenAmount: number | string): Promise<boolean>;
     private withdrawApproveEstimateGas;
     withdrawApprove(lpTokenAmount: number | string): Promise<string[]>;
     private withdrawEstimateGas;
     withdraw(lpTokenAmount: number | string, slippage?: number): Promise<string>;
     withdrawWrappedExpected(lpTokenAmount: number | string): Promise<string[]>;
+    withdrawWrappedExpectedBigInt(lpTokenAmount: bigint): Promise<bigint[]>;
     private withdrawWrappedEstimateGas;
     withdrawWrapped(lpTokenAmount: number | string, slippage?: number): Promise<string>;
     withdrawImbalanceExpected(amounts: (number | string)[]): Promise<string>;
@@ -139,17 +151,21 @@ export declare class PoolTemplate extends CorePool {
     withdrawImbalanceWrapped(amounts: (number | string)[], slippage?: number): Promise<string>;
     _withdrawOneCoinExpected(_lpTokenAmount: bigint, i: number): Promise<bigint>;
     withdrawOneCoinExpected(lpTokenAmount: number | string, coin: string | number): Promise<string>;
+    withdrawOneCoinExpectedBigInt(lpTokenAmount: bigint, coin: string | number): Promise<bigint>;
     withdrawOneCoinBonus(lpTokenAmount: number | string, coin: string | number): Promise<string>;
     withdrawOneCoinIsApproved(lpTokenAmount: number | string): Promise<boolean>;
     private withdrawOneCoinApproveEstimateGas;
     withdrawOneCoinApprove(lpTokenAmount: number | string): Promise<string[]>;
     private withdrawOneCoinEstimateGas;
     withdrawOneCoin(lpTokenAmount: number | string, coin: string | number, slippage?: number): Promise<string>;
+    getWithdrawOneCoinInfo(): Promise<IMethodInfo>;
     _withdrawOneCoinWrappedExpected(_lpTokenAmount: bigint, i: number): Promise<bigint>;
     withdrawOneCoinWrappedExpected(lpTokenAmount: number | string, coin: string | number): Promise<string>;
+    withdrawOneCoinWrappedExpectedBigInt(lpTokenAmount: bigint, coin: string | number): Promise<bigint>;
     withdrawOneCoinWrappedBonus(lpTokenAmount: number | string, coin: string | number): Promise<string>;
     private withdrawOneCoinWrappedEstimateGas;
     withdrawOneCoinWrapped(lpTokenAmount: number | string, coin: string | number, slippage?: number): Promise<string>;
+    getWithdrawOneCoinWrappedInfo(): Promise<IMethodInfo>;
     private _userLpTotalBalance;
     userBalances(address?: string): Promise<string[]>;
     userWrappedBalances(address?: string): Promise<string[]>;
@@ -181,7 +197,7 @@ export declare class PoolTemplate extends CorePool {
     swapApprove(inputCoin: string | number, amount: number | string): Promise<string[]>;
     private swapEstimateGas;
     swap(inputCoin: string | number, outputCoin: string | number, amount: number | string, slippage?: number): Promise<string>;
-    getSwapInfo(): Promise<ISwapMethodInfo>;
+    getSwapInfo(): Promise<IMethodInfo>;
     _swapWrappedExpected(i: number, j: number, _amount: bigint): Promise<bigint>;
     swapWrappedExpected(inputCoin: string | number, outputCoin: string | number, amount: number | string): Promise<string>;
     swapWrappedExpectedBigInt(inputCoin: string | number, outputCoin: string | number, amount: bigint): Promise<bigint>;
@@ -191,7 +207,7 @@ export declare class PoolTemplate extends CorePool {
     swapWrappedApprove(inputCoin: string | number, amount: number | string): Promise<string[]>;
     private swapWrappedEstimateGas;
     swapWrapped(inputCoin: string | number, outputCoin: string | number, amount: number | string, slippage?: number): Promise<string>;
-    getSwapWrappedInfo(): Promise<ISwapMethodInfo>;
+    getSwapWrappedInfo(): Promise<IMethodInfo>;
     gaugeOptimalDeposits: (...accounts: string[]) => Promise<IDict<string>>;
     _getCoinIdx: (coin: string | number, useUnderlying?: boolean) => number;
     _getRates: () => Promise<bigint[]>;

package/lib/pools/PoolTemplate.js

@@ -575,6 +575,10 @@ export class PoolTemplate extends CorePool {
             swapWrapped: this.swapWrappedEstimateGas.bind(this),
         };
         this.abi = {
+            deposit: this.getDepositInfo.bind(this),
+            depositWrapped: this.getDepositWrappedInfo.bind(this),
+            withdrawOneCoin: this.getWithdrawOneCoinInfo.bind(this),
+            withdrawOneCoinWrapped: this.getWithdrawOneCoinWrappedInfo.bind(this),
             swap: this.getSwapInfo.bind(this),
             swapWrapped: this.getSwapWrappedInfo.bind(this),
         };
@@ -617,6 +621,14 @@ export class PoolTemplate extends CorePool {
             return this.curve.formatUnits(_expected);
         });
     }
+    calcLpTokenAmountBigInt(amounts_1) {
+        return __awaiter(this, arguments, void 0, function* (amounts, isDeposit = true) {
+            if (amounts.length !== this.underlyingCoinAddresses.length) {
+                throw Error(`${this.name} pool has ${this.underlyingCoinAddresses.length} coins (amounts provided for ${amounts.length})`);
+            }
+            return yield this._calcLpTokenAmount(amounts, isDeposit, true);
+        });
+    }
     calcLpTokenAmountWrapped(amounts_1) {
         return __awaiter(this, arguments, void 0, function* (amounts, isDeposit = true) {
             if (amounts.length !== this.wrappedCoinAddresses.length) {
@@ -630,6 +642,17 @@ export class PoolTemplate extends CorePool {
             return this.curve.formatUnits(_expected);
         });
     }
+    calcLpTokenAmountWrappedBigInt(amounts_1) {
+        return __awaiter(this, arguments, void 0, function* (amounts, isDeposit = true) {
+            if (amounts.length !== this.wrappedCoinAddresses.length) {
+                throw Error(`${this.name} pool has ${this.wrappedCoinAddresses.length} coins (amounts provided for ${amounts.length})`);
+            }
+            if (this.isFake) {
+                throw Error(`${this.name} pool doesn't have this method`);
+            }
+            return yield this._calcLpTokenAmount(amounts, isDeposit, false);
+        });
+    }
     // ---------------- DEPOSIT ----------------
     getSeedAmounts(amount1_1) {
         return __awaiter(this, arguments, void 0, function* (amount1, useUnderlying = false) {
@@ -685,6 +708,11 @@ export class PoolTemplate extends CorePool {
             return yield this.calcLpTokenAmount(amounts);
         });
     }
+    depositExpectedBigInt(amounts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.calcLpTokenAmountBigInt(amounts);
+        });
+    }
     // | balanced[i] / sum(balanced[j]) = balance[i] / sum(balance[j]) |
     // | sum(pj * balanced[j]) = sum(aj * pj)                          |
     //
@@ -770,6 +798,11 @@ export class PoolTemplate extends CorePool {
             throw Error(`deposit method doesn't exist for pool ${this.name} (id: ${this.name})`);
         });
     }
+    getDepositInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw Error(`getDepositInfo method doesn't exist for pool ${this.name} (id: ${this.id})`);
+        });
+    }
     // ---------------- DEPOSIT WRAPPED ----------------
     depositWrappedBalancedAmounts() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -784,6 +817,14 @@ export class PoolTemplate extends CorePool {
             return yield this.calcLpTokenAmountWrapped(amounts);
         });
     }
+    depositWrappedExpectedBigInt(amounts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.isFake) {
+                throw Error(`depositWrappedExpectedBigInt method doesn't exist for pool ${this.name} (id: ${this.name})`);
+            }
+            return yield this.calcLpTokenAmountWrappedBigInt(amounts);
+        });
+    }
     depositWrappedBonus(amounts) {
         return __awaiter(this, void 0, void 0, function* () {
             const amountsBN = amounts.map(BN);
@@ -831,6 +872,11 @@ export class PoolTemplate extends CorePool {
             throw Error(`depositWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
         });
     }
+    getDepositWrappedInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw Error(`getDepositWrappedInfo method doesn't exist for pool ${this.name} (id: ${this.id})`);
+        });
+    }
     // ---------------- STAKING ----------------
     stakeIsApproved(lpTokenAmount) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -1275,6 +1321,12 @@ export class PoolTemplate extends CorePool {
             throw Error(`withdrawExpected method doesn't exist for pool ${this.name} (id: ${this.name})`);
         });
     }
+    // OVERRIDE
+    withdrawExpectedBigInt(lpTokenAmount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw Error(`withdrawExpectedBigInt method doesn't exist for pool ${this.name} (id: ${this.name})`);
+        });
+    }
     withdrawIsApproved(lpTokenAmount) {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.zap)
@@ -1316,6 +1368,12 @@ export class PoolTemplate extends CorePool {
         });
     }
     // OVERRIDE
+    withdrawWrappedExpectedBigInt(lpTokenAmount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw Error(`withdrawWrappedExpectedBigInt method doesn't exist for pool ${this.name} (id: ${this.name})`);
+        });
+    }
+    // OVERRIDE
     withdrawWrappedEstimateGas(lpTokenAmount) {
         return __awaiter(this, void 0, void 0, function* () {
             throw Error(`withdrawWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
@@ -1462,6 +1520,12 @@ export class PoolTemplate extends CorePool {
             return this.curve.formatUnits(_expected, this.underlyingDecimals[i]);
         });
     }
+    withdrawOneCoinExpectedBigInt(lpTokenAmount, coin) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const i = this._getCoinIdx(coin);
+            return yield this._withdrawOneCoinExpected(lpTokenAmount, i);
+        });
+    }
     withdrawOneCoinBonus(lpTokenAmount, coin) {
         return __awaiter(this, void 0, void 0, function* () {
             let pricesBN = [];
@@ -1530,6 +1594,11 @@ export class PoolTemplate extends CorePool {
             throw Error(`withdrawOneCoin method doesn't exist for pool ${this.name} (id: ${this.name})`);
         });
     }
+    getWithdrawOneCoinInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw Error(`getWithdrawOneCoinInfo method doesn't exist for pool ${this.name} (id: ${this.id})`);
+        });
+    }
     // ---------------- WITHDRAW ONE COIN WRAPPED ----------------
     // OVERRIDE
     _withdrawOneCoinWrappedExpected(_lpTokenAmount, i) {
@@ -1545,6 +1614,12 @@ export class PoolTemplate extends CorePool {
             return this.curve.formatUnits(_expected, this.wrappedDecimals[i]);
         });
     }
+    // OVERRIDE
+    withdrawOneCoinWrappedExpectedBigInt(lpTokenAmount, coin) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw Error(`withdrawOneCoinWrappedExpectedBigInt method doesn't exist for pool ${this.name} (id: ${this.name})`);
+        });
+    }
     withdrawOneCoinWrappedBonus(lpTokenAmount, coin) {
         return __awaiter(this, void 0, void 0, function* () {
             const prices = yield this._wrappedPrices();
@@ -1568,6 +1643,11 @@ export class PoolTemplate extends CorePool {
             throw Error(`withdrawOneCoinWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
         });
     }
+    getWithdrawOneCoinWrappedInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw Error(`getWithdrawOneCoinWrappedInfo method doesn't exist for pool ${this.name} (id: ${this.id})`);
+        });
+    }
     // ---------------- USER BALANCES, BASE PROFIT AND SHARE ----------------
     _userLpTotalBalance(address) {
         return __awaiter(this, void 0, void 0, function* () {

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

@@ -1,26 +1,32 @@
 import { PoolTemplate } from "../PoolTemplate.js";
+import { IMethodInfo } from "../../interfaces.js";
 export declare const depositMetaFactoryMixin: {
-    _deposit(this: PoolTemplate, _amounts: bigint[], slippage?: number, estimateGas?: boolean): Promise<string | number | number[]>;
-    depositEstimateGas(this: PoolTemplate, amounts: (number | string)[]): Promise<string | number | number[]>;
-    deposit(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<string | number | number[]>;
+    _deposit(this: PoolTemplate, _amounts: bigint[], slippage?: number, estimateGas?: boolean, getInfo?: boolean): Promise<string | number | number[] | IMethodInfo>;
+    depositEstimateGas(this: PoolTemplate, amounts: (number | string)[]): 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): Promise<string | number | number[]>;
+    _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[]>;
     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): Promise<string | number | number[]>;
+    _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[]>;
     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): Promise<string | number | number[]>;
+    _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[]>;
     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): Promise<string | number | number[]>;
+    _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[]>;
     deposit(this: PoolTemplate, amounts: (number | string)[], slippage?: number): Promise<string>;
+    getDepositInfo(this: PoolTemplate): Promise<IMethodInfo>;
 };

package/lib/pools/mixins/depositMixins.js

@@ -36,13 +36,20 @@ function _depositMinAmount(_amounts_1) {
 }
 export const depositMetaFactoryMixin = {
     _deposit(_amounts_1, slippage_1) {
-        return __awaiter(this, arguments, void 0, function* (_amounts, slippage, estimateGas = false) {
+        return __awaiter(this, arguments, void 0, function* (_amounts, slippage, estimateGas = false, getInfo = false) {
+            const contract = this.curve.contracts[this.zap].contract;
+            if (getInfo) {
+                return {
+                    address: this.zap,
+                    method: 'add_liquidity',
+                    abi: contract.add_liquidity.fragment,
+                };
+            }
             if (!estimateGas)
                 yield _ensureAllowance.call(this.curve, this.underlyingCoinAddresses, _amounts, this.zap);
             const _minMintAmount = yield _depositMinAmount.call(this, _amounts, slippage);
             const ethIndex = this.curve.getEthIndex(this.underlyingCoinAddresses);
             const value = _amounts[ethIndex] || parseUnits("0");
-            const contract = this.curve.contracts[this.zap].contract;
             const gas = yield contract.add_liquidity.estimateGas(this.address, _amounts, _minMintAmount, Object.assign(Object.assign({}, this.curve.constantOptions), { value }));
             if (estimateGas)
                 return smartNumber(gas);
@@ -62,16 +69,28 @@ export const depositMetaFactoryMixin = {
             return yield depositMetaFactoryMixin._deposit.call(this, _amounts, slippage);
         });
     },
+    getDepositInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield depositMetaFactoryMixin._deposit.call(this, [], 0, false, true);
+        });
+    },
 };
 export const depositCryptoMetaFactoryMixin = {
     _deposit(_amounts_1, slippage_1) {
-        return __awaiter(this, arguments, void 0, function* (_amounts, slippage, estimateGas = false) {
+        return __awaiter(this, arguments, void 0, function* (_amounts, slippage, estimateGas = false, getInfo = false) {
+            const contract = this.curve.contracts[this.zap].contract;
+            if (getInfo) {
+                return {
+                    address: this.zap,
+                    method: 'add_liquidity',
+                    abi: contract.add_liquidity.fragment,
+                };
+            }
             if (!estimateGas)
                 yield _ensureAllowance.call(this.curve, this.underlyingCoinAddresses, _amounts, this.zap);
             const _minMintAmount = yield _depositMinAmount.call(this, _amounts, slippage);
             const ethIndex = this.curve.getEthIndex(this.underlyingCoinAddresses);
             const value = _amounts[ethIndex] || this.curve.parseUnits("0");
-            const contract = this.curve.contracts[this.zap].contract;
             const gas = yield contract.add_liquidity.estimateGas(this.address, _amounts, _minMintAmount, true, Object.assign(Object.assign({}, this.curve.constantOptions), { value }));
             if (estimateGas)
                 return smartNumber(gas);
@@ -91,16 +110,28 @@ export const depositCryptoMetaFactoryMixin = {
             return yield depositCryptoMetaFactoryMixin._deposit.call(this, _amounts, slippage);
         });
     },
+    getDepositInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield depositCryptoMetaFactoryMixin._deposit.call(this, [], 0, false, true);
+        });
+    },
 };
 export const depositZapMixin = {
     _deposit(_amounts_1, slippage_1) {
-        return __awaiter(this, arguments, void 0, function* (_amounts, slippage, estimateGas = false) {
+        return __awaiter(this, arguments, void 0, function* (_amounts, slippage, estimateGas = false, getInfo = false) {
+            const contract = this.curve.contracts[this.zap].contract;
+            if (getInfo) {
+                return {
+                    address: this.zap,
+                    method: 'add_liquidity',
+                    abi: contract.add_liquidity.fragment,
+                };
+            }
             if (!estimateGas)
                 yield _ensureAllowance.call(this.curve, this.underlyingCoinAddresses, _amounts, this.zap);
             const _minMintAmount = yield _depositMinAmount.call(this, _amounts, slippage);
             const ethIndex = this.curve.getEthIndex(this.underlyingCoinAddresses);
             const value = _amounts[ethIndex] || this.curve.parseUnits("0");
-            const contract = this.curve.contracts[this.zap].contract;
             const args = [_amounts, _minMintAmount];
             if (`add_liquidity(uint256[${this.underlyingCoinAddresses.length}],uint256,bool)` in contract)
                 args.push(true);
@@ -123,16 +154,28 @@ export const depositZapMixin = {
             return yield depositZapMixin._deposit.call(this, _amounts, slippage);
         });
     },
+    getDepositInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield depositZapMixin._deposit.call(this, [], 0, false, true);
+        });
+    },
 };
 export const depositLendingOrCryptoMixin = {
     _deposit(_amounts_1, slippage_1) {
-        return __awaiter(this, arguments, void 0, function* (_amounts, slippage, estimateGas = false) {
+        return __awaiter(this, arguments, void 0, function* (_amounts, slippage, estimateGas = false, getInfo = false) {
+            const contract = this.curve.contracts[this.address].contract;
+            if (getInfo) {
+                return {
+                    address: this.address,
+                    method: 'add_liquidity',
+                    abi: contract.add_liquidity.fragment,
+                };
+            }
             if (!estimateGas)
                 yield _ensureAllowance.call(this.curve, this.underlyingCoinAddresses, _amounts, this.address);
             const _minMintAmount = yield _depositMinAmount.call(this, _amounts, slippage);
             const ethIndex = this.curve.getEthIndex(this.underlyingCoinAddresses);
             const value = _amounts[ethIndex] || this.curve.parseUnits("0");
-            const contract = this.curve.contracts[this.address].contract;
             const gas = yield contract.add_liquidity.estimateGas(_amounts, _minMintAmount, true, Object.assign(Object.assign({}, this.curve.constantOptions), { value }));
             if (estimateGas)
                 return smartNumber(gas);
@@ -152,16 +195,28 @@ export const depositLendingOrCryptoMixin = {
             return yield depositLendingOrCryptoMixin._deposit.call(this, _amounts, slippage);
         });
     },
+    getDepositInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield depositLendingOrCryptoMixin._deposit.call(this, [], 0, false, true);
+        });
+    },
 };
 export const depositPlainMixin = {
     _deposit(_amounts_1, slippage_1) {
-        return __awaiter(this, arguments, void 0, function* (_amounts, slippage, estimateGas = false) {
+        return __awaiter(this, arguments, void 0, function* (_amounts, slippage, estimateGas = false, getInfo = false) {
+            const contract = this.curve.contracts[this.address].contract;
+            if (getInfo) {
+                return {
+                    address: this.address,
+                    method: 'add_liquidity',
+                    abi: contract.add_liquidity.fragment,
+                };
+            }
             if (!estimateGas)
                 yield _ensureAllowance.call(this.curve, this.wrappedCoinAddresses, _amounts, this.address);
             const _minMintAmount = yield _depositMinAmount.call(this, _amounts, slippage);
             const ethIndex = this.curve.getEthIndex(this.wrappedCoinAddresses);
             const value = _amounts[ethIndex] || this.curve.parseUnits("0");
-            const contract = this.curve.contracts[this.address].contract;
             const gas = yield contract.add_liquidity.estimateGas(_amounts, _minMintAmount, Object.assign(Object.assign({}, this.curve.constantOptions), { value }));
             if (estimateGas)
                 return smartNumber(gas);
@@ -181,4 +236,9 @@ export const depositPlainMixin = {
             return yield depositPlainMixin._deposit.call(this, _amounts, slippage);
         });
     },
+    getDepositInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield depositPlainMixin._deposit.call(this, [], 0, false, true);
+        });
+    },
 };

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

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

package/lib/pools/mixins/depositWrappedMixins.js

@@ -39,13 +39,20 @@ function _depositWrappedMinAmount(_amounts_1) {
 }
 export const depositWrapped2argsMixin = {
     _depositWrapped(_amounts_1, slippage_1) {
-        return __awaiter(this, arguments, void 0, function* (_amounts, slippage, estimateGas = false) {
+        return __awaiter(this, arguments, void 0, function* (_amounts, slippage, estimateGas = false, getInfo = false) {
+            const contract = this.curve.contracts[this.address].contract;
+            if (getInfo) {
+                return {
+                    address: this.address,
+                    method: 'add_liquidity',
+                    abi: contract.add_liquidity.fragment,
+                };
+            }
             if (!estimateGas)
                 yield _ensureAllowance.call(this.curve, this.wrappedCoinAddresses, _amounts, this.address);
             const _minMintAmount = yield _depositWrappedMinAmount.call(this, _amounts, slippage);
             const ethIndex = this.curve.getEthIndex(this.wrappedCoinAddresses);
             const value = _amounts[ethIndex] || this.curve.parseUnits("0");
-            const contract = this.curve.contracts[this.address].contract;
             const gas = yield contract.add_liquidity.estimateGas(_amounts, _minMintAmount, Object.assign(Object.assign({}, this.curve.constantOptions), { value }));
             if (estimateGas)
                 return smartNumber(gas);
@@ -65,16 +72,28 @@ export const depositWrapped2argsMixin = {
             return yield depositWrapped2argsMixin._depositWrapped.call(this, _amounts, slippage);
         });
     },
+    getDepositWrappedInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield depositWrapped2argsMixin._depositWrapped.call(this, [], 0, false, true);
+        });
+    },
 };
 export const depositWrapped3argsMixin = {
     _depositWrapped(_amounts_1, slippage_1) {
-        return __awaiter(this, arguments, void 0, function* (_amounts, slippage, estimateGas = false) {
+        return __awaiter(this, arguments, void 0, function* (_amounts, slippage, estimateGas = false, getInfo = false) {
+            const contract = this.curve.contracts[this.address].contract;
+            if (getInfo) {
+                return {
+                    address: this.address,
+                    method: 'add_liquidity',
+                    abi: contract.add_liquidity.fragment,
+                };
+            }
             if (!estimateGas)
                 yield _ensureAllowance.call(this.curve, this.wrappedCoinAddresses, _amounts, this.address);
             const _minMintAmount = yield _depositWrappedMinAmount.call(this, _amounts, slippage);
             const ethIndex = this.curve.getEthIndex(this.wrappedCoinAddresses);
             const value = _amounts[ethIndex] || this.curve.parseUnits("0");
-            const contract = this.curve.contracts[this.address].contract;
             const gas = yield contract.add_liquidity.estimateGas(_amounts, _minMintAmount, false, Object.assign(Object.assign({}, this.curve.constantOptions), { value }));
             if (estimateGas)
                 return smartNumber(gas);
@@ -94,4 +113,9 @@ export const depositWrapped3argsMixin = {
             return yield depositWrapped3argsMixin._depositWrapped.call(this, _amounts, slippage);
         });
     },
+    getDepositWrappedInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield depositWrapped3argsMixin._depositWrapped.call(this, [], 0, false, true);
+        });
+    },
 };

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

@@ -1,26 +1,26 @@
 import { PoolTemplate } from "../PoolTemplate.js";
-import { ISwapMethodInfo } from "../../interfaces.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[] | ISwapMethodInfo>;
+    _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>;
     swap(this: PoolTemplate, inputCoin: string | number, outputCoin: string | number, amount: number | string, slippage?: number): Promise<string>;
-    getSwapInfo(this: PoolTemplate): Promise<ISwapMethodInfo>;
+    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[] | ISwapMethodInfo>;
+    _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>;
     swap(this: PoolTemplate, inputCoin: string | number, outputCoin: string | number, amount: number | string, slippage?: number): Promise<string>;
-    getSwapInfo(this: PoolTemplate): Promise<ISwapMethodInfo>;
+    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[] | ISwapMethodInfo>;
+    _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>;
     swap(this: PoolTemplate, inputCoin: string | number, outputCoin: string | number, amount: number | string, slippage?: number): Promise<string>;
-    getSwapInfo(this: PoolTemplate): Promise<ISwapMethodInfo>;
+    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[] | ISwapMethodInfo>;
+    _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>;
     swap(this: PoolTemplate, inputCoin: string | number, outputCoin: string | number, amount: number | string, slippage?: number): Promise<string>;
-    getSwapInfo(this: PoolTemplate): Promise<ISwapMethodInfo>;
+    getSwapInfo(this: PoolTemplate): Promise<IMethodInfo>;
 };

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

@@ -1,16 +1,16 @@
 import { PoolTemplate } from "../PoolTemplate.js";
-import { ISwapMethodInfo } from "../../interfaces.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[] | ISwapMethodInfo>;
+    _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>;
     swapWrapped(this: PoolTemplate, inputCoin: string | number, outputCoin: string | number, amount: number | string, slippage?: number): Promise<string>;
-    getSwapWrappedInfo(this: PoolTemplate): Promise<ISwapMethodInfo>;
+    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[] | ISwapMethodInfo>;
+    _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>;
     swapWrapped(this: PoolTemplate, inputCoin: string | number, outputCoin: string | number, amount: number | string, slippage?: number): Promise<string>;
-    getSwapWrappedInfo(this: PoolTemplate): Promise<ISwapMethodInfo>;
+    getSwapWrappedInfo(this: PoolTemplate): Promise<IMethodInfo>;
 };
 export declare const swapWrappedExpectedAndApproveMixin: {
     swapWrappedExpected(this: PoolTemplate, inputCoin: string | number, outputCoin: string | number, amount: number | string): Promise<string>;

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

@@ -1,13 +1,17 @@
 import { PoolTemplate } from "../PoolTemplate.js";
 export declare const withdrawExpectedMixin: {
     withdrawExpected(this: PoolTemplate, lpTokenAmount: number | string): Promise<string[]>;
+    withdrawExpectedBigInt(this: PoolTemplate, lpTokenAmount: bigint): Promise<bigint[]>;
 };
 export declare const withdrawExpectedLendingOrCryptoMixin: {
     withdrawExpected(this: PoolTemplate, lpTokenAmount: number | string): Promise<string[]>;
+    withdrawExpectedBigInt(this: PoolTemplate, lpTokenAmount: bigint): Promise<bigint[]>;
 };
 export declare const withdrawExpectedMetaMixin: {
     withdrawExpected(this: PoolTemplate, lpTokenAmount: number | string): Promise<string[]>;
+    withdrawExpectedBigInt(this: PoolTemplate, lpTokenAmount: bigint): Promise<bigint[]>;
 };
 export declare const withdrawWrappedExpectedMixin: {
     withdrawWrappedExpected(this: PoolTemplate, lpTokenAmount: number | string): Promise<string[]>;
+    withdrawWrappedExpectedBigInt(this: PoolTemplate, lpTokenAmount: bigint): Promise<bigint[]>;
 };

package/lib/pools/mixins/withdrawExpectedMixins.js

@@ -18,6 +18,11 @@ export const withdrawExpectedMixin = {
             return _expected.map((amount, i) => formatUnits(amount, this.underlyingDecimals[i]));
         });
     },
+    withdrawExpectedBigInt(lpTokenAmount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _calcExpectedAmounts.call(this, lpTokenAmount);
+        });
+    },
 };
 export const withdrawExpectedLendingOrCryptoMixin = {
     withdrawExpected(lpTokenAmount) {
@@ -29,6 +34,13 @@ export const withdrawExpectedLendingOrCryptoMixin = {
             return _expected.map((amount, i) => formatUnits(amount, this.underlyingDecimals[i]));
         });
     },
+    withdrawExpectedBigInt(lpTokenAmount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const _expectedAmounts = yield _calcExpectedAmounts.call(this, lpTokenAmount);
+            const _rates = yield this._getRates();
+            return _expectedAmounts.map((_amount, i) => _amount * _rates[i] / parseUnits(String(Math.pow(10, 18)), 0));
+        });
+    },
 };
 export const withdrawExpectedMetaMixin = {
     withdrawExpected(lpTokenAmount) {
@@ -38,6 +50,11 @@ export const withdrawExpectedMetaMixin = {
             return _expected.map((amount, i) => formatUnits(amount, this.underlyingDecimals[i]));
         });
     },
+    withdrawExpectedBigInt(lpTokenAmount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _calcExpectedUnderlyingAmountsMeta.call(this, lpTokenAmount);
+        });
+    },
 };
 export const withdrawWrappedExpectedMixin = {
     withdrawWrappedExpected(lpTokenAmount) {
@@ -47,4 +64,9 @@ export const withdrawWrappedExpectedMixin = {
             return _expected.map((amount, i) => formatUnits(amount, this.wrappedDecimals[i]));
         });
     },
+    withdrawWrappedExpectedBigInt(lpTokenAmount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield _calcExpectedAmounts.call(this, lpTokenAmount);
+        });
+    },
 };

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

@@ -1,26 +1,32 @@
 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): Promise<string | number | number[]>;
+    _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[]>;
     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): Promise<string | number | number[]>;
+    _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[]>;
     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): Promise<string | number | number[]>;
+    _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[]>;
     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): Promise<string | number | number[]>;
+    _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[]>;
     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): Promise<string | number | number[]>;
+    _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[]>;
     withdrawOneCoin(this: PoolTemplate, lpTokenAmount: number | string, coin: string | number, slippage?: number): Promise<string>;
+    getWithdrawOneCoinInfo(this: PoolTemplate): Promise<IMethodInfo>;
 };

package/lib/pools/mixins/withdrawOneCoinMixins.js

@@ -33,11 +33,18 @@ function _withdrawOneCoinMinAmount(_lpTokenAmount_1, i_1) {
 }
 export const withdrawOneCoinMetaFactoryMixin = {
     _withdrawOneCoin(_lpTokenAmount_1, i_1, slippage_1) {
-        return __awaiter(this, arguments, void 0, function* (_lpTokenAmount, i, slippage, estimateGas = false) {
+        return __awaiter(this, arguments, void 0, function* (_lpTokenAmount, i, slippage, estimateGas = false, getInfo = false) {
+            const contract = this.curve.contracts[this.zap].contract;
+            if (getInfo) {
+                return {
+                    address: this.zap,
+                    method: 'remove_liquidity_one_coin',
+                    abi: contract.remove_liquidity_one_coin.fragment,
+                };
+            }
             if (!estimateGas)
                 yield _ensureAllowance.bind(this.curve, [this.lpToken], [_lpTokenAmount], this.zap);
             const _minAmount = yield _withdrawOneCoinMinAmount.call(this, _lpTokenAmount, i, slippage);
-            const contract = this.curve.contracts[this.zap].contract;
             const gas = yield contract.remove_liquidity_one_coin.estimateGas(this.address, _lpTokenAmount, i, _minAmount, this.curve.constantOptions);
             if (estimateGas)
                 return smartNumber(gas);
@@ -57,14 +64,26 @@ export const withdrawOneCoinMetaFactoryMixin = {
             return yield withdrawOneCoinMetaFactoryMixin._withdrawOneCoin.call(this, _lpTokenAmount, i, slippage);
         });
     },
+    getWithdrawOneCoinInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield withdrawOneCoinMetaFactoryMixin._withdrawOneCoin.call(this, BigInt(0), 0, 0, false, true);
+        });
+    },
 };
 export const withdrawOneCoinCryptoMetaFactoryMixin = {
     _withdrawOneCoin(_lpTokenAmount_1, i_1, slippage_1) {
-        return __awaiter(this, arguments, void 0, function* (_lpTokenAmount, i, slippage, estimateGas = false) {
+        return __awaiter(this, arguments, void 0, function* (_lpTokenAmount, i, slippage, estimateGas = false, getInfo = false) {
+            const contract = this.curve.contracts[this.zap].contract;
+            if (getInfo) {
+                return {
+                    address: this.zap,
+                    method: 'remove_liquidity_one_coin',
+                    abi: contract.remove_liquidity_one_coin.fragment,
+                };
+            }
             if (!estimateGas)
                 yield _ensureAllowance.bind(this.curve, [this.lpToken], [_lpTokenAmount], this.zap);
             const _minAmount = yield _withdrawOneCoinMinAmount.call(this, _lpTokenAmount, i, slippage);
-            const contract = this.curve.contracts[this.zap].contract;
             const gas = yield contract.remove_liquidity_one_coin.estimateGas(this.address, _lpTokenAmount, i, _minAmount, true, this.curve.constantOptions);
             if (estimateGas)
                 return smartNumber(gas);
@@ -84,14 +103,26 @@ export const withdrawOneCoinCryptoMetaFactoryMixin = {
             return yield withdrawOneCoinCryptoMetaFactoryMixin._withdrawOneCoin.call(this, _lpTokenAmount, i, slippage);
         });
     },
+    getWithdrawOneCoinInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield withdrawOneCoinCryptoMetaFactoryMixin._withdrawOneCoin.call(this, BigInt(0), 0, 0, false, true);
+        });
+    },
 };
 export const withdrawOneCoinZapMixin = {
     _withdrawOneCoin(_lpTokenAmount_1, i_1, slippage_1) {
-        return __awaiter(this, arguments, void 0, function* (_lpTokenAmount, i, slippage, estimateGas = false) {
+        return __awaiter(this, arguments, void 0, function* (_lpTokenAmount, i, slippage, estimateGas = false, getInfo = false) {
+            const contract = this.curve.contracts[this.zap].contract;
+            if (getInfo) {
+                return {
+                    address: this.zap,
+                    method: 'remove_liquidity_one_coin',
+                    abi: contract.remove_liquidity_one_coin.fragment,
+                };
+            }
             if (!estimateGas)
                 yield _ensureAllowance.bind(this.curve, [this.lpToken], [_lpTokenAmount], this.zap);
             const _minAmount = yield _withdrawOneCoinMinAmount.call(this, _lpTokenAmount, i, slippage);
-            const contract = this.curve.contracts[this.zap].contract;
             const args = [_lpTokenAmount, i, _minAmount];
             if (`remove_liquidity_one_coin(uint256,uint256,uint256,bool)` in contract)
                 args.push(true);
@@ -114,12 +145,24 @@ export const withdrawOneCoinZapMixin = {
             return yield withdrawOneCoinZapMixin._withdrawOneCoin.call(this, _lpTokenAmount, i, slippage);
         });
     },
+    getWithdrawOneCoinInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield withdrawOneCoinZapMixin._withdrawOneCoin.call(this, BigInt(0), 0, 0, false, true);
+        });
+    },
 };
 export const withdrawOneCoinLendingOrCryptoMixin = {
     _withdrawOneCoin(_lpTokenAmount_1, i_1, slippage_1) {
-        return __awaiter(this, arguments, void 0, function* (_lpTokenAmount, i, slippage, estimateGas = false) {
-            const _minAmount = yield _withdrawOneCoinMinAmount.call(this, _lpTokenAmount, i, slippage);
+        return __awaiter(this, arguments, void 0, function* (_lpTokenAmount, i, slippage, estimateGas = false, getInfo = false) {
             const contract = this.curve.contracts[this.address].contract;
+            if (getInfo) {
+                return {
+                    address: this.address,
+                    method: 'remove_liquidity_one_coin',
+                    abi: contract.remove_liquidity_one_coin.fragment,
+                };
+            }
+            const _minAmount = yield _withdrawOneCoinMinAmount.call(this, _lpTokenAmount, i, slippage);
             const gas = yield contract.remove_liquidity_one_coin.estimateGas(_lpTokenAmount, i, _minAmount, true, this.curve.constantOptions);
             if (estimateGas)
                 return smartNumber(gas);
@@ -139,12 +182,24 @@ export const withdrawOneCoinLendingOrCryptoMixin = {
             return yield withdrawOneCoinLendingOrCryptoMixin._withdrawOneCoin.call(this, _lpTokenAmount, i, slippage);
         });
     },
+    getWithdrawOneCoinInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield withdrawOneCoinLendingOrCryptoMixin._withdrawOneCoin.call(this, BigInt(0), 0, 0, false, true);
+        });
+    },
 };
 export const withdrawOneCoinPlainMixin = {
     _withdrawOneCoin(_lpTokenAmount_1, i_1, slippage_1) {
-        return __awaiter(this, arguments, void 0, function* (_lpTokenAmount, i, slippage, estimateGas = false) {
-            const _minAmount = yield _withdrawOneCoinMinAmount.call(this, _lpTokenAmount, i, slippage);
+        return __awaiter(this, arguments, void 0, function* (_lpTokenAmount, i, slippage, estimateGas = false, getInfo = false) {
             const contract = this.curve.contracts[this.address].contract;
+            if (getInfo) {
+                return {
+                    address: this.address,
+                    method: 'remove_liquidity_one_coin',
+                    abi: contract.remove_liquidity_one_coin.fragment,
+                };
+            }
+            const _minAmount = yield _withdrawOneCoinMinAmount.call(this, _lpTokenAmount, i, slippage);
             const gas = yield contract.remove_liquidity_one_coin.estimateGas(_lpTokenAmount, i, _minAmount, this.curve.constantOptions);
             if (estimateGas)
                 return smartNumber(gas);
@@ -164,4 +219,9 @@ export const withdrawOneCoinPlainMixin = {
             return yield withdrawOneCoinPlainMixin._withdrawOneCoin.call(this, _lpTokenAmount, i, slippage);
         });
     },
+    getWithdrawOneCoinInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield withdrawOneCoinPlainMixin._withdrawOneCoin.call(this, BigInt(0), 0, 0, false, true);
+        });
+    },
 };

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

@@ -1,7 +1,9 @@
 import { PoolTemplate } from "../PoolTemplate.js";
 export declare const withdrawOneCoinWrappedExpected2argsMixin: {
     _withdrawOneCoinWrappedExpected(this: PoolTemplate, _lpTokenAmount: bigint, i: number): Promise<bigint>;
+    withdrawOneCoinWrappedExpectedBigInt(this: PoolTemplate, lpTokenAmount: bigint, coin: string | number): Promise<bigint>;
 };
 export declare const withdrawOneCoinWrappedExpected3argsMixin: {
     _withdrawOneCoinWrappedExpected(this: PoolTemplate, _lpTokenAmount: bigint, i: number): Promise<bigint>;
+    withdrawOneCoinWrappedExpectedBigInt(this: PoolTemplate, lpTokenAmount: bigint, coin: string | number): Promise<bigint>;
 };

package/lib/pools/mixins/withdrawOneCoinWrappedExpectedMixins.js

@@ -14,6 +14,12 @@ export const withdrawOneCoinWrappedExpected2argsMixin = {
             return yield contract.calc_withdraw_one_coin(_lpTokenAmount, i, this.curve.constantOptions);
         });
     },
+    withdrawOneCoinWrappedExpectedBigInt(lpTokenAmount, coin) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const i = this._getCoinIdx(coin, false);
+            return yield this._withdrawOneCoinWrappedExpected(lpTokenAmount, i);
+        });
+    },
 };
 export const withdrawOneCoinWrappedExpected3argsMixin = {
     _withdrawOneCoinWrappedExpected(_lpTokenAmount, i) {
@@ -22,4 +28,10 @@ export const withdrawOneCoinWrappedExpected3argsMixin = {
             return yield contract.calc_withdraw_one_coin(_lpTokenAmount, i, false, this.curve.constantOptions);
         });
     },
+    withdrawOneCoinWrappedExpectedBigInt(lpTokenAmount, coin) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const i = this._getCoinIdx(coin, false);
+            return yield this._withdrawOneCoinWrappedExpected(lpTokenAmount, i);
+        });
+    },
 };

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

@@ -1,11 +1,14 @@
 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): Promise<string | number | number[]>;
+    _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>;
     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): Promise<string | number | number[]>;
+    _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>;
     withdrawOneCoinWrapped(this: PoolTemplate, lpTokenAmount: number | string, coin: string | number, slippage?: number): Promise<string>;
+    getWithdrawOneCoinWrappedInfo(this: PoolTemplate): Promise<IMethodInfo>;
 };

package/lib/pools/mixins/withdrawOneCoinWrappedMixins.js

@@ -29,9 +29,16 @@ function _withdrawOneCoinWrappedMinAmount(_lpTokenAmount_1, i_1) {
 }
 export const withdrawOneCoinWrappedLendingOrCryptoMixin = {
     _withdrawOneCoinWrapped(_lpTokenAmount_1, i_1, slippage_1) {
-        return __awaiter(this, arguments, void 0, function* (_lpTokenAmount, i, slippage, estimateGas = false) {
-            const _minAmount = yield _withdrawOneCoinWrappedMinAmount.call(this, _lpTokenAmount, i, slippage);
+        return __awaiter(this, arguments, void 0, function* (_lpTokenAmount, i, slippage, estimateGas = false, getInfo = false) {
             const contract = this.curve.contracts[this.address].contract;
+            if (getInfo) {
+                return {
+                    address: this.address,
+                    method: 'remove_liquidity_one_coin',
+                    abi: contract.remove_liquidity_one_coin.fragment,
+                };
+            }
+            const _minAmount = yield _withdrawOneCoinWrappedMinAmount.call(this, _lpTokenAmount, i, slippage);
             const gas = yield contract.remove_liquidity_one_coin.estimateGas(_lpTokenAmount, i, _minAmount, false, this.curve.constantOptions);
             if (estimateGas)
                 return smartNumber(gas);
@@ -51,12 +58,24 @@ export const withdrawOneCoinWrappedLendingOrCryptoMixin = {
             return yield withdrawOneCoinWrappedLendingOrCryptoMixin._withdrawOneCoinWrapped.call(this, _lpTokenAmount, i, slippage);
         });
     },
+    getWithdrawOneCoinWrappedInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield withdrawOneCoinWrappedLendingOrCryptoMixin._withdrawOneCoinWrapped.call(this, BigInt(0), 0, 0, false, true);
+        });
+    },
 };
 export const withdrawOneCoinWrappedMixin = {
     _withdrawOneCoinWrapped(_lpTokenAmount_1, i_1, slippage_1) {
-        return __awaiter(this, arguments, void 0, function* (_lpTokenAmount, i, slippage, estimateGas = false) {
-            const _minAmount = yield _withdrawOneCoinWrappedMinAmount.call(this, _lpTokenAmount, i, slippage);
+        return __awaiter(this, arguments, void 0, function* (_lpTokenAmount, i, slippage, estimateGas = false, getInfo = false) {
             const contract = this.curve.contracts[this.address].contract;
+            if (getInfo) {
+                return {
+                    address: this.address,
+                    method: 'remove_liquidity_one_coin',
+                    abi: contract.remove_liquidity_one_coin.fragment,
+                };
+            }
+            const _minAmount = yield _withdrawOneCoinWrappedMinAmount.call(this, _lpTokenAmount, i, slippage);
             const gas = yield contract.remove_liquidity_one_coin.estimateGas(_lpTokenAmount, i, _minAmount, this.curve.constantOptions);
             if (estimateGas)
                 return smartNumber(gas);
@@ -76,4 +95,9 @@ export const withdrawOneCoinWrappedMixin = {
             return yield withdrawOneCoinWrappedMixin._withdrawOneCoinWrapped.call(this, _lpTokenAmount, i, slippage);
         });
     },
+    getWithdrawOneCoinWrappedInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield withdrawOneCoinWrappedMixin._withdrawOneCoinWrapped.call(this, BigInt(0), 0, 0, false, true);
+        });
+    },
 };

package/package.json

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