@aintivirus-ai/mixer-sdk 1.0.0

package/dist/evm/index.d.ts

@@ -0,0 +1,117 @@
+import { Contract, Signer, Provider } from "ethers";
+import { AssetMode, WithdrawalProof, TransactionResult, StakeSeason, StakerRecord } from "../types";
+/**
+ * EVM SDK for AintiVirus Mixer
+ */
+export declare class AintiVirusEVM {
+    private factory;
+    private token;
+    private signer;
+    private provider;
+    private static readonly FACTORY_ABI;
+    private static readonly ERC20_ABI;
+    private static readonly STAKING_ABI;
+    constructor(factoryAddress: string, tokenAddress: string, signerOrProvider: Signer | Provider);
+    /**
+     * Get the factory contract instance
+     */
+    getFactory(): Contract;
+    /**
+     * Get the token contract instance
+     */
+    getToken(): Contract;
+    /**
+     * Get the provider instance
+     */
+    getProvider(): Provider;
+    /**
+     * Calculate total deposit amount including fees
+     */
+    calculateDepositAmount(amount: bigint): Promise<bigint>;
+    /**
+     * Get fee rate
+     */
+    getFeeRate(): Promise<bigint>;
+    /**
+     * Get mixer address for a specific mode and amount
+     */
+    getMixer(mode: AssetMode, amount: bigint): Promise<string>;
+    /**
+     * Check if mixer exists for a specific mode and amount
+     */
+    mixerExists(mode: AssetMode, amount: bigint): Promise<boolean>;
+    /**
+     * Deposit ETH into the mixer
+     */
+    depositEth(amount: bigint, commitment: bigint): Promise<TransactionResult>;
+    /**
+     * Deposit tokens into the mixer
+     */
+    depositToken(amount: bigint, commitment: bigint): Promise<TransactionResult>;
+    /**
+     * Withdraw from the mixer
+     */
+    withdraw(proof: WithdrawalProof, amount: bigint, mode: AssetMode): Promise<TransactionResult>;
+    /**
+     * Stake ETH
+     */
+    stakeEther(amount: bigint): Promise<TransactionResult>;
+    /**
+     * Stake tokens
+     */
+    stakeToken(amount: bigint): Promise<TransactionResult>;
+    /**
+     * Claim ETH rewards
+     */
+    claimEth(seasonId: bigint): Promise<TransactionResult>;
+    /**
+     * Claim token rewards
+     */
+    claimToken(seasonId: bigint): Promise<TransactionResult>;
+    /**
+     * Unstake ETH
+     */
+    unstakeEth(): Promise<TransactionResult>;
+    /**
+     * Unstake tokens
+     */
+    unstakeToken(): Promise<TransactionResult>;
+    /**
+     * Get current stake season
+     */
+    getCurrentStakeSeason(): Promise<bigint>;
+    /**
+     * Get staking contract address
+     */
+    getStakingAddress(): Promise<string>;
+    /**
+     * Get stake season information
+     */
+    getStakeSeason(seasonId: bigint): Promise<StakeSeason>;
+    /**
+     * Get staker record
+     */
+    getStakerRecord(address: string): Promise<StakerRecord>;
+    /**
+     * Check if user has claimed rewards for a season
+     */
+    hasClaimedEth(address: string, seasonId: bigint): Promise<boolean>;
+    /**
+     * Check if user has claimed token rewards for a season
+     */
+    hasClaimedToken(address: string, seasonId: bigint): Promise<boolean>;
+    /**
+     * Get token balance of an address
+     */
+    getTokenBalance(address: string): Promise<bigint>;
+    /**
+     * Get ETH balance of an address
+     */
+    getEthBalance(address: string): Promise<bigint>;
+    /**
+     * Deploy a new mixer instance
+     */
+    deployMixer(mode: AssetMode, amount: bigint): Promise<TransactionResult & {
+        mixerAddress: string;
+    }>;
+}

package/dist/evm/index.js

