@clober/v2-sdk 0.0.128 → 1.0.0-rc.10

package/dist/cjs/call.js

@@ -1,1057 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.resumePool = exports.pausePool = exports.setStrategyConfig = exports.adjustOrderPrice = exports.refillOrder = exports.removeLiquidity = exports.addLiquidity = exports.openPool = exports.cancelOrders = exports.cancelOrder = exports.claimOrders = exports.claimOrder = exports.marketOrder = exports.limitOrder = exports.openMarket = void 0;
-const viem_1 = require("viem");
-const chain_1 = require("./constants/chain");
-const unit_size_1 = require("./utils/unit-size");
-const controller_abi_1 = require("./abis/core/controller-abi");
-const time_1 = require("./utils/time");
-const build_transaction_1 = require("./utils/build-transaction");
-const addresses_1 = require("./constants/addresses");
-const fee_1 = require("./constants/fee");
-const market_1 = require("./apis/market");
-const prices_1 = require("./utils/prices");
-const tick_1 = require("./utils/tick");
-const view_1 = require("./view");
-const book_id_1 = require("./utils/book-id");
-const approval_1 = require("./utils/approval");
-const order_1 = require("./utils/order");
-const bigint_1 = require("./utils/bigint");
-const pool_1 = require("./apis/pool");
-const rebalancer_abi_1 = require("./abis/rebalancer/rebalancer-abi");
-const pool_2 = require("./utils/pool");
-const odos_1 = require("./apis/odos");
-const minter_abi_1 = require("./abis/rebalancer/minter-abi");
-const permit_1 = require("./constants/permit");
-const math_1 = require("./utils/math");
-const pool_key_1 = require("./utils/pool-key");
-const operator_abi_1 = require("./abis/rebalancer/operator-abi");
-const strategy_abi_1 = require("./abis/rebalancer/strategy-abi");
-const open_order_1 = require("./apis/open-order");
-const quotes_1 = require("./utils/quotes");
-const openMarket = async ({ chainId, userAddress, inputToken, outputToken, options, }) => {
-    const publicClient = (0, viem_1.createPublicClient)({
-        chain: chain_1.CHAIN_MAP[chainId],
-        transport: options?.rpcUrl ? (0, viem_1.http)(options.rpcUrl) : (0, viem_1.http)(),
-    });
-    const market = await (0, market_1.fetchMarket)(publicClient, chainId, [inputToken, outputToken], !!(options && options.useSubgraph));
-    const isBid = (0, viem_1.isAddressEqual)(market.quote.address, inputToken);
-    if ((isBid && !market.bidBook.isOpened) ||
-        (!isBid && !market.askBook.isOpened)) {
-        const unitSize = (0, unit_size_1.calculateUnitSize)(chainId, isBid ? market.quote : market.base);
-        return (0, build_transaction_1.buildTransaction)(publicClient, {
-            chain: chain_1.CHAIN_MAP[chainId],
-            address: addresses_1.CONTRACT_ADDRESSES[chainId].Controller,
-            account: userAddress,
-            abi: controller_abi_1.CONTROLLER_ABI,
-            functionName: 'open',
-            args: [
-                [
-                    {
-                        key: {
-                            base: outputToken,
-                            unitSize,
-                            quote: inputToken,
-                            makerPolicy: fee_1.MAKER_DEFAULT_POLICY[chainId].value,
-                            hooks: viem_1.zeroAddress,
-                            takerPolicy: fee_1.TAKER_DEFAULT_POLICY[chainId].value,
-                        },
-                        hookData: viem_1.zeroHash,
-                    },
-                ],
-                (0, time_1.getDeadlineTimestampInSeconds)(),
-            ],
-        }, options?.gasLimit);
-    }
-    return undefined;
-};
-exports.openMarket = openMarket;
-const limitOrder = async ({ chainId, userAddress, inputToken, outputToken, amount, price, options, }) => {
-    const [roundingUpMakeBid, roundingDownMakeAsk, roundingDownTakenBid, roundingUpTakenAsk,] = [
-        options?.roundingUpMakeBid ? options.roundingUpMakeBid : false,
-        options?.roundingDownMakeAsk ? options.roundingDownMakeAsk : false,
-        options?.roundingDownTakenBid ? options.roundingDownTakenBid : false,
-        options?.roundingUpTakenAsk ? options.roundingUpTakenAsk : false,
-    ];
-    const publicClient = (0, viem_1.createPublicClient)({
-        chain: chain_1.CHAIN_MAP[chainId],
-        transport: options?.rpcUrl ? (0, viem_1.http)(options.rpcUrl) : (0, viem_1.http)(),
-    });
-    const market = await (0, market_1.fetchMarket)(publicClient, chainId, [inputToken, outputToken], !!(options && options.useSubgraph));
-    const isBid = (0, viem_1.isAddressEqual)(market.quote.address, inputToken);
-    const [inputCurrency, outputCurrency] = isBid
-        ? [market.quote, market.base]
-        : [market.base, market.quote];
-    if ((isBid && !market.bidBook.isOpened) ||
-        (!isBid && !market.askBook.isOpened)) {
-        throw new Error(`
-       Open the market before placing a limit order.
-       import { openMarket } from '@clober/v2-sdk'
-
-       const transaction = await openMarket({
-            chainId: ${chainId},
-            inputToken: '${inputToken}',
-            outputToken: '${outputToken}',
-       })
-    `);
-    }
-    const { roundingDownTick, roundingUpTick } = (0, prices_1.parsePrice)(Number(price), market.quote.decimals, market.base.decimals);
-    const tokensToSettle = [inputToken, outputToken].filter((address) => !(0, viem_1.isAddressEqual)(address, viem_1.zeroAddress));
-    const quoteAmount = (0, viem_1.parseUnits)(amount, inputCurrency.decimals);
-    const unitSize = (0, unit_size_1.calculateUnitSize)(chainId, inputCurrency);
-    const { takenAmount, spentAmount, bookId, events } = await (0, view_1.getExpectedOutput)({
-        chainId,
-        inputToken,
-        outputToken,
-        amountIn: amount,
-        options: {
-            ...options,
-            limitPrice: price,
-        },
-    });
-    const isETH = (0, viem_1.isAddressEqual)(inputToken, viem_1.zeroAddress);
-    const makeParam = {
-        id: (0, book_id_1.toBookId)(chainId, inputToken, outputToken, unitSize),
-        tick: options?.makeTick
-            ? Number(options.makeTick)
-            : Number(isBid
-                ? roundingUpMakeBid
-                    ? roundingUpTick
-                    : roundingDownTick
-                : (0, tick_1.invertTick)(roundingDownMakeAsk ? roundingDownTick : roundingUpTick)),
-        quoteAmount,
-        hookData: viem_1.zeroHash,
-    };
-    if (options?.postOnly === true || spentAmount === '0') {
-        return {
-            transaction: await (0, build_transaction_1.buildTransaction)(publicClient, {
-                chain: chain_1.CHAIN_MAP[chainId],
-                account: userAddress,
-                address: addresses_1.CONTRACT_ADDRESSES[chainId].Controller,
-                abi: controller_abi_1.CONTROLLER_ABI,
-                functionName: 'make',
-                args: [
-                    [makeParam],
-                    tokensToSettle,
-                    options?.erc20PermitParam ? [options.erc20PermitParam] : [],
-                    (0, time_1.getDeadlineTimestampInSeconds)(),
-                ],
-                value: isETH ? quoteAmount : 0n,
-            }, options?.gasLimit),
-            result: {
-                make: {
-                    amount: (0, viem_1.formatUnits)(quoteAmount, inputCurrency.decimals),
-                    currency: inputCurrency,
-                    direction: 'in',
-                    price: (0, prices_1.formatPrice)(isBid
-                        ? (0, tick_1.toPrice)(BigInt(makeParam.tick))
-                        : (0, tick_1.toPrice)((0, tick_1.invertTick)(BigInt(makeParam.tick))), market.quote.decimals, market.base.decimals),
-                },
-                spent: {
-                    amount: '0',
-                    currency: inputCurrency,
-                    direction: 'in',
-                    events: [],
-                },
-                taken: {
-                    amount: '0',
-                    currency: outputCurrency,
-                    direction: 'out',
-                    events: [],
-                },
-            },
-        };
-    }
-    else {
-        return {
-            transaction: await (0, build_transaction_1.buildTransaction)(publicClient, {
-                chain: chain_1.CHAIN_MAP[chainId],
-                account: userAddress,
-                address: addresses_1.CONTRACT_ADDRESSES[chainId].Controller,
-                abi: controller_abi_1.CONTROLLER_ABI,
-                functionName: 'limit',
-                args: [
-                    [
-                        {
-                            takeBookId: bookId,
-                            makeBookId: makeParam.id,
-                            limitPrice: options?.takeLimitTick
-                                ? (0, tick_1.toPrice)(options.takeLimitTick)
-                                : (0, tick_1.toPrice)(isBid
-                                    ? (0, tick_1.invertTick)(roundingUpTakenAsk
-                                        ? roundingUpTick
-                                        : roundingDownTick)
-                                    : roundingDownTakenBid
-                                        ? roundingDownTick
-                                        : roundingUpTick),
-                            tick: makeParam.tick,
-                            quoteAmount,
-                            takeHookData: viem_1.zeroHash,
-                            makeHookData: makeParam.hookData,
-                        },
-                    ],
-                    tokensToSettle,
-                    options?.erc20PermitParam ? [options.erc20PermitParam] : [],
-                    (0, time_1.getDeadlineTimestampInSeconds)(),
-                ],
-                value: isETH ? quoteAmount : 0n,
-            }, options?.gasLimit),
-            result: {
-                make: {
-                    amount: (0, viem_1.formatUnits)(quoteAmount - (0, viem_1.parseUnits)(spentAmount, inputCurrency.decimals), inputCurrency.decimals),
-                    currency: inputCurrency,
-                    direction: 'in',
-                    price: (0, prices_1.formatPrice)(isBid
-                        ? (0, tick_1.toPrice)(BigInt(makeParam.tick))
-                        : (0, tick_1.toPrice)((0, tick_1.invertTick)(BigInt(makeParam.tick))), market.quote.decimals, market.base.decimals),
-                },
-                spent: {
-                    amount: spentAmount,
-                    currency: inputCurrency,
-                    direction: 'in',
-                    events: events.map(({ price, spentAmount }) => ({
-                        price,
-                        amount: spentAmount,
-                    })),
-                },
-                taken: {
-                    amount: takenAmount,
-                    currency: outputCurrency,
-                    direction: 'out',
-                    events: events.map(({ price, takenAmount }) => ({
-                        price,
-                        amount: takenAmount,
-                    })),
-                },
-            },
-        };
-    }
-};
-exports.limitOrder = limitOrder;
-const marketOrder = async ({ chainId, userAddress, inputToken, outputToken, amountIn, amountOut, options, }) => {
-    if (!amountIn && !amountOut) {
-        throw new Error('Either amountIn or amountOut must be provided');
-    }
-    else if (amountIn && amountOut) {
-        throw new Error('Only one of amountIn or amountOut can be provided');
-    }
-    const publicClient = (0, viem_1.createPublicClient)({
-        chain: chain_1.CHAIN_MAP[chainId],
-        transport: options?.rpcUrl ? (0, viem_1.http)(options.rpcUrl) : (0, viem_1.http)(),
-    });
-    const market = await (0, market_1.fetchMarket)(publicClient, chainId, [inputToken, outputToken], !!(options && options.useSubgraph));
-    const isTakingBid = (0, viem_1.isAddressEqual)(market.base.address, inputToken);
-    const [inputCurrency, outputCurrency] = isTakingBid
-        ? [market.base, market.quote]
-        : [market.quote, market.base];
-    if ((isTakingBid && !market.bidBook.isOpened) ||
-        (!isTakingBid && !market.askBook.isOpened)) {
-        throw new Error(`
-       Open the market before placing a market order.
-       import { openMarket } from '@clober/v2-sdk'
-
-       const transaction = await openMarket(
-            ${chainId},
-           '${inputToken}',
-           '${outputToken}',
-       )
-    `);
-    }
-    const tokensToSettle = [inputToken, outputToken].filter((address) => !(0, viem_1.isAddressEqual)(address, viem_1.zeroAddress));
-    const isETH = (0, viem_1.isAddressEqual)(inputToken, viem_1.zeroAddress);
-    if (amountIn && !amountOut) {
-        const { bookId, takenAmount, spentAmount, events } = await (0, view_1.getExpectedOutput)({
-            chainId,
-            inputToken,
-            outputToken,
-            amountIn,
-            options: {
-                ...options,
-            },
-        });
-        const baseAmount = (0, viem_1.parseUnits)(amountIn, inputCurrency.decimals);
-        return {
-            transaction: await (0, build_transaction_1.buildTransaction)(publicClient, {
-                chain: chain_1.CHAIN_MAP[chainId],
-                account: userAddress,
-                address: addresses_1.CONTRACT_ADDRESSES[chainId].Controller,
-                abi: controller_abi_1.CONTROLLER_ABI,
-                functionName: 'spend',
-                args: [
-                    [
-                        {
-                            id: bookId,
-                            limitPrice: 0n,
-                            baseAmount,
-                            minQuoteAmount: options?.slippage
-                                ? (0, bigint_1.applyPercent)((0, viem_1.parseUnits)(takenAmount, outputCurrency.decimals), 100 - options.slippage)
-                                : 0n,
-                            hookData: viem_1.zeroHash,
-                        },
-                    ],
-                    tokensToSettle,
-                    options?.erc20PermitParam ? [options.erc20PermitParam] : [],
-                    (0, time_1.getDeadlineTimestampInSeconds)(),
-                ],
-                value: isETH ? baseAmount : 0n,
-            }, options?.gasLimit),
-            result: {
-                spent: {
-                    amount: spentAmount,
-                    currency: inputCurrency,
-                    direction: 'in',
-                    events: events.map(({ price, spentAmount }) => ({
-                        price,
-                        amount: spentAmount,
-                    })),
-                },
-                taken: {
-                    amount: takenAmount,
-                    currency: outputCurrency,
-                    direction: 'out',
-                    events: events.map(({ price, takenAmount }) => ({
-                        price,
-                        amount: takenAmount,
-                    })),
-                },
-            },
-        };
-    }
-    else if (!amountIn && amountOut) {
-        const { bookId, spentAmount, takenAmount, events } = await (0, view_1.getExpectedInput)({
-            chainId,
-            inputToken,
-            outputToken,
-            amountOut,
-            options: {
-                ...options,
-            },
-        });
-        const quoteAmount = (0, viem_1.parseUnits)(amountOut, outputCurrency.decimals);
-        const baseAmount = (0, viem_1.parseUnits)(spentAmount, inputCurrency.decimals);
-        const maxBaseAmount = options?.erc20PermitParam?.permitAmount ??
-            (options?.slippage
-                ? (0, bigint_1.applyPercent)(baseAmount, 100 + options.slippage)
-                : isETH
-                    ? baseAmount
-                    : 2n ** 256n - 1n);
-        return {
-            transaction: await (0, build_transaction_1.buildTransaction)(publicClient, {
-                chain: chain_1.CHAIN_MAP[chainId],
-                account: userAddress,
-                address: addresses_1.CONTRACT_ADDRESSES[chainId].Controller,
-                abi: controller_abi_1.CONTROLLER_ABI,
-                functionName: 'take',
-                args: [
-                    [
-                        {
-                            id: bookId,
-                            limitPrice: 0n,
-                            quoteAmount,
-                            maxBaseAmount,
-                            hookData: viem_1.zeroHash,
-                        },
-                    ],
-                    tokensToSettle,
-                    options?.erc20PermitParam ? [options.erc20PermitParam] : [],
-                    (0, time_1.getDeadlineTimestampInSeconds)(),
-                ],
-                value: isETH ? maxBaseAmount : 0n,
-            }, options?.gasLimit),
-            result: {
-                spent: {
-                    amount: spentAmount,
-                    currency: inputCurrency,
-                    direction: 'in',
-                    events: events.map(({ price, spentAmount }) => ({
-                        price,
-                        amount: spentAmount,
-                    })),
-                },
-                taken: {
-                    amount: takenAmount,
-                    currency: outputCurrency,
-                    direction: 'out',
-                    events: events.map(({ price, takenAmount }) => ({
-                        price,
-                        amount: takenAmount,
-                    })),
-                },
-            },
-        };
-    }
-    else {
-        throw new Error('Either amountIn or amountOut must be provided');
-    }
-};
-exports.marketOrder = marketOrder;
-const claimOrder = async ({ chainId, userAddress, id, options, }) => {
-    const { transaction, result } = await (0, exports.claimOrders)({
-        chainId,
-        userAddress,
-        ids: [id],
-        options: { ...options },
-    });
-    return {
-        transaction,
-        result: result[0],
-    };
-};
-exports.claimOrder = claimOrder;
-const claimOrders = async ({ chainId, userAddress, ids, options, }) => {
-    const publicClient = (0, viem_1.createPublicClient)({
-        chain: chain_1.CHAIN_MAP[chainId],
-        transport: options?.rpcUrl ? (0, viem_1.http)(options.rpcUrl) : (0, viem_1.http)(),
-    });
-    const isApprovedForAll = await (0, approval_1.fetchIsApprovedForAll)(publicClient, chainId, userAddress);
-    if (!isApprovedForAll) {
-        throw new Error(`
-       Set ApprovalForAll before calling this function.
-       import { setApprovalOfOpenOrdersForAll } from '@clober/v2-sdk'
-
-       const hash = await setApprovalOfOpenOrdersForAll({
-            chainId: ${chainId},
-            walletClient, // use viem
-       })
-    `);
-    }
-    const useSubgraph = !!(options && options.useSubgraph);
-    const orders = (useSubgraph
-        ? await (0, open_order_1.fetchOpenOrdersByOrderIdsFromSubgraph)(chainId, ids)
-        : await (0, order_1.fetchOnChainOrders)(publicClient, chainId, ids.map((id) => BigInt(id)))).filter((order) => (0, viem_1.isAddressEqual)(order.user, userAddress) && order.claimable.value !== '0');
-    const tokensToSettle = orders
-        .map((order) => [order.inputCurrency.address, order.outputCurrency.address])
-        .flat()
-        .filter((address, index, self) => self.findIndex((c) => (0, viem_1.isAddressEqual)(c, address)) === index)
-        .filter((address) => !(0, viem_1.isAddressEqual)(address, viem_1.zeroAddress));
-    return {
-        transaction: await (0, build_transaction_1.buildTransaction)(publicClient, {
-            chain: chain_1.CHAIN_MAP[chainId],
-            account: userAddress,
-            address: addresses_1.CONTRACT_ADDRESSES[chainId].Controller,
-            abi: controller_abi_1.CONTROLLER_ABI,
-            functionName: 'claim',
-            args: [
-                orders.map(({ id }) => ({
-                    id,
-                    hookData: viem_1.zeroHash,
-                })),
-                tokensToSettle,
-                [],
-                (0, time_1.getDeadlineTimestampInSeconds)(),
-            ],
-        }, options?.gasLimit),
-        result: orders.reduce((acc, { claimable: { currency, value } }) => {
-            const index = acc.findIndex((c) => (0, viem_1.isAddressEqual)(c.currency.address, currency.address));
-            if (index === -1) {
-                return [...acc, { currency, amount: value, direction: 'out' }];
-            }
-            acc[index].amount = (Number(acc[index].amount) + Number(value)).toString();
-            return acc;
-        }, []),
-    };
-};
-exports.claimOrders = claimOrders;
-const cancelOrder = async ({ chainId, userAddress, id, options, }) => {
-    const { transaction, result } = await (0, exports.cancelOrders)({
-        chainId,
-        userAddress,
-        ids: [id],
-        options: { ...options },
-    });
-    return {
-        transaction,
-        result: result[0],
-    };
-};
-exports.cancelOrder = cancelOrder;
-const cancelOrders = async ({ chainId, userAddress, ids, options, }) => {
-    const publicClient = (0, viem_1.createPublicClient)({
-        chain: chain_1.CHAIN_MAP[chainId],
-        transport: options?.rpcUrl ? (0, viem_1.http)(options.rpcUrl) : (0, viem_1.http)(),
-    });
-    const isApprovedForAll = await (0, approval_1.fetchIsApprovedForAll)(publicClient, chainId, userAddress);
-    if (!isApprovedForAll) {
-        throw new Error(`
-       Set ApprovalForAll before calling this function.
-       import { setApprovalOfOpenOrdersForAll } from '@clober/v2-sdk'
-
-       const hash = await setApprovalOfOpenOrdersForAll({
-            chainId: ${chainId},
-            walletClient, // use viem
-       })
-    `);
-    }
-    const useSubgraph = !!(options && options.useSubgraph);
-    const orders = (useSubgraph
-        ? await (0, open_order_1.fetchOpenOrdersByOrderIdsFromSubgraph)(chainId, ids)
-        : await (0, order_1.fetchOnChainOrders)(publicClient, chainId, ids.map((id) => BigInt(id)))).filter((order) => (0, viem_1.isAddressEqual)(order.user, userAddress) && order.cancelable.value !== '0');
-    const tokensToSettle = orders
-        .map((order) => [order.inputCurrency.address, order.outputCurrency.address])
-        .flat()
-        .filter((address, index, self) => self.findIndex((c) => (0, viem_1.isAddressEqual)(c, address)) === index)
-        .filter((address) => !(0, viem_1.isAddressEqual)(address, viem_1.zeroAddress));
-    return {
-        transaction: await (0, build_transaction_1.buildTransaction)(publicClient, {
-            chain: chain_1.CHAIN_MAP[chainId],
-            account: userAddress,
-            address: addresses_1.CONTRACT_ADDRESSES[chainId].Controller,
-            abi: controller_abi_1.CONTROLLER_ABI,
-            functionName: 'cancel',
-            args: [
-                orders.map(({ id }) => ({
-                    id,
-                    leftQuoteAmount: 0n,
-                    hookData: viem_1.zeroHash,
-                })),
-                tokensToSettle,
-                [],
-                (0, time_1.getDeadlineTimestampInSeconds)(),
-            ],
-        }, options?.gasLimit),
-        result: orders.reduce((acc, { cancelable: { currency, value } }) => {
-            const index = acc.findIndex((c) => (0, viem_1.isAddressEqual)(c.currency.address, currency.address));
-            if (index === -1) {
-                return [...acc, { currency, amount: value, direction: 'out' }];
-            }
-            acc[index].amount = (Number(acc[index].amount) + Number(value)).toString();
-            return acc;
-        }, []),
-    };
-};
-exports.cancelOrders = cancelOrders;
-const openPool = async ({ chainId, userAddress, tokenA, tokenB, salt, options, }) => {
-    const publicClient = (0, viem_1.createPublicClient)({
-        chain: chain_1.CHAIN_MAP[chainId],
-        transport: options?.rpcUrl ? (0, viem_1.http)(options.rpcUrl) : (0, viem_1.http)(),
-    });
-    const pool = await (0, pool_1.fetchPool)(publicClient, chainId, [tokenA, tokenB], salt, !!(options && options.useSubgraph));
-    if (!pool.isOpened) {
-        return (0, build_transaction_1.buildTransaction)(publicClient, {
-            chain: chain_1.CHAIN_MAP[chainId],
-            address: addresses_1.CONTRACT_ADDRESSES[chainId].Rebalancer,
-            account: userAddress,
-            abi: rebalancer_abi_1.REBALANCER_ABI,
-            functionName: 'open',
-            args: [
-                {
-                    base: pool.market.bidBook.base.address,
-                    unitSize: pool.market.bidBook.unitSize,
-                    quote: pool.market.bidBook.quote.address,
-                    makerPolicy: fee_1.MAKER_DEFAULT_POLICY[chainId].value,
-                    hooks: viem_1.zeroAddress,
-                    takerPolicy: fee_1.TAKER_DEFAULT_POLICY[chainId].value,
-                },
-                {
-                    base: pool.market.askBook.base.address,
-                    unitSize: pool.market.askBook.unitSize,
-                    quote: pool.market.askBook.quote.address,
-                    makerPolicy: fee_1.MAKER_DEFAULT_POLICY[chainId].value,
-                    hooks: viem_1.zeroAddress,
-                    takerPolicy: fee_1.TAKER_DEFAULT_POLICY[chainId].value,
-                },
-                (0, pool_key_1.toBytes32)(salt),
-                addresses_1.CONTRACT_ADDRESSES[chainId].Strategy,
-            ],
-        }, options?.gasLimit);
-    }
-    return undefined;
-};
-exports.openPool = openPool;
-const addLiquidity = async ({ chainId, userAddress, token0, token1, salt, amount0, amount1, options, }) => {
-    const publicClient = (0, viem_1.createPublicClient)({
-        chain: chain_1.CHAIN_MAP[chainId],
-        transport: options?.rpcUrl ? (0, viem_1.http)(options.rpcUrl) : (0, viem_1.http)(),
-    });
-    const pool = await (0, pool_1.fetchPool)(publicClient, chainId, [token0, token1], salt, !!(options && options.useSubgraph));
-    if (!pool.isOpened) {
-        throw new Error(`
-       Open the pool before adding liquidity.
-       import { openPool } from '@clober/v2-sdk'
-
-       const transaction = await openPool({
-            chainId: ${chainId},
-            tokenA: '${token0}',
-            tokenB: '${token1}',
-            salt: '0x0000000000000000000000000000000000000000000000000000000000000000',
-       })
-    `);
-    }
-    const [amountAOrigin, amountBOrigin] = (0, viem_1.isAddressEqual)(pool.currencyA.address, (0, viem_1.getAddress)(token0))
-        ? [
-            (0, viem_1.parseUnits)(amount0 ?? '0', pool.currencyA.decimals),
-            (0, viem_1.parseUnits)(amount1 ?? '0', pool.currencyB.decimals),
-        ]
-        : [
-            (0, viem_1.parseUnits)(amount1 ?? '0', pool.currencyA.decimals),
-            (0, viem_1.parseUnits)(amount0 ?? '0', pool.currencyB.decimals),
-        ];
-    let [amountA, amountB] = [amountAOrigin, amountBOrigin];
-    const tokenAPermitParams = (0, viem_1.isAddressEqual)(pool.currencyA.address, (0, viem_1.getAddress)(token0))
-        ? options?.token0PermitParams ?? permit_1.emptyERC20PermitParams
-        : options?.token1PermitParams ?? permit_1.emptyERC20PermitParams;
-    const tokenBPermitParams = (0, viem_1.isAddressEqual)(pool.currencyA.address, (0, viem_1.getAddress)(token0))
-        ? options?.token1PermitParams ?? permit_1.emptyERC20PermitParams
-        : options?.token0PermitParams ?? permit_1.emptyERC20PermitParams;
-    let disableSwap = !!(options && options.disableSwap);
-    if (pool.totalSupply === 0n ||
-        (pool.liquidityA === 0n && pool.liquidityB === 0n)) {
-        disableSwap = true;
-    }
-    const slippageLimitPercent = options?.slippage ?? 1.0;
-    const swapParams = {
-        inCurrency: viem_1.zeroAddress,
-        amount: 0n,
-        data: '0x',
-    };
-    if (!disableSwap) {
-        const currencyBPerCurrencyA = options?.testnetPrice
-            ? (0, viem_1.isAddressEqual)((0, view_1.getQuoteToken)({
-                chainId,
-                token0,
-                token1,
-            }), pool.currencyA.address)
-                ? 1 / Number(options.testnetPrice)
-                : Number(options.testnetPrice)
-            : undefined;
-        const swapAmountA = (0, viem_1.parseUnits)('1', pool.currencyA.decimals);
-        let swapAmountB = -1n;
-        if (options && options.token0Price && options.token1Price) {
-            const tokenAPrice = (0, viem_1.isAddressEqual)(pool.currencyA.address, (0, viem_1.getAddress)(token0))
-                ? options.token0Price
-                : options.token1Price;
-            const tokenBPrice = (0, viem_1.isAddressEqual)(pool.currencyA.address, (0, viem_1.getAddress)(token0))
-                ? options.token1Price
-                : options.token0Price;
-            swapAmountB = (0, quotes_1.quotes)(swapAmountA, tokenAPrice, tokenBPrice, pool.currencyA.decimals, pool.currencyB.decimals);
-        }
-        else {
-            ;
-            ({ amountOut: swapAmountB } = await (0, odos_1.fetchQuote)({
-                chainId,
-                amountIn: swapAmountA,
-                tokenIn: pool.currencyA,
-                tokenOut: pool.currencyB,
-                slippageLimitPercent: 1,
-                userAddress: addresses_1.CONTRACT_ADDRESSES[chainId].Minter,
-                testnetPrice: currencyBPerCurrencyA,
-            }));
-        }
-        if (swapAmountB === -1n) {
-            throw new Error('Failed to fetch quote');
-        }
-        const { deltaA, deltaB } = (0, pool_2.getIdealDelta)(amountA, amountB, pool.liquidityA, pool.liquidityB, swapAmountA, swapAmountB);
-        if (deltaA < 0n) {
-            swapParams.inCurrency = pool.currencyA.address;
-            swapParams.amount = -deltaA;
-            const { amountOut: actualDeltaB, data: calldata } = await (0, odos_1.fetchCallData)({
-                chainId,
-                amountIn: swapParams.amount,
-                tokenIn: pool.currencyA,
-                tokenOut: pool.currencyB,
-                slippageLimitPercent,
-                userAddress: addresses_1.CONTRACT_ADDRESSES[chainId].Minter,
-                testnetPrice: currencyBPerCurrencyA,
-            });
-            swapParams.data = calldata;
-            amountA += deltaA;
-            amountB += actualDeltaB;
-        }
-        else if (deltaB < 0n) {
-            swapParams.inCurrency = pool.currencyB.address;
-            swapParams.amount = -deltaB;
-            const { amountOut: actualDeltaA, data: calldata } = await (0, odos_1.fetchCallData)({
-                chainId,
-                amountIn: swapParams.amount,
-                tokenIn: pool.currencyB,
-                tokenOut: pool.currencyA,
-                slippageLimitPercent,
-                userAddress: addresses_1.CONTRACT_ADDRESSES[chainId].Minter,
-                testnetPrice: currencyBPerCurrencyA
-                    ? 1 / currencyBPerCurrencyA
-                    : undefined,
-            });
-            swapParams.data = calldata;
-            amountA += actualDeltaA;
-            amountB += deltaB;
-        }
-    }
-    const { mintAmount, inAmountA, inAmountB } = (0, pool_2.getExpectedMintResult)(pool.totalSupply, pool.liquidityA, pool.liquidityB, amountA, amountB, pool.currencyA, pool.currencyB);
-    if (mintAmount === 0n) {
-        return {
-            transaction: undefined,
-            result: {
-                currencyA: {
-                    currency: pool.currencyA,
-                    amount: '0',
-                    direction: 'in',
-                },
-                currencyB: {
-                    currency: pool.currencyB,
-                    amount: '0',
-                    direction: 'in',
-                },
-                lpCurrency: {
-                    currency: pool.currencyLp,
-                    amount: '0',
-                    direction: 'out',
-                },
-            },
-        };
-    }
-    const minMintAmount = (0, bigint_1.applyPercent)(mintAmount, 100 - slippageLimitPercent);
-    const transaction = await (0, build_transaction_1.buildTransaction)(publicClient, {
-        chain: chain_1.CHAIN_MAP[chainId],
-        account: userAddress,
-        address: addresses_1.CONTRACT_ADDRESSES[chainId].Minter,
-        abi: minter_abi_1.MINTER_ABI,
-        functionName: 'mint',
-        args: [
-            pool.key,
-            amountAOrigin,
-            amountBOrigin,
-            minMintAmount,
-            {
-                permitAmount: tokenAPermitParams.permitAmount,
-                signature: tokenAPermitParams.signature,
-            },
-            {
-                permitAmount: tokenBPermitParams.permitAmount,
-                signature: tokenBPermitParams.signature,
-            },
-            swapParams,
-        ],
-        value: (0, viem_1.isAddressEqual)(token0, viem_1.zeroAddress)
-            ? amountAOrigin
-            : (0, viem_1.isAddressEqual)(token1, viem_1.zeroAddress)
-                ? amountBOrigin
-                : undefined,
-    }, options?.gasLimit);
-    const currencyARefund = amountA - inAmountA;
-    const currencyBRefund = amountB - inAmountB;
-    const currencyAResultAmount = amountAOrigin - currencyARefund;
-    const currencyBResultAmount = amountBOrigin - currencyBRefund;
-    return {
-        transaction,
-        result: {
-            currencyA: {
-                currency: pool.currencyA,
-                amount: (0, viem_1.formatUnits)((0, math_1.abs)(currencyAResultAmount), pool.currencyA.decimals),
-                direction: currencyAResultAmount >= 0 ? 'in' : 'out',
-            },
-            currencyB: {
-                currency: pool.currencyB,
-                amount: (0, viem_1.formatUnits)((0, math_1.abs)(currencyBResultAmount), pool.currencyB.decimals),
-                direction: currencyBResultAmount >= 0 ? 'in' : 'out',
-            },
-            lpCurrency: {
-                currency: pool.currencyLp,
-                amount: (0, viem_1.formatUnits)(mintAmount, pool.currencyLp.decimals),
-                direction: 'out',
-            },
-        },
-    };
-};
-exports.addLiquidity = addLiquidity;
-const removeLiquidity = async ({ chainId, userAddress, token0, token1, salt, amount, options, }) => {
-    const publicClient = (0, viem_1.createPublicClient)({
-        chain: chain_1.CHAIN_MAP[chainId],
-        transport: options?.rpcUrl ? (0, viem_1.http)(options.rpcUrl) : (0, viem_1.http)(),
-    });
-    const pool = await (0, pool_1.fetchPool)(publicClient, chainId, [token0, token1], salt, !!(options && options.useSubgraph));
-    if (!pool.isOpened) {
-        throw new Error(`
-       Open the pool before removing liquidity.
-       import { openPool } from '@clober/v2-sdk'
-
-       const transaction = await openPool({
-            chainId: ${chainId},
-            tokenA: '${token0}',
-            tokenB: '${token1}',
-            salt: '0x0000000000000000000000000000000000000000000000000000000000000000',
-       })
-    `);
-    }
-    const burnAmount = (0, viem_1.parseUnits)(amount, pool.currencyLp.decimals);
-    const slippageLimitPercent = options?.slippage ?? 2;
-    const withdrawAmountA = (burnAmount * pool.liquidityA) / pool.totalSupply;
-    const withdrawAmountB = (burnAmount * pool.liquidityB) / pool.totalSupply;
-    const minWithdrawAmountA = (0, bigint_1.applyPercent)(withdrawAmountA, 100 - slippageLimitPercent);
-    const minWithdrawAmountB = (0, bigint_1.applyPercent)(withdrawAmountB, 100 - slippageLimitPercent);
-    if (burnAmount === 0n) {
-        return {
-            transaction: undefined,
-            result: {
-                currencyA: {
-                    currency: pool.currencyA,
-                    amount: '0',
-                    direction: 'out',
-                },
-                currencyB: {
-                    currency: pool.currencyB,
-                    amount: '0',
-                    direction: 'out',
-                },
-                lpCurrency: {
-                    currency: pool.currencyLp,
-                    amount: '0',
-                    direction: 'in',
-                },
-            },
-        };
-    }
-    const transaction = await (0, build_transaction_1.buildTransaction)(publicClient, {
-        chain: chain_1.CHAIN_MAP[chainId],
-        account: userAddress,
-        address: addresses_1.CONTRACT_ADDRESSES[chainId].Rebalancer,
-        abi: rebalancer_abi_1.REBALANCER_ABI,
-        functionName: 'burn',
-        args: [pool.key, burnAmount, minWithdrawAmountA, minWithdrawAmountB],
-    }, options?.gasLimit);
-    return {
-        transaction,
-        result: {
-            currencyA: {
-                currency: pool.currencyA,
-                amount: (0, viem_1.formatUnits)(withdrawAmountA, pool.currencyA.decimals),
-                direction: 'out',
-            },
-            currencyB: {
-                currency: pool.currencyB,
-                amount: (0, viem_1.formatUnits)(withdrawAmountB, pool.currencyB.decimals),
-                direction: 'out',
-            },
-            lpCurrency: {
-                currency: pool.currencyLp,
-                amount: amount,
-                direction: 'in',
-            },
-        },
-    };
-};
-exports.removeLiquidity = removeLiquidity;
-const refillOrder = async ({ chainId, userAddress, token0, token1, salt, options, }) => {
-    const publicClient = (0, viem_1.createPublicClient)({
-        chain: chain_1.CHAIN_MAP[chainId],
-        transport: options?.rpcUrl ? (0, viem_1.http)(options.rpcUrl) : (0, viem_1.http)(),
-    });
-    const pool = options?.pool
-        ? options.pool
-        : (await (0, pool_1.fetchPool)(publicClient, chainId, [token0, token1], salt, !!(options && options.useSubgraph))).toJson();
-    if (!pool.isOpened) {
-        throw new Error(`
-       Open the pool before rebalancing pool.
-       import { openPool } from '@clober/v2-sdk'
-
-       const transaction = await openPool({
-            chainId: ${chainId},
-            tokenA: '${token0}',
-            tokenB: '${token1}',
-            salt: '0x0000000000000000000000000000000000000000000000000000000000000000',
-       })
-    `);
-    }
-    return (0, build_transaction_1.buildTransaction)(publicClient, {
-        chain: chain_1.CHAIN_MAP[chainId],
-        account: userAddress,
-        address: addresses_1.CONTRACT_ADDRESSES[chainId].Rebalancer,
-        abi: rebalancer_abi_1.REBALANCER_ABI,
-        functionName: 'rebalance',
-        args: [pool.key],
-    }, options?.gasLimit, options?.gasPriceLimit);
-};
-exports.refillOrder = refillOrder;
-const adjustOrderPrice = async ({ chainId, userAddress, token0, token1, salt, oraclePrice, bidPrice, askPrice, alpha, options, }) => {
-    if (Number(alpha) <= 0 || Number(alpha) > 1) {
-        throw new Error('Alpha value must be in the range (0, 1]');
-    }
-    if (Number(bidPrice) <= 0 || Number(askPrice) <= 0) {
-        throw new Error('Price must be greater than 0');
-    }
-    if (Number(bidPrice) >= Number(askPrice)) {
-        throw new Error('Bid price must be less than ask price');
-    }
-    const publicClient = (0, viem_1.createPublicClient)({
-        chain: chain_1.CHAIN_MAP[chainId],
-        transport: options?.rpcUrl ? (0, viem_1.http)(options.rpcUrl) : (0, viem_1.http)(),
-    });
-    const pool = options?.pool
-        ? options.pool
-        : (await (0, pool_1.fetchPool)(publicClient, chainId, [token0, token1], salt, !!(options && options.useSubgraph))).toJson();
-    if (!pool.isOpened) {
-        throw new Error(`
-       Open the pool before updating strategy price.
-       import { openPool } from '@clober/v2-sdk'
-
-       const transaction = await openPool({
-            chainId: ${chainId},
-            tokenA: '${token0}',
-            tokenB: '${token1}',
-            salt: '0x0000000000000000000000000000000000000000000000000000000000000000',
-       })
-    `);
-    }
-    const [roundingUpBidPrice, roundingUpAskPrice] = [
-        options?.roundingUpBidPrice ? options.roundingUpBidPrice : false,
-        options?.roundingUpAskPrice ? options.roundingUpAskPrice : false,
-    ];
-    const { roundingDownTick: roundingDownTickA, roundingUpTick: roundingUpTickA, } = (0, prices_1.parsePrice)(Number(bidPrice), pool.currencyA.decimals, pool.currencyB.decimals);
-    const { roundingDownTick: roundingDownTickB, roundingUpTick: roundingUpTickB, } = (0, prices_1.parsePrice)(Number(askPrice), pool.currencyA.decimals, pool.currencyB.decimals);
-    const oracleRawPrice = (0, prices_1.convertHumanReadablePriceToRawPrice)(Number(oraclePrice), pool.currencyA.decimals, pool.currencyB.decimals);
-    const tickA = options?.bidTick
-        ? Number(options.bidTick)
-        : Number(roundingUpBidPrice ? roundingUpTickA : roundingDownTickA);
-    let tickB = options?.askTick
-        ? Number(options.askTick)
-        : Number((0, tick_1.invertTick)(roundingUpAskPrice ? roundingUpTickB : roundingDownTickB));
-    if ((0, tick_1.invertTick)(BigInt(tickB)) <= BigInt(tickA)) {
-        tickB = Number((0, tick_1.invertTick)(BigInt(tickA + 1)));
-    }
-    const rateRaw = (0, viem_1.parseUnits)(alpha, 6);
-    return (0, build_transaction_1.buildTransaction)(publicClient, {
-        chain: chain_1.CHAIN_MAP[chainId],
-        account: userAddress,
-        address: addresses_1.CONTRACT_ADDRESSES[chainId].Operator,
-        abi: operator_abi_1.OPERATOR_ABI,
-        functionName: 'updatePosition',
-        args: [pool.key, oracleRawPrice, tickA, tickB, rateRaw],
-    }, options?.gasLimit, options?.gasPriceLimit);
-};
-exports.adjustOrderPrice = adjustOrderPrice;
-const setStrategyConfig = async ({ chainId, userAddress, token0, token1, salt, config, options, }) => {
-    if (Number(config.referenceThreshold) < 0 ||
-        Number(config.referenceThreshold) > 1) {
-        throw new Error('Reference threshold must be in the range [0, 1]');
-    }
-    if (Number(config.rebalanceThreshold) < 0 ||
-        Number(config.rebalanceThreshold) > 1) {
-        throw new Error('Rebalance threshold must be in the range [0, 1]');
-    }
-    if (Number(config.priceThresholdA) < 0 ||
-        Number(config.priceThresholdA) > 1 ||
-        Number(config.priceThresholdB) < 0 ||
-        Number(config.priceThresholdB) > 1) {
-        throw new Error('Price threshold must be in the range [0, 1]');
-    }
-    if (Number(config.rateA) < 0 ||
-        Number(config.rateA) > 1 ||
-        Number(config.rateB) < 0 ||
-        Number(config.rateB) > 1) {
-        throw new Error('Rate must be in the range [0, 1]');
-    }
-    if (Number(config.minRateA) < 0 ||
-        Number(config.minRateA) > 1 ||
-        Number(config.minRateB) < 0 ||
-        Number(config.minRateB) > 1) {
-        throw new Error('Min rate must be in the range [0, 1]');
-    }
-    if (Number(config.minRateA) > Number(config.rateA) ||
-        Number(config.minRateB) > Number(config.rateB)) {
-        throw new Error('Min rate must be less or equal to rate');
-    }
-    const publicClient = (0, viem_1.createPublicClient)({
-        chain: chain_1.CHAIN_MAP[chainId],
-        transport: options?.rpcUrl ? (0, viem_1.http)(options.rpcUrl) : (0, viem_1.http)(),
-    });
-    const pool = await (0, pool_1.fetchPool)(publicClient, chainId, [token0, token1], salt, !!(options && options.useSubgraph));
-    if (!pool.isOpened) {
-        throw new Error(`
-       Open the pool before set strategy config.
-       import { openPool } from '@clober/v2-sdk'
-
-       const transaction = await openPool({
-            chainId: ${chainId},
-            tokenA: '${token0}',
-            tokenB: '${token1}',
-       })
-    `);
-    }
-    const configRaw = {
-        referenceThreshold: (0, viem_1.parseUnits)(config.referenceThreshold, 6),
-        rebalanceThreshold: (0, viem_1.parseUnits)(config.rebalanceThreshold, 6),
-        rateA: (0, viem_1.parseUnits)(config.rateA, 6),
-        rateB: (0, viem_1.parseUnits)(config.rateB, 6),
-        minRateA: (0, viem_1.parseUnits)(config.minRateA, 6),
-        minRateB: (0, viem_1.parseUnits)(config.minRateB, 6),
-        priceThresholdA: (0, viem_1.parseUnits)(config.priceThresholdA, 6),
-        priceThresholdB: (0, viem_1.parseUnits)(config.priceThresholdB, 6),
-    };
-    return (0, build_transaction_1.buildTransaction)(publicClient, {
-        chain: chain_1.CHAIN_MAP[chainId],
-        account: userAddress,
-        address: addresses_1.CONTRACT_ADDRESSES[chainId].Strategy,
-        abi: strategy_abi_1.STRATEGY_ABI,
-        functionName: 'setConfig',
-        args: [pool.key, configRaw],
-    }, options?.gasLimit);
-};
-exports.setStrategyConfig = setStrategyConfig;
-const pausePool = async ({ chainId, userAddress, token0, token1, salt, options, }) => {
-    const publicClient = (0, viem_1.createPublicClient)({
-        chain: chain_1.CHAIN_MAP[chainId],
-        transport: options?.rpcUrl ? (0, viem_1.http)(options.rpcUrl) : (0, viem_1.http)(),
-    });
-    const pool = options?.pool
-        ? options.pool
-        : (await (0, pool_1.fetchPool)(publicClient, chainId, [token0, token1], salt, !!(options && options.useSubgraph))).toJson();
-    if (!pool.isOpened) {
-        throw new Error(`
-       Open the pool before trying pause.
-       import { openPool } from '@clober/v2-sdk'
-
-       const transaction = await openPool({
-            chainId: ${chainId},
-            tokenA: '${token0}',
-            tokenB: '${token1}',
-            salt: '0x0000000000000000000000000000000000000000000000000000000000000000',
-       })
-    `);
-    }
-    if (pool.paused) {
-        return undefined;
-    }
-    return (0, build_transaction_1.buildTransaction)(publicClient, {
-        chain: chain_1.CHAIN_MAP[chainId],
-        account: userAddress,
-        address: addresses_1.CONTRACT_ADDRESSES[chainId].Operator,
-        abi: operator_abi_1.OPERATOR_ABI,
-        functionName: 'pause',
-        args: [pool.key],
-    }, options?.gasLimit, options?.gasPriceLimit);
-};
-exports.pausePool = pausePool;
-const resumePool = async ({ chainId, userAddress, token0, token1, salt, options, }) => {
-    const publicClient = (0, viem_1.createPublicClient)({
-        chain: chain_1.CHAIN_MAP[chainId],
-        transport: options?.rpcUrl ? (0, viem_1.http)(options.rpcUrl) : (0, viem_1.http)(),
-    });
-    const pool = options?.pool
-        ? options.pool
-        : (await (0, pool_1.fetchPool)(publicClient, chainId, [token0, token1], salt, !!(options && options.useSubgraph))).toJson();
-    if (!pool.isOpened) {
-        throw new Error(`
-       Open the pool before trying resume.
-       import { openPool } from '@clober/v2-sdk'
-
-       const transaction = await openPool({
-            chainId: ${chainId},
-            tokenA: '${token0}',
-            tokenB: '${token1}',
-            salt: '0x0000000000000000000000000000000000000000000000000000000000000000',
-       })
-    `);
-    }
-    if (!pool.paused) {
-        return undefined;
-    }
-    return (0, build_transaction_1.buildTransaction)(publicClient, {
-        chain: chain_1.CHAIN_MAP[chainId],
-        account: userAddress,
-        address: addresses_1.CONTRACT_ADDRESSES[chainId].Strategy,
-        abi: strategy_abi_1.STRATEGY_ABI,
-        functionName: 'unpause',
-        args: [pool.key],
-    }, options?.gasLimit, options?.gasPriceLimit);
-};
-exports.resumePool = resumePool;
-//# sourceMappingURL=call.js.map