@clober/v2-sdk 0.0.7 → 0.0.9-6.dev

package/dist/esm/view.js

@@ -1,18 +1,60 @@
-import { formatUnits, isAddressEqual, parseUnits } from 'viem';
+import { createPublicClient, formatUnits, getAddress, http, isAddressEqual, parseUnits, } from 'viem';
 import { fetchMarket } from './apis/market';
-import { parsePrice } from './utils/prices';
-import { MAX_PRICE } from './constants/price';
-import { fetchOpenOrder, fetchOpenOrders } from './apis/open-order';
-import { decorator } from './utils/decorator';
-import { fetchChartLogs, fetchLatestChartLog } from './apis/chart-logs';
+import { CHAIN_MAP } from './constants/chain';
+import { formatPrice, parsePrice } from './utils/prices';
+import { fetchOpenOrder, fetchOpenOrdersByUserAddress } from './apis/open-order';
+import { CHART_LOG_INTERVAL_TIMESTAMP, fetchChartLogs, fetchLatestChartLog, } from './apis/chart-logs';
+import { getMarketId } from './utils/market';
+import { CONTRACT_ADDRESSES } from './constants/addresses';
+import { invertTick, toPrice } from './utils/tick';
+import { MAX_TICK, MIN_TICK } from './constants/tick';
+import { fetchPool, fetchPoolPerformance } from './apis/pool';
+import { fetchLastRawAmounts, fetchStrategyPosition } from './apis/strategy';
+import { Subgraph } from './constants/subgraph';
+import { fillAndSortByTimestamp } from './utils/time-series';
+import { fetchVCLOBList } from './apis/vclob';
+import { ELECTION_GOVERNOR_ABI } from './abis/governance/election-governor-abi';
+import { VCLOB_ABI } from './abis/governance/vclob-abi';
+import { KEEPERS_REGISTRY_ABI } from './abis/governance/keepers-registry-abi';
+import { MAKER_DEFAULT_POLICY, TAKER_DEFAULT_POLICY } from './constants/fee';
+/**
+ * Get contract addresses by chain id
+ * @param chainId - chain id from {@link CHAIN_IDS}
+ * @returns Contract addresses
+ *
+ * @example
+ * import { getContractAddresses } from '@clober/v2-sdk'
+ *
+ * const addresses = await getContractAddresses({
+ *   chainId: 421614,
+ * })
+ */
+export const getContractAddresses = ({ chainId }) => {
+    return CONTRACT_ADDRESSES[chainId];
+};
+/**
+ * Get subgraph block number by chain id
+ * @param chainId - chain id from {@link CHAIN_IDS}
+ * @returns Contract addresses
+ *
+ * @example
+ * import { getContractAddresses } from '@clober/v2-sdk'
+ *
+ * const blockNumber = await getSubgraphBlockNumber({
+ *   chainId: 421614,
+ * })
+ */
+export const getSubgraphBlockNumber = async ({ chainId, }) => {
+    const { data: { latestBlock: { blockNumber }, }, } = await Subgraph.get(chainId, 'getLatestBlockNumber', 'query getLatestBlockNumber { latestBlock(id: "latest") { blockNumber } }', {});
+    return Number(blockNumber);
+};
 /**
  * Get market information by chain id and token addresses
  * @param chainId - chain id from {@link CHAIN_IDS}
  * @param token0 - token0 address
  * @param token1 - token1 address
- * @param options
+ * @param options {@link DefaultReadContractOptions} options.
  * @param options.n - number of depth levels to fetch
- * @param options.rpcUrl - RPC URL of the blockchain
  * @returns A market {@link Market}
  *
  * @example
@@ -24,23 +66,391 @@ import { fetchChartLogs, fetchLatestChartLog } from './apis/chart-logs';
  *   token1: '0x0000000000000000000000000000000000000000',
  * })
  */
