@clober/v2-sdk 0.0.11 → 0.0.12-8.dev.0

package/dist/cjs/call.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.cancelOrders = exports.cancelOrder = exports.claimOrders = exports.claimOrder = exports.marketOrder = exports.limitOrder = exports.openMarket = void 0;
+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_1 = require("./utils/unit");
+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");
@@ -15,17 +15,34 @@ 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 decorator_1 = require("./utils/decorator");
 const order_1 = require("./utils/order");
-const decimals_1 = require("./utils/decimals");
 const bigint_1 = require("./utils/bigint");
-exports.openMarket = (0, decorator_1.decorator)(async ({ chainId, inputToken, outputToken, options, }) => {
-    const market = await (0, market_1.fetchMarket)(chainId, [inputToken, outputToken]);
+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.bidBookOpen) || (!isBid && !market.askBookOpen)) {
-        const unit = await (0, unit_1.calculateUnit)(chainId, isBid ? market.quote : market.base);
-        return (0, build_transaction_1.buildTransaction)(chainId, {
+    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: [
@@ -33,11 +50,11 @@ exports.openMarket = (0, decorator_1.decorator)(async ({ chainId, inputToken, ou
                     {
                         key: {
                             base: outputToken,
-                            unit,
+                            unitSize,
                             quote: inputToken,
-                            makerPolicy: fee_1.MAKER_DEFAULT_POLICY.value,
+                            makerPolicy: fee_1.MAKER_DEFAULT_POLICY[chainId].value,
                             hooks: viem_1.zeroAddress,
-                            takerPolicy: fee_1.TAKER_DEFAULT_POLICY.value,
+                            takerPolicy: fee_1.TAKER_DEFAULT_POLICY[chainId].value,
                         },
                         hookData: viem_1.zeroHash,
                     },
@@ -47,14 +64,26 @@ exports.openMarket = (0, decorator_1.decorator)(async ({ chainId, inputToken, ou
         }, options?.gasLimit);
     }
     return undefined;
-});
-exports.limitOrder = (0, decorator_1.decorator)(async ({ chainId, userAddress, inputToken, outputToken, amount, price, options, }) => {
-    const market = await (0, market_1.fetchMarket)(chainId, [inputToken, outputToken]);
+};
+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.bidBookOpen) || (!isBid && !market.askBookOpen)) {
+    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'
@@ -66,33 +95,36 @@ exports.limitOrder = (0, decorator_1.decorator)(async ({ chainId, userAddress, i
        })
     `);
     }
-    const rawPrice = (0, prices_1.parsePrice)(Number(price), market.quote.decimals, market.base.decimals);
-    const tick = isBid ? (0, tick_1.fromPrice)(rawPrice) : (0, tick_1.fromPrice)((0, tick_1.invertPrice)(rawPrice));
+    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 [unit, { spendAmount, bookId }] = await Promise.all([
-        (0, unit_1.calculateUnit)(chainId, inputCurrency),
-        (0, view_1.getExpectedOutput)({
-            chainId,
-            inputToken,
-            outputToken,
-            amountIn: amount,
-            options: {
-                ...options,
-                limitPrice: price,
-            },
-        }),
-    ]);
+    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)(inputToken, outputToken, unit),
-        tick: Number(tick),
+        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 || spendAmount === '0') {
+    if (options?.postOnly === true || spentAmount === '0') {
         return {
-            transaction: await (0, build_transaction_1.buildTransaction)(chainId, {
+            transaction: await (0, build_transaction_1.buildTransaction)(publicClient, {
                 chain: chain_1.CHAIN_MAP[chainId],
                 account: userAddress,
                 address: addresses_1.CONTRACT_ADDRESSES[chainId].Controller,
@@ -111,18 +143,28 @@ exports.limitOrder = (0, decorator_1.decorator)(async ({ chainId, userAddress, i
                     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),
                 },
-                take: {
+                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)(chainId, {
+            transaction: await (0, build_transaction_1.buildTransaction)(publicClient, {
                 chain: chain_1.CHAIN_MAP[chainId],
                 account: userAddress,
                 address: addresses_1.CONTRACT_ADDRESSES[chainId].Controller,
@@ -133,7 +175,15 @@ exports.limitOrder = (0, decorator_1.decorator)(async ({ chainId, userAddress, i
                         {
                             takeBookId: bookId,
                             makeBookId: makeParam.id,
-                            limitPrice: isBid ? (0, tick_1.invertPrice)(rawPrice) : rawPrice,
+                            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,
@@ -148,27 +198,54 @@ exports.limitOrder = (0, decorator_1.decorator)(async ({ chainId, userAddress, i
             }, options?.gasLimit),
             result: {
                 make: {
-                    amount: (0, viem_1.formatUnits)(quoteAmount, inputCurrency.decimals),
+                    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),
                 },
-                take: {
-                    amount: spendAmount,
+                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.marketOrder = (0, decorator_1.decorator)(async ({ chainId, userAddress, inputToken, outputToken, amountIn, amountOut, options, }) => {
-    const market = await (0, market_1.fetchMarket)(chainId, [inputToken, outputToken]);
+};
+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.bidBookOpen) ||
-        (!isTakingBid && !market.askBookOpen)) {
+    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'
@@ -183,7 +260,7 @@ exports.marketOrder = (0, decorator_1.decorator)(async ({ chainId, userAddress,
     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, spendAmount } = await (0, view_1.getExpectedOutput)({
+        const { bookId, takenAmount, spentAmount, events } = await (0, view_1.getExpectedOutput)({
             chainId,
             inputToken,
             outputToken,
@@ -194,7 +271,7 @@ exports.marketOrder = (0, decorator_1.decorator)(async ({ chainId, userAddress,
         });
         const baseAmount = (0, viem_1.parseUnits)(amountIn, inputCurrency.decimals);
         return {
-            transaction: await (0, build_transaction_1.buildTransaction)(chainId, {
+            transaction: await (0, build_transaction_1.buildTransaction)(publicClient, {
                 chain: chain_1.CHAIN_MAP[chainId],
                 account: userAddress,
                 address: addresses_1.CONTRACT_ADDRESSES[chainId].Controller,
@@ -219,21 +296,29 @@ exports.marketOrder = (0, decorator_1.decorator)(async ({ chainId, userAddress,
                 value: isETH ? baseAmount : 0n,
             }, options?.gasLimit),
             result: {
-                spend: {
-                    amount: spendAmount,
+                spent: {
+                    amount: spentAmount,
                     currency: inputCurrency,
                     direction: 'in',
+                    events: events.map(({ price, spentAmount }) => ({
+                        price,
+                        amount: spentAmount,
+                    })),
                 },
-                take: {
+                taken: {
                     amount: takenAmount,
                     currency: outputCurrency,
                     direction: 'out',
+                    events: events.map(({ price, takenAmount }) => ({
+                        price,
+                        amount: takenAmount,
+                    })),
                 },
             },
         };
     }
-    else if (amountIn && amountOut) {
-        const { bookId, spendAmount, takenAmount } = await (0, view_1.getExpectedInput)({
+    else if (!amountIn && amountOut) {
+        const { bookId, spentAmount, takenAmount, events } = await (0, view_1.getExpectedInput)({
             chainId,
             inputToken,
             outputToken,
@@ -243,9 +328,15 @@ exports.marketOrder = (0, decorator_1.decorator)(async ({ chainId, userAddress,
             },
         });
         const quoteAmount = (0, viem_1.parseUnits)(amountOut, outputCurrency.decimals);
-        const baseAmount = (0, viem_1.parseUnits)(amountIn ?? spendAmount, inputCurrency.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)(chainId, {
+            transaction: await (0, build_transaction_1.buildTransaction)(publicClient, {
                 chain: chain_1.CHAIN_MAP[chainId],
                 account: userAddress,
                 address: addresses_1.CONTRACT_ADDRESSES[chainId].Controller,
@@ -257,9 +348,7 @@ exports.marketOrder = (0, decorator_1.decorator)(async ({ chainId, userAddress,
                             id: bookId,
                             limitPrice: 0n,
                             quoteAmount,
-                            maxBaseAmount: options?.slippage
-                                ? (0, bigint_1.applyPercent)(baseAmount, 100 + options.slippage)
-                                : 2n ** 256n - 1n,
+                            maxBaseAmount,
                             hookData: viem_1.zeroHash,
                         },
                     ],
@@ -267,18 +356,26 @@ exports.marketOrder = (0, decorator_1.decorator)(async ({ chainId, userAddress,
                     options?.erc20PermitParam ? [options.erc20PermitParam] : [],
                     (0, time_1.getDeadlineTimestampInSeconds)(),
                 ],
-                value: isETH ? baseAmount : 0n,
+                value: isETH ? maxBaseAmount : 0n,
             }, options?.gasLimit),
             result: {
-                spend: {
-                    amount: spendAmount,
+                spent: {
+                    amount: spentAmount,
                     currency: inputCurrency,
                     direction: 'in',
+                    events: events.map(({ price, spentAmount }) => ({
+                        price,
+                        amount: spentAmount,
+                    })),
                 },
-                take: {
+                taken: {
                     amount: takenAmount,
                     currency: outputCurrency,
                     direction: 'out',
+                    events: events.map(({ price, takenAmount }) => ({
+                        price,
+                        amount: takenAmount,
+                    })),
                 },
             },
         };
@@ -286,8 +383,9 @@ exports.marketOrder = (0, decorator_1.decorator)(async ({ chainId, userAddress,
     else {
         throw new Error('Either amountIn or amountOut must be provided');
     }
-});
-exports.claimOrder = (0, decorator_1.decorator)(async ({ chainId, userAddress, id, options, }) => {
+};
+exports.marketOrder = marketOrder;
+const claimOrder = async ({ chainId, userAddress, id, options, }) => {
     const { transaction, result } = await (0, exports.claimOrders)({
         chainId,
         userAddress,
@@ -298,9 +396,14 @@ exports.claimOrder = (0, decorator_1.decorator)(async ({ chainId, userAddress, i
         transaction,
         result: result[0],
     };
-});
-exports.claimOrders = (0, decorator_1.decorator)(async ({ chainId, userAddress, ids, options, }) => {
-    const isApprovedForAll = await (0, approval_1.fetchIsApprovedForAll)(chainId, userAddress);
+};
+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.
@@ -312,22 +415,25 @@ exports.claimOrders = (0, decorator_1.decorator)(async ({ chainId, userAddress,
        })
     `);
     }
-    const orders = (await (0, order_1.fetchOrders)(chainId, ids.map((id) => BigInt(id)))).filter((order) => (0, viem_1.isAddressEqual)(order.owner, userAddress) && order.claimable > 0n);
+    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.baseCurrency.address, order.quoteCurrency.address])
+        .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)(chainId, {
+        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(({ orderId }) => ({
-                    id: orderId,
+                orders.map(({ id }) => ({
+                    id,
                     hookData: viem_1.zeroHash,
                 })),
                 tokensToSettle,
@@ -335,25 +441,18 @@ exports.claimOrders = (0, decorator_1.decorator)(async ({ chainId, userAddress,
                 (0, time_1.getDeadlineTimestampInSeconds)(),
             ],
         }, options?.gasLimit),
-        result: orders
-            .map((order) => {
-            const amount = (0, decimals_1.quoteToBase)(order.tick, order.unit * order.claimable, false);
-            return {
-                currency: order.baseCurrency,
-                amount: (0, viem_1.formatUnits)(amount, order.baseCurrency.decimals),
-            };
-        })
-            .reduce((acc, { currency, amount }) => {
+        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, direction: 'out' }];
+                return [...acc, { currency, amount: value, direction: 'out' }];
             }
-            acc[index].amount = (Number(acc[index].amount) + Number(amount)).toString();
+            acc[index].amount = (Number(acc[index].amount) + Number(value)).toString();
             return acc;
         }, []),
     };
-});
-exports.cancelOrder = (0, decorator_1.decorator)(async ({ chainId, userAddress, id, options, }) => {
+};
+exports.claimOrders = claimOrders;
+const cancelOrder = async ({ chainId, userAddress, id, options, }) => {
     const { transaction, result } = await (0, exports.cancelOrders)({
         chainId,
         userAddress,
@@ -364,9 +463,14 @@ exports.cancelOrder = (0, decorator_1.decorator)(async ({ chainId, userAddress,
         transaction,
         result: result[0],
     };
-});
-exports.cancelOrders = (0, decorator_1.decorator)(async ({ chainId, userAddress, ids, options, }) => {
-    const isApprovedForAll = await (0, approval_1.fetchIsApprovedForAll)(chainId, userAddress);
+};
+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.
@@ -378,22 +482,25 @@ exports.cancelOrders = (0, decorator_1.decorator)(async ({ chainId, userAddress,
        })
     `);
     }
-    const orders = (await (0, order_1.fetchOrders)(chainId, ids.map((id) => BigInt(id)))).filter((order) => (0, viem_1.isAddressEqual)(order.owner, userAddress) && order.open > 0n);
+    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.baseCurrency.address, order.quoteCurrency.address])
+        .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)(chainId, {
+        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(({ orderId }) => ({
-                    id: orderId,
+                orders.map(({ id }) => ({
+                    id,
                     leftQuoteAmount: 0n,
                     hookData: viem_1.zeroHash,
                 })),
@@ -402,24 +509,549 @@ exports.cancelOrders = (0, decorator_1.decorator)(async ({ chainId, userAddress,
                 (0, time_1.getDeadlineTimestampInSeconds)(),
             ],
         }, options?.gasLimit),
-        result: orders
-            .map((order) => {
-            const amount = (0, bigint_1.applyPercent)(order.unit * order.open, 100 +
-                (Number(fee_1.MAKER_DEFAULT_POLICY.rate) * 100) /
-                    Number(fee_1.MAKER_DEFAULT_POLICY.RATE_PRECISION), 6);
-            return {
-                currency: order.quoteCurrency,
-                amount: (0, viem_1.formatUnits)(amount, order.quoteCurrency.decimals),
-            };
-        })
-            .reduce((acc, { currency, amount }) => {
+        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, direction: 'out' }];
+                return [...acc, { currency, amount: value, direction: 'out' }];
             }
-            acc[index].amount = (Number(acc[index].amount) + Number(amount)).toString();
+            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