@aintivirus-ai/mixer-sdk 1.0.0

package/dist/hooks/useWithdraw.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * Hook for withdrawing (EVM or Solana)
+ * Use this hook when you only need withdraw functionality
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useWithdraw = useWithdraw;
+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 withdrawing funds
+ * Only initializes what's needed for withdrawals
+ */
+function useWithdraw(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;
+    // 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
+            const nullifierHash = proof.pubSignals[0];
+            const instructionData = new Uint8Array(0);
+            return solanaSDK.withdraw(instructionData, nullifierHash, amount, mode);
+        }
+        throw new Error(`Unsupported chain type: ${chainType}`);
+    }, [evmSDK, solanaSDK]);
+    return {
+        withdraw,
+        isEVMReady,
+        isSolanaReady,
+    };
+}

package/dist/hooks/utils.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Shared utility functions for hooks
+ */
+/**
+ * Create ethers provider from viem public client
+ */
+export declare function createEthersProviderFromViem(publicClient: any): any;
+/**
+ * Create ethers signer from viem wallet client
+ */
+export declare function createEthersSignerFromViem(walletClient: any, publicClient: any): any;

package/dist/hooks/utils.js

@@ -0,0 +1,65 @@
+"use strict";
+/**
+ * Shared utility functions for hooks
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEthersProviderFromViem = createEthersProviderFromViem;
+exports.createEthersSignerFromViem = createEthersSignerFromViem;
+/**
+ * Create ethers provider from viem public client
+ */
+function createEthersProviderFromViem(publicClient) {
+    if (!publicClient)
+        return null;
+    return {
+        getBalance: async (address) => {
+            const balance = await publicClient.getBalance({ address });
+            return BigInt(balance.toString());
+        },
+        getTransaction: async (hash) => {
+            return publicClient.getTransaction({ hash });
+        },
+        getTransactionReceipt: async (hash) => {
+            return publicClient.getTransactionReceipt({ hash });
+        },
+        waitForTransaction: async (hash) => {
+            return publicClient.waitForTransactionReceipt({ hash });
+        },
+        call: async (params) => {
+            return publicClient.call(params);
+        },
+        estimateGas: async (params) => {
+            return publicClient.estimateGas(params);
+        },
+    };
+}
+/**
+ * Create ethers signer from viem wallet client
+ */
+function createEthersSignerFromViem(walletClient, publicClient) {
+    if (!walletClient)
+        return null;
+    const provider = createEthersProviderFromViem(publicClient);
+    return {
+        ...walletClient,
+        provider,
+        getAddress: async () => walletClient.account.address,
+        signMessage: async (message) => {
+            const msg = typeof message === "string"
+                ? message
+                : new TextDecoder().decode(message);
+            return walletClient.signMessage({ message: msg });
+        },
+        sendTransaction: async (tx) => {
+            const viemTx = {
+                to: tx.to,
+                value: tx.value ? BigInt(tx.value.toString()) : undefined,
+                data: tx.data,
+                gas: tx.gasLimit ? BigInt(tx.gasLimit.toString()) : undefined,
+                gasPrice: tx.gasPrice ? BigInt(tx.gasPrice.toString()) : undefined,
+            };
+            const hash = await walletClient.sendTransaction(viemTx);
+            return { hash };
+        },
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * AintiVirus Mixer SDK
+ * Easy-to-use TypeScript SDK for privacy-preserving transactions on EVM and Solana
+ */
+import { SDKConfig } from "./types";
+import { AintiVirusEVM } from "./evm";
+import { AintiVirusSolana } from "./solana";
+export * from "./types";
+export { AintiVirusEVM };
+export { AintiVirusSolana };
+export * from "./utils/crypto";
+export * from "./utils/proof";
+export { AssetMode } from "./types";
+export type { DepositData, WithdrawalProof, TransactionResult } from "./types";
+export type { SDKConfig } from "./types";
+/**
+ * Main SDK class that provides a unified interface
+ * Can be initialized for either EVM or Solana (or both)
+ */
+export declare class AintiVirusSDK {
+    evm?: AintiVirusEVM;
+    solana?: AintiVirusSolana;
+    /**
+     * Initialize SDK with configuration
+     */
+    constructor(config: SDKConfig);
+    /**
+     * Set Solana wallet (required for Solana transactions)
+     */
+    setSolanaWallet(wallet: any): void;
+}
+export default AintiVirusSDK;

package/dist/index.js

@@ -0,0 +1,97 @@
+"use strict";
+/**
+ * AintiVirus Mixer SDK
+ * Easy-to-use TypeScript SDK for privacy-preserving transactions on EVM and Solana
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AintiVirusSDK = exports.AssetMode = exports.AintiVirusSolana = exports.AintiVirusEVM = void 0;
+const evm_1 = require("./evm");
+Object.defineProperty(exports, "AintiVirusEVM", { enumerable: true, get: function () { return evm_1.AintiVirusEVM; } });
+const solana_1 = require("./solana");
+Object.defineProperty(exports, "AintiVirusSolana", { enumerable: true, get: function () { return solana_1.AintiVirusSolana; } });
+// Export types
+__exportStar(require("./types"), exports);
+// Export utilities
+__exportStar(require("./utils/crypto"), exports);
+__exportStar(require("./utils/proof"), exports);
+// Re-export commonly used types for convenience
+var types_1 = require("./types");
+Object.defineProperty(exports, "AssetMode", { enumerable: true, get: function () { return types_1.AssetMode; } });
+/**
+ * Main SDK class that provides a unified interface
+ * Can be initialized for either EVM or Solana (or both)
+ */
+class AintiVirusSDK {
+    /**
+     * Initialize SDK with configuration
+     */
+    constructor(config) {
+        if (config.evm) {
+            // Import ethers dynamically to avoid issues if not using EVM
+            try {
+                const ethers = require("ethers");
+                const provider = config.evm.provider ||
+                    (config.evm.rpcUrl
+                        ? new ethers.JsonRpcProvider(config.evm.rpcUrl)
+                        : null);
+                if (!provider) {
+                    throw new Error("EVM provider or rpcUrl required");
+                }
+                const signer = provider instanceof ethers.Signer ? provider : null;
+                const { AintiVirusEVM } = require("./evm");
+                this.evm = new AintiVirusEVM(config.evm.factoryAddress, config.evm.tokenAddress, signer || provider);
+            }
+            catch (error) {
+                throw new Error(`Failed to initialize EVM SDK: ${error}`);
+            }
+        }
+        if (config.solana) {
+            // Import Solana dependencies dynamically
+            try {
+                const { Connection } = require("@solana/web3.js");
+                const connection = config.solana.connection ||
+                    (config.solana.rpcUrl ? new Connection(config.solana.rpcUrl) : null);
+                if (!connection) {
+                    throw new Error("Solana connection or rpcUrl required");
+                }
+                // Note: Wallet must be provided when creating AintiVirusSolana instance
+                // This unified SDK class is mainly for convenience - use individual SDKs directly for better control
+                throw new Error("Solana SDK should be initialized directly. Use AintiVirusSolana class.");
+            }
+            catch (error) {
+                if (error instanceof Error &&
+                    error.message.includes("Solana SDK should be initialized")) {
+                    throw error;
+                }
+                throw new Error(`Failed to initialize Solana SDK: ${error}`);
+            }
+        }
+    }
+    /**
+     * Set Solana wallet (required for Solana transactions)
+     */
+    setSolanaWallet(wallet) {
+        if (!this.solana) {
+            throw new Error("Solana SDK not initialized");
+        }
+        // Note: This would require modifying AintiVirusSolana to accept wallet updates
+        // For now, wallet should be provided during initialization
+    }
+}
+exports.AintiVirusSDK = AintiVirusSDK;
+// Default export
+exports.default = AintiVirusSDK;

package/dist/solana/index.d.ts

@@ -0,0 +1,139 @@
+import * as anchor from "@coral-xyz/anchor";
+import { PublicKey, Connection } from "@solana/web3.js";
+import { AssetMode, TransactionResult, StakeSeason, StakerRecord } from "../types";
+/**
+ * Solana SDK for AintiVirus Mixer
+ */
+export declare class AintiVirusSolana {
+    private factoryProgram;
+    private mixerProgram;
+    private stakingProgram;
+    private connection;
+    private wallet;
+    private tokenMint?;
+    constructor(factoryProgramId: string, mixerProgramId: string, stakingProgramId: string, wallet: anchor.Wallet, connection: Connection, tokenMint?: string);
+    /**
+     * Get factory PDA
+     */
+    private getFactoryPda;
+    /**
+     * Get mixer pool PDA
+     */
+    private getMixerPoolPda;
+    /**
+     * Get mixer config PDA
+     */
+    private getMixerConfigPda;
+    /**
+     * Get merkle tree PDA
+     */
+    private getMerkleTreePda;
+    /**
+     * Get mixer address for a specific mode and amount
+     */
+    getMixer(mode: AssetMode, amount: bigint): Promise<PublicKey>;
+    /**
+     * Check if mixer exists
+     */
+    mixerExists(mode: AssetMode, amount: bigint): Promise<boolean>;
+    /**
+     * Deposit SOL into the mixer
+     */
+    depositSol(amount: bigint, commitment: bigint): Promise<TransactionResult>;
+    /**
+     * Deposit tokens into the mixer
+     */
+    depositToken(amount: bigint, commitment: bigint): Promise<TransactionResult>;
+    /**
+     * Withdraw from the mixer
+     */
+    withdraw(instructionData: Buffer, nullifierHash: bigint, amount: bigint, mode: AssetMode): Promise<TransactionResult>;
+    /**
+     * Stake SOL
+     */
+    stakeSol(amount: bigint): Promise<TransactionResult>;
+    /**
+     * Stake tokens
+     */
+    stakeToken(amount: bigint): Promise<TransactionResult>;
+    /**
+     * Claim SOL rewards
+     */
+    claimSol(seasonId: bigint): Promise<TransactionResult>;
+    /**
+     * Claim token rewards
+     */
+    claimToken(seasonId: bigint): Promise<TransactionResult>;
+    /**
+     * Unstake SOL
+     */
+    unstakeSol(): Promise<TransactionResult>;
+    /**
+     * Unstake tokens
+     */
+    unstakeToken(): Promise<TransactionResult>;
+    /**
+     * Get current stake season
+     */
+    getCurrentStakeSeason(): Promise<bigint>;
+    /**
+     * Get SOL balance
+     */
+    getSolBalance(address: PublicKey): Promise<bigint>;
+    /**
+     * Get token balance
+     */
+    getTokenBalance(address: PublicKey): Promise<bigint>;
+    /**
+     * Deploy mixer instance
+     */
+    deployMixer(mode: AssetMode, amount: bigint): Promise<TransactionResult>;
+    /**
+     * Set fee rate (admin function)
+     */
+    setFeeRate(feeRate: bigint): Promise<TransactionResult>;
+    /**
+     * Set staking season period (admin function)
+     */
+    setStakingSeasonPeriod(period: bigint): Promise<TransactionResult>;
+    /**
+     * Start stake season (admin function)
+     */
+    startStakeSeason(): Promise<TransactionResult>;
+    /**
+     * Set verifier address (admin function)
+     */
+    setVerifier(verifierAddress: string): Promise<TransactionResult>;
+    /**
+     * Set hasher address (admin function)
+     */
+    setHasher(hasherAddress: string): Promise<TransactionResult>;
+    /**
+     * Calculate deposit amount including fees
+     */
+    calculateDepositAmount(amount: bigint): Promise<bigint>;
+    /**
+     * Get fee rate
+     */
+    getFeeRate(): Promise<bigint>;
+    /**
+     * Get stake season information
+     */
+    getStakeSeason(seasonId: bigint): Promise<StakeSeason>;
+    /**
+     * Get staker record
+     */
+    getStakerRecord(address: string): Promise<StakerRecord>;
+    /**
+     * Check if address has claimed SOL for a season
+     */
+    hasClaimedSol(address: string, seasonId: bigint): Promise<boolean>;
+    /**
+     * Check if address has claimed tokens for a season
+     */
+    hasClaimedToken(address: string, seasonId: bigint): Promise<boolean>;
+    /**
+     * Get staking address (PDA)
+     */
+    getStakingAddress(): Promise<PublicKey>;
+}