@aintivirus-ai/mixer-sdk 1.0.0

package/dist/hooks/useDeploy.js

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * Hook for deploying mixers (EVM or Solana)
+ * Use this hook when you need to deploy new mixer instances
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDeploy = useDeploy;
+const react_1 = require("react");
+const types_1 = require("../types");
+const evm_1 = require("../evm");
+const solana_1 = require("../solana");
+const wagmi_1 = require("wagmi");
+const utils_1 = require("./utils");
+/**
+ * Hook for deploying mixers
+ * Only initializes what's needed for deployment
+ */
+function useDeploy(config) {
+    // EVM setup
+    const { isConnected: evmConnected } = (0, wagmi_1.useAccount)();
+    const { data: walletClient } = (0, wagmi_1.useWalletClient)();
+    const publicClient = (0, wagmi_1.usePublicClient)();
+    const evmSDK = (0, react_1.useMemo)(() => {
+        if (!config.evm?.factoryAddress) {
+            return null;
+        }
+        if (!publicClient) {
+            return null;
+        }
+        try {
+            const provider = (0, utils_1.createEthersProviderFromViem)(publicClient);
+            const signerOrProvider = walletClient
+                ? (0, utils_1.createEthersSignerFromViem)(walletClient, publicClient)
+                : provider;
+            return new evm_1.AintiVirusEVM(config.evm.factoryAddress, config.evm.tokenAddress || "0x0000000000000000000000000000000000000000", signerOrProvider);
+        }
+        catch (error) {
+            console.error("Failed to initialize AintiVirusEVM:", error);
+            return null;
+        }
+    }, [
+        config.evm?.factoryAddress,
+        config.evm?.tokenAddress,
+        walletClient,
+        publicClient,
+    ]);
+    const isEVMReady = !!evmSDK && evmConnected;
+    // Solana setup
+    const solanaSDK = (0, react_1.useMemo)(() => {
+        if (!config.solana?.factoryProgramId ||
+            !config.solana?.mixerProgramId ||
+            !config.solana?.stakingProgramId) {
+            return null;
+        }
+        if (!config.solanaWallet || !config.solanaConnection) {
+            return null;
+        }
+        try {
+            return new solana_1.AintiVirusSolana(config.solana.factoryProgramId, config.solana.mixerProgramId, config.solana.stakingProgramId, config.solanaWallet, config.solanaConnection, config.solana.tokenMint);
+        }
+        catch (error) {
+            console.error("Failed to initialize AintiVirusSolana:", error);
+            return null;
+        }
+    }, [
+        config.solana?.factoryProgramId,
+        config.solana?.mixerProgramId,
+        config.solana?.stakingProgramId,
+        config.solana?.tokenMint,
+        config.solanaWallet,
+        config.solanaConnection,
+    ]);
+    const isSolanaReady = !!solanaSDK && !!config.solanaWallet?.publicKey;
+    // Deploy mixer function
+    const deployMixer = (0, react_1.useCallback)(async (chainType, mode, amount) => {
+        if (chainType === types_1.ChainType.EVM) {
+            if (!evmSDK) {
+                throw new Error("EVM SDK not initialized");
+            }
+            return evmSDK.deployMixer(mode, amount);
+        }
+        else if (chainType === types_1.ChainType.SOLANA) {
+            if (!solanaSDK) {
+                throw new Error("Solana SDK not initialized");
+            }
+            const result = await solanaSDK.deployMixer(mode, amount);
+            return result;
+        }
+        throw new Error(`Unsupported chain type: ${chainType}`);
+    }, [evmSDK, solanaSDK]);
+    return {
+        deployMixer,
+        isEVMReady,
+        isSolanaReady,
+    };
+}

package/dist/hooks/useDeposit.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Hook for depositing (EVM or Solana)
+ * Use this hook when you only need deposit functionality
+ */
+import { ChainType, EVMHookConfig, SolanaHookConfig } from "../types";
+import { Wallet } from "@coral-xyz/anchor";
+import { Connection } from "@solana/web3.js";
+import { TransactionResult } from "../types";
+/**
+ * Hook configuration for deposit
+ */
+export interface DepositHookConfig {
+    evm?: EVMHookConfig;
+    solana?: SolanaHookConfig;
+    solanaWallet?: Wallet;
+    solanaConnection?: Connection;
+}
+/**
+ * Deposit hook return type
+ */
+export interface UseDepositReturn {
+    deposit: (chainType: ChainType, amount: bigint, commitment: bigint) => Promise<TransactionResult>;
+    isEVMReady: boolean;
+    isSolanaReady: boolean;
+}
+/**
+ * Hook for depositing funds
+ * Only initializes what's needed for deposits
+ */
+export declare function useDeposit(config: DepositHookConfig): UseDepositReturn;

