@whetstone-research/doppler-sdk 1.0.2 → 1.0.4

package/dist/solana/react/index.cjs

@@ -0,0 +1,1465 @@
+'use strict';
+
+var chunkBXATWUGJ_cjs = require('../../chunk-BXATWUGJ.cjs');
+var chunkDPKVNI6Q_cjs = require('../../chunk-DPKVNI6Q.cjs');
+require('../../chunk-Q7SFCCGT.cjs');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+var kit = require('@solana/kit');
+
+var AmmContext = react.createContext(null);
+function AmmProvider({
+  rpc,
+  programId = chunkDPKVNI6Q_cjs.CPMM_PROGRAM_ID,
+  commitment = "confirmed",
+  refreshInterval = 3e4,
+  defaultSlippageBps = 50,
+  children
+}) {
+  const value = react.useMemo(
+    () => ({
+      rpc,
+      programId,
+      commitment,
+      refreshInterval,
+      defaultSlippageBps
+    }),
+    [rpc, programId, commitment, refreshInterval, defaultSlippageBps]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(AmmContext.Provider, { value, children });
+}
+function useAmm() {
+  const context = react.useContext(AmmContext);
+  if (!context) {
+    throw new Error("useAmm must be used within an AmmProvider");
+  }
+  return context;
+}
+function useAmmOptional() {
+  return react.useContext(AmmContext);
+}
+var WalletContext = react.createContext(null);
+function WalletProvider({
+  wallet,
+  signAndSendTransaction,
+  children
+}) {
+  const value = react.useMemo(
+    () => ({
+      ...wallet,
+      signAndSendTransaction
+    }),
+    [wallet, signAndSendTransaction]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(WalletContext.Provider, { value, children });
+}
+function useWallet() {
+  const context = react.useContext(WalletContext);
+  if (!context) {
+    throw new Error("useWallet must be used within a WalletProvider");
+  }
+  return context;
+}
+function useWalletOptional() {
+  return react.useContext(WalletContext);
+}
+function useWalletAddress() {
+  const { connected, address } = useWallet();
+  if (!connected || !address) {
+    throw new Error("Wallet is not connected");
+  }
+  return address;
+}
+var AmmContext2 = react.createContext(null);
+AmmContext2.displayName = "AmmContext";
+function useAmm2() {
+  const ctx = react.useContext(AmmContext2);
+  if (!ctx) {
+    throw new Error("useAmm must be used within AmmProvider");
+  }
+  return ctx;
+}
+function createAmmContextValue(config) {
+  const {
+    endpoint,
+    programId,
+    commitment = "confirmed",
+    refreshInterval = 3e4,
+    defaultSlippageBps = 50
+  } = config;
+  const rpc = kit.createSolanaRpc(endpoint);
+  return {
+    rpc,
+    endpoint,
+    programId: programId ?? chunkDPKVNI6Q_cjs.CPMM_PROGRAM_ID,
+    commitment,
+    refreshInterval,
+    defaultSlippageBps
+  };
+}
+function AmmProvider2({
+  children,
+  endpoint,
+  programId,
+  commitment = "confirmed",
+  refreshInterval = 3e4,
+  defaultSlippageBps = 50
+}) {
+  const value = react.useMemo(
+    () => createAmmContextValue({
+      endpoint,
+      programId,
+      commitment,
+      refreshInterval,
+      defaultSlippageBps
+    }),
+    [endpoint, programId, commitment, refreshInterval, defaultSlippageBps]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(AmmContext2.Provider, { value, children });
+}
+function isConnectableWallet(wallet) {
+  return "standard:connect" in wallet.features;
+}
+function getWallets() {
+  if (typeof window === "undefined") {
+    return [];
+  }
+  const registry = window.navigator?.wallets;
+  if (!registry) {
+    return [];
+  }
+  const wallets = [];
+  try {
+    const registered = registry.get?.() ?? [];
+    for (const wallet of registered) {
+      const supportsSolana = wallet.chains?.some(
+        (chain) => chain.startsWith("solana:")
+      );
+      if (supportsSolana && isConnectableWallet(wallet)) {
+        wallets.push(wallet);
+      }
+    }
+  } catch {
+  }
+  return wallets;
+}
+var WalletContext2 = react.createContext(null);
+WalletContext2.displayName = "WalletContext";
+function useWallet2() {
+  const ctx = react.useContext(WalletContext2);
+  if (!ctx) {
+    throw new Error("useWallet must be used within WalletProvider");
+  }
+  return ctx;
+}
+function createWalletContextValue() {
+  return {
+    wallet: null,
+    account: null,
+    connected: false,
+    connecting: false,
+    wallets: [],
+    select: () => {
+    },
+    connect: async () => {
+    },
+    disconnect: async () => {
+    },
+    error: null
+  };
+}
+function WalletProvider2({
+  children,
+  autoConnect = false,
+  onConnect,
+  onDisconnect,
+  onError
+}) {
+  const [wallets, setWallets] = react.useState([]);
+  const [wallet, setWallet] = react.useState(null);
+  const [account, setAccount] = react.useState(null);
+  const [connecting, setConnecting] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const connected = account !== null;
+  react.useEffect(() => {
+    const discovered = getWallets();
+    setWallets(discovered);
+    if (typeof window !== "undefined") {
+      const registry = window.navigator?.wallets;
+      if (registry?.on) {
+        const unsubscribe = registry.on("register", () => {
+          setWallets(getWallets());
+        });
+        return () => {
+          unsubscribe?.();
+        };
+      }
+    }
+    return void 0;
+  }, []);
+  const select = react.useCallback((newWallet) => {
+    setWallet(newWallet);
+    setError(null);
+  }, []);
+  const connect = react.useCallback(async () => {
+    if (!wallet) {
+      const err = new Error("No wallet selected");
+      setError(err);
+      onError?.(err);
+      return;
+    }
+    setConnecting(true);
+    setError(null);
+    try {
+      const connectFeature = wallet.features["standard:connect"];
+      const result = await connectFeature.connect();
+      if (result.accounts.length > 0) {
+        const connectedAccount = result.accounts[0];
+        setAccount(connectedAccount);
+        onConnect?.(connectedAccount);
+      } else {
+        throw new Error("No accounts returned from wallet");
+      }
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      setError(error2);
+      onError?.(error2);
+    } finally {
+      setConnecting(false);
+    }
+  }, [wallet, onConnect, onError]);
+  const disconnect = react.useCallback(async () => {
+    if (!wallet) {
+      return;
+    }
+    try {
+      const disconnectFeature = wallet.features["standard:disconnect"];
+      if (disconnectFeature) {
+        await disconnectFeature.disconnect();
+      }
+    } catch (err) {
+      console.warn("Disconnect error:", err);
+    } finally {
+      setAccount(null);
+      onDisconnect?.();
+    }
+  }, [wallet, onDisconnect]);
+  react.useEffect(() => {
+    if (autoConnect && wallet && !connected && !connecting) {
+      const connectFeature = wallet.features["standard:connect"];
+      connectFeature.connect({ silent: true }).then(
+        (result) => {
+          if (result.accounts.length > 0) {
+            setAccount(result.accounts[0]);
+            onConnect?.(result.accounts[0]);
+          }
+        }
+      ).catch(() => {
+      });
+    }
+  }, [autoConnect, wallet, connected, connecting, onConnect]);
+  react.useEffect(() => {
+    if (!wallet) return void 0;
+    const eventsFeature = wallet.features["standard:events"];
+    if (eventsFeature?.on) {
+      const unsubscribe = eventsFeature.on("change", () => {
+        if (wallet.accounts.length > 0) {
+          setAccount(wallet.accounts[0]);
+        } else {
+          setAccount(null);
+          onDisconnect?.();
+        }
+      });
+      return () => {
+        unsubscribe?.();
+      };
+    }
+    return void 0;
+  }, [wallet, onDisconnect]);
+  const value = react.useMemo(
+    () => ({
+      wallet,
+      account,
+      connected,
+      connecting,
+      wallets,
+      select,
+      connect,
+      disconnect,
+      error
+    }),
+    [
+      wallet,
+      account,
+      connected,
+      connecting,
+      wallets,
+      select,
+      connect,
+      disconnect,
+      error
+    ]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(WalletContext2.Provider, { value, children });
+}
+function usePool(poolAddress, options = {}) {
+  const {
+    rpc,
+    programId,
+    commitment: defaultCommitment,
+    refreshInterval: defaultRefreshInterval
+  } = useAmm();
+  const {
+    refreshInterval = defaultRefreshInterval,
+    fetchOnMount = true,
+    commitment = defaultCommitment
+  } = options;
+  const [pool, setPool] = react.useState(null);
+  const [loading, setLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const [refetching, setRefetching] = react.useState(false);
+  const mountedRef = react.useRef(true);
+  const fetchPoolData = react.useCallback(
+    async (isRefetch = false) => {
+      if (!poolAddress) {
+        setPool(null);
+        setLoading(false);
+        return;
+      }
+      if (isRefetch) {
+        setRefetching(true);
+      } else {
+        setLoading(true);
+      }
+      setError(null);
+      try {
+        const poolData = await chunkBXATWUGJ_cjs.fetchPool(rpc, poolAddress, {
+          programId,
+          commitment
+        });
+        if (mountedRef.current) {
+          setPool(poolData);
+        }
+      } catch (err) {
+        if (mountedRef.current) {
+          setError(err instanceof Error ? err : new Error(String(err)));
+        }
+      } finally {
+        if (mountedRef.current) {
+          setLoading(false);
+          setRefetching(false);
+        }
+      }
+    },
+    [poolAddress, rpc, programId, commitment]
+  );
+  const refetch = react.useCallback(async () => {
+    await fetchPoolData(true);
+  }, [fetchPoolData]);
+  react.useEffect(() => {
+    mountedRef.current = true;
+    if (fetchOnMount) {
+      fetchPoolData(false);
+    }
+    return () => {
+      mountedRef.current = false;
+    };
+  }, [fetchPoolData, fetchOnMount]);
+  react.useEffect(() => {
+    if (refreshInterval <= 0 || !poolAddress) {
+      return;
+    }
+    const intervalId = setInterval(() => {
+      fetchPoolData(true);
+    }, refreshInterval);
+    return () => {
+      clearInterval(intervalId);
+    };
+  }, [fetchPoolData, refreshInterval, poolAddress]);
+  return {
+    pool,
+    loading,
+    error,
+    refetch,
+    refetching
+  };
+}
+function usePools(poolAddresses, options = {}) {
+  const {
+    rpc,
+    programId,
+    commitment: defaultCommitment,
+    refreshInterval: defaultRefreshInterval
+  } = useAmm();
+  const {
+    refreshInterval = defaultRefreshInterval,
+    fetchOnMount = true,
+    commitment = defaultCommitment
+  } = options;
+  const [pools, setPools] = react.useState(/* @__PURE__ */ new Map());
+  const [loading, setLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const mountedRef = react.useRef(true);
+  const fetchPools = react.useCallback(async () => {
+    if (poolAddresses.length === 0) {
+      setPools(/* @__PURE__ */ new Map());
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const results = await Promise.all(
+        poolAddresses.map(
+          (addr) => chunkBXATWUGJ_cjs.fetchPool(rpc, addr, { programId, commitment }).then((pool) => [addr, pool]).catch(() => [addr, null])
+        )
+      );
+      if (mountedRef.current) {
+        const poolMap = /* @__PURE__ */ new Map();
+        for (const [addr, pool] of results) {
+          if (pool) {
+            poolMap.set(addr, pool);
+          }
+        }
+        setPools(poolMap);
+      }
+    } catch (err) {
+      if (mountedRef.current) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    } finally {
+      if (mountedRef.current) {
+        setLoading(false);
+      }
+    }
+  }, [poolAddresses, rpc, programId, commitment]);
+  react.useEffect(() => {
+    mountedRef.current = true;
+    if (fetchOnMount) {
+      fetchPools();
+    }
+    return () => {
+      mountedRef.current = false;
+    };
+  }, [fetchPools, fetchOnMount]);
+  react.useEffect(() => {
+    if (refreshInterval <= 0 || poolAddresses.length === 0) {
+      return;
+    }
+    const intervalId = setInterval(fetchPools, refreshInterval);
+    return () => clearInterval(intervalId);
+  }, [fetchPools, refreshInterval, poolAddresses.length]);
+  return {
+    pools,
+    loading,
+    error,
+    refetch: fetchPools
+  };
+}
+function useSwap(options) {
+  const { defaultSlippageBps: contextSlippage } = useAmm();
+  const {
+    defaultSlippageBps = contextSlippage ?? 50,
+    pool,
+    token0Mint,
+    token1Mint
+  } = options;
+  const [state, setState] = react.useState({
+    inputToken: token0Mint,
+    outputToken: token1Mint,
+    inputAmount: 0n,
+    outputAmount: 0n,
+    exactInput: true,
+    slippageBps: defaultSlippageBps
+  });
+  const [quoting] = react.useState(false);
+  const direction = react.useMemo(() => {
+    if (!token0Mint || !token1Mint || !state.inputToken) return null;
+    if (state.inputToken === token0Mint) return 0;
+    if (state.inputToken === token1Mint) return 1;
+    return null;
+  }, [token0Mint, token1Mint, state.inputToken]);
+  const quote = react.useMemo(() => {
+    if (!pool || direction === null) {
+      return null;
+    }
+    if (state.exactInput) {
+      if (state.inputAmount === 0n) {
+        return {
+          amountOut: 0n,
+          feeTotal: 0n,
+          feeDist: 0n,
+          feeComp: 0n,
+          priceImpact: 0,
+          executionPrice: 0,
+          minAmountOut: 0n,
+          maxAmountIn: 0n,
+          direction,
+          isValid: false,
+          error: null
+        };
+      }
+      try {
+        const swapQuote = chunkBXATWUGJ_cjs.getSwapQuote(pool, state.inputAmount, direction);
+        const slippageFactor = chunkDPKVNI6Q_cjs.BPS_DENOM - BigInt(state.slippageBps);
+        const minAmountOut = swapQuote.amountOut * slippageFactor / chunkDPKVNI6Q_cjs.BPS_DENOM;
+        return {
+          ...swapQuote,
+          minAmountOut,
+          maxAmountIn: state.inputAmount,
+          direction,
+          isValid: swapQuote.amountOut > 0n,
+          error: null
+        };
+      } catch (err) {
+        return {
+          amountOut: 0n,
+          feeTotal: 0n,
+          feeDist: 0n,
+          feeComp: 0n,
+          priceImpact: 0,
+          executionPrice: 0,
+          minAmountOut: 0n,
+          maxAmountIn: 0n,
+          direction,
+          isValid: false,
+          error: err instanceof Error ? err.message : "Failed to calculate quote"
+        };
+      }
+    } else {
+      if (state.outputAmount === 0n) {
+        return {
+          amountOut: 0n,
+          feeTotal: 0n,
+          feeDist: 0n,
+          feeComp: 0n,
+          priceImpact: 0,
+          executionPrice: 0,
+          minAmountOut: 0n,
+          maxAmountIn: 0n,
+          direction,
+          isValid: false,
+          error: null
+        };
+      }
+      try {
+        const { amountIn, feeTotal } = chunkBXATWUGJ_cjs.getSwapQuoteExactOut(
+          pool,
+          state.outputAmount,
+          direction
+        );
+        const slippageFactor = chunkDPKVNI6Q_cjs.BPS_DENOM + BigInt(state.slippageBps);
+        const maxAmountIn = amountIn * slippageFactor / chunkDPKVNI6Q_cjs.BPS_DENOM;
+        const forwardQuote = chunkBXATWUGJ_cjs.getSwapQuote(pool, amountIn, direction);
+        return {
+          amountOut: state.outputAmount,
+          feeTotal,
+          feeDist: 0n,
+          // Not calculated for exact out
+          feeComp: 0n,
+          priceImpact: forwardQuote.priceImpact,
+          executionPrice: chunkBXATWUGJ_cjs.ratioToNumber(state.outputAmount, amountIn),
+          minAmountOut: state.outputAmount,
+          maxAmountIn,
+          direction,
+          isValid: amountIn > 0n,
+          error: null
+        };
+      } catch (err) {
+        return {
+          amountOut: 0n,
+          feeTotal: 0n,
+          feeDist: 0n,
+          feeComp: 0n,
+          priceImpact: 0,
+          executionPrice: 0,
+          minAmountOut: 0n,
+          maxAmountIn: 0n,
+          direction,
+          isValid: false,
+          error: err instanceof Error ? err.message : "Failed to calculate quote"
+        };
+      }
+    }
+  }, [
+    pool,
+    direction,
+    state.inputAmount,
+    state.outputAmount,
+    state.exactInput,
+    state.slippageBps
+  ]);
+  const setInputToken = react.useCallback((token) => {
+    setState((s) => ({ ...s, inputToken: token }));
+  }, []);
+  const setOutputToken = react.useCallback((token) => {
+    setState((s) => ({ ...s, outputToken: token }));
+  }, []);
+  const setInputAmount = react.useCallback((amount) => {
+    setState((s) => ({
+      ...s,
+      inputAmount: amount,
+      exactInput: true
+    }));
+  }, []);
+  const setOutputAmount = react.useCallback((amount) => {
+    setState((s) => ({
+      ...s,
+      outputAmount: amount,
+      exactInput: false
+    }));
+  }, []);
+  const setSlippage = react.useCallback((bps) => {
+    setState((s) => ({ ...s, slippageBps: bps }));
+  }, []);
+  const flipTokens = react.useCallback(() => {
+    setState((s) => ({
+      ...s,
+      inputToken: s.outputToken,
+      outputToken: s.inputToken,
+      inputAmount: s.outputAmount,
+      outputAmount: s.inputAmount
+    }));
+  }, []);
+  const reset = react.useCallback(() => {
+    setState({
+      inputToken: token0Mint,
+      outputToken: token1Mint,
+      inputAmount: 0n,
+      outputAmount: 0n,
+      exactInput: true,
+      slippageBps: defaultSlippageBps
+    });
+  }, [token0Mint, token1Mint, defaultSlippageBps]);
+  const canSwap = react.useMemo(() => {
+    return !!(quote?.isValid && state.inputToken && state.outputToken && (state.exactInput ? state.inputAmount > 0n : state.outputAmount > 0n));
+  }, [quote, state]);
+  return {
+    state,
+    quote,
+    quoting,
+    setInputToken,
+    setOutputToken,
+    setInputAmount,
+    setOutputAmount,
+    setSlippage,
+    flipTokens,
+    reset,
+    canSwap
+  };
+}
+function useLiquidity(options) {
+  const { defaultSlippageBps: contextSlippage } = useAmm();
+  const {
+    pool,
+    userShares = 0n,
+    defaultSlippageBps = contextSlippage ?? 50,
+    defaultMode = "add"
+  } = options;
+  const [mode, setMode] = react.useState(defaultMode);
+  const [addState, setAddState] = react.useState({
+    amount0: 0n,
+    amount1: 0n,
+    slippageBps: defaultSlippageBps
+  });
+  const [removeState, setRemoveState] = react.useState({
+    shares: 0n,
+    percentage: 0,
+    slippageBps: defaultSlippageBps
+  });
+  const addQuote = react.useMemo(() => {
+    if (!pool) {
+      return null;
+    }
+    if (addState.amount0 === 0n && addState.amount1 === 0n) {
+      return {
+        sharesOut: 0n,
+        amount0: 0n,
+        amount1: 0n,
+        poolShare: 0,
+        minSharesOut: 0n,
+        isValid: false,
+        error: null
+      };
+    }
+    try {
+      const quote = chunkBXATWUGJ_cjs.getAddLiquidityQuote(
+        pool,
+        addState.amount0,
+        addState.amount1
+      );
+      const slippageFactor = chunkDPKVNI6Q_cjs.BPS_DENOM - BigInt(addState.slippageBps);
+      const minSharesOut = quote.sharesOut * slippageFactor / chunkDPKVNI6Q_cjs.BPS_DENOM;
+      return {
+        ...quote,
+        minSharesOut,
+        isValid: quote.sharesOut > 0n,
+        error: null
+      };
+    } catch (err) {
+      return {
+        sharesOut: 0n,
+        amount0: 0n,
+        amount1: 0n,
+        poolShare: 0,
+        minSharesOut: 0n,
+        isValid: false,
+        error: err instanceof Error ? err.message : "Failed to calculate quote"
+      };
+    }
+  }, [pool, addState.amount0, addState.amount1, addState.slippageBps]);
+  const removeQuote = react.useMemo(() => {
+    if (!pool) {
+      return null;
+    }
+    if (removeState.shares === 0n) {
+      return {
+        amount0: 0n,
+        amount1: 0n,
+        minAmount0Out: 0n,
+        minAmount1Out: 0n,
+        isValid: false,
+        error: null
+      };
+    }
+    try {
+      const quote = chunkBXATWUGJ_cjs.getRemoveLiquidityQuote(pool, removeState.shares);
+      const slippageFactor = chunkDPKVNI6Q_cjs.BPS_DENOM - BigInt(removeState.slippageBps);
+      const minAmount0Out = quote.amount0 * slippageFactor / chunkDPKVNI6Q_cjs.BPS_DENOM;
+      const minAmount1Out = quote.amount1 * slippageFactor / chunkDPKVNI6Q_cjs.BPS_DENOM;
+      return {
+        ...quote,
+        minAmount0Out,
+        minAmount1Out,
+        isValid: quote.amount0 > 0n || quote.amount1 > 0n,
+        error: null
+      };
+    } catch (err) {
+      return {
+        amount0: 0n,
+        amount1: 0n,
+        minAmount0Out: 0n,
+        minAmount1Out: 0n,
+        isValid: false,
+        error: err instanceof Error ? err.message : "Failed to calculate quote"
+      };
+    }
+  }, [pool, removeState.shares, removeState.slippageBps]);
+  const setAmount0 = react.useCallback((amount) => {
+    setAddState((s) => ({ ...s, amount0: amount }));
+  }, []);
+  const setAmount1 = react.useCallback((amount) => {
+    setAddState((s) => ({ ...s, amount1: amount }));
+  }, []);
+  const setShares = react.useCallback(
+    (shares) => {
+      setRemoveState((s) => ({
+        ...s,
+        shares,
+        percentage: userShares > 0n ? Number(shares * 100n / userShares) : 0
+      }));
+    },
+    [userShares]
+  );
+  const setPercentage = react.useCallback(
+    (percentage) => {
+      const clampedPercentage = Math.min(100, Math.max(0, percentage));
+      const shares = userShares * BigInt(Math.round(clampedPercentage)) / 100n;
+      setRemoveState((s) => ({
+        ...s,
+        shares,
+        percentage: clampedPercentage
+      }));
+    },
+    [userShares]
+  );
+  const setSlippage = react.useCallback((bps) => {
+    setAddState((s) => ({ ...s, slippageBps: bps }));
+    setRemoveState((s) => ({ ...s, slippageBps: bps }));
+  }, []);
+  const reset = react.useCallback(() => {
+    setAddState({
+      amount0: 0n,
+      amount1: 0n,
+      slippageBps: defaultSlippageBps
+    });
+    setRemoveState({
+      shares: 0n,
+      percentage: 0,
+      slippageBps: defaultSlippageBps
+    });
+  }, [defaultSlippageBps]);
+  const canAdd = react.useMemo(() => {
+    return !!(addQuote?.isValid && (addState.amount0 > 0n || addState.amount1 > 0n));
+  }, [addQuote, addState]);
+  const canRemove = react.useMemo(() => {
+    return !!(removeQuote?.isValid && removeState.shares > 0n && removeState.shares <= userShares);
+  }, [removeQuote, removeState.shares, userShares]);
+  return {
+    mode,
+    setMode,
+    addState,
+    addQuote,
+    setAmount0,
+    setAmount1,
+    canAdd,
+    removeState,
+    removeQuote,
+    setShares,
+    setPercentage,
+    canRemove,
+    setSlippage,
+    reset
+  };
+}
+function usePosition(poolAddress, positionId = 0n, options = {}) {
+  const {
+    rpc,
+    programId,
+    commitment: defaultCommitment,
+    refreshInterval: defaultRefreshInterval
+  } = useAmm();
+  const wallet = useWalletOptional();
+  const {
+    refreshInterval = defaultRefreshInterval,
+    fetchOnMount = true,
+    commitment = defaultCommitment,
+    pool: providedPool
+  } = options;
+  const [position, setPosition] = react.useState(null);
+  const [positionAddress, setPositionAddress] = react.useState();
+  const [pool, setPool] = react.useState(providedPool ?? null);
+  const [loading, setLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const mountedRef = react.useRef(true);
+  const ownerAddress = wallet?.address;
+  const fetchPositionData = react.useCallback(async () => {
+    if (!poolAddress || !ownerAddress) {
+      setPosition(null);
+      setPositionAddress(void 0);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const { getPositionAddress } = await import('../../pda-ZZMBZSFU.cjs');
+      const [posAddr] = await getPositionAddress(
+        poolAddress,
+        ownerAddress,
+        positionId,
+        programId
+      );
+      setPositionAddress(posAddr);
+      const [positionData, poolData] = await Promise.all([
+        chunkBXATWUGJ_cjs.fetchPosition(rpc, posAddr, { programId, commitment }),
+        providedPool ? Promise.resolve(providedPool) : chunkBXATWUGJ_cjs.fetchPool(rpc, poolAddress, { programId, commitment })
+      ]);
+      if (mountedRef.current) {
+        setPosition(positionData);
+        setPool(poolData);
+      }
+    } catch (err) {
+      if (mountedRef.current) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    } finally {
+      if (mountedRef.current) {
+        setLoading(false);
+      }
+    }
+  }, [
+    poolAddress,
+    ownerAddress,
+    positionId,
+    rpc,
+    programId,
+    commitment,
+    providedPool
+  ]);
+  const refetch = react.useCallback(async () => {
+    await fetchPositionData();
+  }, [fetchPositionData]);
+  const pendingFees = react.useMemo(() => {
+    if (!pool || !position) return null;
+    return chunkBXATWUGJ_cjs.getPendingFees(pool, position);
+  }, [pool, position]);
+  const value = react.useMemo(() => {
+    if (!pool || !position) return null;
+    return chunkBXATWUGJ_cjs.getPositionValue(pool, position);
+  }, [pool, position]);
+  react.useEffect(() => {
+    mountedRef.current = true;
+    if (fetchOnMount) {
+      fetchPositionData();
+    }
+    return () => {
+      mountedRef.current = false;
+    };
+  }, [fetchPositionData, fetchOnMount]);
+  react.useEffect(() => {
+    if (refreshInterval <= 0 || !poolAddress || !ownerAddress) {
+      return;
+    }
+    const intervalId = setInterval(fetchPositionData, refreshInterval);
+    return () => clearInterval(intervalId);
+  }, [fetchPositionData, refreshInterval, poolAddress, ownerAddress]);
+  return {
+    position,
+    positionAddress,
+    loading,
+    error,
+    refetch,
+    pendingFees,
+    value
+  };
+}
+function useUserPositions(poolFilter, options = {}) {
+  const {
+    rpc,
+    programId,
+    commitment: defaultCommitment,
+    refreshInterval: defaultRefreshInterval
+  } = useAmm();
+  const wallet = useWalletOptional();
+  const {
+    refreshInterval = defaultRefreshInterval,
+    fetchOnMount = true,
+    commitment = defaultCommitment
+  } = options;
+  const [positions, setPositions] = react.useState([]);
+  const [loading, setLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const mountedRef = react.useRef(true);
+  const ownerAddress = wallet?.address;
+  const fetchPositions = react.useCallback(async () => {
+    if (!ownerAddress) {
+      setPositions([]);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const positionsData = await chunkBXATWUGJ_cjs.fetchUserPositions(
+        rpc,
+        ownerAddress,
+        poolFilter,
+        {
+          programId,
+          commitment
+        }
+      );
+      if (mountedRef.current) {
+        setPositions(positionsData.filter((p) => p.account.shares > 0n));
+      }
+    } catch (err) {
+      if (mountedRef.current) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    } finally {
+      if (mountedRef.current) {
+        setLoading(false);
+      }
+    }
+  }, [ownerAddress, poolFilter, rpc, programId, commitment]);
+  react.useEffect(() => {
+    mountedRef.current = true;
+    if (fetchOnMount) {
+      fetchPositions();
+    }
+    return () => {
+      mountedRef.current = false;
+    };
+  }, [fetchPositions, fetchOnMount]);
+  react.useEffect(() => {
+    if (refreshInterval <= 0 || !ownerAddress) {
+      return;
+    }
+    const intervalId = setInterval(fetchPositions, refreshInterval);
+    return () => clearInterval(intervalId);
+  }, [fetchPositions, refreshInterval, ownerAddress]);
+  return {
+    positions,
+    loading,
+    error,
+    refetch: fetchPositions
+  };
+}
+function useFees(positionAddress, poolAddress, options = {}) {
+  const {
+    rpc,
+    programId,
+    commitment: defaultCommitment,
+    refreshInterval: defaultRefreshInterval
+  } = useAmm();
+  const wallet = useWalletOptional();
+  const {
+    refreshInterval = defaultRefreshInterval,
+    fetchOnMount = true,
+    commitment = defaultCommitment,
+    pool: providedPool,
+    position: providedPosition
+  } = options;
+  const [pool, setPool] = react.useState(providedPool ?? null);
+  const [position, setPosition] = react.useState(
+    providedPosition ?? null
+  );
+  const [loading, setLoading] = react.useState(true);
+  const [refetching, setRefetching] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [status, setStatus] = react.useState("idle");
+  const [txError, setTxError] = react.useState(null);
+  const [txSignature, setTxSignature] = react.useState(null);
+  const mountedRef = react.useRef(true);
+  react.useEffect(() => {
+    if (providedPool) setPool(providedPool);
+    if (providedPosition) setPosition(providedPosition);
+  }, [providedPool, providedPosition]);
+  const fees = react.useMemo(() => {
+    if (!pool || !position) return null;
+    const { pending0, pending1 } = chunkBXATWUGJ_cjs.getPendingFees(pool, position);
+    return {
+      pending0,
+      pending1,
+      hasFees: pending0 > 0n || pending1 > 0n
+    };
+  }, [pool, position]);
+  const fetchFeesData = react.useCallback(
+    async (isRefetch = false) => {
+      if (providedPool && providedPosition) {
+        setLoading(false);
+        return;
+      }
+      if (!positionAddress && !providedPosition) {
+        setLoading(false);
+        return;
+      }
+      if (isRefetch) {
+        setRefetching(true);
+      } else {
+        setLoading(true);
+      }
+      setError(null);
+      try {
+        const promises = [];
+        if (!providedPosition && positionAddress) {
+          promises.push(
+            chunkBXATWUGJ_cjs.fetchPosition(rpc, positionAddress, { programId, commitment })
+          );
+        } else {
+          promises.push(Promise.resolve(providedPosition));
+        }
+        if (!providedPool && poolAddress) {
+          promises.push(chunkBXATWUGJ_cjs.fetchPool(rpc, poolAddress, { programId, commitment }));
+        } else {
+          promises.push(Promise.resolve(providedPool));
+        }
+        const [posData, poolData] = await Promise.all(promises);
+        if (mountedRef.current) {
+          if (posData && !providedPosition) setPosition(posData);
+          if (poolData && !providedPool) setPool(poolData);
+        }
+      } catch (err) {
+        if (mountedRef.current) {
+          setError(err instanceof Error ? err : new Error(String(err)));
+        }
+      } finally {
+        if (mountedRef.current) {
+          setLoading(false);
+          setRefetching(false);
+        }
+      }
+    },
+    [
+      positionAddress,
+      poolAddress,
+      providedPool,
+      providedPosition,
+      rpc,
+      programId,
+      commitment
+    ]
+  );
+  const refetch = react.useCallback(async () => {
+    await fetchFeesData(true);
+  }, [fetchFeesData]);
+  const collect = react.useCallback(
+    async (collectOptions) => {
+      if (!pool || !poolAddress || !position || !positionAddress || !wallet?.address) {
+        throw new Error("Pool, position, or wallet not available");
+      }
+      if (!wallet.signer) {
+        throw new Error("Wallet signer is not available");
+      }
+      setStatus("signing");
+      setTxError(null);
+      setTxSignature(null);
+      try {
+        const {
+          max0 = chunkBXATWUGJ_cjs.MAX_FEE_AMOUNT,
+          max1 = chunkBXATWUGJ_cjs.MAX_FEE_AMOUNT,
+          userToken0,
+          userToken1
+        } = collectOptions;
+        const ix = chunkBXATWUGJ_cjs.createCollectFeesInstruction(
+          {
+            pool: poolAddress,
+            position: positionAddress,
+            owner: wallet.address,
+            authority: pool.authority,
+            vault0: pool.vault0,
+            vault1: pool.vault1,
+            token0Mint: pool.token0Mint,
+            token1Mint: pool.token1Mint,
+            user0: userToken0,
+            user1: userToken1
+          },
+          { max0, max1 },
+          programId
+        );
+        const { value: latestBlockhash } = await rpc.getLatestBlockhash({ commitment }).send();
+        const baseMessage = kit.createTransactionMessage({ version: "legacy" });
+        const messageWithPayer = kit.setTransactionMessageFeePayerSigner(
+          wallet.signer,
+          baseMessage
+        );
+        const messageWithLifetime = kit.setTransactionMessageLifetimeUsingBlockhash(
+          latestBlockhash,
+          messageWithPayer
+        );
+        const messageWithIx = kit.appendTransactionMessageInstruction(
+          ix,
+          messageWithLifetime
+        );
+        setStatus("sending");
+        const signedTransaction = await kit.signTransactionMessageWithSigners(messageWithIx);
+        const wireTransaction = kit.getBase64EncodedWireTransaction(signedTransaction);
+        const signature = await rpc.sendTransaction(wireTransaction, { encoding: "base64" }).send();
+        setStatus("success");
+        setTxSignature(signature);
+        await fetchFeesData(true);
+        return signature;
+      } catch (err) {
+        setStatus("error");
+        const error2 = err instanceof Error ? err : new Error(String(err));
+        setTxError(error2);
+        throw error2;
+      }
+    },
+    [
+      pool,
+      poolAddress,
+      position,
+      positionAddress,
+      wallet,
+      programId,
+      rpc,
+      commitment,
+      fetchFeesData
+    ]
+  );
+  const reset = react.useCallback(() => {
+    setStatus("idle");
+    setTxError(null);
+    setTxSignature(null);
+  }, []);
+  const canCollect = react.useMemo(() => {
+    return !!(fees?.hasFees && wallet?.connected && wallet?.signer && pool && position);
+  }, [fees, wallet, pool, position]);
+  react.useEffect(() => {
+    mountedRef.current = true;
+    if (fetchOnMount) {
+      fetchFeesData(false);
+    }
+    return () => {
+      mountedRef.current = false;
+    };
+  }, [fetchFeesData, fetchOnMount]);
+  react.useEffect(() => {
+    if (refreshInterval <= 0) {
+      return;
+    }
+    const intervalId = setInterval(() => {
+      fetchFeesData(true);
+    }, refreshInterval);
+    return () => {
+      clearInterval(intervalId);
+    };
+  }, [fetchFeesData, refreshInterval]);
+  return {
+    fees,
+    loading,
+    error,
+    refetch,
+    refetching,
+    collect,
+    status,
+    txError,
+    txSignature,
+    reset,
+    canCollect
+  };
+}
+function useFeesFromData(pool, position) {
+  return react.useMemo(() => {
+    if (!pool || !position) return null;
+    const { pending0, pending1 } = chunkBXATWUGJ_cjs.getPendingFees(pool, position);
+    return {
+      pending0,
+      pending1,
+      hasFees: pending0 > 0n || pending1 > 0n
+    };
+  }, [pool, position]);
+}
+function useOracle(poolAddress, options = {}) {
+  const {
+    rpc,
+    programId,
+    commitment: defaultCommitment,
+    refreshInterval: defaultRefreshInterval
+  } = useAmm();
+  const {
+    refreshInterval = defaultRefreshInterval,
+    fetchOnMount = true,
+    commitment = defaultCommitment
+  } = options;
+  const [oracle, setOracle] = react.useState(null);
+  const [oracleAddress, setOracleAddress] = react.useState(null);
+  const [loading, setLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const mountedRef = react.useRef(true);
+  const fetchOracleData = react.useCallback(async () => {
+    if (!poolAddress) {
+      setOracle(null);
+      setOracleAddress(null);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const [oracleAddr] = await chunkDPKVNI6Q_cjs.getOracleAddress(poolAddress, programId);
+      setOracleAddress(oracleAddr);
+      const oracleData = await chunkBXATWUGJ_cjs.fetchOracle(rpc, oracleAddr, {
+        programId,
+        commitment
+      });
+      if (mountedRef.current) {
+        setOracle(oracleData);
+      }
+    } catch (err) {
+      if (mountedRef.current) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    } finally {
+      if (mountedRef.current) {
+        setLoading(false);
+      }
+    }
+  }, [poolAddress, rpc, programId, commitment]);
+  const refetch = react.useCallback(async () => {
+    await fetchOracleData();
+  }, [fetchOracleData]);
+  const twap = react.useCallback(
+    (windowSeconds) => {
+      if (!oracle || !oracle.initialized) return null;
+      return chunkBXATWUGJ_cjs.consultTwap(oracle, windowSeconds);
+    },
+    [oracle]
+  );
+  const spotPrice = react.useMemo(() => {
+    if (!oracle || !oracle.initialized) return null;
+    const prices = chunkBXATWUGJ_cjs.getOracleSpotPrices(oracle);
+    return { price0: prices.price0, price1: prices.price1 };
+  }, [oracle]);
+  const deviation = react.useMemo(() => {
+    if (!oracle || !oracle.initialized) return null;
+    const dev = chunkBXATWUGJ_cjs.getOracleDeviation(oracle);
+    return { deviation0: dev.deviation0, deviation1: dev.deviation1 };
+  }, [oracle]);
+  const age = react.useMemo(() => {
+    if (!oracle || !oracle.initialized) return null;
+    return chunkBXATWUGJ_cjs.getOracleAge(oracle);
+  }, [oracle]);
+  const isStaleCheck = react.useCallback(
+    (maxAgeSeconds) => {
+      if (!oracle || !oracle.initialized) return true;
+      return chunkBXATWUGJ_cjs.isOracleStale(oracle, maxAgeSeconds);
+    },
+    [oracle]
+  );
+  const bufferStats = react.useMemo(() => {
+    if (!oracle || !oracle.initialized) return null;
+    const stats = chunkBXATWUGJ_cjs.getOracleBufferStats(oracle);
+    return {
+      capacity: stats.capacity,
+      filledCount: stats.filledCount,
+      currentIndex: stats.currentIndex,
+      timeSpanSeconds: stats.timeSpanSeconds
+    };
+  }, [oracle]);
+  const compareWithPool = react.useCallback(
+    (pool) => {
+      if (!oracle || !oracle.initialized) return null;
+      return chunkBXATWUGJ_cjs.comparePoolAndOraclePrices(pool, oracle);
+    },
+    [oracle]
+  );
+  react.useEffect(() => {
+    mountedRef.current = true;
+    if (fetchOnMount) {
+      fetchOracleData();
+    }
+    return () => {
+      mountedRef.current = false;
+    };
+  }, [fetchOracleData, fetchOnMount]);
+  react.useEffect(() => {
+    if (refreshInterval <= 0 || !poolAddress) {
+      return;
+    }
+    const intervalId = setInterval(fetchOracleData, refreshInterval);
+    return () => clearInterval(intervalId);
+  }, [fetchOracleData, refreshInterval, poolAddress]);
+  return {
+    oracle,
+    oracleAddress,
+    loading,
+    error,
+    refetch,
+    twap,
+    spotPrice,
+    deviation,
+    age,
+    isStale: isStaleCheck,
+    bufferStats,
+    compareWithPool
+  };
+}
+function useTwap(poolAddress, windowSeconds, options = {}) {
+  const { oracle, loading, error, refetch } = useOracle(poolAddress, options);
+  const twap = react.useMemo(() => {
+    if (!oracle || !oracle.initialized) return null;
+    return chunkBXATWUGJ_cjs.consultTwap(oracle, windowSeconds);
+  }, [oracle, windowSeconds]);
+  return {
+    twap,
+    loading,
+    error,
+    refetch
+  };
+}
+function useOracles(poolAddresses, options = {}) {
+  const {
+    rpc,
+    programId,
+    commitment: defaultCommitment,
+    refreshInterval: defaultRefreshInterval
+  } = useAmm();
+  const {
+    refreshInterval = defaultRefreshInterval,
+    fetchOnMount = true,
+    commitment = defaultCommitment
+  } = options;
+  const [oracles, setOracles] = react.useState(
+    /* @__PURE__ */ new Map()
+  );
+  const [loading, setLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const mountedRef = react.useRef(true);
+  const fetchOracles = react.useCallback(async () => {
+    if (poolAddresses.length === 0) {
+      setOracles(/* @__PURE__ */ new Map());
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const results = await Promise.all(
+        poolAddresses.map(async (poolAddr) => {
+          try {
+            const result = await chunkBXATWUGJ_cjs.getOracleForPool(rpc, poolAddr, {
+              programId,
+              commitment
+            });
+            return [poolAddr, result];
+          } catch {
+            return [poolAddr, null];
+          }
+        })
+      );
+      if (mountedRef.current) {
+        const oracleMap = /* @__PURE__ */ new Map();
+        for (const [poolAddr, oracleData] of results) {
+          if (oracleData) {
+            oracleMap.set(poolAddr, oracleData);
+          }
+        }
+        setOracles(oracleMap);
+      }
+    } catch (err) {
+      if (mountedRef.current) {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    } finally {
+      if (mountedRef.current) {
+        setLoading(false);
+      }
+    }
+  }, [poolAddresses, rpc, programId, commitment]);
+  react.useEffect(() => {
+    mountedRef.current = true;
+    if (fetchOnMount) {
+      fetchOracles();
+    }
+    return () => {
+      mountedRef.current = false;
+    };
+  }, [fetchOracles, fetchOnMount]);
+  react.useEffect(() => {
+    if (refreshInterval <= 0 || poolAddresses.length === 0) {
+      return;
+    }
+    const intervalId = setInterval(fetchOracles, refreshInterval);
+    return () => clearInterval(intervalId);
+  }, [fetchOracles, refreshInterval, poolAddresses.length]);
+  return {
+    oracles,
+    loading,
+    error,
+    refetch: fetchOracles
+  };
+}
+
+exports.AmmContext = AmmContext;
+exports.AmmProvider = AmmProvider;
+exports.EndpointAmmContext = AmmContext2;
+exports.EndpointAmmProvider = AmmProvider2;
+exports.WalletContext = WalletContext;
+exports.WalletProvider = WalletProvider;
+exports.WalletStandardContext = WalletContext2;
+exports.WalletStandardProvider = WalletProvider2;
+exports.createAmmContextValue = createAmmContextValue;
+exports.createWalletContextValue = createWalletContextValue;
+exports.useAmm = useAmm;
+exports.useAmmOptional = useAmmOptional;
+exports.useEndpointAmm = useAmm2;
+exports.useFees = useFees;
+exports.useFeesFromData = useFeesFromData;
+exports.useLiquidity = useLiquidity;
+exports.useOracle = useOracle;
+exports.useOracles = useOracles;
+exports.usePool = usePool;
+exports.usePools = usePools;
+exports.usePosition = usePosition;
+exports.useStandardWallet = useWallet2;
+exports.useSwap = useSwap;
+exports.useTwap = useTwap;
+exports.useUserPositions = useUserPositions;
+exports.useWallet = useWallet;
+exports.useWalletAddress = useWalletAddress;
+exports.useWalletOptional = useWalletOptional;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map