@curvefi/api 2.68.31 → 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 () => {
@@ -1380,6 +1391,98 @@ import curve from "@curvefi/api";
 })()
 ```
 
+## FastBridge
+
+FastBridge allows bridging crvUSD from L2 networks (Arbitrum, Optimism, Fraxtal) to Ethereum mainnet.
+
+```ts
+import curve from "@curvefi/api";
+
+(async () => {
+    // Initialize on L2 network (Arbitrum, Optimism, or Fraxtal)
+    await curve.init('JsonRpc', {}, { gasPrice: 0, maxFeePerGas: 0, maxPriorityFeePerGas: 0, chainId: 42161 }); // Arbitrum
+    
+    // Check if FastBridge is supported on current network
+    curve.fastBridge.isSupported();
+    // true (on Arbitrum, Optimism, Fraxtal)
+    // false (on other networks)
+    
+    // Assert that FastBridge is supported (throws error if not)
+    curve.fastBridge.assertIsSupported();
+    // No error on supported networks
+    // Throws "FastBridge is not available on this network" on unsupported networks
+    
+    // Get list of supported networks
+    const supportedNetworks = curve.fastBridge.getSupportedNetworks();
+    console.log(supportedNetworks);
+    // [
+    //     {
+    //         chainId: 42161,
+    //         name: 'Arbitrum',
+    //         fastBridgeAddress: '0x1F2aF270029d028400265Ce1dd0919BA8780dAe1',
+    //         crvUsdAddress: '0x498Bf2B1e120FeD3ad3D42EA2165E9b73f99C1e5'
+    //     },
+    //     {
+    //         chainId: 10,
+    //         name: 'Optimism',
+    //         fastBridgeAddress: '0xD16d5eC345Dd86Fb63C6a9C43c517210F1027914',
+    //         crvUsdAddress: '0x417Ac0e078398C154EdFadD9Ef675d30Be60Af93'
+    //     },
+    //     {
+    //         chainId: 252,
+    //         name: 'Fraxtal',
+    //         fastBridgeAddress: '0x3fE593E651Cd0B383AD36b75F4159f30BB0631A6',
+    //         crvUsdAddress: '0x67bCae3700C0fd13FB1951C7801050349F8C5caa'
+    //     }
+    // ]
+
+    // Check allowed bridge amounts (min/max)
+    const { min, max } = await curve.fastBridge.allowedToBridge();
+    console.log(min, max);
+    // 10.0 49990.0
+
+    // Get bridge cost (must be called before bridging to cache the value)
+    const cost = await curve.fastBridge.bridgeCost();
+    console.log(cost);
+    // 0.001234567890123456 (in ETH)
+
+    // Check if crvUSD is approved for the amount you want to bridge
+    await curve.fastBridge.isApproved(1000);
+    // false
+
+    // Approve crvUSD for bridging
+    await curve.fastBridge.approve(1000);
+    // [
+    //     '0xc111e471715ae6f5437e12d3b94868a5b6542cd7304efca18b5782d315760ae5'
+    // ]
+
+    // Bridge crvUSD to Ethereum mainnet
+    // Note: You must call bridgeCost() first to cache the cost value
+    const bridgeTx = await curve.fastBridge.bridge(1000);
+    // OR bridge to specific address:
+    // const bridgeTx = await curve.fastBridge.bridge(1000, '0x742d35Cc6634C0532925a3b844Bc9e7595f0bEb');
+    console.log(bridgeTx.hash);
+    // 0xc7ba1d60871c0295ac5471bb602c37ec0f00a71543b3a041308ebd91833f26ba
+
+    // Estimate gas for approve
+    await curve.fastBridge.estimateGas.approve(1000);
+    // 46000
+
+    // Estimate gas for bridge
+    await curve.fastBridge.estimateGas.bridge(1000);
+    // 150000
+})()
+```
+
+**Important Notes:**
+1. FastBridge is only available on L2 networks (Arbitrum, Optimism, Fraxtal)
+   - Use `isSupported()` to check if current network supports FastBridge
+   - Use `assertIsSupported()` to throw an error if not supported
+2. You must call `bridgeCost()` before calling `bridge()` to cache the cost value
+3. The bridge method is payable - it will send the cost amount in ETH/native currency
+4. Bridge amount must be within the allowed range (min/max from `allowedToBridge()`)
+5. `_min_amount` is automatically set equal to `_amount` for slippage protection
+
 ## Boosting
 
 ### Lock

package/lib/bridge.d.ts

@@ -0,0 +1,21 @@
+import { ethers } from "ethers";
+import { type Curve } from "./curve.js";
+export interface IFastBridgeNetwork {
+    chainId: number;
+    name: string;
+    fastBridgeAddress: string;
+    crvUsdAddress: string;
+}
+export declare function isSupported(this: Curve): boolean;
+export declare function assertIsSupported(this: Curve): void;
+export declare function allowedToBridge(this: Curve): Promise<{
+    min: number;
+    max: number;
+}>;
+export declare function bridgeCost(this: Curve): Promise<number>;
+export declare function bridgeIsApproved(this: Curve, amount: number | string): Promise<boolean>;
+export declare function bridgeApproveEstimateGas(this: Curve, amount: number | string): Promise<number | number[]>;
+export declare function bridgeApprove(this: Curve, amount: number | string): Promise<string[]>;
+export declare function bridgeEstimateGas(this: Curve, amount: number | string, address?: string): Promise<number | number[]>;
+export declare function bridge(this: Curve, amount: number | string, address?: string): Promise<ethers.ContractTransactionResponse>;
+export declare function getSupportedNetworks(): IFastBridgeNetwork[];

package/lib/bridge.js

@@ -0,0 +1,128 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { ensureAllowance, ensureAllowanceEstimateGas, hasAllowance, parseUnits, DIGas, smartNumber, } from "./utils.js";
+import { NETWORK_CONSTANTS } from "./constants/network_constants.js";
+const CRVUSD_DECIMALS = 18;
+const _bridgeCostCache = {};
+export function isSupported() {
+    return !!(this.constants.ALIASES.fast_bridge && this.constants.ALIASES.crvusd);
+}
+export function assertIsSupported() {
+    if (!this.constants.ALIASES.fast_bridge) {
+        throw new Error("FastBridge is not available on this network");
+    }
+    if (!this.constants.ALIASES.crvusd) {
+        throw new Error("crvUSD is not available on this network");
+    }
+}
+function _allowedToBridge() {
+    return __awaiter(this, void 0, void 0, function* () {
+        assertIsSupported.call(this);
+        const contract = this.contracts[this.constants.ALIASES.fast_bridge].contract;
+        const result = yield contract.allowed_to_bridge(this.constantOptions);
+        return {
+            _min: result[0],
+            _max: result[1],
+        };
+    });
+}
+export function allowedToBridge() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { _min, _max } = yield _allowedToBridge.call(this);
+        return {
+            min: Number(this.formatUnits(_min, CRVUSD_DECIMALS)),
+            max: Number(this.formatUnits(_max, CRVUSD_DECIMALS)),
+        };
+    });
+}
+function _bridgeCost() {
+    return __awaiter(this, void 0, void 0, function* () {
+        assertIsSupported.call(this);
+        const contract = this.contracts[this.constants.ALIASES.fast_bridge].contract;
+        return yield contract.cost(this.constantOptions);
+    });
+}
+export function bridgeCost() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const _cost = yield _bridgeCost.call(this);
+        const key = `${this.chainId}`;
+        _bridgeCostCache[key] = _cost;
+        return Number(this.formatUnits(_cost, 18));
+    });
+}
+export function bridgeIsApproved(amount) {
+    return __awaiter(this, void 0, void 0, function* () {
+        assertIsSupported.call(this);
+        return yield hasAllowance.call(this, [this.constants.ALIASES.crvusd], [amount], this.signerAddress, this.constants.ALIASES.fast_bridge);
+    });
+}
+export function bridgeApproveEstimateGas(amount) {
+    return __awaiter(this, void 0, void 0, function* () {
+        assertIsSupported.call(this);
+        return yield ensureAllowanceEstimateGas.call(this, [this.constants.ALIASES.crvusd], [amount], this.constants.ALIASES.fast_bridge);
+    });
+}
+export function bridgeApprove(amount) {
+    return __awaiter(this, void 0, void 0, function* () {
+        assertIsSupported.call(this);
+        return yield ensureAllowance.call(this, [this.constants.ALIASES.crvusd], [amount], this.constants.ALIASES.fast_bridge);
+    });
+}
+function _bridge(amount_1, address_1) {
+    return __awaiter(this, arguments, void 0, function* (amount, address, estimateGas = false) {
+        assertIsSupported.call(this);
+        const _amount = parseUnits(amount, CRVUSD_DECIMALS);
+        const { _min, _max } = yield _allowedToBridge.call(this);
+        if (_amount < _min || _amount > _max) {
+            throw new Error(`Amount must be between ${this.formatUnits(_min, CRVUSD_DECIMALS)} and ${this.formatUnits(_max, CRVUSD_DECIMALS)}`);
+        }
+        const key = `${this.chainId}`;
+        const _cost = _bridgeCostCache[key];
+        if (_cost === undefined) {
+            throw new Error("You must call bridgeCost() first to get the bridge cost");
+        }
+        const to = address || this.signerAddress;
+        const contract = this.contracts[this.constants.ALIASES.fast_bridge].contract;
+        if (!estimateGas)
+            yield bridgeApprove.call(this, amount);
+        const gas = yield contract.bridge.estimateGas(this.constants.ALIASES.crvusd, to, _amount, _amount, Object.assign(Object.assign({}, this.constantOptions), { value: _cost }));
+        if (estimateGas)
+            return smartNumber(gas);
+        yield this.updateFeeData();
+        const gasLimit = DIGas(gas) * this.parseUnits("160", 0) / this.parseUnits("100", 0);
+        return yield contract.bridge(this.constants.ALIASES.crvusd, to, _amount, _amount, Object.assign(Object.assign({}, this.options), { value: _cost, gasLimit }));
+    });
+}
+export function bridgeEstimateGas(amount, address) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield _bridge.call(this, amount, address, true);
+    });
+}
+export function bridge(amount, address) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield _bridge.call(this, amount, address, false);
+    });
+}
+export function getSupportedNetworks() {
+    var _a, _b;
+    const networks = [];
+    for (const [chainIdStr, config] of Object.entries(NETWORK_CONSTANTS)) {
+        const chainId = Number(chainIdStr);
+        if (((_a = config.ALIASES) === null || _a === void 0 ? void 0 : _a.fast_bridge) && ((_b = config.ALIASES) === null || _b === void 0 ? void 0 : _b.crvusd)) {
+            networks.push({
+                chainId,
+                name: config.NAME,
+                fastBridgeAddress: config.ALIASES.fast_bridge,
+                crvUsdAddress: config.ALIASES.crvusd,
+            });
+        }
+    }
+    return networks;
+}

package/lib/constants/abis/fastBridge.json

@@ -0,0 +1,400 @@
+[
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": false,
+                "name": "min_amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "SetMinAmount",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": false,
+                "name": "limit",
+                "type": "uint256"
+            }
+        ],
+        "name": "SetLimit",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": false,
+                "name": "bridger",
+                "type": "address"
+            }
+        ],
+        "name": "SetBridger",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": false,
+                "name": "messenger",
+                "type": "address"
+            }
+        ],
+        "name": "SetMessenger",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "name": "previous_owner",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "name": "new_owner",
+                "type": "address"
+            }
+        ],
+        "name": "OwnershipTransferred",
+        "type": "event"
+    },
+    {
+        "anonymous": false,
+        "inputs": [
+            {
+                "indexed": true,
+                "name": "token",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "name": "sender",
+                "type": "address"
+            },
+            {
+                "indexed": true,
+                "name": "receiver",
+                "type": "address"
+            },
+            {
+                "indexed": false,
+                "name": "amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "Bridge",
+        "type": "event"
+    },
+    {
+        "inputs": [],
+        "name": "owner",
+        "outputs": [
+            {
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "name": "new_owner",
+                "type": "address"
+            }
+        ],
+        "name": "transfer_ownership",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "renounce_ownership",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "cost",
+        "outputs": [
+            {
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "name": "_token",
+                "type": "address"
+            },
+            {
+                "name": "_to",
+                "type": "address"
+            },
+            {
+                "name": "_amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "bridge",
+        "outputs": [
+            {
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "payable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "name": "_token",
+                "type": "address"
+            },
+            {
+                "name": "_to",
+                "type": "address"
+            },
+            {
+                "name": "_amount",
+                "type": "uint256"
+            },
+            {
+                "name": "_min_amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "bridge",
+        "outputs": [
+            {
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "payable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "allowed_to_bridge",
+        "outputs": [
+            {
+                "name": "",
+                "type": "uint256"
+            },
+            {
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "name": "_ts",
+                "type": "uint256"
+            }
+        ],
+        "name": "allowed_to_bridge",
+        "outputs": [
+            {
+                "name": "",
+                "type": "uint256"
+            },
+            {
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "name": "_min_amount",
+                "type": "uint256"
+            }
+        ],
+        "name": "set_min_amount",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "name": "_limit",
+                "type": "uint256"
+            }
+        ],
+        "name": "set_limit",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "name": "_bridger",
+                "type": "address"
+            }
+        ],
+        "name": "set_bridger",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "name": "_messenger",
+                "type": "address"
+            }
+        ],
+        "name": "set_messenger",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "version",
+        "outputs": [
+            {
+                "name": "",
+                "type": "string"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "CRVUSD",
+        "outputs": [
+            {
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "VAULT",
+        "outputs": [
+            {
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "min_amount",
+        "outputs": [
+            {
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "limit",
+        "outputs": [
+            {
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "name": "arg0",
+                "type": "uint256"
+            }
+        ],
+        "name": "bridged",
+        "outputs": [
+            {
+                "name": "",
+                "type": "uint256"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "bridger",
+        "outputs": [
+            {
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [],
+        "name": "messenger",
+        "outputs": [
+            {
+                "name": "",
+                "type": "address"
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function"
+    },
+    {
+        "inputs": [
+            {
+                "name": "_crvusd",
+                "type": "address"
+            },
+            {
+                "name": "_vault",
+                "type": "address"
+            },
+            {
+                "name": "_bridger",
+                "type": "address"
+            },
+            {
+                "name": "_messenger",
+                "type": "address"
+            }
+        ],
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "constructor"
+    }
+]

package/lib/constants/network_constants.js

@@ -100,6 +100,8 @@ const ALIASES_ARBITRUM = lowerCaseValues({
     "twocrypto_factory": '0x98EE851a00abeE0d95D08cF4CA2BdCE32aeaAF7F',
     "tricrypto_factory": '0xbC0797015fcFc47d9C1856639CaE50D0e69FbEE8',
     "factory_admin": "",
+    "fast_bridge": "0x1F2aF270029d028400265Ce1dd0919BA8780dAe1",
+    "crvusd": "0x498Bf2B1e120FeD3ad3D42EA2165E9b73f99C1e5",
 });
 const ALIASES_OPTIMISM = lowerCaseValues({
     "crv": "0x0994206dfE8De6Ec6920FF4D779B0d950605Fb53",
@@ -120,6 +122,8 @@ const ALIASES_OPTIMISM = lowerCaseValues({
     "factory_admin": "",
     "gas_oracle": '0xc0d3C0d3C0d3c0D3C0D3C0d3C0d3C0D3C0D3000f',
     "gas_oracle_blob": '0x420000000000000000000000000000000000000f',
+    "fast_bridge": "0xD16d5eC345Dd86Fb63C6a9C43c517210F1027914",
+    "crvusd": "0xC52D7F23a2e460248Db6eE192Cb23dD12bDDCbf6",
 });
 const ALIASES_XDAI = lowerCaseValues({
     "crv": "0x712b3d230f3c1c19db860d80619288b1f0bdd0bd",
@@ -274,6 +278,8 @@ const ALIASES_FRAXTAL = lowerCaseValues({
     "twocrypto_factory": '0x98EE851a00abeE0d95D08cF4CA2BdCE32aeaAF7F',
     "tricrypto_factory": '0xc9Fe0C63Af9A39402e8a5514f9c43Af0322b665F',
     "factory_admin": '0x0000000000000000000000000000000000000000',
+    "fast_bridge": "0x3fE593E651Cd0B383AD36b75F4159f30BB0631A6",
+    "crvusd": "0xB102f7Efa0d5dE071A8D37B3548e1C7CB148Caf3",
 });
 const ALIASES_XLAYER = lowerCaseValues({
     "crv": "0x0000000000000000000000000000000000000000",

package/lib/curve.js

@@ -48,6 +48,7 @@ import gasOracleBlobABI from './constants/abis/gas_oracle_optimism_blob.json' wi
 import votingProposalABI from './constants/abis/voting_proposal.json' with { type: 'json' };
 import circulatingSupplyABI from './constants/abis/circulating_supply.json' with { type: 'json' };
 import rootGaugeFactoryABI from "./constants/abis/gauge_factory/root_gauge_factory.json" with { type: "json" };
+import fastBridgeABI from './constants/abis/fastBridge.json' with { type: 'json' };
 import { extractDecimals, extractGauges, formatUnits, lowerCasePoolDataAddresses, parseUnits, } from "./constants/utils.js";
 import { _getHiddenPools } from "./external-api.js";
 import { L2Networks } from "./constants/L2Networks.js";
@@ -561,6 +562,13 @@ export class Curve {
             this.constants.DECIMALS[this.constants.ALIASES.crv] = 18;
             this.setContract(this.constants.COINS.scrvusd, ERC20Abi);
             this.constants.DECIMALS[this.constants.COINS.scrvusd] = 18;
+            if (this.constants.ALIASES.fast_bridge) {
+                this.setContract(this.constants.ALIASES.fast_bridge, fastBridgeABI);
+            }
+            if (this.constants.ALIASES.crvusd) {
+                this.setContract(this.constants.ALIASES.crvusd, ERC20Abi);
+                this.constants.DECIMALS[this.constants.ALIASES.crvusd] = 18;
+            }
             if (this.chainId === 1) {
                 this.setContract(this.constants.ALIASES.minter, minterMainnetABI);
                 this.setContract(this.constants.ALIASES.fee_distributor_crvusd, feeDistributorCrvUSDABI);

package/lib/index.d.ts

@@ -1,5 +1,6 @@
 import { ethers } from "ethers";
 import { PoolTemplate } from "./pools/index.js";
+import { getSupportedNetworks } from "./bridge.js";
 import { deployCryptoPoolEstimateGas, deployTwocryptoPoolEstimateGas } from './factory/deploy.js';
 import { getTwoCryptoImplementations } from './constants/twoCryptoImplementations.js';
 export declare const createCurve: () => {
@@ -268,6 +269,23 @@ export declare const createCurve: () => {
             swapFromCalldata: (tx: ethers.TransactionRequest) => Promise<number | number[]>;
         };
     };
+    fastBridge: {
+        assertIsSupported: () => void;
+        isSupported: () => boolean;
+        getSupportedNetworks: typeof getSupportedNetworks;
+        allowedToBridge: () => Promise<{
+            min: number;
+            max: number;
+        }>;
+        bridgeCost: () => Promise<number>;
+        isApproved: (amount: string | number) => Promise<boolean>;
+        approve: (amount: string | number) => Promise<string[]>;
+        bridge: (amount: string | number, address?: string | undefined) => Promise<ethers.ContractTransactionResponse>;
+        estimateGas: {
+            approve: (amount: string | number) => Promise<number | number[]>;
+            bridge: (amount: string | number, address?: string | undefined) => Promise<number | number[]>;
+        };
+    };
     dao: {
         crvSupplyStats: () => Promise<{
             circulating: string;
@@ -585,6 +603,23 @@ declare const _default: {
             swapFromCalldata: (tx: ethers.TransactionRequest) => Promise<number | number[]>;
         };
     };
+    fastBridge: {
+        assertIsSupported: () => void;
+        isSupported: () => boolean;
+        getSupportedNetworks: typeof getSupportedNetworks;
+        allowedToBridge: () => Promise<{
+            min: number;
+            max: number;
+        }>;
+        bridgeCost: () => Promise<number>;
+        isApproved: (amount: string | number) => Promise<boolean>;
+        approve: (amount: string | number) => Promise<string[]>;
+        bridge: (amount: string | number, address?: string | undefined) => Promise<ethers.ContractTransactionResponse>;
+        estimateGas: {
+            approve: (amount: string | number) => Promise<number | number[]>;
+            bridge: (amount: string | number, address?: string | undefined) => Promise<number | number[]>;
+        };
+    };
     dao: {
         crvSupplyStats: () => Promise<{
             circulating: string;

package/lib/index.js

@@ -10,6 +10,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, approveFromCalldata, approveFromCalldataEstimateGas, swapFromCalldata, swapFromCalldataEstimateGas, } from "./router.js";
+import { isSupported, assertIsSupported, allowedToBridge, bridgeCost, bridgeIsApproved, bridgeApproveEstimateGas, bridgeApprove, bridgeEstimateGas, bridge, getSupportedNetworks, } from "./bridge.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";
@@ -242,6 +243,20 @@ export const createCurve = () => {
                 swapFromCalldata: swapFromCalldataEstimateGas.bind(_curve),
             },
         },
+        fastBridge: {
+            assertIsSupported: assertIsSupported.bind(_curve),
+            isSupported: isSupported.bind(_curve),
+            getSupportedNetworks: getSupportedNetworks.bind(_curve),
+            allowedToBridge: allowedToBridge.bind(_curve),
+            bridgeCost: bridgeCost.bind(_curve),
+            isApproved: bridgeIsApproved.bind(_curve),
+            approve: bridgeApprove.bind(_curve),
+            bridge: bridge.bind(_curve),
+            estimateGas: {
+                approve: bridgeApproveEstimateGas.bind(_curve),
+                bridge: bridgeEstimateGas.bind(_curve),
+            },
+        },
         dao: {
             // --- CRV lock ---
             // View methods

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.31",
+  "version": "2.68.33",
   "description": "JavaScript library for curve.finance",
   "main": "lib/index.js",
   "author": "Macket",