package/dist/hooks/useDeposit.js

@@ -0,0 +1,96 @@
+"use strict";
+/**
+ * Hook for depositing (EVM or Solana)
+ * Use this hook when you only need deposit functionality
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useDeposit = useDeposit;
+const react_1 = require("react");
+const types_1 = require("../types");
+const evm_1 = require("../evm");
+const solana_1 = require("../solana");
+const wagmi_1 = require("wagmi");
+const utils_1 = require("./utils");
+/**
+ * Hook for depositing funds
+ * Only initializes what's needed for deposits
+ */
+function useDeposit(config) {
+    // EVM setup (only if EVM config provided)
+    const { isConnected: evmConnected } = (0, wagmi_1.useAccount)();
+    const { data: walletClient } = (0, wagmi_1.useWalletClient)();
+    const publicClient = (0, wagmi_1.usePublicClient)();
+    const evmSDK = (0, react_1.useMemo)(() => {
+        if (!config.evm?.factoryAddress) {
+            return null;
+        }
+        if (!publicClient) {
+            return null;
+        }
+        try {
+            const provider = (0, utils_1.createEthersProviderFromViem)(publicClient);
+            const signerOrProvider = walletClient
+                ? (0, utils_1.createEthersSignerFromViem)(walletClient, publicClient)
+                : provider;
+            return new evm_1.AintiVirusEVM(config.evm.factoryAddress, config.evm.tokenAddress || "0x0000000000000000000000000000000000000000", // Default to zero address if not provided
+            signerOrProvider);
+        }
+        catch (error) {
+            console.error("Failed to initialize AintiVirusEVM:", error);
+            return null;
+        }
+    }, [
+        config.evm?.factoryAddress,
+        config.evm?.tokenAddress,
+        walletClient,
+        publicClient,
+    ]);
+    const isEVMReady = !!evmSDK && evmConnected;
+    // Solana setup (only if Solana config provided)
+    const solanaSDK = (0, react_1.useMemo)(() => {
+        if (!config.solana?.factoryProgramId ||
+            !config.solana?.mixerProgramId ||
+            !config.solana?.stakingProgramId) {
+            return null;
+        }
+        if (!config.solanaWallet || !config.solanaConnection) {
+            return null;
+        }
+        try {
+            return new solana_1.AintiVirusSolana(config.solana.factoryProgramId, config.solana.mixerProgramId, config.solana.stakingProgramId, config.solanaWallet, config.solanaConnection, config.solana.tokenMint);
+        }
+        catch (error) {
+            console.error("Failed to initialize AintiVirusSolana:", error);
+            return null;
+        }
+    }, [
+        config.solana?.factoryProgramId,
+        config.solana?.mixerProgramId,
+        config.solana?.stakingProgramId,
+        config.solana?.tokenMint,
+        config.solanaWallet,
+        config.solanaConnection,
+    ]);
+    const isSolanaReady = !!solanaSDK && !!config.solanaWallet?.publicKey;
+    // Deposit function
+    const deposit = (0, react_1.useCallback)(async (chainType, amount, commitment) => {
+        if (chainType === types_1.ChainType.EVM) {
+            if (!evmSDK) {
+                throw new Error("EVM SDK not initialized");
+            }
+            return evmSDK.depositEth(amount, commitment);
+        }
+        else if (chainType === types_1.ChainType.SOLANA) {
+            if (!solanaSDK) {
+                throw new Error("Solana SDK not initialized");
+            }
+            return solanaSDK.depositSol(amount, commitment);
+        }
+        throw new Error(`Unsupported chain type: ${chainType}`);
+    }, [evmSDK, solanaSDK]);
+    return {
+        deposit,
+        isEVMReady,
+        isSolanaReady,
+    };
+}

