@curvefi/api 2.68.27 → 2.68.29

package/README.md

@@ -1277,6 +1277,106 @@ import curve from "@curvefi/api";
     // OR const tx = await curve.router.populateSwap('0x6B175474E89094C44Da98b954EedeAC495271d0F', '0xD533a949740bb3306d119CC777fa900bA034cd52', '1000', 0.5);
     console.log(data);
     // 0x8f726f1c000000000000000000000000...
+    
+    // --- Execute swap from external calldata (e.g., from router API) ---
+    
+    // Swap using ready transaction data (from router API or any other provider)
+    // Uses standard ethers.js TransactionRequest
+ё    
+    // Option 1: Use built-in approve methods
+    await curve.router.isApproved('DAI', 1000);
+    // false
+    await curve.router.approve('DAI', 1000);
+    // [ '0xc111e471715ae6f5437e12d3b94868a5b6542cd7304efca18b5782d315760ae5' ]
+    
+    // Option 2: Get populated approve transactions (for multisig, batching, etc.)
+    const approveTxs = await curve.router.populateApprove('DAI', 1000, false, userAddress);
+    // [{ to: '0x6B17...', data: '0x...', ... }]
+    
+    // Option 3: Execute approve from calldata (when API returns approve tx)
+    const approveCalldata = {
+        to: "0x6B175474E89094C44Da98b954EedeAC495271d0F",  // Token address
+        data: "0x095ea7b3...",  // Approve calldata from API
+    };
+    const approveHash = await curve.router.approveFromCalldata(approveCalldata);
+    // 0x1234...
+    
+    // Get swap transaction data from external API
+    const swapCalldata = {
+        to: "0x99a58482BD75cbab83b27EC03CA68fF489b5788f",  // Router contract address
+        data: "0x5c9c18e2....",  // Swap calldata from API
+        value: 0n  // Optional: amount of ETH to send
+    };
+    
+    // Estimate gas
+    const gasEstimateFromCalldata = await curve.router.estimateGas.swapFromCalldata(swapCalldata);
+    console.log(gasEstimateFromCalldata);
+    // 476904
+    
+    // Execute swap (returns transaction hash)
+    const swapHash = await curve.router.swapFromCalldata(swapCalldata);
+    console.log(swapHash);
+    // 0xc7ba1d60871c0295ac5471bb602c37ec0f00a71543b3a041308ebd91833f26ba
+    
+    
+    // --- Complete example: Generate calldata and execute with approveFromCalldata/swapFromCalldata ---
+    
+    // This example demonstrates a full workflow where you generate transaction calldata
+    // internally and then execute it using the *FromCalldata methods. This pattern is useful
+    // for transaction batching, multisig workflows, or when you need to store/forward
+    // transaction data before execution.
+    
+    const inputCoin = '0xcbb7c0000ab88b473b1f5afd9ef808440eed33bf';  // cbBTC
+    const outputCoin = '0xdac17f958d2ee523a2206206994597c13d831ec7'; // USDT
+    const amount = 2;
+    
+    // Step 1: Find the best route and cache it
+    await curve.router.getBestRouteAndOutput(inputCoin, outputCoin, amount);
+    
+    // Step 2: Generate swap transaction calldata
+    const swapTx = await curve.router.populateSwap(inputCoin, outputCoin, amount);
+    console.log(swapTx);
+    // {
+    //     to: '0x99a58482BD75cbab83b27EC03CA68fF489b5788f',
+    //     data: '0x...',
+    //     from: '0x...',
+    //     amount: '2'
+    // }
+    
+    // Step 3: Check if approval is needed
+    const isApproved = await curve.router.isApproved(inputCoin, amount);
+    console.log(isApproved);
+    // false
+    
+    // Step 4: Generate approve transaction calldata
+    const approveTxs = await curve.router.populateApprove(
+        inputCoin,
+        amount,
+        false,
+        curve.signerAddress
+    );
+    console.log(approveTxs);
+    // [{ to: '0xcbb7c0...', data: '0x095ea7b3...', ... }]
+    
+    // Step 5: Execute approve using calldata
+    const approveHash = await curve.router.approveFromCalldata(approveTxs[0]);
+    console.log(approveHash);
+    // 0xabc123...
+    
+    // Step 6: Verify approval
+    const isNowApproved = await curve.router.isApproved(inputCoin, amount);
+    console.log(isNowApproved);
+    // true
+    
+    // Step 7: Estimate gas for swap
+    const estimatedGas = await curve.router.estimateGas.swapFromCalldata(swapTx);
+    console.log(estimatedGas);
+    // 287654
+    
+    // Step 8: Execute swap using calldata
+    const swapTxHash = await curve.router.swapFromCalldata(swapTx);
+    console.log(swapTxHash);
+    // 0xdef456...
 })()
 ```
 

package/lib/index.d.ts

@@ -259,9 +259,13 @@ export declare const createCurve: () => {
         swap: (inputCoin: string, outputCoin: string, amount: string | number, slippage?: number | undefined) => Promise<ethers.ContractTransactionResponse>;
         populateSwap: (inputCoin: string, outputCoin: string, amount: string | number, slippage?: number | undefined) => Promise<ethers.TransactionLike<string>>;
         getSwappedAmount: (tx: ethers.ContractTransactionResponse, outputCoin: string) => Promise<string>;
+        approveFromCalldata: (tx: ethers.TransactionRequest) => Promise<string>;
+        swapFromCalldata: (tx: ethers.TransactionRequest) => Promise<string>;
         estimateGas: {
             approve: (inputCoin: string, amount: string | number) => Promise<number | number[]>;
             swap: (inputCoin: string, outputCoin: string, amount: string | number) => Promise<number | number[]>;
+            approveFromCalldata: (tx: ethers.TransactionRequest) => Promise<number | number[]>;
+            swapFromCalldata: (tx: ethers.TransactionRequest) => Promise<number | number[]>;
         };
     };
     dao: {
@@ -572,9 +576,13 @@ declare const _default: {
         swap: (inputCoin: string, outputCoin: string, amount: string | number, slippage?: number | undefined) => Promise<ethers.ContractTransactionResponse>;
         populateSwap: (inputCoin: string, outputCoin: string, amount: string | number, slippage?: number | undefined) => Promise<ethers.TransactionLike<string>>;
         getSwappedAmount: (tx: ethers.ContractTransactionResponse, outputCoin: string) => Promise<string>;
+        approveFromCalldata: (tx: ethers.TransactionRequest) => Promise<string>;
+        swapFromCalldata: (tx: ethers.TransactionRequest) => Promise<string>;
         estimateGas: {
             approve: (inputCoin: string, amount: string | number) => Promise<number | number[]>;
             swap: (inputCoin: string, outputCoin: string, amount: string | number) => Promise<number | number[]>;
+            approveFromCalldata: (tx: ethers.TransactionRequest) => Promise<number | number[]>;
+            swapFromCalldata: (tx: ethers.TransactionRequest) => Promise<number | number[]>;
         };
     };
     dao: {

package/lib/index.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { PoolTemplate, getPool } from "./pools/index.js";
 import { getUserPoolListByLiquidity, getUserPoolListByClaimable, getUserPoolList, getUserLiquidityUSD, getUserClaimable, } from "./pools/utils.js";
-import { getBestRouteAndOutput, getArgs, swapExpected, swapRequired, swapPriceImpact, swapIsApproved, swapApproveEstimateGas, swapApprove, swapPopulateApprove, swapEstimateGas, swap, populateSwap, getSwappedAmount, } from "./router.js";
+import { getBestRouteAndOutput, getArgs, swapExpected, swapRequired, swapPriceImpact, swapIsApproved, swapApproveEstimateGas, swapApprove, swapPopulateApprove, swapEstimateGas, swap, populateSwap, getSwappedAmount, approveFromCalldata, approveFromCalldataEstimateGas, swapFromCalldata, swapFromCalldataEstimateGas, } from "./router.js";
 import { Curve } from "./curve.js";
 import { getCrv, getLockedAmountAndUnlockTime, getVeCrv, getVeCrvPct, calcUnlockTime, createLockEstimateGas, createLock, isApproved, approveEstimateGas, approve, increaseAmountEstimateGas, increaseAmount, increaseUnlockTimeEstimateGas, increaseUnlockTime, withdrawLockedCrvEstimateGas, withdrawLockedCrv, claimableFees, claimFeesEstimateGas, claimFees, lastEthBlock, getAnycallBalance, topUpAnycall, topUpAnycallEstimateGas, lastBlockSent, blockToSend, sendBlockhash, sendBlockhashEstimateGas, submitProof, submitProofEstimateGas, claimFeesCrvUSDEstimateGas, claimableFeesCrvUSD, claimFeesCrvUSD, calculateVeCrv, } from "./boosting.js";
 import { getBalances, getAllowance, hasAllowance, ensureAllowanceEstimateGas, ensureAllowance, populateApprove, getUsdRate, getGasPriceFromL1, getGasPriceFromL2, getGasInfoForL2, getTVL, getCoinsData, getVolume, hasDepositAndStake, hasRouter, getBasePools, getGasPrice, getCurveLiteNetworks, } from "./utils.js";
@@ -233,9 +233,13 @@ export const createCurve = () => {
             swap: swap.bind(_curve),
             populateSwap: populateSwap.bind(_curve),
             getSwappedAmount: getSwappedAmount.bind(_curve),
+            approveFromCalldata: approveFromCalldata.bind(_curve),
+            swapFromCalldata: swapFromCalldata.bind(_curve),
             estimateGas: {
                 approve: swapApproveEstimateGas.bind(_curve),
                 swap: swapEstimateGas.bind(_curve),
+                approveFromCalldata: approveFromCalldataEstimateGas.bind(_curve),
+                swapFromCalldata: swapFromCalldataEstimateGas.bind(_curve),
             },
         },
         dao: {

package/lib/pools/poolConstructor.js

@@ -17,22 +17,15 @@ import { swapWrappedExpectedAndApproveMixin, swapWrappedMixin, swapWrappedRequir
 import { findAbiSignature, getCountArgsOfMethodByAbi, getPoolIdBySwapAddress } from "../utils.js";
 import { StatsPool } from "./subClasses/statsPool.js";
 export function getPool(poolIdOrAddress) {
-    let poolId;
-    const _poolIdOrAddress = poolIdOrAddress.toLowerCase();
-    if (_poolIdOrAddress.startsWith('0x')) {
-        poolId = getPoolIdBySwapAddress.call(this, _poolIdOrAddress);
-        if (!poolId || !this.getPoolsData()[poolId]) {
-            throw new Error(`Pool with address ${_poolIdOrAddress} not found`);
-        }
+    const poolId = poolIdOrAddress.toLowerCase().startsWith('0x') ? getPoolIdBySwapAddress.call(this, poolIdOrAddress.toLowerCase()) : poolIdOrAddress;
+    if (!poolId) {
+        throw new Error(`Pool with address ${poolIdOrAddress} not found`);
     }
-    else {
-        poolId = _poolIdOrAddress;
-        const poolsData = this.getPoolsData();
-        if (!poolsData[poolId]) {
-            throw new Error(`Pool with id ${_poolIdOrAddress} not found`);
-        }
+    const poolData = (this.getPoolsData())[poolId];
+    if (!poolData) {
+        throw new Error(`Pool with id ${poolIdOrAddress} not found`);
     }
-    const poolDummy = new PoolTemplate(poolId, this);
+    const poolDummy = new PoolTemplate(poolId, this, poolData);
     class Pool extends PoolTemplate {
         constructor(poolId, curve) {
             super(poolId, curve);

package/lib/router.d.ts

@@ -25,3 +25,7 @@ export declare function swapEstimateGas(this: Curve, inputCoin: string, outputCo
 export declare function swap(this: Curve, inputCoin: string, outputCoin: string, amount: number | string, slippage?: number): Promise<ethers.ContractTransactionResponse>;
 export declare function populateSwap(this: Curve, inputCoin: string, outputCoin: string, amount: number | string, slippage?: number): Promise<TransactionLike>;
 export declare function getSwappedAmount(this: Curve, tx: ethers.ContractTransactionResponse, outputCoin: string): Promise<string>;
+export declare function approveFromCalldataEstimateGas(this: Curve, tx: ethers.TransactionRequest): Promise<number | number[]>;
+export declare function approveFromCalldata(this: Curve, tx: ethers.TransactionRequest): Promise<string>;
+export declare function swapFromCalldataEstimateGas(this: Curve, tx: ethers.TransactionRequest): Promise<number | number[]>;
+export declare function swapFromCalldata(this: Curve, tx: ethers.TransactionRequest): Promise<string>;

package/lib/router.js

@@ -458,3 +458,47 @@ export function getSwappedAmount(tx, outputCoin) {
         return this.formatUnits(res[res.length - 1], outputCoinDecimals);
     });
 }
+function _approveFromCalldata(tx_1) {
+    return __awaiter(this, arguments, void 0, function* (tx, estimateGas = false) {
+        if (!this.signer) {
+            throw new Error("Signer is not available");
+        }
+        const gas = yield this.signer.estimateGas(Object.assign(Object.assign({}, tx), this.constantOptions));
+        if (estimateGas)
+            return smartNumber(gas);
+        yield this.updateFeeData();
+        return (yield this.signer.sendTransaction(Object.assign(Object.assign({}, tx), this.options))).hash;
+    });
+}
+export function approveFromCalldataEstimateGas(tx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield _approveFromCalldata.call(this, tx, true);
+    });
+}
+export function approveFromCalldata(tx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield _approveFromCalldata.call(this, tx, false);
+    });
+}
+function _swapFromCalldata(tx_1) {
+    return __awaiter(this, arguments, void 0, function* (tx, estimateGas = false) {
+        if (!this.signer) {
+            throw new Error("Signer is not available");
+        }
+        const gas = yield this.signer.estimateGas(Object.assign(Object.assign({}, tx), this.constantOptions));
+        if (estimateGas)
+            return smartNumber(gas);
+        yield this.updateFeeData();
+        return (yield this.signer.sendTransaction(Object.assign(Object.assign({}, tx), this.options))).hash;
+    });
+}
+export function swapFromCalldataEstimateGas(tx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield _swapFromCalldata.call(this, tx, true);
+    });
+}
+export function swapFromCalldata(tx) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield _swapFromCalldata.call(this, tx, false);
+    });
+}

package/package.json

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