-export const getMarket = decorator(async ({ chainId, token0, token1, options, }) => {
+export const getMarket = async ({ chainId, token0, token1, options, }) => {
     if (isAddressEqual(token0, token1)) {
         throw new Error('Token0 and token1 must be different');
     }
-    const market = await fetchMarket(chainId, [token0, token1], options?.n);
+    const publicClient = createPublicClient({
+        chain: CHAIN_MAP[chainId],
+        transport: options?.rpcUrl ? http(options.rpcUrl) : http(),
+    });
+    const market = await fetchMarket(publicClient, chainId, [token0, token1], options && options.makerFeePolicy
+        ? options.makerFeePolicy
+        : MAKER_DEFAULT_POLICY[chainId], options && options.takerFeePolicy
+        ? options.takerFeePolicy
+        : MAKER_DEFAULT_POLICY[chainId], !!(options && options.useSubgraph), options?.n);
+    return market.toJson();
+};
+/**
+ * Get pool information by chain id and token addresses
+ * @param chainId - chain id from {@link CHAIN_IDS}
+ * @param token0 - token0 address
+ * @param token1 - token1 address
+ * @param salt - salt for the pool
+ * @param options {@link DefaultReadContractOptions} options.
+ * @param options.n - number of depth levels to fetch
+ * @returns A pool {@link Pool}
+ *
+ * @example
+ * import { getPool } from '@clober/v2-sdk'
+ *
+ * const market = await getPool({
+ *   chainId: 421614,
+ *   token0: '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+ *   token1: '0x0000000000000000000000000000000000000000',
+ *   salt: '0x0000000000000000000000000000000000000000000000000000000000000000',
+ * })
+ */
+export const getPool = async ({ chainId, token0, token1, salt, options, }) => {
+    if (isAddressEqual(token0, token1)) {
+        throw new Error('Token0 and token1 must be different');
+    }
+    const publicClient = createPublicClient({
+        chain: CHAIN_MAP[chainId],
+        transport: options?.rpcUrl ? http(options.rpcUrl) : http(),
+    });
+    const pool = await fetchPool(publicClient, chainId, [token0, token1], salt, !!(options && options.useSubgraph), options?.market);
+    return pool.toJson();
+};
+export const getPoolPerformance = async ({ chainId, token0, token1, salt, volumeFromTimestamp, volumeToTimestamp, snapshotFromTimestamp, snapshotToTimestamp, snapshotIntervalType, spreadProfitFromTimestamp, spreadProfitToTimestamp, options, }) => {
+    if (isAddressEqual(token0, token1)) {
+        throw new Error('Token0 and token1 must be different');
+    }
+    if (!options?.useSubgraph) {
+        throw new Error('useSubgraph must be true');
+    }
+    let pool;
+    if (options?.pool) {
+        pool = options.pool;
+    }
+    else {
+        const publicClient = createPublicClient({
+            chain: CHAIN_MAP[chainId],
+            transport: options?.rpcUrl ? http(options.rpcUrl) : http(),
+        });
+        pool = (await fetchPool(publicClient, chainId, [token0, token1], salt, !!(options && options.useSubgraph), undefined)).toJson();
+    }
+    const poolPerformance = await fetchPoolPerformance(chainId, pool.key, volumeFromTimestamp, snapshotFromTimestamp, snapshotIntervalType, spreadProfitFromTimestamp);
+    const poolVolumes = fillAndSortByTimestamp(poolPerformance.poolVolumes, 300, volumeFromTimestamp, volumeToTimestamp, (timestamp) => {
+        const emptyPoolVolume = {
+            id: '',
+            poolKey: pool.key,
+            intervalType: '5m',
+            timestamp: BigInt(timestamp),
+            currencyAVolume: 0n,
+            currencyBVolume: 0n,
+            bookACurrencyAVolume: 0n,
+            bookACurrencyBVolume: 0n,
+            bookBCurrencyAVolume: 0n,
+            bookBCurrencyBVolume: 0n,
+        };
+        return emptyPoolVolume;
+    });
+    const poolSnapshots = fillAndSortByTimestamp(poolPerformance.poolSnapshots, CHART_LOG_INTERVAL_TIMESTAMP[snapshotIntervalType], snapshotFromTimestamp, snapshotToTimestamp, (timestamp, prev) => {
+        const emptyPoolSnapshot = {
+            id: '',
+            poolKey: pool.key,
+            intervalType: snapshotIntervalType,
+            timestamp: BigInt(timestamp),
+            price: prev ? prev.price : 0n,
+            liquidityA: prev ? prev.liquidityA : 0n,
+            liquidityB: prev ? prev.liquidityB : 0n,
+            totalSupply: prev ? prev.totalSupply : 0n,
+        };
+        return emptyPoolSnapshot;
+    });
+    const poolSpreadProfits = fillAndSortByTimestamp(poolPerformance.poolSpreadProfits, 300, spreadProfitFromTimestamp, spreadProfitToTimestamp, (timestamp) => {
+        const emptyPoolSpreadProfit = {
+            id: '',
+            intervalType: '5m',
+            timestamp: BigInt(timestamp),
+            accumulatedProfitInUsd: '0',
+        };
+        return emptyPoolSpreadProfit;
+    });
     return {
+        poolVolumes: poolVolumes.map((poolVolume) => ({
+            poolKey: poolVolume.poolKey,
+            intervalType: poolVolume.intervalType,
+            timestamp: Number(poolVolume.timestamp),
+            currencyAVolume: {
+                currency: pool.currencyA,
+                value: formatUnits(poolVolume.currencyAVolume, pool.currencyA.decimals),
+            },
+            currencyBVolume: {
+                currency: pool.currencyB,
+                value: formatUnits(poolVolume.currencyBVolume, pool.currencyB.decimals),
+            },
+        })),
+        poolSnapshots: poolSnapshots.map((poolSnapshot) => ({
+            poolKey: poolSnapshot.poolKey,
+            intervalType: poolSnapshot.intervalType,
+            timestamp: Number(poolSnapshot.timestamp),
+            price: formatUnits(poolSnapshot.price, 18),
+            liquidityA: {
+                currency: pool.currencyA,
+                value: formatUnits(poolSnapshot.liquidityA, pool.currencyA.decimals),
+            },
+            liquidityB: {
+                currency: pool.currencyB,
+                value: formatUnits(poolSnapshot.liquidityB, pool.currencyB.decimals),
+            },
+            totalSupply: {
+                currency: pool.currencyLp,
+                value: formatUnits(poolSnapshot.totalSupply, pool.currencyLp.decimals),
+            },
+        })),
+        poolSpreadProfits: poolSpreadProfits.map((poolSpreadProfit) => ({
+            intervalType: poolSpreadProfit.intervalType,
+            timestamp: Number(poolSpreadProfit.timestamp),
+            accumulatedProfitInUsd: poolSpreadProfit.accumulatedProfitInUsd,
+        })),
+    };
+};
+export const getStrategyPrice = async ({ chainId, token0, token1, salt, options, }) => {
+    if (isAddressEqual(token0, token1)) {
+        throw new Error('Token0 and token1 must be different');
+    }
+    const publicClient = createPublicClient({
+        chain: CHAIN_MAP[chainId],
+        transport: options?.rpcUrl ? http(options.rpcUrl) : http(),
+    });
+    return fetchStrategyPosition(publicClient, chainId, [token0, token1], salt, !!(options && options.useSubgraph), options?.market);
+};
+export const getLastRawAmounts = async ({ chainId, token0, token1, salt, options, }) => {
+    if (isAddressEqual(token0, token1)) {
+        throw new Error('Token0 and token1 must be different');
+    }
+    const publicClient = createPublicClient({
+        chain: CHAIN_MAP[chainId],
+        transport: options?.rpcUrl ? http(options.rpcUrl) : http(),
+    });
+    return fetchLastRawAmounts(publicClient, chainId, [token0, token1], salt, !!(options && options.useSubgraph), options?.market);
+};
+export const getVCLOBList = async ({ chainId, userAddress, options, }) => {
+    const publicClient = createPublicClient({
+        chain: CHAIN_MAP[chainId],
+        transport: options?.rpcUrl ? http(options.rpcUrl) : http(),
+    });
+    return fetchVCLOBList(publicClient, chainId, userAddress, !!(options && options.useSubgraph));
+};
+export const getKeepersElectionGovernorMetadata = async ({ chainId, options, }) => {
+    const publicClient = createPublicClient({
+        chain: CHAIN_MAP[chainId],
+        transport: options?.rpcUrl ? http(options.rpcUrl) : http(),
+    });
+    const [minCandidateBalance, quota] = await publicClient.multicall({
+        contracts: [
+            {
+                address: CONTRACT_ADDRESSES[chainId].ElectionGovernor,
+                abi: ELECTION_GOVERNOR_ABI,
+                functionName: 'minCandidateBalance',
+            },
+            {
+                address: CONTRACT_ADDRESSES[chainId].ElectionGovernor,
+                abi: ELECTION_GOVERNOR_ABI,
+                functionName: 'quota',
+            },
+        ],
+        allowFailure: false,
+    });
+    return {
+        minCandidateBalance,
+        quota,
+    };
+};
+export const getKeepersElectionCurrentRoundData = async ({ chainId, userAddress, options, }) => {
+    const publicClient = createPublicClient({
+        chain: CHAIN_MAP[chainId],
+        transport: options?.rpcUrl ? http(options.rpcUrl) : http(),
+    });
+    const [currentRound, nextRoundStartTime, currentKeepers] = await publicClient.multicall({
+        contracts: [
+            {
+                address: CONTRACT_ADDRESSES[chainId].ElectionGovernor,
+                abi: ELECTION_GOVERNOR_ABI,
+                functionName: 'currentRound',
+            },
+            {
+                address: CONTRACT_ADDRESSES[chainId].ElectionGovernor,
+                abi: ELECTION_GOVERNOR_ABI,
+                functionName: 'nextRoundStartTime',
+            },
+            {
+                address: CONTRACT_ADDRESSES[chainId].KeepersRegistry,
+                abi: KEEPERS_REGISTRY_ABI,
+                functionName: 'getCurrentKeepers',
+            },
+        ],
+        allowFailure: false,
+    });
+    const [currentRoundData, candidates, finalists] = await publicClient.multicall({
+        contracts: [
+            {
+                address: CONTRACT_ADDRESSES[chainId].ElectionGovernor,
+                abi: ELECTION_GOVERNOR_ABI,
+                functionName: 'getRoundData',
+                args: [currentRound],
+            },
+            {
+                address: CONTRACT_ADDRESSES[chainId].ElectionGovernor,
+                abi: ELECTION_GOVERNOR_ABI,
+                functionName: 'getCandidates',
+                args: [currentRound],
+            },
+            {
+                address: CONTRACT_ADDRESSES[chainId].ElectionGovernor,
+                abi: ELECTION_GOVERNOR_ABI,
+                functionName: 'getFinalists',
+                args: [currentRound],
+            },
+        ],
+        allowFailure: false,
+    });
+    const [userVCLOBAmount, ...multicallResults] = await publicClient.multicall({
+        contracts: [
+            {
+                address: CONTRACT_ADDRESSES[chainId].VoteLockedCloberToken,
+                abi: VCLOB_ABI,
+                functionName: 'getPastBalanceOf',
+                args: [userAddress, currentRoundData.startTime],
+            },
+            ...candidates.map((candidate) => ({
+                address: CONTRACT_ADDRESSES[chainId].VoteLockedCloberToken,
+                abi: VCLOB_ABI,
+                functionName: 'getPastBalanceOf',
+                args: [candidate, currentRoundData.startTime],
+            })),
+            ...candidates.map((candidate) => ({
+                address: CONTRACT_ADDRESSES[chainId].ElectionGovernor,
+                abi: ELECTION_GOVERNOR_ABI,
+                functionName: 'hasVotedTo',
+                args: [currentRound, userAddress, candidate],
+            })),
+            ...candidates.map((candidate) => ({
+                address: CONTRACT_ADDRESSES[chainId].ElectionGovernor,
+                abi: ELECTION_GOVERNOR_ABI,
+                functionName: 'getVotes',
+                args: [currentRound, candidate],
+            })),
+        ],
+        allowFailure: false,
+    });
+    const vclobAmountOfCandidateList = multicallResults.slice(0, candidates.length);
+    const hasVotedToCandidateList = multicallResults.slice(candidates.length, candidates.length * 2);
+    const votesForCandidateList = multicallResults.slice(candidates.length * 2);
+    const candidateDataMap = new Map();
+    for (let i = 0; i < candidates.length; i++) {
+        candidateDataMap.set(candidates[i], {
+            address: candidates[i],
+            vclobAmount: vclobAmountOfCandidateList[i],
+            hasVotedTo: hasVotedToCandidateList[i],
+            forVotes: votesForCandidateList[i][0],
+            againstVotes: votesForCandidateList[i][1],
+        });
+    }
+    return {
+        round: currentRound,
+        keepers: currentKeepers,
+        nextRoundStartTime: nextRoundStartTime,
+        vclobAmount: userVCLOBAmount,
+        status: currentRoundData.status,
+        quota: currentRoundData.quota,
+        finalistsThreshold: currentRoundData.finalistsThreshold,
+        startTime: BigInt(currentRoundData.startTime),
+        votingEndTime: BigInt(currentRoundData.votingEndTime),
+        registrationEndTime: BigInt(currentRoundData.registrationEndTime),
+        candidatesLength: currentRoundData.candidatesLength,
+        finalistsLength: currentRoundData.finalistsLength,
+        candidates: candidates.map((candidate) => candidateDataMap.get(candidate)),
+        finalists: finalists.map((finalist) => candidateDataMap.get(finalist)),
+    };
+};
+/**
+ * Calculates and returns the neighboring price ticks and their corresponding prices for a given input price.
+ *
+ * @param {CHAIN_IDS} chainId - chain id from {@link CHAIN_IDS}
+ * @param {string} price - The input price to calculate the neighborhood for, as a string.
+ * @param {Currency} currency0 - token0 currency {@link Currency}.
+ * @param {Currency} currency1 - token1 currency {@link Currency}.
+ *
+ * @returns {Object} An object containing the normal and inverted price neighborhoods. Each neighborhood includes:
+ *   - up: The tick and price for one tick above the current price.
+ *   - now: The tick and price for the current price.
+ *   - down: The tick and price for one tick below the current price.
+ */
+export const getPriceNeighborhood = ({ chainId, price, currency0, currency1, }) => {
+    const quoteTokenAddress = getQuoteToken({
         chainId,
-        quote: market.quote,
-        base: market.base,
-        makerFee: market.makerFee,
-        takerFee: market.takerFee,
-        bids: market.bids,
-        bidBookOpen: market.bidBookOpen,
-        asks: market.asks,
-        askBookOpen: market.askBookOpen,
+        token0: currency0.address,
+        token1: currency1.address,
+    });
+    const quoteCurrency = isAddressEqual(quoteTokenAddress, currency0.address)
+        ? currency0
+        : currency1;
+    const baseCurrency = isAddressEqual(quoteTokenAddress, currency0.address)
+        ? currency1
+        : currency0;
+    const { roundingDownTick, roundingUpTick } = parsePrice(Number(price), quoteCurrency.decimals, baseCurrency.decimals);
+    const bidBookTick = roundingDownTick;
+    const askBookTick = invertTick(roundingUpTick);
+    return {
+        normal: {
+            nextUp: {
+                tick: bidBookTick + 2n,
+                price: formatPrice(toPrice(bidBookTick + 2n), quoteCurrency.decimals, baseCurrency.decimals),
+                marketPrice: formatPrice(toPrice(bidBookTick + 2n), quoteCurrency.decimals, baseCurrency.decimals),
+            },
+            up: {
+                tick: bidBookTick + 1n,
+                price: formatPrice(toPrice(bidBookTick + 1n), quoteCurrency.decimals, baseCurrency.decimals),
+                marketPrice: formatPrice(toPrice(bidBookTick + 1n), quoteCurrency.decimals, baseCurrency.decimals),
+            },
+            now: {
+                tick: bidBookTick,
+                price: formatPrice(toPrice(bidBookTick), quoteCurrency.decimals, baseCurrency.decimals),
+                marketPrice: formatPrice(toPrice(bidBookTick), quoteCurrency.decimals, baseCurrency.decimals),
+            },
+            down: {
+                tick: bidBookTick - 1n,
+                price: formatPrice(toPrice(bidBookTick - 1n), quoteCurrency.decimals, baseCurrency.decimals),
+                marketPrice: formatPrice(toPrice(bidBookTick - 1n), quoteCurrency.decimals, baseCurrency.decimals),
+            },
+            nextDown: {
+                tick: bidBookTick - 2n,
+                price: formatPrice(toPrice(bidBookTick - 2n), quoteCurrency.decimals, baseCurrency.decimals),
+                marketPrice: formatPrice(toPrice(bidBookTick - 2n), quoteCurrency.decimals, baseCurrency.decimals),
+            },
+        },
+        inverted: {
+            nextUp: {
+                tick: askBookTick + 2n,
+                price: formatPrice(toPrice(askBookTick + 2n), baseCurrency.decimals, quoteCurrency.decimals),
+                marketPrice: formatPrice(toPrice(invertTick(askBookTick + 2n)), quoteCurrency.decimals, baseCurrency.decimals),
+            },
+            up: {
+                tick: askBookTick + 1n,
+                price: formatPrice(toPrice(askBookTick + 1n), baseCurrency.decimals, quoteCurrency.decimals),
+                marketPrice: formatPrice(toPrice(invertTick(askBookTick + 1n)), quoteCurrency.decimals, baseCurrency.decimals),
+            },
+            now: {
+                tick: askBookTick,
+                price: formatPrice(toPrice(askBookTick), baseCurrency.decimals, quoteCurrency.decimals),
+                marketPrice: formatPrice(toPrice(invertTick(askBookTick)), quoteCurrency.decimals, baseCurrency.decimals),
+            },
+            down: {
+                tick: askBookTick - 1n,
+                price: formatPrice(toPrice(askBookTick - 1n), baseCurrency.decimals, quoteCurrency.decimals),
+                marketPrice: formatPrice(toPrice(invertTick(askBookTick - 1n)), quoteCurrency.decimals, baseCurrency.decimals),
+            },
+            nextDown: {
+                tick: askBookTick - 2n,
+                price: formatPrice(toPrice(askBookTick - 2n), baseCurrency.decimals, quoteCurrency.decimals),
+                marketPrice: formatPrice(toPrice(invertTick(askBookTick - 2n)), quoteCurrency.decimals, baseCurrency.decimals),
+            },
+        },
     };
-});
+};
 /**
  * Calculates the expected output for a given input amount, based on the provided market data.
  *
@@ -48,40 +458,71 @@ export const getMarket = decorator(async ({ chainId, token0, token1, options, })
  * @param inputToken The address of the input token.
  * @param outputToken The address of the output token.
  * @param amountIn The amount of expected input amount. (ex 1.2 ETH -> 1.2)
- * @param options
- * @param options.limitPrice The maximum limit price to spend.
- * @param options.rpcUrl The RPC URL of the blockchain.
+ * @param options {@link DefaultReadContractOptions} options.
+ * @param options.limitPrice The maximum limit price to take.
+ * @param options.roundingDownTakenBid Whether to round down the taken bid.
+ * @param options.roundingUpTakenAsk Whether to round up the taken ask.
  * @returns A Promise resolving to an object containing the taken amount, spend amount and result of the calculation.
  * @example
  * import { getExpectedOutput } from '@clober/v2-sdk'
  *
- * const { takenAmount, spendAmount } = await getExpectedOutput({
+ * const { takenAmount, spentAmount } = await getExpectedOutput({
  *   chainId: 421614,
  *   inputToken: '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
  *   outputToken: '0x0000000000000000000000000000000000000000',
  *   amountIn: '1000.123', // spend 1000.123 USDC
  * })
  */