package/dist/hooks/useStake.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Hook for staking (EVM or Solana)
+ * Use this hook when you only need staking functionality
+ */
+import { ChainType, EVMHookConfig, SolanaHookConfig } from "../types";
+import { Wallet } from "@coral-xyz/anchor";
+import { Connection } from "@solana/web3.js";
+import { TransactionResult } from "../types";
+/**
+ * Hook configuration for staking
+ */
+export interface StakeHookConfig {
+    evm?: EVMHookConfig;
+    solana?: SolanaHookConfig;
+    solanaWallet?: Wallet;
+    solanaConnection?: Connection;
+}
+/**
+ * Staking hook return type
+ */
+export interface UseStakeReturn {
+    stake: (chainType: ChainType, amount: bigint) => Promise<TransactionResult>;
+    unstake: (chainType: ChainType) => Promise<TransactionResult>;
+    isEVMReady: boolean;
+    isSolanaReady: boolean;
+}
+/**
+ * Hook for staking/unstaking funds
+ * Only initializes what's needed for staking
+ */
+export declare function useStake(config: StakeHookConfig): UseStakeReturn;

package/dist/hooks/useStake.js

@@ -0,0 +1,112 @@
+"use strict";
+/**
+ * Hook for staking (EVM or Solana)
+ * Use this hook when you only need staking functionality
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useStake = useStake;
+const react_1 = require("react");
+const types_1 = require("../types");
+const evm_1 = require("../evm");
+const solana_1 = require("../solana");
+const wagmi_1 = require("wagmi");
+const utils_1 = require("./utils");
+/**
+ * Hook for staking/unstaking funds
+ * Only initializes what's needed for staking
+ */
+function useStake(config) {
+    // EVM setup
+    const { isConnected: evmConnected } = (0, wagmi_1.useAccount)();
+    const { data: walletClient } = (0, wagmi_1.useWalletClient)();
+    const publicClient = (0, wagmi_1.usePublicClient)();
+    const evmSDK = (0, react_1.useMemo)(() => {
+        if (!config.evm?.factoryAddress) {
+            return null;
+        }
+        if (!publicClient) {
+            return null;
+        }
+        try {
+            const provider = (0, utils_1.createEthersProviderFromViem)(publicClient);
+            const signerOrProvider = walletClient
+                ? (0, utils_1.createEthersSignerFromViem)(walletClient, publicClient)
+                : provider;
+            return new evm_1.AintiVirusEVM(config.evm.factoryAddress, config.evm.tokenAddress || "0x0000000000000000000000000000000000000000", signerOrProvider);
+        }
+        catch (error) {
+            console.error("Failed to initialize AintiVirusEVM:", error);
+            return null;
+        }
+    }, [
+        config.evm?.factoryAddress,
+        config.evm?.tokenAddress,
+        walletClient,
+        publicClient,
+    ]);
+    const isEVMReady = !!evmSDK && evmConnected;
+    // Solana setup
+    const solanaSDK = (0, react_1.useMemo)(() => {
+        if (!config.solana?.factoryProgramId ||
+            !config.solana?.mixerProgramId ||
+            !config.solana?.stakingProgramId) {
+            return null;
+        }
+        if (!config.solanaWallet || !config.solanaConnection) {
+            return null;
+        }
+        try {
+            return new solana_1.AintiVirusSolana(config.solana.factoryProgramId, config.solana.mixerProgramId, config.solana.stakingProgramId, config.solanaWallet, config.solanaConnection, config.solana.tokenMint);
+        }
+        catch (error) {
+            console.error("Failed to initialize AintiVirusSolana:", error);
+            return null;
+        }
+    }, [
+        config.solana?.factoryProgramId,
+        config.solana?.mixerProgramId,
+        config.solana?.stakingProgramId,
+        config.solana?.tokenMint,
+        config.solanaWallet,
+        config.solanaConnection,
+    ]);
+    const isSolanaReady = !!solanaSDK && !!config.solanaWallet?.publicKey;
+    // Stake function
+    const stake = (0, react_1.useCallback)(async (chainType, amount) => {
+        if (chainType === types_1.ChainType.EVM) {
+            if (!evmSDK) {
+                throw new Error("EVM SDK not initialized");
+            }
+            return evmSDK.stakeEther(amount);
+        }
+        else if (chainType === types_1.ChainType.SOLANA) {
+            if (!solanaSDK) {
+                throw new Error("Solana SDK not initialized");
+            }
+            return solanaSDK.stakeSol(amount);
+        }
+        throw new Error(`Unsupported chain type: ${chainType}`);
+    }, [evmSDK, solanaSDK]);
+    // Unstake function
+    const unstake = (0, react_1.useCallback)(async (chainType) => {
+        if (chainType === types_1.ChainType.EVM) {
+            if (!evmSDK) {
+                throw new Error("EVM SDK not initialized");
+            }
+            return evmSDK.unstakeEth();
+        }
+        else if (chainType === types_1.ChainType.SOLANA) {
+            if (!solanaSDK) {
+                throw new Error("Solana SDK not initialized");
+            }
+            return solanaSDK.unstakeSol();
+        }
+        throw new Error(`Unsupported chain type: ${chainType}`);
+    }, [evmSDK, solanaSDK]);
+    return {
+        stake,
+        unstake,
+        isEVMReady,
+        isSolanaReady,
+    };
+}

