@aintivirus-ai/mixer-sdk 1.0.0

package/dist/hooks/useAdmin.js

@@ -0,0 +1,195 @@
+"use strict";
+/**
+ * Hook for admin functions (EVM or Solana)
+ * Use this hook when you need to perform admin operations
+ * Requires OPERATOR_ROLE or ADMIN_ROLE
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAdmin = useAdmin;
+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 admin functions
+ * Only initializes what's needed for admin operations
+ */
+function useAdmin(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;
+    // Admin functions
+    const setFeeRate = (0, react_1.useCallback)(async (chainType, feeRate) => {
+        if (chainType === types_1.ChainType.EVM) {
+            if (!evmSDK) {
+                throw new Error("EVM SDK not initialized");
+            }
+            const factory = evmSDK.getFactory();
+            const tx = await factory.setFeeRate(feeRate);
+            const receipt = await tx.wait();
+            return {
+                txHash: receipt.hash,
+                blockNumber: receipt.blockNumber,
+                blockTime: (await evmSDK.getProvider().getBlock(receipt.blockNumber))?.timestamp,
+            };
+        }
+        else if (chainType === types_1.ChainType.SOLANA) {
+            if (!solanaSDK) {
+                throw new Error("Solana SDK not initialized");
+            }
+            return solanaSDK.setFeeRate(feeRate);
+        }
+        throw new Error(`Unsupported chain type: ${chainType}`);
+    }, [evmSDK, solanaSDK]);
+    const setStakingSeasonPeriod = (0, react_1.useCallback)(async (chainType, period) => {
+        if (chainType === types_1.ChainType.EVM) {
+            if (!evmSDK) {
+                throw new Error("EVM SDK not initialized");
+            }
+            const factory = evmSDK.getFactory();
+            const tx = await factory.setStakingSeasonPeriod(period);
+            const receipt = await tx.wait();
+            return {
+                txHash: receipt.hash,
+                blockNumber: receipt.blockNumber,
+                blockTime: (await evmSDK.getProvider().getBlock(receipt.blockNumber))?.timestamp,
+            };
+        }
+        else if (chainType === types_1.ChainType.SOLANA) {
+            if (!solanaSDK) {
+                throw new Error("Solana SDK not initialized");
+            }
+            return solanaSDK.setStakingSeasonPeriod(period);
+        }
+        throw new Error(`Unsupported chain type: ${chainType}`);
+    }, [evmSDK, solanaSDK]);
+    const startStakeSeason = (0, react_1.useCallback)(async (chainType) => {
+        if (chainType === types_1.ChainType.EVM) {
+            if (!evmSDK) {
+                throw new Error("EVM SDK not initialized");
+            }
+            const factory = evmSDK.getFactory();
+            const tx = await factory.startStakeSeason();
+            const receipt = await tx.wait();
+            return {
+                txHash: receipt.hash,
+                blockNumber: receipt.blockNumber,
+                blockTime: (await evmSDK.getProvider().getBlock(receipt.blockNumber))?.timestamp,
+            };
+        }
+        else if (chainType === types_1.ChainType.SOLANA) {
+            if (!solanaSDK) {
+                throw new Error("Solana SDK not initialized");
+            }
+            return solanaSDK.startStakeSeason();
+        }
+        throw new Error(`Unsupported chain type: ${chainType}`);
+    }, [evmSDK, solanaSDK]);
+    const setVerifier = (0, react_1.useCallback)(async (chainType, verifierAddress) => {
+        if (chainType === types_1.ChainType.EVM) {
+            if (!evmSDK) {
+                throw new Error("EVM SDK not initialized");
+            }
+            const factory = evmSDK.getFactory();
+            const tx = await factory.setVerifier(verifierAddress);
+            const receipt = await tx.wait();
+            return {
+                txHash: receipt.hash,
+                blockNumber: receipt.blockNumber,
+                blockTime: (await evmSDK.getProvider().getBlock(receipt.blockNumber))?.timestamp,
+            };
+        }
+        else if (chainType === types_1.ChainType.SOLANA) {
+            if (!solanaSDK) {
+                throw new Error("Solana SDK not initialized");
+            }
+            return solanaSDK.setVerifier(verifierAddress);
+        }
+        throw new Error(`Unsupported chain type: ${chainType}`);
+    }, [evmSDK, solanaSDK]);
+    const setHasher = (0, react_1.useCallback)(async (chainType, hasherAddress) => {
+        if (chainType === types_1.ChainType.EVM) {
+            if (!evmSDK) {
+                throw new Error("EVM SDK not initialized");
+            }
+            const factory = evmSDK.getFactory();
+            const tx = await factory.setHasher(hasherAddress);
+            const receipt = await tx.wait();
+            return {
+                txHash: receipt.hash,
+                blockNumber: receipt.blockNumber,
+                blockTime: (await evmSDK.getProvider().getBlock(receipt.blockNumber))?.timestamp,
+            };
+        }
+        else if (chainType === types_1.ChainType.SOLANA) {
+            if (!solanaSDK) {
+                throw new Error("Solana SDK not initialized");
+            }
+            return solanaSDK.setHasher(hasherAddress);
+        }
+        throw new Error(`Unsupported chain type: ${chainType}`);
+    }, [evmSDK, solanaSDK]);
+    return {
+        setFeeRate,
+        setStakingSeasonPeriod,
+        startStakeSeason,
+        setVerifier,
+        setHasher,
+        isEVMReady,
+        isSolanaReady,
+    };
+}

