@whetstone-research/doppler-sdk 0.0.24 → 1.0.0

package/dist/solana/react/index.js

@@ -0,0 +1,1436 @@
+import { fetchPool, getSwapQuote, getSwapQuoteExactOut, ratioToNumber, getAddLiquidityQuote, getRemoveLiquidityQuote, fetchPosition, getPendingFees, getPositionValue, fetchUserPositions, MAX_FEE_AMOUNT, createCollectFeesInstruction, fetchOracle, consultTwap, getOracleSpotPrices, getOracleDeviation, getOracleAge, isOracleStale, getOracleBufferStats, comparePoolAndOraclePrices, getOracleForPool } from '../../chunk-RO6R66OM.js';
+import { PROGRAM_ID, BPS_DENOM, getOracleAddress } from '../../chunk-3LTCKCJC.js';
+import '../../chunk-PZ5AY32C.js';
+import { createContext, useMemo, useContext, useState, useEffect, useCallback, useRef } from 'react';
+import { jsx } from 'react/jsx-runtime';
+import { createSolanaRpc, createTransactionMessage, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, appendTransactionMessageInstruction, signTransactionMessageWithSigners, getBase64EncodedWireTransaction } from '@solana/kit';
+
+var AmmContext = createContext(null);
+function AmmProvider({
+  rpc,
+  programId = PROGRAM_ID,
+  commitment = "confirmed",
+  refreshInterval = 3e4,
+  defaultSlippageBps = 50,
+  children
+}) {
+  const value = useMemo(
+    () => ({
+      rpc,
+      programId,
+      commitment,
+      refreshInterval,
+      defaultSlippageBps
+    }),
+    [rpc, programId, commitment, refreshInterval, defaultSlippageBps]
+  );
+  return /* @__PURE__ */ jsx(AmmContext.Provider, { value, children });
+}
+function useAmm() {
+  const context = useContext(AmmContext);
+  if (!context) {
+    throw new Error("useAmm must be used within an AmmProvider");
+  }
+  return context;
+}
+function useAmmOptional() {
+  return useContext(AmmContext);
+}
+var WalletContext = createContext(null);
+function WalletProvider({
+  wallet,
+  signAndSendTransaction,
+  children
+}) {
+  const value = useMemo(
+    () => ({
+      ...wallet,
+      signAndSendTransaction
+    }),
+    [wallet, signAndSendTransaction]
+  );
+  return /* @__PURE__ */ jsx(WalletContext.Provider, { value, children });
+}
+function useWallet() {
+  const context = useContext(WalletContext);
+  if (!context) {
+    throw new Error("useWallet must be used within a WalletProvider");
+  }
+  return context;
+}
+function useWalletOptional() {
+  return useContext(WalletContext);
+}
+function useWalletAddress() {
+  const { connected, address } = useWallet();
+  if (!connected || !address) {
+    throw new Error("Wallet is not connected");
+  }
+  return address;
+}
+var AmmContext2 = createContext(null);
+AmmContext2.displayName = "AmmContext";
+function useAmm2() {
+  const ctx = 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 = createSolanaRpc(endpoint);
+  return {
+    rpc,
+    endpoint,
+    programId: programId ?? PROGRAM_ID,
+    commitment,
+    refreshInterval,
+    defaultSlippageBps
+  };
+}
+function AmmProvider2({
+  children,
+  endpoint,
+  programId,
+  commitment = "confirmed",
+  refreshInterval = 3e4,
+  defaultSlippageBps = 50
+}) {
+  const value = useMemo(
+    () => createAmmContextValue({
+      endpoint,
+      programId,
+      commitment,
+      refreshInterval,
+      defaultSlippageBps
+    }),
+    [endpoint, programId, commitment, refreshInterval, defaultSlippageBps]
+  );
+  return /* @__PURE__ */ 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 = createContext(null);
+WalletContext2.displayName = "WalletContext";
+function useWallet2() {
+  const ctx = 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] = useState([]);
+  const [wallet, setWallet] = useState(null);
+  const [account, setAccount] = useState(null);
+  const [connecting, setConnecting] = useState(false);
+  const [error, setError] = useState(null);
+  const connected = account !== null;
+  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 = useCallback((newWallet) => {
+    setWallet(newWallet);
+    setError(null);
+  }, []);
+  const connect = 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 = 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]);
+  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]);
+  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 = useMemo(
+    () => ({
+      wallet,
+      account,
+      connected,
+      connecting,
+      wallets,
+      select,
+      connect,
+      disconnect,
+      error
+    }),
+    [
+      wallet,
+      account,
+      connected,
+      connecting,
+      wallets,
+      select,
+      connect,
+      disconnect,
+      error
+    ]
+  );
+  return /* @__PURE__ */ 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] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const [refetching, setRefetching] = useState(false);
+  const mountedRef = useRef(true);
+  const fetchPoolData = useCallback(
+    async (isRefetch = false) => {
+      if (!poolAddress) {
+        setPool(null);
+        setLoading(false);
+        return;
+      }
+      if (isRefetch) {
+        setRefetching(true);
+      } else {
+        setLoading(true);
+      }
+      setError(null);
+      try {
+        const poolData = await 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 = useCallback(async () => {
+    await fetchPoolData(true);
+  }, [fetchPoolData]);
+  useEffect(() => {
+    mountedRef.current = true;
+    if (fetchOnMount) {
+      fetchPoolData(false);
+    }
+    return () => {
+      mountedRef.current = false;
+    };
+  }, [fetchPoolData, fetchOnMount]);
+  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] = useState(/* @__PURE__ */ new Map());
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const mountedRef = useRef(true);
+  const fetchPools = 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) => 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]);
+  useEffect(() => {
+    mountedRef.current = true;
+    if (fetchOnMount) {
+      fetchPools();
+    }
+    return () => {
+      mountedRef.current = false;
+    };
+  }, [fetchPools, fetchOnMount]);
+  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] = useState({
+    inputToken: token0Mint,
+    outputToken: token1Mint,
+    inputAmount: 0n,
+    outputAmount: 0n,
+    exactInput: true,
+    slippageBps: defaultSlippageBps
+  });
+  const [quoting] = useState(false);
+  const direction = 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 = 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 = getSwapQuote(pool, state.inputAmount, direction);
+        const slippageFactor = BPS_DENOM - BigInt(state.slippageBps);
+        const minAmountOut = swapQuote.amountOut * slippageFactor / 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 } = getSwapQuoteExactOut(
+          pool,
+          state.outputAmount,
+          direction
+        );
+        const slippageFactor = BPS_DENOM + BigInt(state.slippageBps);
+        const maxAmountIn = amountIn * slippageFactor / BPS_DENOM;
+        const forwardQuote = getSwapQuote(pool, amountIn, direction);
+        return {
+          amountOut: state.outputAmount,
+          feeTotal,
+          feeDist: 0n,
+          // Not calculated for exact out
+          feeComp: 0n,
+          priceImpact: forwardQuote.priceImpact,
+          executionPrice: 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 = useCallback((token) => {
+    setState((s) => ({ ...s, inputToken: token }));
+  }, []);
+  const setOutputToken = useCallback((token) => {
+    setState((s) => ({ ...s, outputToken: token }));
+  }, []);
+  const setInputAmount = useCallback((amount) => {
+    setState((s) => ({
+      ...s,
+      inputAmount: amount,
+      exactInput: true
+    }));
+  }, []);
+  const setOutputAmount = useCallback((amount) => {
+    setState((s) => ({
+      ...s,
+      outputAmount: amount,
+      exactInput: false
+    }));
+  }, []);
+  const setSlippage = useCallback((bps) => {
+    setState((s) => ({ ...s, slippageBps: bps }));
+  }, []);
+  const flipTokens = useCallback(() => {
+    setState((s) => ({
+      ...s,
+      inputToken: s.outputToken,
+      outputToken: s.inputToken,
+      inputAmount: s.outputAmount,
+      outputAmount: s.inputAmount
+    }));
+  }, []);
+  const reset = useCallback(() => {
+    setState({
+      inputToken: token0Mint,
+      outputToken: token1Mint,
+      inputAmount: 0n,
+      outputAmount: 0n,
+      exactInput: true,
+      slippageBps: defaultSlippageBps
+    });
+  }, [token0Mint, token1Mint, defaultSlippageBps]);
+  const canSwap = 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] = useState(defaultMode);
+  const [addState, setAddState] = useState({
+    amount0: 0n,
+    amount1: 0n,
+    slippageBps: defaultSlippageBps
+  });
+  const [removeState, setRemoveState] = useState({
+    shares: 0n,
+    percentage: 0,
+    slippageBps: defaultSlippageBps
+  });
+  const addQuote = 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 = getAddLiquidityQuote(
+        pool,
+        addState.amount0,
+        addState.amount1
+      );
+      const slippageFactor = BPS_DENOM - BigInt(addState.slippageBps);
+      const minSharesOut = quote.sharesOut * slippageFactor / 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 = 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 = getRemoveLiquidityQuote(pool, removeState.shares);
+      const slippageFactor = BPS_DENOM - BigInt(removeState.slippageBps);
+      const minAmount0Out = quote.amount0 * slippageFactor / BPS_DENOM;
+      const minAmount1Out = quote.amount1 * slippageFactor / 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 = useCallback((amount) => {
+    setAddState((s) => ({ ...s, amount0: amount }));
+  }, []);
+  const setAmount1 = useCallback((amount) => {
+    setAddState((s) => ({ ...s, amount1: amount }));
+  }, []);
+  const setShares = useCallback(
+    (shares) => {
+      setRemoveState((s) => ({
+        ...s,
+        shares,
+        percentage: userShares > 0n ? Number(shares * 100n / userShares) : 0
+      }));
+    },
+    [userShares]
+  );
+  const setPercentage = 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 = useCallback((bps) => {
+    setAddState((s) => ({ ...s, slippageBps: bps }));
+    setRemoveState((s) => ({ ...s, slippageBps: bps }));
+  }, []);
+  const reset = useCallback(() => {
+    setAddState({
+      amount0: 0n,
+      amount1: 0n,
+      slippageBps: defaultSlippageBps
+    });
+    setRemoveState({
+      shares: 0n,
+      percentage: 0,
+      slippageBps: defaultSlippageBps
+    });
+  }, [defaultSlippageBps]);
+  const canAdd = useMemo(() => {
+    return !!(addQuote?.isValid && (addState.amount0 > 0n || addState.amount1 > 0n));
+  }, [addQuote, addState]);
+  const canRemove = 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] = useState(null);
+  const [positionAddress, setPositionAddress] = useState();
+  const [pool, setPool] = useState(providedPool ?? null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const mountedRef = useRef(true);
+  const ownerAddress = wallet?.address;
+  const fetchPositionData = useCallback(async () => {
+    if (!poolAddress || !ownerAddress) {
+      setPosition(null);
+      setPositionAddress(void 0);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const { getPositionAddress } = await import('../../pda-RVIHNLRP.js');
+      const [posAddr] = await getPositionAddress(
+        poolAddress,
+        ownerAddress,
+        positionId,
+        programId
+      );
+      setPositionAddress(posAddr);
+      const [positionData, poolData] = await Promise.all([
+        fetchPosition(rpc, posAddr, { programId, commitment }),
+        providedPool ? Promise.resolve(providedPool) : 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 = useCallback(async () => {
+    await fetchPositionData();
+  }, [fetchPositionData]);
+  const pendingFees = useMemo(() => {
+    if (!pool || !position) return null;
+    return getPendingFees(pool, position);
+  }, [pool, position]);
+  const value = useMemo(() => {
+    if (!pool || !position) return null;
+    return getPositionValue(pool, position);
+  }, [pool, position]);
+  useEffect(() => {
+    mountedRef.current = true;
+    if (fetchOnMount) {
+      fetchPositionData();
+    }
+    return () => {
+      mountedRef.current = false;
+    };
+  }, [fetchPositionData, fetchOnMount]);
+  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] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const mountedRef = useRef(true);
+  const ownerAddress = wallet?.address;
+  const fetchPositions = useCallback(async () => {
+    if (!ownerAddress) {
+      setPositions([]);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const positionsData = await 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]);
+  useEffect(() => {
+    mountedRef.current = true;
+    if (fetchOnMount) {
+      fetchPositions();
+    }
+    return () => {
+      mountedRef.current = false;
+    };
+  }, [fetchPositions, fetchOnMount]);
+  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] = useState(providedPool ?? null);
+  const [position, setPosition] = useState(
+    providedPosition ?? null
+  );
+  const [loading, setLoading] = useState(true);
+  const [refetching, setRefetching] = useState(false);
+  const [error, setError] = useState(null);
+  const [status, setStatus] = useState("idle");
+  const [txError, setTxError] = useState(null);
+  const [txSignature, setTxSignature] = useState(null);
+  const mountedRef = useRef(true);
+  useEffect(() => {
+    if (providedPool) setPool(providedPool);
+    if (providedPosition) setPosition(providedPosition);
+  }, [providedPool, providedPosition]);
+  const fees = useMemo(() => {
+    if (!pool || !position) return null;
+    const { pending0, pending1 } = getPendingFees(pool, position);
+    return {
+      pending0,
+      pending1,
+      hasFees: pending0 > 0n || pending1 > 0n
+    };
+  }, [pool, position]);
+  const fetchFeesData = 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(
+            fetchPosition(rpc, positionAddress, { programId, commitment })
+          );
+        } else {
+          promises.push(Promise.resolve(providedPosition));
+        }
+        if (!providedPool && poolAddress) {
+          promises.push(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 = useCallback(async () => {
+    await fetchFeesData(true);
+  }, [fetchFeesData]);
+  const collect = 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 = MAX_FEE_AMOUNT,
+          max1 = MAX_FEE_AMOUNT,
+          userToken0,
+          userToken1
+        } = collectOptions;
+        const ix = 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 = createTransactionMessage({ version: "legacy" });
+        const messageWithPayer = setTransactionMessageFeePayerSigner(
+          wallet.signer,
+          baseMessage
+        );
+        const messageWithLifetime = setTransactionMessageLifetimeUsingBlockhash(
+          latestBlockhash,
+          messageWithPayer
+        );
+        const messageWithIx = appendTransactionMessageInstruction(
+          ix,
+          messageWithLifetime
+        );
+        setStatus("sending");
+        const signedTransaction = await signTransactionMessageWithSigners(messageWithIx);
+        const wireTransaction = 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 = useCallback(() => {
+    setStatus("idle");
+    setTxError(null);
+    setTxSignature(null);
+  }, []);
+  const canCollect = useMemo(() => {
+    return !!(fees?.hasFees && wallet?.connected && wallet?.signer && pool && position);
+  }, [fees, wallet, pool, position]);
+  useEffect(() => {
+    mountedRef.current = true;
+    if (fetchOnMount) {
+      fetchFeesData(false);
+    }
+    return () => {
+      mountedRef.current = false;
+    };
+  }, [fetchFeesData, fetchOnMount]);
+  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 useMemo(() => {
+    if (!pool || !position) return null;
+    const { pending0, pending1 } = 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] = useState(null);
+  const [oracleAddress, setOracleAddress] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const mountedRef = useRef(true);
+  const fetchOracleData = useCallback(async () => {
+    if (!poolAddress) {
+      setOracle(null);
+      setOracleAddress(null);
+      setLoading(false);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const [oracleAddr] = await getOracleAddress(poolAddress, programId);
+      setOracleAddress(oracleAddr);
+      const oracleData = await 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 = useCallback(async () => {
+    await fetchOracleData();
+  }, [fetchOracleData]);
+  const twap = useCallback(
+    (windowSeconds) => {
+      if (!oracle || !oracle.initialized) return null;
+      return consultTwap(oracle, windowSeconds);
+    },
+    [oracle]
+  );
+  const spotPrice = useMemo(() => {
+    if (!oracle || !oracle.initialized) return null;
+    const prices = getOracleSpotPrices(oracle);
+    return { price0: prices.price0, price1: prices.price1 };
+  }, [oracle]);
+  const deviation = useMemo(() => {
+    if (!oracle || !oracle.initialized) return null;
+    const dev = getOracleDeviation(oracle);
+    return { deviation0: dev.deviation0, deviation1: dev.deviation1 };
+  }, [oracle]);
+  const age = useMemo(() => {
+    if (!oracle || !oracle.initialized) return null;
+    return getOracleAge(oracle);
+  }, [oracle]);
+  const isStaleCheck = useCallback(
+    (maxAgeSeconds) => {
+      if (!oracle || !oracle.initialized) return true;
+      return isOracleStale(oracle, maxAgeSeconds);
+    },
+    [oracle]
+  );
+  const bufferStats = useMemo(() => {
+    if (!oracle || !oracle.initialized) return null;
+    const stats = getOracleBufferStats(oracle);
+    return {
+      capacity: stats.capacity,
+      filledCount: stats.filledCount,
+      currentIndex: stats.currentIndex,
+      timeSpanSeconds: stats.timeSpanSeconds
+    };
+  }, [oracle]);
+  const compareWithPool = useCallback(
+    (pool) => {
+      if (!oracle || !oracle.initialized) return null;
+      return comparePoolAndOraclePrices(pool, oracle);
+    },
+    [oracle]
+  );
+  useEffect(() => {
+    mountedRef.current = true;
+    if (fetchOnMount) {
+      fetchOracleData();
+    }
+    return () => {
+      mountedRef.current = false;
+    };
+  }, [fetchOracleData, fetchOnMount]);
+  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 = useMemo(() => {
+    if (!oracle || !oracle.initialized) return null;
+    return 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] = useState(
+    /* @__PURE__ */ new Map()
+  );
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const mountedRef = useRef(true);
+  const fetchOracles = 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 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]);
+  useEffect(() => {
+    mountedRef.current = true;
+    if (fetchOnMount) {
+      fetchOracles();
+    }
+    return () => {
+      mountedRef.current = false;
+    };
+  }, [fetchOracles, fetchOnMount]);
+  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
+  };
+}
+
+export { AmmContext, AmmProvider, AmmContext2 as EndpointAmmContext, AmmProvider2 as EndpointAmmProvider, WalletContext, WalletProvider, WalletContext2 as WalletStandardContext, WalletProvider2 as WalletStandardProvider, createAmmContextValue, createWalletContextValue, useAmm, useAmmOptional, useAmm2 as useEndpointAmm, useFees, useFeesFromData, useLiquidity, useOracle, useOracles, usePool, usePools, usePosition, useWallet2 as useStandardWallet, useSwap, useTwap, useUserPositions, useWallet, useWalletAddress, useWalletOptional };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map