package/dist/hooks/useView.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Hook for view/read-only functions (EVM or Solana)
+ * Use this hook when you only need to read data from contracts
+ */
+import { ChainType, EVMHookConfig, SolanaHookConfig, AssetMode, StakeSeason, StakerRecord } from "../types";
+import { Wallet } from "@coral-xyz/anchor";
+import { Connection } from "@solana/web3.js";
+/**
+ * Hook configuration for view functions
+ */
+export interface ViewHookConfig {
+    evm?: EVMHookConfig;
+    solana?: SolanaHookConfig;
+    solanaWallet?: Wallet;
+    solanaConnection?: Connection;
+}
+/**
+ * View hook return type
+ */
+export interface UseViewReturn {
+    getMixer: (chainType: ChainType, mode: AssetMode, amount: bigint) => Promise<string | null>;
+    mixerExists: (chainType: ChainType, mode: AssetMode, amount: bigint) => Promise<boolean>;
+    calculateDepositAmount: (chainType: ChainType, amount: bigint) => Promise<bigint | null>;
+    getFeeRate: (chainType: ChainType) => Promise<bigint | null>;
+    getCurrentSeason: (chainType: ChainType) => Promise<bigint | null>;
+    getStakeSeason: (chainType: ChainType, seasonId: bigint) => Promise<StakeSeason | null>;
+    getStakerRecord: (chainType: ChainType, address: string) => Promise<StakerRecord | null>;
+    hasClaimedEth: (chainType: ChainType, address: string, seasonId: bigint) => Promise<boolean | null>;
+    hasClaimedToken: (chainType: ChainType, address: string, seasonId: bigint) => Promise<boolean | null>;
+    getStakingAddress: (chainType: ChainType) => Promise<string | null>;
+    getTokenBalance: (chainType: ChainType, address: string) => Promise<bigint | null>;
+    getEthBalance: (chainType: ChainType, address: string) => Promise<bigint | null>;
+    isEVMReady: boolean;
+    isSolanaReady: boolean;
+}
+/**
+ * Hook for view/read-only functions
+ * Only initializes what's needed for reading data
+ */
+export declare function useView(config: ViewHookConfig): UseViewReturn;

package/dist/hooks/useView.js