-export const getExpectedOutput = decorator(async ({ chainId, inputToken, outputToken, amountIn, options, }) => {
-    const market = await fetchMarket(chainId, [inputToken, outputToken]);
+export const getExpectedOutput = async ({ chainId, inputToken, outputToken, amountIn, options, }) => {
+    const [roundingDownTakenBid, roundingUpTakenAsk] = [
+        options?.roundingDownTakenBid ? options.roundingDownTakenBid : false,
+        options?.roundingUpTakenAsk ? options.roundingUpTakenAsk : false,
+    ];
+    const publicClient = createPublicClient({
+        chain: CHAIN_MAP[chainId],
+        transport: options?.rpcUrl ? http(options.rpcUrl) : http(),
+    });
+    const market = await fetchMarket(publicClient, chainId, [inputToken, outputToken], options && options.makerFeePolicy
+        ? options.makerFeePolicy
+        : MAKER_DEFAULT_POLICY[chainId], options && options.takerFeePolicy
+        ? options.takerFeePolicy
+        : MAKER_DEFAULT_POLICY[chainId], !!(options && options.useSubgraph));
     const isBid = isAddressEqual(market.quote.address, inputToken);
-    const rawLimitPrice = options && options.limitPrice
+    const { roundingDownTick, roundingUpTick } = options && options.limitPrice
         ? parsePrice(Number(options.limitPrice), market.quote.decimals, market.base.decimals)
         : isBid
-            ? MAX_PRICE
-            : 0n;
+            ? {
+                roundingDownTick: MAX_TICK,
+                roundingUpTick: MAX_TICK,
+            }
+            : {
+                roundingDownTick: MIN_TICK,
+                roundingUpTick: MIN_TICK,
+            };
     const inputCurrency = isBid ? market.quote : market.base;
-    const { takenQuoteAmount, spendBaseAmount, bookId } = market.spend({
-        spendBase: !isBid,
-        limitPrice: rawLimitPrice,
+    const isTakingBidSide = !isBid;
+    const { takenQuoteAmount, spentBaseAmount, bookId, events } = market.spend({
+        spentBase: isTakingBidSide,
+        limitTick: isTakingBidSide
+            ? roundingDownTakenBid
+                ? roundingDownTick
+                : roundingUpTick
+            : roundingUpTakenAsk
+                ? roundingUpTick
+                : roundingDownTick,
         amountIn: parseUnits(amountIn, inputCurrency.decimals),
     });
     return {
         takenAmount: formatUnits(takenQuoteAmount, isBid ? market.base.decimals : market.quote.decimals),
-        spendAmount: formatUnits(spendBaseAmount, isBid ? market.quote.decimals : market.base.decimals),
+        spentAmount: formatUnits(spentBaseAmount, isBid ? market.quote.decimals : market.base.decimals),
         bookId,
+        events: events.map(({ tick, takenQuoteAmount, spentBaseAmount }) => ({
+            price: formatPrice(toPrice(isBid ? invertTick(BigInt(tick)) : BigInt(tick)), market.quote.decimals, market.base.decimals),
+            takenAmount: formatUnits(takenQuoteAmount, isBid ? market.base.decimals : market.quote.decimals),
+            spentAmount: formatUnits(spentBaseAmount, isBid ? market.quote.decimals : market.base.decimals),
+        })),
     };
-});
+};
 /**
  * Calculates the expected input for a given output amount, based on the provided market data.
  *
@@ -89,47 +530,72 @@ export const getExpectedOutput = decorator(async ({ chainId, inputToken, outputT
  * @param inputToken The address of the input token.
  * @param outputToken The address of the output token.
  * @param amountOut The amount of expected output amount. (ex 1.2 ETH -> 1.2)
- * @param options
+ * @param options {@link DefaultReadContractOptions} options.
  * @param options.limitPrice The maximum limit price to take.
- * @param options.rpcUrl The RPC URL of the blockchain.
- * @returns A Promise resolving to an object containing the taken amount, spend amount and result of the calculation.
+ * @param options.roundingDownTakenBid Whether to round down the taken bid.
+ * @param options.roundingUpTakenAsk Whether to round up the taken ask.
+ * @param options.useSubgraph Whether to use the subgraph to fetch the market data.
+ * @returns A Promise resolving to an object containing the taken amount, spent amount and result of the calculation.
  * @example
  * import { getExpectedInput } from '@clober/v2-sdk'
  *
- * const { takenAmount, spendAmount } = await getExpectedInput({
+ * const { takenAmount, spentAmount } = await getExpectedInput({
  *   chainId: 421614,
  *   inputToken: '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
  *   outputToken: '0x0000000000000000000000000000000000000000',
  *   amountOut: '0.1', // take 0.1 ETH
  * })
  */
-export const getExpectedInput = decorator(async ({ chainId, inputToken, outputToken, amountOut, options, }) => {
-    const market = await fetchMarket(chainId, [inputToken, outputToken]);
+export const getExpectedInput = async ({ chainId, inputToken, outputToken, amountOut, options, }) => {
+    const [roundingDownTakenBid, roundingUpTakenAsk] = [
+        options?.roundingDownTakenBid ? options.roundingDownTakenBid : false,
+        options?.roundingUpTakenAsk ? options.roundingUpTakenAsk : false,
+    ];
+    const publicClient = createPublicClient({
+        chain: CHAIN_MAP[chainId],
+        transport: options?.rpcUrl ? http(options.rpcUrl) : http(),
+    });
+    const market = await fetchMarket(publicClient, chainId, [inputToken, outputToken], options && options.makerFeePolicy
+        ? options.makerFeePolicy
+        : MAKER_DEFAULT_POLICY[chainId], options && options.takerFeePolicy
+        ? options.takerFeePolicy
+        : TAKER_DEFAULT_POLICY[chainId], !!(options && options.useSubgraph));
     const isBid = isAddressEqual(market.quote.address, inputToken);
-    const rawLimitPrice = options && options.limitPrice
+    const { roundingDownTick, roundingUpTick } = options && options.limitPrice
         ? parsePrice(Number(options.limitPrice), market.quote.decimals, market.base.decimals)
         : isBid
-            ? MAX_PRICE
-            : 0n;
+            ? { roundingDownTick: MAX_TICK, roundingUpTick: MAX_TICK }
+            : { roundingDownTick: MIN_TICK, roundingUpTick: MIN_TICK };
     const outputCurrency = isBid ? market.base : market.quote;
-    const { takenQuoteAmount, spendBaseAmount, bookId } = market.take({
-        takeQuote: !isBid,
-        limitPrice: rawLimitPrice,
+    const isTakingBidSide = !isBid;
+    const { takenQuoteAmount, spentBaseAmount, bookId, events } = market.take({
+        takeQuote: isTakingBidSide,
+        limitTick: isTakingBidSide
+            ? roundingDownTakenBid
+                ? roundingDownTick
+                : roundingUpTick
+            : roundingUpTakenAsk
+                ? roundingUpTick
+                : roundingDownTick,
         amountOut: parseUnits(amountOut, outputCurrency.decimals),
     });
     return {
         takenAmount: formatUnits(takenQuoteAmount, isBid ? market.base.decimals : market.quote.decimals),
-        spendAmount: formatUnits(spendBaseAmount, isBid ? market.quote.decimals : market.base.decimals),
+        spentAmount: formatUnits(spentBaseAmount, isBid ? market.quote.decimals : market.base.decimals),
         bookId,
+        events: events.map(({ tick, takenQuoteAmount, spentBaseAmount }) => ({
+            price: formatPrice(toPrice(isBid ? invertTick(BigInt(tick)) : BigInt(tick)), market.quote.decimals, market.base.decimals),
+            takenAmount: formatUnits(takenQuoteAmount, isBid ? market.base.decimals : market.quote.decimals),
+            spentAmount: formatUnits(spentBaseAmount, isBid ? market.quote.decimals : market.base.decimals),
+        })),
     };
-});
+};
 /**
  * Retrieves the open order with the specified ID on the given chain.
  *
  * @param {CHAIN_IDS} chainId The chain ID.
  * @param {string} id The ID of the open order.
- * @param options
- * @param options.rpcUrl The RPC URL of the blockchain.
+ * @param options {@link DefaultReadContractOptions} options.
  * @returns {Promise<OpenOrder>} Promise resolving to the open order object, or undefined if not found.
  * @example
  * import { getOpenOrder } from '@clober/v2-sdk'
@@ -139,16 +605,21 @@ export const getExpectedInput = decorator(async ({ chainId, inputToken, outputTo
  *   id: '46223845323662364279893361453861711542636620039907198451770258805035840307200'
  * })
  */
-export const getOpenOrder = decorator(async ({ chainId, id, }) => {
-    return fetchOpenOrder(chainId, id);
-});
+export const getOpenOrder = async ({ chainId, id, options, }) => {
+    const publicClient = createPublicClient({
+        chain: CHAIN_MAP[chainId],
+        transport: options?.rpcUrl ? http(options.rpcUrl) : http(),
+    });
+    return fetchOpenOrder(publicClient, chainId, id, options && options.makerFeePolicy
+        ? options.makerFeePolicy
+        : MAKER_DEFAULT_POLICY[chainId]);
+};
 /**
  * Retrieves open orders for the specified user on the given chain.
  *
  * @param {CHAIN_IDS} chainId The chain ID.
  * @param {`0x${string}`} userAddress The Ethereum address of the user.
- * @param options
- * @param options.rpcUrl The RPC URL of the blockchain.
+ * @param options {@link DefaultReadContractOptions} options.
  * @returns {Promise<OpenOrder[]>} Promise resolving to an array of open orders.
  * @example
  * import { getOpenOrders } from '@clober/v2-sdk'
@@ -158,9 +629,15 @@ export const getOpenOrder = decorator(async ({ chainId, id, }) => {
  *   userAddress: '0x5F79EE8f8fA862E98201120d83c4eC39D9468D49'
  * })
  */
-export const getOpenOrders = decorator(async ({ chainId, userAddress, }) => {
-    return fetchOpenOrders(chainId, userAddress);
-});
+export const getOpenOrders = async ({ chainId, userAddress, options, }) => {
+    const publicClient = createPublicClient({
+        chain: CHAIN_MAP[chainId],
+        transport: options?.rpcUrl ? http(options.rpcUrl) : http(),
+    });
+    return fetchOpenOrdersByUserAddress(publicClient, chainId, userAddress, options && options.makerFeePolicy
+        ? options.makerFeePolicy
+        : MAKER_DEFAULT_POLICY[chainId]);
+};
 /**
  * Retrieves the latest chart log for a specific market.
  *
@@ -178,9 +655,9 @@ export const getOpenOrders = decorator(async ({ chainId, userAddress, }) => {
  *   base: '0x0000000000000000000000000000000000000000',
  * })
  */
-export const getLatestChartLog = decorator(async ({ chainId, quote, base, }) => {
+export const getLatestChartLog = async ({ chainId, quote, base, }) => {
     return fetchLatestChartLog(chainId, `${base}/${quote}`);
-});
+};
 /**
  * Retrieves chart logs for a specific market within a specified time interval.
  *
@@ -204,7 +681,27 @@ export const getLatestChartLog = decorator(async ({ chainId, quote, base, }) =>
  *   to: 1713312000,
  * })
  */
-export const getChartLogs = decorator(async ({ chainId, quote, base, intervalType, from, to, }) => {
+export const getChartLogs = async ({ chainId, quote, base, intervalType, from, to, }) => {
     return fetchChartLogs(chainId, `${base}/${quote}`, intervalType, from, to);
-});
+};
+/**
+ * Retrieves the quote token address for a given chain and a pair of tokens.
+ *
+ * @param chainId - chain id from {@link CHAIN_IDS}
+ * @param token0 - token0 address
+ * @param token1 - token1 address
+ * @returns {string} The address of the quote token.
+ *
+ * @example
+ * import { getQuoteToken } from '@clober/v2-sdk'
+ *
+ * const quote = await getQuoteToken({
+ *   chainId: 421614,
+ *   token0: '0x00bfd44e79fb7f6dd5887a9426c8ef85a0cd23e0',
+ *   token1: '0x0000000000000000000000000000000000000000',
+ * })
+ */
+export const getQuoteToken = ({ chainId, token0, token1, }) => {
+    return getAddress(getMarketId(chainId, [token0, token1]).quoteTokenAddress);
+};
 //# sourceMappingURL=view.js.map