package/dist/hooks/useAintiVirus.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Unified hook for AintiVirus Mixer
+ * Supports both EVM and Solana chains with unified API
+ *
+ * Configure both chains at initialization, then use chain type parameter for each function call
+ */
+import { ChainType, EVMHookConfig, SolanaHookConfig } from "../types";
+import { Wallet } from "@coral-xyz/anchor";
+import { Connection } from "@solana/web3.js";
+import { AintiVirusEVM } from "../evm";
+import { AintiVirusSolana } from "../solana";
+import { AssetMode, WithdrawalProof, TransactionResult } from "../types";
+/**
+ * Unified hook configuration
+ */
+export interface UnifiedHookConfig {
+    evm?: EVMHookConfig;
+    solana?: SolanaHookConfig;
+    solanaWallet?: Wallet;
+    solanaConnection?: Connection;
+}
+/**
+ * Unified hook return type
+ */
+export interface UseAintiVirusReturn {
+    deposit: (chainType: ChainType, amount: bigint, commitment: bigint) => Promise<TransactionResult>;
+    withdraw: (chainType: ChainType, proof: WithdrawalProof, amount: bigint, mode: AssetMode) => Promise<TransactionResult>;
+    stake: (chainType: ChainType, amount: bigint) => Promise<TransactionResult>;
+    unstake: (chainType: ChainType) => Promise<TransactionResult>;
+    claim: (chainType: ChainType, seasonId: bigint) => Promise<TransactionResult>;
+    getCurrentSeason: (chainType: ChainType) => Promise<bigint | null>;
+    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>;
+    isEVMReady: boolean;
+    isSolanaReady: boolean;
+    evmAddress?: string;
+    solanaAddress?: string;
+    evmSDK: AintiVirusEVM | null;
+    solanaSDK: AintiVirusSolana | null;
+}
+/**
+ * Main unified hook that supports both EVM and Solana
+ *
+ * @param config - Configuration object with both EVM and Solana configs
+ * @returns Unified API with chain type parameter for each function
+ */
+export declare function useAintiVirus(config: UnifiedHookConfig): UseAintiVirusReturn;

package/dist/hooks/useAintiVirus.js

@@ -0,0 +1,238 @@
+"use strict";
+/**
+ * Unified hook for AintiVirus Mixer
+ * Supports both EVM and Solana chains with unified API
+ *
+ * Configure both chains at initialization, then use chain type parameter for each function call
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useAintiVirus = useAintiVirus;
+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");
+/**
+ * Main unified hook that supports both EVM and Solana
+ *
+ * @param config - Configuration object with both EVM and Solana configs
+ * @returns Unified API with chain type parameter for each function
+ */
+function useAintiVirus(config) {
+    // EVM setup
+    const { address: evmAddress, 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;
+    const solanaAddress = config.solanaWallet?.publicKey?.toString();
+    // 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]);
+    // Withdraw function
+    const withdraw = (0, react_1.useCallback)(async (chainType, proof, amount, mode) => {
+        if (chainType === types_1.ChainType.EVM) {
+            if (!evmSDK) {
+                throw new Error("EVM SDK not initialized");
+            }
+            return evmSDK.withdraw(proof, amount, mode);
+        }
+        else if (chainType === types_1.ChainType.SOLANA) {
+            if (!solanaSDK) {
+                throw new Error("Solana SDK not initialized");
+            }
+            // Solana withdraw needs instruction data and nullifier hash
+            // This is a simplified version - you may need to adjust based on your Solana implementation
+            const nullifierHash = proof.pubSignals[0];
+            // Create empty buffer for instruction data (placeholder)
+            const instructionData = new Uint8Array(0);
+            return solanaSDK.withdraw(instructionData, nullifierHash, amount, mode);
+        }
+        throw new Error(`Unsupported chain type: ${chainType}`);
+    }, [evmSDK, solanaSDK]);
+    // 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]);
+    // Claim function
+    const claim = (0, react_1.useCallback)(async (chainType, seasonId) => {
+        if (chainType === types_1.ChainType.EVM) {
+            if (!evmSDK) {
+                throw new Error("EVM SDK not initialized");
+            }
+            return evmSDK.claimEth(seasonId);
+        }
+        else if (chainType === types_1.ChainType.SOLANA) {
+            if (!solanaSDK) {
+                throw new Error("Solana SDK not initialized");
+            }
+            return solanaSDK.claimSol(seasonId);
+        }
+        throw new Error(`Unsupported chain type: ${chainType}`);
+    }, [evmSDK, solanaSDK]);
+    // Get current season
+    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]);
+    // Get mixer
+    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 mixer = await solanaSDK.getMixer(mode, amount);
+            return mixer.toString();
+        }
+        return null;
+    }, [evmSDK, solanaSDK]);
+    // Check if mixer exists
+    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]);
+    // Calculate deposit amount
+    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) {
+            // Solana doesn't have fee calculation in the same way
+            // Return amount as-is or implement fee calculation if needed
+            return amount;
+        }
+        return null;
+    }, [evmSDK, solanaSDK]);
+    return {
+        deposit,
+        withdraw,
+        stake,
+        unstake,
+        claim,
+        getCurrentSeason,
+        getMixer,
+        mixerExists,
+        calculateDepositAmount,
+        isEVMReady,
+        isSolanaReady,
+        evmAddress: evmAddress,
+        solanaAddress,
+        evmSDK,
+        solanaSDK,
+    };
+}

