@curvefi/api 2.68.24 → 2.68.25

package/README.md

@@ -983,6 +983,55 @@ import curve from "@curvefi/api";
 })()
 ```
 
+### Getting swap ABI metadata
+```ts
+(async () => {
+    await curve.init('JsonRpc', {}, { gasPrice: 0, maxFeePerGas: 0, maxPriorityFeePerGas: 0 });
+
+    const pool = curve.getPool('mim');
+
+    // Get exact ABI information for swap (underlying) without executing the transaction
+    const swapInfo = await pool.abi.swap();
+    console.log(swapInfo);
+    // {
+    //     address: '0x5a6a4d54456819380173272a5e8e9b9904bdf41b',  // Contract address
+    //     method: 'exchange_underlying',                           // Method name (exchange or exchange_underlying)
+    //     abi: {
+    //         type: 'function',
+    //         name: 'exchange_underlying',
+    //         inputs: [
+    //             { name: 'i', type: 'int128' },
+    //             { name: 'j', type: 'int128' },
+    //             { name: 'dx', type: 'uint256' },
+    //             { name: 'min_dy', type: 'uint256' }
+    //         ],
+    //         outputs: [ { name: '', type: 'uint256' } ],
+    //         stateMutability: 'nonpayable'
+    //     }
+    // }
+
+    // Get exact ABI information for swap wrapped without executing the transaction
+    const swapWrappedInfo = await pool.abi.swapWrapped();
+    console.log(swapWrappedInfo);
+    // {
+    //     address: '0x5a6a4d54456819380173272a5e8e9b9904bdf41b',  // Contract address
+    //     method: 'exchange',                                      // Method name (always exchange for wrapped)
+    //     abi: {
+    //         type: 'function',
+    //         name: 'exchange',
+    //         inputs: [
+    //             { name: 'i', type: 'int128' },
+    //             { name: 'j', type: 'int128' },
+    //             { name: 'dx', type: 'uint256' },
+    //             { name: 'min_dy', type: 'uint256' }
+    //         ],
+    //         outputs: [ { name: '', type: 'uint256' } ],
+    //         stateMutability: 'nonpayable'
+    //     }
+    // }
+})()
+```
+
 ### Deposit & Stake
 ```ts
 (async () => {

package/lib/interfaces.d.ts

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

package/lib/pools/PoolTemplate.d.ts

@@ -1,6 +1,6 @@
 import BigNumber from 'bignumber.js';
 import memoize from "memoizee";
-import { IDict, IProfit } from '../interfaces';
+import { IDict, IProfit, ISwapMethodInfo } from '../interfaces';
 import { Curve } from "../curve.js";
 import { CorePool } from "./subClasses/corePool.js";
 import { StatsPool } from "./subClasses/statsPool.js";
@@ -36,6 +36,10 @@ export declare class PoolTemplate extends CorePool {
         swapWrappedApprove: (inputCoin: string | number, amount: number | string) => Promise<number | number[]>;
         swapWrapped: (inputCoin: string | number, outputCoin: string | number, amount: number | string, slippage: number) => Promise<number | number[]>;
     };
+    abi: {
+        swap: () => Promise<ISwapMethodInfo>;
+        swapWrapped: () => Promise<ISwapMethodInfo>;
+    };
     stats: StatsPool;
     wallet: WalletPool;
     constructor(id: string, curve: Curve, poolData?: import("../interfaces").IPoolData);
@@ -176,6 +180,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>;
     _swapWrappedExpected(i: number, j: number, _amount: bigint): Promise<bigint>;
     swapWrappedExpected(inputCoin: string | number, outputCoin: string | number, amount: number | string): Promise<string>;
     swapWrappedPriceImpact(inputCoin: string | number, outputCoin: string | number, amount: number | string): Promise<number>;
@@ -184,6 +189,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>;
     gaugeOptimalDeposits: (...accounts: string[]) => Promise<IDict<string>>;
     _getCoinIdx: (coin: string | number, useUnderlying?: boolean) => number;
     _getRates: () => Promise<bigint[]>;

package/lib/pools/PoolTemplate.js

@@ -574,6 +574,10 @@ export class PoolTemplate extends CorePool {
             swapWrappedApprove: this.swapWrappedApproveEstimateGas.bind(this),
             swapWrapped: this.swapWrappedEstimateGas.bind(this),
         };
+        this.abi = {
+            swap: this.getSwapInfo.bind(this),
+            swapWrapped: this.getSwapWrappedInfo.bind(this),
+        };
     }
     hasVyperVulnerability() {
         return checkVyperVulnerability(this.curve.chainId, this.id, this.implementation);
@@ -1802,6 +1806,12 @@ export class PoolTemplate extends CorePool {
             throw Error(`swap method doesn't exist for pool ${this.name} (id: ${this.name})`);
         });
     }