@@ -0,0 +1,255 @@
+"use strict";
+/**
+ * Hook for view/read-only functions (EVM or Solana)
+ * Use this hook when you only need to read data from contracts
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useView = useView;
+const react_1 = require("react");
+const types_1 = require("../types");
+const web3_js_1 = require("@solana/web3.js");
+const evm_1 = require("../evm");
+const solana_1 = require("../solana");
+const wagmi_1 = require("wagmi");
+const utils_1 = require("./utils");
+/**
+ * Hook for view/read-only functions
+ * Only initializes what's needed for reading data
+ */
+function useView(config) {
+    // EVM setup
+    const { isConnected: evmConnected } = (0, wagmi_1.useAccount)();
+    const { data: walletClient } = (0, wagmi_1.useWalletClient)();
+    const publicClient = (0, wagmi_1.usePublicClient)();
+    const evmSDK = (0, react_1.useMemo)(() => {
+        if (!config.evm?.factoryAddress) {
+            return null;
+        }
+        if (!publicClient) {
+            return null;
+        }
+        try {
+            const provider = (0, utils_1.createEthersProviderFromViem)(publicClient);
+            const signerOrProvider = walletClient
+                ? (0, utils_1.createEthersSignerFromViem)(walletClient, publicClient)
+                : provider;
+            return new evm_1.AintiVirusEVM(config.evm.factoryAddress, config.evm.tokenAddress || "0x0000000000000000000000000000000000000000", signerOrProvider);
+        }
+        catch (error) {
+            console.error("Failed to initialize AintiVirusEVM:", error);
+            return null;
+        }
+    }, [
+        config.evm?.factoryAddress,
+        config.evm?.tokenAddress,
+        walletClient,
+        publicClient,
+    ]);
+    const isEVMReady = !!evmSDK;
+    // Solana setup
+    const solanaSDK = (0, react_1.useMemo)(() => {
+        if (!config.solana?.factoryProgramId ||
+            !config.solana?.mixerProgramId ||
+            !config.solana?.stakingProgramId) {
+            return null;
+        }
+        if (!config.solanaConnection) {
+            return null;
+        }
+        try {
+            // For view functions, we don't need wallet, but SDK requires it
+            // We'll create a dummy wallet or handle it gracefully
+            if (!config.solanaWallet) {
+                return null;
+            }
+            return new solana_1.AintiVirusSolana(config.solana.factoryProgramId, config.solana.mixerProgramId, config.solana.stakingProgramId, config.solanaWallet, config.solanaConnection, config.solana.tokenMint);
+        }
+        catch (error) {
+            console.error("Failed to initialize AintiVirusSolana:", error);
+            return null;
+        }
+    }, [
+        config.solana?.factoryProgramId,
+        config.solana?.mixerProgramId,
+        config.solana?.stakingProgramId,
+        config.solana?.tokenMint,
+        config.solanaWallet,
+        config.solanaConnection,
+    ]);
+    const isSolanaReady = !!solanaSDK;
+    // View functions
+    const getMixer = (0, react_1.useCallback)(async (chainType, mode, amount) => {
+        if (chainType === types_1.ChainType.EVM) {
+            if (!evmSDK)
+                return null;
+            return evmSDK.getMixer(mode, amount);
+        }
+        else if (chainType === types_1.ChainType.SOLANA) {
+            if (!solanaSDK)
+                return null;
+            const mixerPubkey = await solanaSDK.getMixer(mode, amount);
+            return mixerPubkey.toString();
+        }
+        return null;
+    }, [evmSDK, solanaSDK]);
+    const mixerExists = (0, react_1.useCallback)(async (chainType, mode, amount) => {
+        if (chainType === types_1.ChainType.EVM) {
+            if (!evmSDK)
+                return false;
+            return evmSDK.mixerExists(mode, amount);
+        }
+        else if (chainType === types_1.ChainType.SOLANA) {
+            if (!solanaSDK)
+                return false;
+            return solanaSDK.mixerExists(mode, amount);
+        }
+        return false;
+    }, [evmSDK, solanaSDK]);
+    const calculateDepositAmount = (0, react_1.useCallback)(async (chainType, amount) => {
+        if (chainType === types_1.ChainType.EVM) {
+            if (!evmSDK)
+                return null;
+            return evmSDK.calculateDepositAmount(amount);
+        }
+        else if (chainType === types_1.ChainType.SOLANA) {
+            if (!solanaSDK)
+                return null;
+            return solanaSDK.calculateDepositAmount(amount);
+        }
+        return null;
+    }, [evmSDK, solanaSDK]);
+    const getFeeRate = (0, react_1.useCallback)(async (chainType) => {
+        if (chainType === types_1.ChainType.EVM) {
+            if (!evmSDK)
+                return null;
+            return evmSDK.getFeeRate();
+        }
+        else if (chainType === types_1.ChainType.SOLANA) {
+            if (!solanaSDK)
+                return null;
+            return solanaSDK.getFeeRate();
+        }
+        return null;
+    }, [evmSDK, solanaSDK]);
+    const getCurrentSeason = (0, react_1.useCallback)(async (chainType) => {
+        if (chainType === types_1.ChainType.EVM) {
+            if (!evmSDK)
+                return null;
+            return evmSDK.getCurrentStakeSeason();
+        }
+        else if (chainType === types_1.ChainType.SOLANA) {
+            if (!solanaSDK)
+                return null;
+            return solanaSDK.getCurrentStakeSeason();
+        }
+        return null;
+    }, [evmSDK, solanaSDK]);
+    const getStakeSeason = (0, react_1.useCallback)(async (chainType, seasonId) => {
+        if (chainType === types_1.ChainType.EVM) {
+            if (!evmSDK)
+                return null;
+            return evmSDK.getStakeSeason(seasonId);
+        }
+        else if (chainType === types_1.ChainType.SOLANA) {
+            if (!solanaSDK)
+                return null;
+            return solanaSDK.getStakeSeason(seasonId);
+        }
+        return null;
+    }, [evmSDK, solanaSDK]);
+    const getStakerRecord = (0, react_1.useCallback)(async (chainType, address) => {
+        if (chainType === types_1.ChainType.EVM) {
+            if (!evmSDK)
+                return null;
+            return evmSDK.getStakerRecord(address);
+        }
+        else if (chainType === types_1.ChainType.SOLANA) {
+            if (!solanaSDK)
+                return null;
+            return solanaSDK.getStakerRecord(address);
+        }
+        return null;
+    }, [evmSDK, solanaSDK]);
+    const hasClaimedEth = (0, react_1.useCallback)(async (chainType, address, seasonId) => {
+        if (chainType === types_1.ChainType.EVM) {
+            if (!evmSDK)
+                return null;
+            return evmSDK.hasClaimedEth(address, seasonId);
+        }
+        else if (chainType === types_1.ChainType.SOLANA) {
+            if (!solanaSDK)
+                return null;
+            return solanaSDK.hasClaimedSol(address, seasonId);
+        }
+        return null;
+    }, [evmSDK, solanaSDK]);
+    const hasClaimedToken = (0, react_1.useCallback)(async (chainType, address, seasonId) => {
+        if (chainType === types_1.ChainType.EVM) {
+            if (!evmSDK)
+                return null;
+            return evmSDK.hasClaimedToken(address, seasonId);
+        }
+        else if (chainType === types_1.ChainType.SOLANA) {
+            if (!solanaSDK)
+                return null;
+            return solanaSDK.hasClaimedToken(address, seasonId);
+        }
+        return null;
+    }, [evmSDK, solanaSDK]);
+    const getStakingAddress = (0, react_1.useCallback)(async (chainType) => {
+        if (chainType === types_1.ChainType.EVM) {
+            if (!evmSDK)
+                return null;
+            return evmSDK.getStakingAddress();
+        }
+        else if (chainType === types_1.ChainType.SOLANA) {
+            if (!solanaSDK)
+                return null;
+            const stakingAddress = await solanaSDK.getStakingAddress();
+            return stakingAddress.toString();
+        }
+        return null;
+    }, [evmSDK, solanaSDK]);
+    const getTokenBalance = (0, react_1.useCallback)(async (chainType, address) => {
+        if (chainType === types_1.ChainType.EVM) {
+            if (!evmSDK)
+                return null;
+            return evmSDK.getTokenBalance(address);
+        }
+        else if (chainType === types_1.ChainType.SOLANA) {
+            if (!solanaSDK)
+                return null;
+            return solanaSDK.getTokenBalance(new web3_js_1.PublicKey(address));
+        }
+        return null;
+    }, [evmSDK, solanaSDK]);
+    const getEthBalance = (0, react_1.useCallback)(async (chainType, address) => {
+        if (chainType === types_1.ChainType.EVM) {
+            if (!evmSDK)
+                return null;
+            return evmSDK.getEthBalance(address);
+        }
+        else if (chainType === types_1.ChainType.SOLANA) {
+            if (!solanaSDK)
+                return null;
+            return solanaSDK.getSolBalance(new web3_js_1.PublicKey(address));
+        }
+        return null;
+    }, [evmSDK, solanaSDK]);
+    return {
+        getMixer,
+        mixerExists,
+        calculateDepositAmount,
+        getFeeRate,
+        getCurrentSeason,
+        getStakeSeason,
+        getStakerRecord,
+        hasClaimedEth,
+        hasClaimedToken,
+        getStakingAddress,
+        getTokenBalance,
+        getEthBalance,
+        isEVMReady,
+        isSolanaReady,
+    };
+}

package/dist/hooks/useWithdraw.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Hook for withdrawing (EVM or Solana)
+ * Use this hook when you only need withdraw functionality
+ */
+import { ChainType, EVMHookConfig, SolanaHookConfig, AssetMode, WithdrawalProof } from "../types";
+import { Wallet } from "@coral-xyz/anchor";
+import { Connection } from "@solana/web3.js";
+import { TransactionResult } from "../types";
+/**
+ * Hook configuration for withdraw
+ */
+export interface WithdrawHookConfig {
+    evm?: EVMHookConfig;
+    solana?: SolanaHookConfig;
+    solanaWallet?: Wallet;
+    solanaConnection?: Connection;
+}
+/**
+ * Withdraw hook return type
+ */
+export interface UseWithdrawReturn {
+    withdraw: (chainType: ChainType, proof: WithdrawalProof, amount: bigint, mode: AssetMode) => Promise<TransactionResult>;
+    isEVMReady: boolean;
+    isSolanaReady: boolean;
+}
+/**
+ * Hook for withdrawing funds
+ * Only initializes what's needed for withdrawals
+ */
+export declare function useWithdraw(config: WithdrawHookConfig): UseWithdrawReturn;