package/dist/hooks/useClaim.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Hook for claiming rewards (EVM or Solana)
+ * Use this hook when you only need claim 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 claiming
+ */
+export interface ClaimHookConfig {
+    evm?: EVMHookConfig;
+    solana?: SolanaHookConfig;
+    solanaWallet?: Wallet;
+    solanaConnection?: Connection;
+}
+/**
+ * Claim hook return type
+ */
+export interface UseClaimReturn {
+    claim: (chainType: ChainType, seasonId: bigint) => Promise<TransactionResult>;
+    getCurrentSeason: (chainType: ChainType) => Promise<bigint | null>;
+    isEVMReady: boolean;
+    isSolanaReady: boolean;
+}
+/**
+ * Hook for claiming rewards
+ * Only initializes what's needed for claiming
+ */
+export declare function useClaim(config: ClaimHookConfig): UseClaimReturn;

package/dist/hooks/useClaim.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * Hook for claiming rewards (EVM or Solana)
+ * Use this hook when you only need claim functionality
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useClaim = useClaim;
+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 claiming rewards
+ * Only initializes what's needed for claiming
+ */
+function useClaim(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;
+    // Claim function
+    const claim = (0, react_1.useCallback)(async (chainType, seasonId) => {
+        if (chainType === types_1.ChainType.EVM) {
+            if (!evmSDK) {
+                throw new Error("EVM SDK not initialized");
+            }
+            return evmSDK.claimEth(seasonId);
+        }
+        else if (chainType === types_1.ChainType.SOLANA) {
+            if (!solanaSDK) {
+                throw new Error("Solana SDK not initialized");
+            }
+            return solanaSDK.claimSol(seasonId);
+        }
+        throw new Error(`Unsupported chain type: ${chainType}`);
+    }, [evmSDK, solanaSDK]);
+    // Get current season
+    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]);
+    return {
+        claim,
+        getCurrentSeason,
+        isEVMReady,
+        isSolanaReady,
+    };
+}

package/dist/hooks/useDeploy.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Hook for deploying mixers (EVM or Solana)
+ * Use this hook when you need to deploy new mixer instances
+ */
+import { ChainType, EVMHookConfig, SolanaHookConfig, AssetMode } from "../types";
+import { Wallet } from "@coral-xyz/anchor";
+import { Connection } from "@solana/web3.js";
+import { TransactionResult } from "../types";
+/**
+ * Hook configuration for deploy
+ */
+export interface DeployHookConfig {
+    evm?: EVMHookConfig;
+    solana?: SolanaHookConfig;
+    solanaWallet?: Wallet;
+    solanaConnection?: Connection;
+}
+/**
+ * Deploy hook return type
+ */
+export interface UseDeployReturn {
+    deployMixer: (chainType: ChainType, mode: AssetMode, amount: bigint) => Promise<TransactionResult & {
+        mixerAddress?: string;
+    }>;
+    isEVMReady: boolean;
+    isSolanaReady: boolean;
+}
+/**
+ * Hook for deploying mixers
+ * Only initializes what's needed for deployment
+ */
+export declare function useDeploy(config: DeployHookConfig): UseDeployReturn;