@@ -0,0 +1,377 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AintiVirusEVM = void 0;
+const ethers_1 = require("ethers");
+const types_1 = require("../types");
+const crypto_1 = require("../utils/crypto");
+/**
+ * EVM SDK for AintiVirus Mixer
+ */
+class AintiVirusEVM {
+    constructor(factoryAddress, tokenAddress, signerOrProvider) {
+        // Check if it's a Signer by checking for provider property
+        // In ethers v6, Signer has a provider property, Provider doesn't
+        const isSigner = signerOrProvider && "provider" in signerOrProvider && signerOrProvider.provider !== null;
+        this.provider = isSigner
+            ? signerOrProvider.provider
+            : signerOrProvider;
+        this.signer = isSigner ? signerOrProvider : null;
+        this.factory = new ethers_1.Contract(factoryAddress, AintiVirusEVM.FACTORY_ABI, signerOrProvider);
+        this.token = new ethers_1.Contract(tokenAddress, AintiVirusEVM.ERC20_ABI, signerOrProvider);
+    }
+    /**
+     * Get the factory contract instance
+     */
+    getFactory() {
+        return this.factory;
+    }
+    /**
+     * Get the token contract instance
+     */
+    getToken() {
+        return this.token;
+    }
+    /**
+     * Get the provider instance
+     */
+    getProvider() {
+        return this.provider;
+    }
+    /**
+     * Calculate total deposit amount including fees
+     */
+    async calculateDepositAmount(amount) {
+        return await this.factory.calculateDepositAmount(amount);
+    }
+    /**
+     * Get fee rate
+     */
+    async getFeeRate() {
+        return await this.factory.feeRate();
+    }
+    /**
+     * Get mixer address for a specific mode and amount
+     */
+    async getMixer(mode, amount) {
+        return await this.factory.getMixer(mode, amount);
+    }
+    /**
+     * Check if mixer exists for a specific mode and amount
+     */
+    async mixerExists(mode, amount) {
+        const mixerAddress = await this.getMixer(mode, amount);
+        return mixerAddress !== "0x0000000000000000000000000000000000000000";
+    }
+    /**
+     * Deposit ETH into the mixer
+     */
+    async depositEth(amount, commitment) {
+        if (!this.signer) {
+            throw new Error("Signer required for transactions");
+        }
+        const totalAmount = await this.calculateDepositAmount(amount);
+        const tx = await this.factory.deposit(types_1.AssetMode.ETH, amount, (0, crypto_1.bigIntToBytes32)(commitment), { value: totalAmount });
+        const receipt = await tx.wait();
+        return {
+            txHash: receipt.hash,
+            blockNumber: receipt.blockNumber,
+            blockTime: (await this.provider.getBlock(receipt.blockNumber))?.timestamp,
+        };
+    }
+    /**
+     * Deposit tokens into the mixer
+     */
+    async depositToken(amount, commitment) {
+        if (!this.signer) {
+            throw new Error("Signer required for transactions");
+        }
+        const totalAmount = await this.calculateDepositAmount(amount);
+        const factoryAddress = await this.factory.getAddress();
+        // Check and approve if needed
+        const allowance = await this.token.allowance(await this.signer.getAddress(), factoryAddress);
+        if (allowance < totalAmount) {
+            const approveTx = await this.token.approve(factoryAddress, totalAmount);
+            await approveTx.wait();
+        }
+        const tx = await this.factory.deposit(types_1.AssetMode.TOKEN, amount, (0, crypto_1.bigIntToBytes32)(commitment));
+        const receipt = await tx.wait();
+        return {
+            txHash: receipt.hash,
+            blockNumber: receipt.blockNumber,
+            blockTime: (await this.provider.getBlock(receipt.blockNumber))?.timestamp,
+        };
+    }
+    /**
+     * Withdraw from the mixer
+     */
+    async withdraw(proof, amount, mode) {
+        if (!this.signer) {
+            throw new Error("Signer required for transactions");
+        }
+        // Format proof for contract
+        const formattedProof = {
+            pA: [proof.pA[0].toString(), proof.pA[1].toString()],
+            pB: [
+                [proof.pB[0][0].toString(), proof.pB[0][1].toString()],
+                [proof.pB[1][0].toString(), proof.pB[1][1].toString()],
+            ],
+            pC: [proof.pC[0].toString(), proof.pC[1].toString()],
+            pubSignals: proof.pubSignals.map((s) => s.toString()),
+        };
+        const tx = await this.factory.withdraw(formattedProof, amount, mode);
+        const receipt = await tx.wait();
+        return {
+            txHash: receipt.hash,
+            blockNumber: receipt.blockNumber,
+            blockTime: (await this.provider.getBlock(receipt.blockNumber))?.timestamp,
+        };
+    }
+    /**
+     * Stake ETH
+     */
+    async stakeEther(amount) {
+        if (!this.signer) {
+            throw new Error("Signer required for transactions");
+        }
+        const tx = await this.factory.stakeEther(amount, { value: amount });
+        const receipt = await tx.wait();
+        return {
+            txHash: receipt.hash,
+            blockNumber: receipt.blockNumber,
+            blockTime: (await this.provider.getBlock(receipt.blockNumber))?.timestamp,
+        };
+    }
+    /**
+     * Stake tokens
+     */
+    async stakeToken(amount) {
+        if (!this.signer) {
+            throw new Error("Signer required for transactions");
+        }
+        const factoryAddress = await this.factory.getAddress();
+        const allowance = await this.token.allowance(await this.signer.getAddress(), factoryAddress);
+        if (allowance < amount) {
+            const approveTx = await this.token.approve(factoryAddress, amount);
+            await approveTx.wait();
+        }
+        const tx = await this.factory.stakeToken(amount);
+        const receipt = await tx.wait();
+        return {
+            txHash: receipt.hash,
+            blockNumber: receipt.blockNumber,
+            blockTime: (await this.provider.getBlock(receipt.blockNumber))?.timestamp,
+        };
+    }
+    /**
+     * Claim ETH rewards
+     */
+    async claimEth(seasonId) {
+        if (!this.signer) {
+            throw new Error("Signer required for transactions");
+        }
+        const tx = await this.factory.claimEth(seasonId);
+        const receipt = await tx.wait();
+        return {
+            txHash: receipt.hash,
+            blockNumber: receipt.blockNumber,
+            blockTime: (await this.provider.getBlock(receipt.blockNumber))?.timestamp,
+        };
+    }
+    /**
+     * Claim token rewards
+     */
+    async claimToken(seasonId) {
+        if (!this.signer) {
+            throw new Error("Signer required for transactions");
+        }
+        const tx = await this.factory.claimToken(seasonId);
+        const receipt = await tx.wait();
+        return {
+            txHash: receipt.hash,
+            blockNumber: receipt.blockNumber,
+            blockTime: (await this.provider.getBlock(receipt.blockNumber))?.timestamp,
+        };
+    }
+    /**
+     * Unstake ETH
+     */
+    async unstakeEth() {
+        if (!this.signer) {
+            throw new Error("Signer required for transactions");
+        }
+        const tx = await this.factory.unstakeEth();
+        const receipt = await tx.wait();
+        return {
+            txHash: receipt.hash,
+            blockNumber: receipt.blockNumber,
+            blockTime: (await this.provider.getBlock(receipt.blockNumber))?.timestamp,
+        };
+    }
+    /**
+     * Unstake tokens
+     */
+    async unstakeToken() {
+        if (!this.signer) {
+            throw new Error("Signer required for transactions");
+        }
+        const tx = await this.factory.unstakeToken();
+        const receipt = await tx.wait();
+        return {
+            txHash: receipt.hash,
+            blockNumber: receipt.blockNumber,
+            blockTime: (await this.provider.getBlock(receipt.blockNumber))?.timestamp,
+        };
+    }
+    /**
+     * Get current stake season
+     */
+    async getCurrentStakeSeason() {
+        return await this.factory.getCurrentStakeSeason();
+    }
+    /**
+     * Get staking contract address
+     */
+    async getStakingAddress() {
+        return await this.factory.staking();
+    }
+    /**
+     * Get stake season information
+     */
+    async getStakeSeason(seasonId) {
+        const stakingAddress = await this.getStakingAddress();
+        const staking = new ethers_1.Contract(stakingAddress, AintiVirusEVM.STAKING_ABI, this.provider);
+        const season = await staking.stakeSeasons(seasonId);
+        return {
+            seasonId: season.seasonId,
+            startTimestamp: season.startTimestamp,
+            endTimestamp: season.endTimestamp,
+            totalStakedEthAmount: season.totalStakedEthAmount,
+            totalStakedTokenAmount: season.totalStakedTokenAmount,
+            totalRewardEthAmount: season.totalRewardEthAmount,
+            totalRewardTokenAmount: season.totalRewardTokenAmount,
+            totalEthWeightValue: season.totalEthWeightValue,
+            totalTokenWeightValue: season.totalTokenWeightValue,
+        };
+    }
+    /**
+     * Get staker record
+     */
+    async getStakerRecord(address) {
+        const stakingAddress = await this.getStakingAddress();
+        const staking = new ethers_1.Contract(stakingAddress, AintiVirusEVM.STAKING_ABI, this.provider);
+        const record = await staking.stakeRecords(address);
+        return {
+            ethStakedSeasonId: record.ethStakedSeasonId,
+            tokenStakedSeasonId: record.tokenStakedSeasonId,
+            ethStakedTimestamp: record.ethStakedTimestamp,
+            tokenStakedTimestamp: record.tokenStakedTimestamp,
+            stakedEthAmount: record.stakedEthAmount,
+            stakedTokenAmount: record.stakedTokenAmount,
+            ethWeightValue: record.ethWeightValue,
+            tokenWeightValue: record.tokenWeightValue,
+        };
+    }
+    /**
+     * Check if user has claimed rewards for a season
+     */
+    async hasClaimedEth(address, seasonId) {
+        const stakingAddress = await this.getStakingAddress();
+        const staking = new ethers_1.Contract(stakingAddress, AintiVirusEVM.STAKING_ABI, this.provider);
+        return await staking.addressToSeasonClaimedEth(address, seasonId);
+    }
+    /**
+     * Check if user has claimed token rewards for a season
+     */
+    async hasClaimedToken(address, seasonId) {
+        const stakingAddress = await this.getStakingAddress();
+        const staking = new ethers_1.Contract(stakingAddress, AintiVirusEVM.STAKING_ABI, this.provider);
+        return await staking.addressToSeasonClaimedToken(address, seasonId);
+    }
+    /**
+     * Get token balance of an address
+     */
+    async getTokenBalance(address) {
+        return await this.token.balanceOf(address);
+    }
+    /**
+     * Get ETH balance of an address
+     */
+    async getEthBalance(address) {
+        return await this.provider.getBalance(address);
+    }
+    /**
+     * Deploy a new mixer instance
+     */
+    async deployMixer(mode, amount) {
+        if (!this.signer) {
+            throw new Error("Signer required for transactions");
+        }
+        const tx = await this.factory.deployMixer(mode, amount);
+        const receipt = await tx.wait();
+        // Extract mixer address from event
+        const event = receipt.logs.find((log) => {
+            try {
+                const parsed = this.factory.interface.parseLog(log);
+                return parsed?.name === "MixerDeployed";
+            }
+            catch {
+                return false;
+            }
+        });
+        let mixerAddress = "";
+        if (event) {
+            const parsed = this.factory.interface.parseLog(event);
+            mixerAddress = parsed?.args.mixer;
+        }
+        return {
+            txHash: receipt.hash,
+            blockNumber: receipt.blockNumber,
+            blockTime: (await this.provider.getBlock(receipt.blockNumber))?.timestamp,
+            mixerAddress,
+        };
+    }
+}
+exports.AintiVirusEVM = AintiVirusEVM;
+// Factory ABI (minimal for main functions)
+AintiVirusEVM.FACTORY_ABI = [
+    "function deposit(uint256 _mode, uint256 _amount, bytes32 _commitment) payable",
+    "function withdraw(tuple(uint256[2] pA, uint256[2][2] pB, uint256[2] pC, uint256[3] pubSignals) _proof, uint256 _amount, uint256 _mode)",
+    "function deployMixer(uint256 _mode, uint256 _amount) returns (address)",
+    "function getMixer(uint256 _mode, uint256 _amount) view returns (address)",
+    "function calculateDepositAmount(uint256 _amount) view returns (uint256)",
+    "function feeRate() view returns (uint256)",
+    "function staking() view returns (address)",
+    "function mixToken() view returns (address)",
+    "function stakeEther(uint256 amount) payable",
+    "function stakeToken(uint256 amount)",
+    "function claimEth(uint256 seasonId)",
+    "function claimToken(uint256 seasonId)",
+    "function unstakeEth()",
+    "function unstakeToken()",
+    "function getCurrentStakeSeason() view returns (uint256)",
+    "function setFeeRate(uint256 _feeRate)",
+    "function setStakingSeasonPeriod(uint256 _period)",
+    "function startStakeSeason()",
+    "function setVerifier(address _verifier)",
+    "function setHasher(address _hasher)",
+    "event MixerDeployed(address indexed mixer, uint256 indexed mode, uint256 indexed amount)",
+    "event Deposit(bytes32 indexed commitment, uint32 leafIndex, uint256 timestamp)",
+    "event Withdrawal(address to, bytes32 nullifierHash)",
+    "event FeeRateUpdated(uint256 oldFeeRate, uint256 newFeeRate)",
+];
+// ERC20 ABI
+AintiVirusEVM.ERC20_ABI = [
+    "function approve(address spender, uint256 amount) returns (bool)",
+    "function allowance(address owner, address spender) view returns (uint256)",
+    "function balanceOf(address account) view returns (uint256)",
+    "function decimals() view returns (uint8)",
+];
+// Staking ABI
+AintiVirusEVM.STAKING_ABI = [
+    "function stakeSeasons(uint256) view returns (uint256 seasonId, uint256 startTimestamp, uint256 endTimestamp, uint256 totalStakedEthAmount, uint256 totalStakedTokenAmount, uint256 totalRewardEthAmount, uint256 totalRewardTokenAmount, uint256 totalEthWeightValue, uint256 totalTokenWeightValue)",
+    "function stakeRecords(address) view returns (uint256 ethStakedSeasonId, uint256 tokenStakedSeasonId, uint256 ethStakedTimestamp, uint256 tokenStakedTimestamp, uint256 stakedEthAmount, uint256 stakedTokenAmount, uint256 ethWeightValue, uint256 tokenWeightValue)",
+    "function addressToSeasonClaimedEth(address, uint256) view returns (bool)",
+    "function addressToSeasonClaimedToken(address, uint256) view returns (bool)",
+    "function stakingSeasonPeriod() view returns (uint256)",
+    "function currentStakeSeason() view returns (uint256)",
+];

