timelock-sdk 0.0.80 → 0.0.82

package/dist/client.d.cts

@@ -1,3 +1,3 @@
 import "./uniswapMathLens-CK8C7WOt.cjs";
-import { B as useOptionPnl, F as useOptionTimeline, H as useMaxPositionSize, I as useSetOperatorPerms, L as useUserOperators, P as OptionTimelineData, R as useExtendOption, V as useMintOption, a as batchGetAmountsFromLiquidity, at as useExerciseOption, c as useLiquidityBlocks, ct as useClosedUserOptions, d as usePriceAtTick, dt as useTimelockConfig, f as UniswapPoolData, h as useCurrentPrice, i as useVaultData, it as useMarketData, l as useBurnLiquidity, lt as TimelockMarketProvider, m as useCurrentTick, n as useLens, o as useMintLiquidity, ot as OptionData, p as usePoolData, r as useVaultTVL, s as LiquidityBlockData, st as useActiveUserOptions, t as useApproval, u as usePriceHistory, ut as useCurrentMarket, z as useOptionPremium } from "./client-D_t-2-g5.cjs";
-export { LiquidityBlockData, OptionData, OptionTimelineData, TimelockMarketProvider, UniswapPoolData, batchGetAmountsFromLiquidity, useActiveUserOptions, useApproval, useBurnLiquidity, useClosedUserOptions, useCurrentMarket, useCurrentPrice, useCurrentTick, useExerciseOption, useExtendOption, useLens, useLiquidityBlocks, useMarketData, useMaxPositionSize, useMintLiquidity, useMintOption, useOptionPnl, useOptionPremium, useOptionTimeline, usePoolData, usePriceAtTick, usePriceHistory, useSetOperatorPerms, useTimelockConfig, useUserOperators, useVaultData, useVaultTVL };
+import { B as useOptionTimeline, F as useUserOperators, G as useMaxPositionSize, H as useOptionPremium, I as usePerpsOperator, L as useClosePerp, P as useSetOperatorPerms, R as useMintPerp, U as useOptionPnl, V as useExtendOption, W as useMintOption, a as batchGetAmountsFromLiquidity, c as useLiquidityBlocks, ct as useExerciseOption, d as usePriceAtTick, dt as useClosedUserOptions, f as UniswapPoolData, ft as TimelockProvider, h as useCurrentPrice, i as useVaultData, l as useBurnLiquidity, lt as OptionData, m as useCurrentTick, mt as useTimelockConfig, n as useLens, o as useMintLiquidity, p as usePoolData, pt as useCurrentMarket, r as useVaultTVL, s as LiquidityBlockData, st as useMarketData, t as useApproval, u as usePriceHistory, ut as useActiveUserOptions, z as OptionTimelineData } from "./client-GoHd57RL.cjs";
+export { LiquidityBlockData, OptionData, OptionTimelineData, TimelockProvider, UniswapPoolData, batchGetAmountsFromLiquidity, useActiveUserOptions, useApproval, useBurnLiquidity, useClosePerp, useClosedUserOptions, useCurrentMarket, useCurrentPrice, useCurrentTick, useExerciseOption, useExtendOption, useLens, useLiquidityBlocks, useMarketData, useMaxPositionSize, useMintLiquidity, useMintOption, useMintPerp, useOptionPnl, useOptionPremium, useOptionTimeline, usePerpsOperator, usePoolData, usePriceAtTick, usePriceHistory, useSetOperatorPerms, useTimelockConfig, useUserOperators, useVaultData, useVaultTVL };

package/dist/client.d.ts

@@ -1,3 +1,3 @@
 import "./uniswapMathLens-C54iWXpi.js";
