@curvefi/api 2.68.32 → 2.68.33

package/README.md

@@ -983,6 +983,17 @@ import curve from "@curvefi/api";
 })()
 ```
 
+### 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 swap ABI metadata
 ```ts
 (async () => {

package/lib/pools/PoolTemplate.d.ts

@@ -49,10 +49,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>;
@@ -62,6 +65,7 @@ export declare class PoolTemplate extends CorePool {
     deposit(amounts: (number | string)[], slippage?: number): Promise<string>;
     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;
@@ -118,12 +122,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,6 +145,7 @@ 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;
@@ -147,6 +154,7 @@ export declare class PoolTemplate extends CorePool {
     withdrawOneCoin(lpTokenAmount: number | string, coin: string | number, slippage?: number): Promise<string>;
     _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>;

package/lib/pools/PoolTemplate.js

@@ -617,6 +617,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 +638,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 +704,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)                          |
     //
@@ -784,6 +808,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);
@@ -1275,6 +1307,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 +1354,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 +1506,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 = [];
@@ -1545,6 +1595,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();

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/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/package.json

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