package/dist/hooks/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * React hooks for AintiVirus Mixer SDK
+ * Optimized for Next.js integration with EVM and Solana support
+ *
+ * Use individual hooks for better code splitting:
+ * - useDeposit: Only for deposits
+ * - useStake: Only for staking/unstaking
+ * - useClaim: Only for claiming rewards
+ * - useWithdraw: Only for withdrawals
+ * - useAintiVirus: All-in-one hook (if you need everything)
+ */
+export { useDeposit } from "./useDeposit";
+export type { DepositHookConfig, UseDepositReturn } from "./useDeposit";
+export { useStake } from "./useStake";
+export type { StakeHookConfig, UseStakeReturn } from "./useStake";
+export { useClaim } from "./useClaim";
+export type { ClaimHookConfig, UseClaimReturn } from "./useClaim";
+export { useWithdraw } from "./useWithdraw";
+export type { WithdrawHookConfig, UseWithdrawReturn } from "./useWithdraw";
+export { useView } from "./useView";
+export type { ViewHookConfig, UseViewReturn } from "./useView";
+export { useDeploy } from "./useDeploy";
+export type { DeployHookConfig, UseDeployReturn } from "./useDeploy";
+export { useAdmin } from "./useAdmin";
+export type { AdminHookConfig, UseAdminReturn } from "./useAdmin";
+export { useAintiVirus } from "./useAintiVirus";
+export type { UnifiedHookConfig, UseAintiVirusReturn } from "./useAintiVirus";
+export { ChainType, AssetMode } from "../types";
+export type { EVMHookConfig, SolanaHookConfig } from "../types";