-import { B as useOptionPnl, F as useOptionTimeline, H as useMaxPositionSize, I as useSetOperatorPerms, L as useUserOperators, P as OptionTimelineData, R as useExtendOption, V as useMintOption, a as batchGetAmountsFromLiquidity, at as useExerciseOption, c as useLiquidityBlocks, ct as useClosedUserOptions, d as usePriceAtTick, dt as useTimelockConfig, f as UniswapPoolData, h as useCurrentPrice, i as useVaultData, it as useMarketData, l as useBurnLiquidity, lt as TimelockMarketProvider, m as useCurrentTick, n as useLens, o as useMintLiquidity, ot as OptionData, p as usePoolData, r as useVaultTVL, s as LiquidityBlockData, st as useActiveUserOptions, t as useApproval, u as usePriceHistory, ut as useCurrentMarket, z as useOptionPremium } from "./client-euowNGgz.js";
-export { LiquidityBlockData, OptionData, OptionTimelineData, TimelockMarketProvider, UniswapPoolData, batchGetAmountsFromLiquidity, useActiveUserOptions, useApproval, useBurnLiquidity, useClosedUserOptions, useCurrentMarket, useCurrentPrice, useCurrentTick, useExerciseOption, useExtendOption, useLens, useLiquidityBlocks, useMarketData, useMaxPositionSize, useMintLiquidity, useMintOption, useOptionPnl, useOptionPremium, useOptionTimeline, usePoolData, usePriceAtTick, usePriceHistory, useSetOperatorPerms, useTimelockConfig, useUserOperators, useVaultData, useVaultTVL };
+import { B as useOptionTimeline, F as useUserOperators, G as useMaxPositionSize, H as useOptionPremium, I as usePerpsOperator, L as useClosePerp, P as useSetOperatorPerms, R as useMintPerp, U as useOptionPnl, V as useExtendOption, W as useMintOption, a as batchGetAmountsFromLiquidity, c as useLiquidityBlocks, ct as useExerciseOption, d as usePriceAtTick, dt as useClosedUserOptions, f as UniswapPoolData, ft as TimelockProvider, h as useCurrentPrice, i as useVaultData, l as useBurnLiquidity, lt as OptionData, m as useCurrentTick, mt as useTimelockConfig, n as useLens, o as useMintLiquidity, p as usePoolData, pt as useCurrentMarket, r as useVaultTVL, s as LiquidityBlockData, st as useMarketData, t as useApproval, u as usePriceHistory, ut as useActiveUserOptions, z as OptionTimelineData } from "./client-BjjoSITU.js";
+export { LiquidityBlockData, OptionData, OptionTimelineData, TimelockProvider, UniswapPoolData, batchGetAmountsFromLiquidity, useActiveUserOptions, useApproval, useBurnLiquidity, useClosePerp, useClosedUserOptions, useCurrentMarket, useCurrentPrice, useCurrentTick, useExerciseOption, useExtendOption, useLens, useLiquidityBlocks, useMarketData, useMaxPositionSize, useMintLiquidity, useMintOption, useMintPerp, useOptionPnl, useOptionPremium, useOptionTimeline, usePerpsOperator, usePoolData, usePriceAtTick, usePriceHistory, useSetOperatorPerms, useTimelockConfig, useUserOperators, useVaultData, useVaultTVL };

package/dist/client.js

@@ -2,7 +2,7 @@
 
 
 import { r as lensAbi, t as optionsMarketAbi } from "./optionsMarket-6PlyceXp.js";
-import { A as getErc20, D as token1ToToken0, E as token0ToToken1, F as uniswapMathLenses, M as getTimelockMarket, N as getUniswapMathLens, P as timelockLenses, d as wrapAmount, j as getTimelockLens, k as getPriceHistory, n as EMPTY_ARRAY, p as wrapPrice, t as getPayoutAtTick, v as getNearestValidStrikeTick, w as roundTickDown, y as getPriceAtTick } from "./optionUtils-CoIk8zAr.js";
+import { A as getErc20, D as token1ToToken0, E as token0ToToken1, F as uniswapMathLenses, M as getTimelockMarket$1, N as getUniswapMathLens, P as timelockLenses, _ as getAmountsFromLiquidity, d as wrapAmount, j as getTimelockLens, k as getPriceHistory, n as EMPTY_ARRAY, p as wrapPrice, t as getPayoutAtTick, v as getNearestValidStrikeTick$1, w as roundTickDown, y as getPriceAtTick } from "./optionUtils-CoIk8zAr.js";
 import { n as uniswapV3PoolAbi, t as singleOwnerVaultAbi } from "./singleOwnerVault-BeJChjfJ.js";
 import { encodeAbiParameters, encodeFunctionData, erc20Abi, maxUint256, zeroAddress } from "viem";
 import React, { createContext, useContext, useMemo } from "react";
@@ -11,6 +11,8 @@ import { GraphQLClient, RequestOptions } from "graphql-request";
 import gql from "graphql-tag";
 import { waitForTransactionReceipt } from "viem/actions";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { getNearestValidStrikeTick, getTimelockMarket } from "timelock-sdk";