+    // OVERRIDE
+    getSwapInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw Error(`getSwapInfo method doesn't exist for pool ${this.name} (id: ${this.id})`);
+        });
+    }
     // ---------------- SWAP WRAPPED ----------------
     _swapWrappedExpected(i, j, _amount) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -1864,6 +1874,12 @@ export class PoolTemplate extends CorePool {
             throw Error(`swapWrapped method doesn't exist for pool ${this.name} (id: ${this.name})`);
         });
     }
+    // OVERRIDE
+    getSwapWrappedInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw Error(`getSwapWrappedInfo method doesn't exist for pool ${this.name} (id: ${this.id})`);
+        });
+    }
     getStoredRates() {
         return __awaiter(this, arguments, void 0, function* (useUnderlying = false) {
             try {

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

@@ -1,21 +1,26 @@
 import { PoolTemplate } from "../PoolTemplate.js";
+import { ISwapMethodInfo } from "../../interfaces.js";
 export declare const swapTricrypto2Mixin: {
-    _swap(this: PoolTemplate, i: number, j: number, _amount: bigint, slippage?: number, estimateGas?: boolean): Promise<string | number | number[]>;
+    _swap(this: PoolTemplate, i: number, j: number, _amount: bigint, slippage?: number, estimateGas?: boolean, getInfo?: boolean): Promise<string | number | number[] | ISwapMethodInfo>;
     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>;
 };
 export declare const swapMetaFactoryMixin: {
-    _swap(this: PoolTemplate, i: number, j: number, _amount: bigint, slippage?: number, estimateGas?: boolean): Promise<string | number | number[]>;
+    _swap(this: PoolTemplate, i: number, j: number, _amount: bigint, slippage?: number, estimateGas?: boolean, getInfo?: boolean): Promise<string | number | number[] | ISwapMethodInfo>;
     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>;
 };
 export declare const swapCryptoMetaFactoryMixin: {
-    _swap(this: PoolTemplate, i: number, j: number, _amount: bigint, slippage?: number, estimateGas?: boolean): Promise<string | number | number[]>;
+    _swap(this: PoolTemplate, i: number, j: number, _amount: bigint, slippage?: number, estimateGas?: boolean, getInfo?: boolean): Promise<string | number | number[] | ISwapMethodInfo>;
     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>;
 };
 export declare const swapMixin: {
-    _swap(this: PoolTemplate, i: number, j: number, _amount: bigint, slippage?: number, estimateGas?: boolean): Promise<string | number | number[]>;
+    _swap(this: PoolTemplate, i: number, j: number, _amount: bigint, slippage?: number, estimateGas?: boolean, getInfo?: boolean): Promise<string | number | number[] | ISwapMethodInfo>;
     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>;
 };

package/lib/pools/mixins/swapMixins.js

@@ -36,13 +36,20 @@ function _swapMinAmount(i_1, j_1, _amount_1) {
 }
 export const swapTricrypto2Mixin = {
     _swap(i_1, j_1, _amount_1, slippage_1) {
-        return __awaiter(this, arguments, void 0, function* (i, j, _amount, slippage, estimateGas = false) {
+        return __awaiter(this, arguments, void 0, function* (i, j, _amount, slippage, estimateGas = false, getInfo = false) {
             const contractAddress = this._swapContractAddress();
+            const contract = this.curve.contracts[contractAddress].contract;
+            const exchangeMethod = 'exchange_underlying' in contract ? 'exchange_underlying' : 'exchange';
+            if (getInfo) {
+                return {
+                    address: contractAddress,
+                    method: exchangeMethod,
+                    abi: contract[exchangeMethod].fragment,
+                };
+            }
             if (!estimateGas)
                 yield _ensureAllowance.call(this.curve, [this.underlyingCoinAddresses[i]], [_amount], contractAddress);
             const _minRecvAmount = yield _swapMinAmount.call(this, i, j, _amount, slippage);
-            const contract = this.curve.contracts[contractAddress].contract;
-            const exchangeMethod = 'exchange_underlying' in contract ? 'exchange_underlying' : 'exchange';
             const value = this.curve.isEth(this.underlyingCoinAddresses[i]) ? _amount : this.curve.parseUnits("0");
             const gas = yield contract[exchangeMethod].estimateGas(i, j, _amount, _minRecvAmount, true, Object.assign(Object.assign({}, this.curve.constantOptions), { value }));
             if (estimateGas)
@@ -63,16 +70,28 @@ export const swapTricrypto2Mixin = {
             return yield swapTricrypto2Mixin._swap.call(this, i, j, _amount, slippage);
         });
     },
+    getSwapInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield swapTricrypto2Mixin._swap.call(this, 0, 0, BigInt(0), 0, false, true);
+        });
+    },
 };
 export const swapMetaFactoryMixin = {
     _swap(i_1, j_1, _amount_1, slippage_1) {
-        return __awaiter(this, arguments, void 0, function* (i, j, _amount, slippage, estimateGas = false) {
+        return __awaiter(this, arguments, void 0, function* (i, j, _amount, slippage, estimateGas = false, getInfo = false) {
             const contractAddress = this._swapContractAddress();
+            const contract = this.curve.contracts[contractAddress].contract;
+            const exchangeMethod = 'exchange_underlying' in contract ? 'exchange_underlying' : 'exchange';
+            if (getInfo) {
+                return {
+                    address: contractAddress,
+                    method: exchangeMethod,
+                    abi: contract[exchangeMethod].fragment,
+                };
+            }
             if (!estimateGas)
                 yield _ensureAllowance.call(this.curve, [this.underlyingCoinAddresses[i]], [_amount], contractAddress);
             const _minRecvAmount = yield _swapMinAmount.call(this, i, j, _amount, slippage);
-            const contract = this.curve.contracts[contractAddress].contract;
-            const exchangeMethod = 'exchange_underlying' in contract ? 'exchange_underlying' : 'exchange';
             const value = this.curve.isEth(this.underlyingCoinAddresses[i]) ? _amount : this.curve.parseUnits("0");
             const gas = yield contract[exchangeMethod].estimateGas(this.address, i, j, _amount, _minRecvAmount, Object.assign(Object.assign({}, this.curve.constantOptions), { value }));
             if (estimateGas)
@@ -93,16 +112,28 @@ export const swapMetaFactoryMixin = {
             return yield swapMetaFactoryMixin._swap.call(this, i, j, _amount, slippage);
         });
     },
+    getSwapInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield swapMetaFactoryMixin._swap.call(this, 0, 0, BigInt(0), 0, false, true);
+        });
+    },
 };
 export const swapCryptoMetaFactoryMixin = {
     _swap(i_1, j_1, _amount_1, slippage_1) {
-        return __awaiter(this, arguments, void 0, function* (i, j, _amount, slippage, estimateGas = false) {
+        return __awaiter(this, arguments, void 0, function* (i, j, _amount, slippage, estimateGas = false, getInfo = false) {
             const contractAddress = this._swapContractAddress();
+            const contract = this.curve.contracts[contractAddress].contract;
+            const exchangeMethod = 'exchange_underlying' in contract ? 'exchange_underlying' : 'exchange';
+            if (getInfo) {
+                return {
+                    address: contractAddress,
+                    method: exchangeMethod,
+                    abi: contract[exchangeMethod].fragment,
+                };
+            }
             if (!estimateGas)
                 yield _ensureAllowance.call(this.curve, [this.underlyingCoinAddresses[i]], [_amount], contractAddress);
             const _minRecvAmount = yield _swapMinAmount.call(this, i, j, _amount, slippage);
-            const contract = this.curve.contracts[contractAddress].contract;
-            const exchangeMethod = 'exchange_underlying' in contract ? 'exchange_underlying' : 'exchange';
             const value = this.curve.isEth(this.underlyingCoinAddresses[i]) ? _amount : this.curve.parseUnits("0");
             const gas = yield contract[exchangeMethod].estimateGas(this.address, i, j, _amount, _minRecvAmount, true, Object.assign(Object.assign({}, this.curve.constantOptions), { value }));
             if (estimateGas)
@@ -123,16 +154,28 @@ export const swapCryptoMetaFactoryMixin = {
             return yield swapCryptoMetaFactoryMixin._swap.call(this, i, j, _amount, slippage);
         });
     },
+    getSwapInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield swapCryptoMetaFactoryMixin._swap.call(this, 0, 0, BigInt(0), 0, false, true);
+        });
+    },
 };
 export const swapMixin = {
     _swap(i_1, j_1, _amount_1, slippage_1) {
-        return __awaiter(this, arguments, void 0, function* (i, j, _amount, slippage, estimateGas = false) {
+        return __awaiter(this, arguments, void 0, function* (i, j, _amount, slippage, estimateGas = false, getInfo = false) {
             const contractAddress = this._swapContractAddress();
+            const contract = this.curve.contracts[contractAddress].contract;
+            const exchangeMethod = 'exchange_underlying' in contract ? 'exchange_underlying' : 'exchange';
+            if (getInfo) {
+                return {
+                    address: contractAddress,
+                    method: exchangeMethod,
+                    abi: contract[exchangeMethod].fragment,
+                };
+            }
             if (!estimateGas)
                 yield _ensureAllowance.call(this.curve, [this.underlyingCoinAddresses[i]], [_amount], contractAddress);
             const _minRecvAmount = yield _swapMinAmount.call(this, i, j, _amount, slippage);
-            const contract = this.curve.contracts[contractAddress].contract;
-            const exchangeMethod = 'exchange_underlying' in contract ? 'exchange_underlying' : 'exchange';
             const value = this.curve.isEth(this.underlyingCoinAddresses[i]) ? _amount : this.curve.parseUnits("0");
             const gas = yield contract[exchangeMethod].estimateGas(i, j, _amount, _minRecvAmount, Object.assign(Object.assign({}, this.curve.constantOptions), { value }));
             if (estimateGas)
@@ -154,4 +197,9 @@ export const swapMixin = {
             return yield swapMixin._swap.call(this, i, j, _amount, slippage);
         });
     },
+    getSwapInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield swapMixin._swap.call(this, 0, 0, BigInt(0), 0, false, true);
+        });
+    },
 };

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

@@ -1,13 +1,16 @@
 import { PoolTemplate } from "../PoolTemplate.js";
+import { ISwapMethodInfo } from "../../interfaces.js";
 export declare const swapWrappedTricrypto2Mixin: {
-    _swapWrapped(this: PoolTemplate, i: number, j: number, _amount: bigint, slippage?: number, estimateGas?: boolean): Promise<string | number | number[]>;
+    _swapWrapped(this: PoolTemplate, i: number, j: number, _amount: bigint, slippage?: number, estimateGas?: boolean, getInfo?: boolean): Promise<string | number | number[] | ISwapMethodInfo>;
     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>;
 };
 export declare const swapWrappedMixin: {
-    _swapWrapped(this: PoolTemplate, i: number, j: number, _amount: bigint, slippage?: number, estimateGas?: boolean): Promise<string | number | number[]>;
+    _swapWrapped(this: PoolTemplate, i: number, j: number, _amount: bigint, slippage?: number, estimateGas?: boolean, getInfo?: boolean): Promise<string | number | number[] | ISwapMethodInfo>;
     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>;
 };
 export declare const swapWrappedExpectedAndApproveMixin: {
     swapWrappedExpected(this: PoolTemplate, inputCoin: string | number, outputCoin: string | number, amount: number | string): Promise<string>;

package/lib/pools/mixins/swapWrappedMixins.js

@@ -35,11 +35,18 @@ function _swapWrappedMinAmount(i_1, j_1, _amount_1) {
 }
 export const swapWrappedTricrypto2Mixin = {
     _swapWrapped(i_1, j_1, _amount_1, slippage_1) {
-        return __awaiter(this, arguments, void 0, function* (i, j, _amount, slippage, estimateGas = false) {
+        return __awaiter(this, arguments, void 0, function* (i, j, _amount, slippage, estimateGas = false, getInfo = false) {
+            const contract = this.curve.contracts[this.address].contract;
+            if (getInfo) {
+                return {
+                    address: this.address,
+                    method: 'exchange',
+                    abi: contract.exchange.fragment,
+                };
+            }
             if (!estimateGas)
                 yield _ensureAllowance.call(this.curve, [this.wrappedCoinAddresses[i]], [_amount], this.address);
             const _minRecvAmount = yield _swapWrappedMinAmount.call(this, i, j, _amount, slippage);
-            const contract = this.curve.contracts[this.address].contract;
             const value = this.curve.isEth(this.wrappedCoinAddresses[i]) ? _amount : this.curve.parseUnits("0");
             const gas = yield contract.exchange.estimateGas(i, j, _amount, _minRecvAmount, false, Object.assign(Object.assign({}, this.curve.constantOptions), { value }));
             if (estimateGas)
@@ -60,14 +67,26 @@ export const swapWrappedTricrypto2Mixin = {
             return yield swapWrappedTricrypto2Mixin._swapWrapped.call(this, i, j, _amount, slippage);
         });
     },
+    getSwapWrappedInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield swapWrappedTricrypto2Mixin._swapWrapped.call(this, 0, 0, BigInt(0), 0, false, true);
+        });
+    },
 };
 export const swapWrappedMixin = {
     _swapWrapped(i_1, j_1, _amount_1, slippage_1) {
-        return __awaiter(this, arguments, void 0, function* (i, j, _amount, slippage, estimateGas = false) {
+        return __awaiter(this, arguments, void 0, function* (i, j, _amount, slippage, estimateGas = false, getInfo = false) {
+            const contract = this.curve.contracts[this.address].contract;
+            if (getInfo) {
+                return {
+                    address: this.address,
+                    method: 'exchange',
+                    abi: contract.exchange.fragment,
+                };
+            }
             if (!estimateGas)
                 yield _ensureAllowance.call(this.curve, [this.wrappedCoinAddresses[i]], [_amount], this.address);
             const _minRecvAmount = yield _swapWrappedMinAmount.call(this, i, j, _amount, slippage);
-            const contract = this.curve.contracts[this.address].contract;
             const value = this.curve.isEth(this.wrappedCoinAddresses[i]) ? _amount : this.curve.parseUnits("0");
             const gas = yield contract.exchange.estimateGas(i, j, _amount, _minRecvAmount, Object.assign(Object.assign({}, this.curve.constantOptions), { value }));
             if (estimateGas)
@@ -88,6 +107,11 @@ export const swapWrappedMixin = {
             return yield swapWrappedMixin._swapWrapped.call(this, i, j, _amount, slippage);
         });
     },
+    getSwapWrappedInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield swapWrappedMixin._swapWrapped.call(this, 0, 0, BigInt(0), 0, false, true);
+        });
+    },
 };
 export const swapWrappedExpectedAndApproveMixin = {
     swapWrappedExpected(inputCoin, outputCoin, amount) {

package/package.json

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