package/dist/hooks/index.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * React hooks for AintiVirus Mixer SDK
+ * Optimized for Next.js integration with EVM and Solana support
+ *
+ * Use individual hooks for better code splitting:
+ * - useDeposit: Only for deposits
+ * - useStake: Only for staking/unstaking
+ * - useClaim: Only for claiming rewards
+ * - useWithdraw: Only for withdrawals
+ * - useAintiVirus: All-in-one hook (if you need everything)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AssetMode = exports.ChainType = exports.useAintiVirus = exports.useAdmin = exports.useDeploy = exports.useView = exports.useWithdraw = exports.useClaim = exports.useStake = exports.useDeposit = void 0;
+// Individual hooks (recommended for code splitting)
+var useDeposit_1 = require("./useDeposit");
+Object.defineProperty(exports, "useDeposit", { enumerable: true, get: function () { return useDeposit_1.useDeposit; } });
+var useStake_1 = require("./useStake");
+Object.defineProperty(exports, "useStake", { enumerable: true, get: function () { return useStake_1.useStake; } });
+var useClaim_1 = require("./useClaim");
+Object.defineProperty(exports, "useClaim", { enumerable: true, get: function () { return useClaim_1.useClaim; } });
+var useWithdraw_1 = require("./useWithdraw");
+Object.defineProperty(exports, "useWithdraw", { enumerable: true, get: function () { return useWithdraw_1.useWithdraw; } });
+var useView_1 = require("./useView");
+Object.defineProperty(exports, "useView", { enumerable: true, get: function () { return useView_1.useView; } });
+var useDeploy_1 = require("./useDeploy");
+Object.defineProperty(exports, "useDeploy", { enumerable: true, get: function () { return useDeploy_1.useDeploy; } });
+var useAdmin_1 = require("./useAdmin");
+Object.defineProperty(exports, "useAdmin", { enumerable: true, get: function () { return useAdmin_1.useAdmin; } });
+// Unified hook (supports both EVM and Solana - use if you need all functions)
+var useAintiVirus_1 = require("./useAintiVirus");
+Object.defineProperty(exports, "useAintiVirus", { enumerable: true, get: function () { return useAintiVirus_1.useAintiVirus; } });
+// Re-export types
+var types_1 = require("../types");
+Object.defineProperty(exports, "ChainType", { enumerable: true, get: function () { return types_1.ChainType; } });
+Object.defineProperty(exports, "AssetMode", { enumerable: true, get: function () { return types_1.AssetMode; } });