+import { useApproval as useApproval$1, useCurrentTick as useCurrentTick$1, useMarketData as useMarketData$1, usePoolData as usePoolData$1, useSetOperatorPerms as useSetOperatorPerms$1, useUserOperators as useUserOperators$1 } from "timelock-sdk/client";
 
 //#region src/generated/graphql.ts
 const UserOptionFieldsFragmentDoc = gql`
@@ -280,9 +282,9 @@ function getSdk(client, withWrapper = defaultWrapper) {
 }
 
 //#endregion
-//#region src/providers/TimelockMarketProvider.tsx
-const TimelockMarketContext = createContext(void 0);
-const TimelockMarketProvider = ({ children, marketData, envioGraphqlUrl }) => {
+//#region src/providers/TimelockProvider.tsx
+const TimelockContext = createContext(void 0);
+const TimelockProvider = ({ children, marketData, envioGraphqlUrl, perpsOperatorUrl }) => {
 	const chainId = useChainId();
 	const lensAddr = timelockLenses[chainId];
 	const uniswapMathLensAddr = uniswapMathLenses[chainId];
@@ -294,24 +296,26 @@ const TimelockMarketProvider = ({ children, marketData, envioGraphqlUrl }) => {
 		lensAddr,
 		uniswapMathLensAddr,
 		envioGraphqlUrl,
-		graphqlClient
+		graphqlClient,
+		perpsOperatorUrl
 	}), [
 		marketData,
 		lensAddr,
 		uniswapMathLensAddr,
 		envioGraphqlUrl,
-		graphqlClient
+		graphqlClient,
+		perpsOperatorUrl
 	]);
-	return /* @__PURE__ */ React.createElement(TimelockMarketContext.Provider, { value: contextValue }, children);
+	return /* @__PURE__ */ React.createElement(TimelockContext.Provider, { value: contextValue }, children);
 };
 const useCurrentMarket = () => {
-	const context = useContext(TimelockMarketContext);
-	if (context === void 0) throw new Error("useCurrentMarket must be used within a TimelockMarketProvider");
+	const context = useContext(TimelockContext);
+	if (context === void 0) throw new Error("useCurrentMarket must be used within a TimelockProvider");
 	return context.marketData;
 };
 const useTimelockConfig = () => {
-	const context = useContext(TimelockMarketContext);
-	if (context === void 0) throw new Error("useConfig must be used within a TimelockMarketProvider");
+	const context = useContext(TimelockContext);
+	if (context === void 0) throw new Error("useConfig must be used within a TimelockProvider");
 	return context;
 };
 
@@ -326,7 +330,7 @@ const useLens = () => {
 };
 
 //#endregion
-//#region src/hooks/market/useMarketData.ts
+//#region src/hooks/options/useMarketData.ts
 const useMarketData = (marketAddr) => {
 	const { graphqlClient } = useTimelockConfig();
 	const { timelockLens } = useLens();
@@ -376,7 +380,7 @@ const usePoolData = (poolAddr) => {
 };
 
 //#endregion
-//#region src/hooks/market/useExerciseOption.ts
+//#region src/hooks/options/useExerciseOption.ts
 const swapper = "0xc396aa907F8De0c32460050B8Adbf047186C504d";
 const useExerciseOption = (marketAddr) => {
 	const { vault, pool } = useMarketData(marketAddr);
@@ -414,7 +418,7 @@ const useExerciseOption = (marketAddr) => {
 };
 
 //#endregion
-//#region src/hooks/market/useMaxPositionSize.ts
+//#region src/hooks/options/useMaxPositionSize.ts
 const useMaxPositionSize = (marketAddr, strikeTick, maxBorrowableRange = 100) => {
 	const { timelockLens } = useLens();
 	const { optionAssetDecimals } = useMarketData(marketAddr);
@@ -498,7 +502,7 @@ const useApproval = () => {
 };
 
 //#endregion
-//#region src/hooks/market/useMintOption.ts
+//#region src/hooks/options/useMintOption.ts
 const useMintOption = (marketAddr) => {
 	const { payoutAsset, vault, pool, optionAssetIsToken0 } = useMarketData(marketAddr);
 	const { tickSpacing } = usePoolData(pool);
@@ -515,8 +519,8 @@ const useMintOption = (marketAddr) => {
 		if (!timelockLens) throw new Error("Timelock lens not available");
 		if (!vault || !payoutAsset || optionAssetIsToken0 === void 0) throw new Error("Market data not available");
 		if (currentTick === void 0 || !tickSpacing) throw new Error("Pool data not available");
-		strikeTick = getNearestValidStrikeTick(optionType, optionAssetIsToken0, tickSpacing, currentTick, strikeTick);
-		const [premium, protocolFee] = await getTimelockMarket(marketAddr, client).read.calculatePremium([
+		strikeTick = getNearestValidStrikeTick$1(optionType, optionAssetIsToken0, tickSpacing, currentTick, strikeTick);
+		const [premium, protocolFee] = await getTimelockMarket$1(marketAddr, client).read.calculatePremium([
 			optionType === "CALL" ? 0 : 1,
 			amount,
 			strikeTick,
@@ -546,7 +550,7 @@ const useMintOption = (marketAddr) => {
 };
 
 //#endregion
-//#region src/hooks/market/useOptionPnl.ts
+//#region src/hooks/options/useOptionPnl.ts
 const useOptionPnl = (option) => {
 	const { marketAddr, optionType, entryTick, positionSizeCurrent } = option;
 	const { pool, optionAssetIsToken0, payoutAssetDecimals, tickSpacing } = useMarketData(marketAddr);
@@ -580,7 +584,7 @@ const useOptionPnl = (option) => {
 };
 
 //#endregion
-//#region src/hooks/market/useOptionPremium.ts
+//#region src/hooks/options/useOptionPremium.ts
 const useOptionPremium = (marketAddr, optionType, optionAmount, addedDuration, remainingDuration = 0, strikeTick) => {
 	const { pool, payoutAssetDecimals, optionAssetIsToken0 } = useMarketData(marketAddr);
 	const { tickSpacing } = usePoolData(pool);
@@ -625,7 +629,7 @@ const useOptionPremium = (marketAddr, optionType, optionAmount, addedDuration, r
 };
 
 //#endregion
-//#region src/hooks/market/useUserOptions.ts
+//#region src/hooks/options/useUserOptions.ts
 const useUserOptions = (userAddr, marketAddr, active = false) => {
 	const { graphqlClient } = useTimelockConfig();
 	userAddr = userAddr === null || userAddr === void 0 ? void 0 : userAddr.toLowerCase();
@@ -678,7 +682,7 @@ const useClosedUserOptions = (userAddr, marketAddr) => {
 };
 
 //#endregion
-//#region src/hooks/market/useExtendOption.ts
+//#region src/hooks/options/useExtendOption.ts
 const useExtendOption = (marketAddr) => {
 	const { payoutAsset } = useMarketData(marketAddr);
 	const queryClient = useQueryClient();
@@ -689,7 +693,7 @@ const useExtendOption = (marketAddr) => {
 	const extendOption = async ({ option, duration }) => {
 		if (!client || !address) throw new Error("Wallet not connected");
 		if (!marketAddr || !payoutAsset) throw new Error("Market address not available");
-		const market = getTimelockMarket(marketAddr, client);
+		const market = getTimelockMarket$1(marketAddr, client);
 		const remainingDuration = Math.max(0, Math.floor((option.expiresAt.getTime() - Date.now()) / 1e3));
 		const [premium, protocolFee] = await market.read.calculatePremium([
 			option.optionType === "CALL" ? 0 : 1,
@@ -717,70 +721,7 @@ const useExtendOption = (marketAddr) => {
 };
 
 //#endregion
-//#region src/hooks/market/useUserOperators.ts
-const useUserOperators = (userAddr, marketAddr) => {
-	const { graphqlClient } = useTimelockConfig();
-	const { data,...rest } = useQuery({
-		queryKey: [
-			"userOperators",
-			(userAddr === null || userAddr === void 0 ? void 0 : userAddr.toLowerCase()) || "--",
-			(marketAddr === null || marketAddr === void 0 ? void 0 : marketAddr.toLowerCase()) || "--"
-		],
-		queryFn: async () => {
-			if (!userAddr || !marketAddr) return void 0;
-			return (await graphqlClient.GetUserMarketOperators({
-				userAddr: userAddr.toLowerCase(),
-				marketAddr: marketAddr.toLowerCase()
-			})).UserMarketOperator.map((operator) => ({
-				...operator,
-				spendingApproval: BigInt(operator.spendingApproval),
-				operatorAddr: operator.operator.address.toLowerCase()
-			}));
-		},
-		enabled: !!userAddr && !!marketAddr && !!graphqlClient
-	});
-	return {
-		...rest,
-		data: data || EMPTY_ARRAY
-	};
-};
-
-//#endregion
-//#region src/hooks/market/useSetOperatorPerms.ts
-const useSetOperatorPerms = (marketAddr) => {
-	const queryClient = useQueryClient();
-	const client = useClient();
-	const { address } = useAccount();
-	const { writeContractAsync } = useWriteContract();
-	const setOperatorPerms = async ({ operator, canExtend, canExercise, canTransfer, canMint, spendingApproval }) => {
-		if (!client || !address) throw new Error("Wallet not connected");
-		if (!marketAddr) throw new Error("Market address not available");
-		const hash = await writeContractAsync({
-			address: marketAddr,
-			abi: optionsMarketAbi,
-			functionName: "setOperatorPerms",
-			args: [
-				operator,
-				canExtend,
-				canExercise,
-				canTransfer,
-				canMint,
-				spendingApproval
-			]
-		});
-		await waitForTransactionReceipt(client, { hash });
-		queryClient.invalidateQueries({ queryKey: [
-			"userOperators",
-			address.toLowerCase(),
-			marketAddr.toLowerCase()
-		] });
-		return hash;
-	};
-	return useMutation({ mutationFn: setOperatorPerms });
-};
-
-//#endregion
-//#region src/hooks/market/useOptionTimeline.ts
+//#region src/hooks/options/useOptionTimeline.ts
 const useOptionTimeline = (marketAddr, optionId) => {
 	const { graphqlClient } = useTimelockConfig();
 	marketAddr = marketAddr === null || marketAddr === void 0 ? void 0 : marketAddr.toLowerCase();
@@ -851,6 +792,220 @@ const useOptionTimeline = (marketAddr, optionId) => {
 	};
 };
 
+//#endregion
+//#region src/lib/perpsOperator.ts
+var PerpsOperator = class {
+	baseUrl;
+	constructor(baseUrl) {
+		this.baseUrl = baseUrl;
+	}
+	async #request(path, body) {
+		const url = new URL(path, this.baseUrl);
+		const res = await fetch(url, {
+			method: body ? "POST" : "GET",
+			headers: {
+				Connection: "keep-alive",
+				"Content-Type": "application/json",
+				"Keep-Alive": "timeout=120"
+			},
+			body: body ? JSON.stringify(body) : void 0
+		});
+		if (res.ok) {
+			const { data } = await res.json();
+			return data;
+		}
+		const resText = await res.text();
+		try {
+			const error = JSON.parse(resText);
+			throw new Error(`${res.status} ${res.statusText}: ${error.error}`);
+		} catch (error) {
+			throw new Error(`${res.status} ${res.statusText}: ${resText}`);
+		}
+	}
+	async getOperatorAddr() {
+		const { address } = await this.#request("api/operator/address");
+		return address;
+	}
+	async getUserPerps(userAddr, marketAddr, type, offset = 0, limit = 1e3) {
+		const params = new URLSearchParams({
+			offset: offset.toString(),
+			limit: limit.toString()
+		});
+		if (type) params.append("type", type);
+		if (marketAddr) params.append("marketAddr", marketAddr);
+		const url = `api/positions/${userAddr}?${params.toString()}`;
+		return (await this.#request(url)).map((p) => ({
+			...p,
+			optionId: BigInt(p.optionId)
+		}));
+	}
+	async mintPerp(body) {
+		const { txHash, optionId } = await this.#request("api/positions/mint", {
+			...body,
+			amount: body.amount.toString()
+		});
+		return {
+			txHash,
+			optionId: BigInt(optionId)
+		};
+	}
+	async exercisePerp(body) {
+		const { txHash, optionId } = await this.#request("api/positions/exercise", {
+			...body,
+			optionId: body.optionId.toString(),
+			liquidities: body.liquidities.map((l) => l.toString())
+		});
+		return {
+			txHash,
+			optionId: BigInt(optionId)
+		};
+	}
+};
+
+//#endregion
+//#region src/hooks/perps/usePerpsOperator.ts
+const usePerpsOperator = () => {
+	const { perpsOperatorUrl } = useTimelockConfig();
+	const operator = useMemo(() => perpsOperatorUrl ? new PerpsOperator(perpsOperatorUrl) : void 0, [perpsOperatorUrl]);
+	const { data: address } = useQuery({
+		queryKey: ["perpsOperatorAddr", perpsOperatorUrl || "--"],
+		queryFn: () => operator === null || operator === void 0 ? void 0 : operator.getOperatorAddr(),
+		staleTime: 1e4,
+		refetchInterval: 1e4,
+		enabled: !!operator
+	});
+	return {
+		operator,
+		address
+	};
+};
+
+//#endregion
+//#region src/hooks/perps/useMintPerp.ts
+const useMintPerp = (marketAddr) => {
+	const queryClient = useQueryClient();
+	const client = useClient();
+	const { address } = useAccount();
+	const { operator, address: operatorAddr } = usePerpsOperator();
+	const { askForApproval } = useApproval$1();
+	const { data: operators } = useUserOperators$1(address, marketAddr);
+	const { mutateAsync: setOperatorPerms } = useSetOperatorPerms$1(marketAddr);
+	const { pool, optionAssetIsToken0, payoutAsset } = useMarketData$1(marketAddr);
+	const { tickSpacing } = usePoolData$1(pool);
+	const { exact: currentTick } = useCurrentTick$1(pool);
+	const userPerms = operatorAddr ? operators.find((o) => o.operatorAddr.toLowerCase() === operatorAddr.toLowerCase()) : void 0;
+	const hasEnoughPerms = userPerms && userPerms.canMint && userPerms.canExtend;
+	const mintPerp = async (data) => {
+		const { optionType, amount, duration, strikeTick } = data;
+		if (!client || !address) throw new Error("Wallet not connected");
+		if (!marketAddr) throw new Error("Market address not found");
+		if (!operator || !operatorAddr) throw new Error("Operator address not found");
+		if (!tickSpacing || currentTick === void 0) throw new Error("Pool data not found");
+		if (optionAssetIsToken0 === void 0 || !payoutAsset) throw new Error("Market data not found");
+		if (!hasEnoughPerms) await setOperatorPerms({
+			operator: operatorAddr,
+			canMint: true,
+			canExtend: true,
+			canExercise: (userPerms === null || userPerms === void 0 ? void 0 : userPerms.canExercise) || false,
+			canTransfer: (userPerms === null || userPerms === void 0 ? void 0 : userPerms.canTransfer) || false,
+			spendingApproval: maxUint256
+		});
+		const market = getTimelockMarket(marketAddr, client);
+		const validStrikeTick = getNearestValidStrikeTick(optionType, optionAssetIsToken0, tickSpacing, currentTick, strikeTick);
+		const [premium, protocolFee] = await market.read.calculatePremium([
+			optionType === "CALL" ? 0 : 1,
+			amount,
+			validStrikeTick,
+			duration,
+			0
+		]);
+		await askForApproval(payoutAsset, marketAddr, (premium + protocolFee) * 11n / 10n);
+		await operator.mintPerp({
+			marketAddr,
+			userAddr: address,
+			amount,
+			optionType,
+			duration,
+			strikeTick: validStrikeTick
+		});
+		queryClient.invalidateQueries({ queryKey: ["userOptions", address.toLowerCase()] });
+	};
+	return useMutation({ mutationFn: mintPerp });
+};
+
+//#endregion
+//#region src/hooks/perps/useClosePerp.ts
+const useClosePerp = () => {
+	const { operator } = usePerpsOperator();
+	return useMutation({ mutationFn: (body) => {
+		if (!operator) throw new Error("Operator not connected");
+		return operator.exercisePerp(body);
+	} });
+};
+
+//#endregion
+//#region src/hooks/operators/useUserOperators.ts
+const useUserOperators = (userAddr, marketAddr) => {
+	const { graphqlClient } = useTimelockConfig();
+	const { data,...rest } = useQuery({
+		queryKey: [
+			"userOperators",
+			(userAddr === null || userAddr === void 0 ? void 0 : userAddr.toLowerCase()) || "--",
+			(marketAddr === null || marketAddr === void 0 ? void 0 : marketAddr.toLowerCase()) || "--"
+		],
+		queryFn: async () => {
+			if (!userAddr || !marketAddr) return void 0;
+			return (await graphqlClient.GetUserMarketOperators({
+				userAddr: userAddr.toLowerCase(),
+				marketAddr: marketAddr.toLowerCase()
+			})).UserMarketOperator.map((operator) => ({
+				...operator,
+				spendingApproval: BigInt(operator.spendingApproval),
+				operatorAddr: operator.operator.address.toLowerCase()
+			}));
+		},
+		enabled: !!userAddr && !!marketAddr && !!graphqlClient
+	});
+	return {
+		...rest,
+		data: data || EMPTY_ARRAY
+	};
+};
+
+//#endregion
+//#region src/hooks/operators/useSetOperatorPerms.ts
+const useSetOperatorPerms = (marketAddr) => {
+	const queryClient = useQueryClient();
+	const client = useClient();
+	const { address } = useAccount();
+	const { writeContractAsync } = useWriteContract();
+	const setOperatorPerms = async ({ operator, canExtend, canExercise, canTransfer, canMint, spendingApproval }) => {
+		if (!client || !address) throw new Error("Wallet not connected");
+		if (!marketAddr) throw new Error("Market address not available");
+		const hash = await writeContractAsync({
+			address: marketAddr,
+			abi: optionsMarketAbi,
+			functionName: "setOperatorPerms",
+			args: [
+				operator,
+				canExtend,
+				canExercise,
+				canTransfer,
+				canMint,
+				spendingApproval
+			]
+		});
+		await waitForTransactionReceipt(client, { hash });
+		queryClient.invalidateQueries({ queryKey: [
+			"userOperators",
+			address.toLowerCase(),
+			marketAddr.toLowerCase()
+		] });
+		return hash;
+	};
+	return useMutation({ mutationFn: setOperatorPerms });
+};
+
 //#endregion
 //#region src/hooks/pool/usePriceAtTick.ts
 const usePriceAtTick = (tick, poolAddr) => {
@@ -987,25 +1142,17 @@ const useLiquidityBlocks = (vaultAddr) => {
 
 //#endregion
 //#region src/hooks/vault/useMintLiquidity.ts
-const batchGetAmountsFromLiquidity = async (lens, tickLower, tickUpper, liquidity, currentTick) => {
-	const currentTicksArray = new Array(tickLower.length).fill(currentTick);
-	const amounts = await lens.read.batchGetAmountsForLiquidityTicks([
-		currentTicksArray,
-		tickLower,
-		tickUpper,
-		liquidity
-	]);
+const batchGetAmountsFromLiquidity = (tickLowers, tickUppers, liquidities, currentTick) => {
 	let totalAmount0 = 0n;
 	let totalAmount1 = 0n;
 	const amounts0 = [];
 	const amounts1 = [];
-	for (const scaled of amounts[0]) {
-		totalAmount0 += scaled;
-		amounts0.push(scaled);
-	}
-	for (const scaled of amounts[1]) {
-		totalAmount1 += scaled;
-		amounts1.push(scaled);
+	for (const [i, tickLower] of tickLowers.entries()) {
+		const [amount0, amount1] = getAmountsFromLiquidity(tickLower, tickUppers[i], liquidities[i], currentTick);
+		totalAmount0 += amount0;
+		totalAmount1 += amount1;
+		amounts0.push(amount0);
+		amounts1.push(amount1);
 	}
 	return {
 		totalAmount0,
@@ -1016,97 +1163,42 @@ const batchGetAmountsFromLiquidity = async (lens, tickLower, tickUpper, liquidit
 };
 const useMintLiquidity = (vaultAddr) => {
 	const client = useClient();
-	const { address } = useAccount();
 	const { pool } = useVaultData(vaultAddr);
-	const { timelockLens, uniswapLens } = useLens();
-	const currentTick = useCurrentTick(pool);
+	const { timelockLens } = useLens();
+	const { exact: currentTick } = useCurrentTick(pool);
 	const { token0, token1 } = usePoolData(pool);
-	const { writeContractAsync, data: hash, isPending, error } = useWriteContract();
-	const { isLoading: isConfirming, isSuccess } = useWaitForTransactionReceipt({ hash });
-	const askForApproval = async (params) => {
-		if (!address || !client) throw new Error("Wallet not connected");
-		if (currentTick.exact === void 0 || !token0 || !token1 || !vaultAddr || !uniswapLens) throw new Error("Current tick not available");
-		const { totalAmount0, totalAmount1 } = await batchGetAmountsFromLiquidity(uniswapLens, params.map((p) => p.tickLower), params.map((p) => p.tickUpper), params.map((p) => p.liquidity), currentTick.exact);
-		const [allowance0, allowance1] = await Promise.all([getErc20(token0, client).read.allowance([address, vaultAddr]), getErc20(token1, client).read.allowance([address, vaultAddr])]);
-		const approvalPromises = [];
-		if (allowance0 <= totalAmount0) {
-			const approvalHash = await writeContractAsync({
-				address: token0,
-				abi: erc20Abi,
-				functionName: "approve",
-				args: [vaultAddr, maxUint256]
-			});
-			approvalPromises.push(waitForTransactionReceipt(client, { hash: approvalHash }));
-		}
-		if (allowance1 <= totalAmount1) {
-			const approvalHash1 = await writeContractAsync({
-				address: token1,
-				abi: erc20Abi,
-				functionName: "approve",
-				args: [vaultAddr, maxUint256]
-			});
-			approvalPromises.push(waitForTransactionReceipt(client, { hash: approvalHash1 }));
-		}
-		if (approvalPromises.length > 0) await Promise.all(approvalPromises);
+	const { askForApproval } = useApproval();
+	const { writeContractAsync } = useWriteContract();
+	const processApproval = async (params) => {
+		if (currentTick === void 0 || !token0 || !token1 || !vaultAddr) throw new Error("Current tick not available");
+		const { totalAmount0, totalAmount1 } = batchGetAmountsFromLiquidity(params.map((p) => p.tickLower), params.map((p) => p.tickUpper), params.map((p) => p.liquidity), currentTick);
+		await askForApproval(token0, vaultAddr, totalAmount0);
+		await askForApproval(token1, vaultAddr, totalAmount1);
 	};
-	const mint = async (tickLower, tickUpper, liquidity) => {
+	return useMutation({ mutationFn: async (params) => {
 		if (!client) throw new Error("Wallet not connected");
-		if (!vaultAddr || !timelockLens) throw new Error("Vault/lens not available");
-		await askForApproval([{
-			tickLower,
-			tickUpper,
-			liquidity
-		}]);
-		const hash$1 = await writeContractAsync({
+		if (currentTick === void 0) throw new Error("Current tick not available");
+		if (!timelockLens || !vaultAddr) throw new Error("Vault/lens not available");
+		if (!Array.isArray(params)) params = [params];
+		if (params.length === 0) throw new Error("No positions to mint");
+		await processApproval(params);
+		const refTicks = await timelockLens.read.batchGetRefTick([vaultAddr, params.map((position) => position.tickLower)]);
+		await waitForTransactionReceipt(client, { hash: await writeContractAsync({
 			address: vaultAddr,
 			abi: singleOwnerVaultAbi,
-			functionName: "mint",
-			args: [
-				tickLower,
-				tickUpper,
-				liquidity,
-				await timelockLens.read.getRefTick([vaultAddr, tickLower])
-			]
-		});
-		await waitForTransactionReceipt(client, { hash: hash$1 });
-		return hash$1;
-	};
-	const mintMultiple = async (positions) => {
-		if (!client) throw new Error("Wallet not connected");
-		if (!currentTick.exact) throw new Error("Current tick not available");
-		if (positions.length === 0) throw new Error("No positions to mint");
-		if (!timelockLens || !vaultAddr) throw new Error("Vault/lens not available");
-		if (positions.length === 1) await mint(positions[0].tickLower, positions[0].tickUpper, positions[0].liquidity);
-		else {
-			await askForApproval(positions);
-			const refTicks = await timelockLens.read.batchGetRefTick([vaultAddr, positions.map((position) => position.tickLower)]);
-			await waitForTransactionReceipt(client, { hash: await writeContractAsync({
-				address: vaultAddr,
+			functionName: "multicall",
+			args: [params.map((p, i) => encodeFunctionData({
 				abi: singleOwnerVaultAbi,
-				functionName: "multicall",
-				args: [positions.map((p, i) => encodeFunctionData({
-					abi: singleOwnerVaultAbi,
-					functionName: "mint",
-					args: [
-						p.tickLower,
-						p.tickUpper,
-						p.liquidity,
-						refTicks[i]
-					]
-				}))]
-			}) });
-		}
-	};
-	return {
-		mintMultiple,
-		mint,
-		hash,
-		isPending,
-		isConfirming,
-		isSuccess,
-		error,
-		isLoading: isPending || isConfirming
-	};
+				functionName: "mint",
+				args: [
+					p.tickLower,
+					p.tickUpper,
+					p.liquidity,
+					refTicks[i]
+				]
+			}))]
+		}) });
+	} });
 };
 
 //#endregion
@@ -1147,5 +1239,5 @@ const useVaultTVL = (vaultAddr) => {
 };
 
 //#endregion
-export { TimelockMarketProvider, batchGetAmountsFromLiquidity, useActiveUserOptions, useApproval, useBurnLiquidity, useClosedUserOptions, useCurrentMarket, useCurrentPrice, useCurrentTick, useExerciseOption, useExtendOption, useLens, useLiquidityBlocks, useMarketData, useMaxPositionSize, useMintLiquidity, useMintOption, useOptionPnl, useOptionPremium, useOptionTimeline, usePoolData, usePriceAtTick, usePriceHistory, useSetOperatorPerms, useTimelockConfig, useUserOperators, useVaultData, useVaultTVL };
+export { TimelockProvider, batchGetAmountsFromLiquidity, useActiveUserOptions, useApproval, useBurnLiquidity, useClosePerp, useClosedUserOptions, useCurrentMarket, useCurrentPrice, useCurrentTick, useExerciseOption, useExtendOption, useLens, useLiquidityBlocks, useMarketData, useMaxPositionSize, useMintLiquidity, useMintOption, useMintPerp, useOptionPnl, useOptionPremium, useOptionTimeline, usePerpsOperator, usePoolData, usePriceAtTick, usePriceHistory, useSetOperatorPerms, useTimelockConfig, useUserOperators, useVaultData, useVaultTVL };
 //# sourceMappingURL=client.js.map