@curvefi/api 2.68.33 → 2.68.34

package/README.md

@@ -994,13 +994,89 @@ import curve from "@curvefi/api";
 - `pool.withdrawOneCoinExpectedBigInt(lpTokenAmount: bigint, coin: string | number): Promise<bigint>`
 - `pool.withdrawOneCoinWrappedExpectedBigInt(lpTokenAmount: bigint, coin: string | number): Promise<bigint>`
 
-### Getting swap ABI metadata
+### 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;
@@ -63,6 +67,7 @@ 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>;
@@ -72,6 +77,7 @@ export declare class PoolTemplate extends CorePool {
     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[]>;
@@ -152,12 +158,14 @@ export declare class PoolTemplate extends CorePool {
     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[]>;
@@ -189,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>;
@@ -199,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),
         };
@@ -794,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* () {
@@ -863,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* () {
@@ -1580,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) {
@@ -1624,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/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/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.33",
+  "version": "2.68.34",
   "description": "JavaScript library for curve.finance",
   "main": "lib/index.js",
   "author": "Macket",