package/dist/hooks/useAdmin.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Hook for admin functions (EVM or Solana)
+ * Use this hook when you need to perform admin operations
+ * Requires OPERATOR_ROLE or ADMIN_ROLE
+ */
+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 admin functions
+ */
+export interface AdminHookConfig {
+    evm?: EVMHookConfig;
+    solana?: SolanaHookConfig;
+    solanaWallet?: Wallet;
+    solanaConnection?: Connection;
+}
+/**
+ * Admin hook return type
+ */
+export interface UseAdminReturn {
+    setFeeRate: (chainType: ChainType, feeRate: bigint) => Promise<TransactionResult>;
+    setStakingSeasonPeriod: (chainType: ChainType, period: bigint) => Promise<TransactionResult>;
+    startStakeSeason: (chainType: ChainType) => Promise<TransactionResult>;
+    setVerifier: (chainType: ChainType, verifierAddress: string) => Promise<TransactionResult>;
+    setHasher: (chainType: ChainType, hasherAddress: string) => Promise<TransactionResult>;
+    isEVMReady: boolean;
+    isSolanaReady: boolean;
+}
+/**
+ * Hook for admin functions
+ * Only initializes what's needed for admin operations
+ */
+export declare function useAdmin(config: AdminHookConfig): UseAdminReturn;