@aintivirus-ai/mixer-sdk 1.0.0

package/dist/solana/index.js

@@ -0,0 +1,694 @@
+"use strict";
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AintiVirusSolana = void 0;
+const anchor = __importStar(require("@coral-xyz/anchor"));
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const types_1 = require("../types");
+/**
+ * Solana SDK for AintiVirus Mixer
+ */
+class AintiVirusSolana {
+    constructor(factoryProgramId, mixerProgramId, stakingProgramId, wallet, connection, tokenMint) {
+        this.connection = connection;
+        this.wallet = wallet;
+        // Initialize programs (using any type for IDL flexibility)
+        this.factoryProgram = new anchor.Program({}, // IDL should be loaded separately
+        new web3_js_1.PublicKey(factoryProgramId), new anchor.AnchorProvider(connection, wallet, {}));
+        this.mixerProgram = new anchor.Program({}, new web3_js_1.PublicKey(mixerProgramId), new anchor.AnchorProvider(connection, wallet, {}));
+        this.stakingProgram = new anchor.Program({}, new web3_js_1.PublicKey(stakingProgramId), new anchor.AnchorProvider(connection, wallet, {}));
+        if (tokenMint) {
+            this.tokenMint = new web3_js_1.PublicKey(tokenMint);
+        }
+    }
+    /**
+     * Get factory PDA
+     */
+    getFactoryPda() {
+        return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("factory")], this.factoryProgram.programId);
+    }
+    /**
+     * Get mixer pool PDA
+     */
+    getMixerPoolPda(mode, amount) {
+        const amountBuffer = Buffer.allocUnsafe(8);
+        amountBuffer.writeBigUInt64LE(amount, 0);
+        return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("mixer_pool"), Buffer.from([mode]), amountBuffer], this.factoryProgram.programId);
+    }
+    /**
+     * Get mixer config PDA
+     */
+    getMixerConfigPda(mode, amount) {
+        const amountBuffer = Buffer.allocUnsafe(8);
+        amountBuffer.writeBigUInt64LE(amount, 0);
+        return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("mixer_config"), Buffer.from([mode]), amountBuffer], this.mixerProgram.programId);
+    }
+    /**
+     * Get merkle tree PDA
+     */
+    getMerkleTreePda(mixerConfigPda) {
+        return web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("merkle_tree"), mixerConfigPda.toBuffer()], this.mixerProgram.programId);
+    }
+    /**
+     * Get mixer address for a specific mode and amount
+     */
+    async getMixer(mode, amount) {
+        const [mixerPoolPda] = this.getMixerPoolPda(mode, amount);
+        // Call get_mixer instruction (view function)
+        try {
+            const mixerConfigPubkey = await this.factoryProgram.methods
+                .getMixer(mode, new anchor.BN(amount.toString()))
+                .accounts({
+                mixerPool: mixerPoolPda,
+            })
+                .view();
+            return mixerConfigPubkey;
+        }
+        catch (error) {
+            throw new Error(`Mixer not found for mode ${mode}, amount ${amount}`);
+        }
+    }
+    /**
+     * Check if mixer exists
+     */
+    async mixerExists(mode, amount) {
+        try {
+            await this.getMixer(mode, amount);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Deposit SOL into the mixer
+     */
+    async depositSol(amount, commitment) {
+        const [factoryPda] = this.getFactoryPda();
+        const [mixerPoolPda] = this.getMixerPoolPda(types_1.AssetMode.ETH, amount);
+        const [mixerConfigPda] = this.getMixerConfigPda(types_1.AssetMode.ETH, amount);
+        const [merkleTreePda] = this.getMerkleTreePda(mixerConfigPda);
+        const commitmentBytes = Buffer.allocUnsafe(32);
+        const commitmentBigInt = commitment;
+        commitmentBytes.writeBigUInt64LE(commitmentBigInt & BigInt("0xFFFFFFFFFFFFFFFF"), 0);
+        commitmentBytes.writeBigUInt64LE((commitmentBigInt >> 64n) & BigInt("0xFFFFFFFFFFFFFFFF"), 8);
+        commitmentBytes.writeBigUInt64LE((commitmentBigInt >> 128n) & BigInt("0xFFFFFFFFFFFFFFFF"), 16);
+        commitmentBytes.writeBigUInt64LE((commitmentBigInt >> 192n) & BigInt("0xFFFFFFFFFFFFFFFF"), 24);
+        const tx = await this.factoryProgram.methods
+            .deposit(types_1.AssetMode.ETH, new anchor.BN(amount.toString()), Array.from(commitmentBytes))
+            .accounts({
+            factory: factoryPda,
+            payer: this.wallet.publicKey,
+            mixerProgram: this.mixerProgram.programId,
+            mixerPool: mixerPoolPda,
+            mixerConfig: mixerConfigPda,
+            merkleTree: merkleTreePda,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        })
+            .rpc();
+        const signature = tx;
+        const txDetails = await this.connection.getTransaction(signature, {
+            commitment: "confirmed",
+        });
+        return {
+            txHash: signature,
+            blockTime: txDetails?.blockTime ?? undefined,
+        };
+    }
+    /**
+     * Deposit tokens into the mixer
+     */
+    async depositToken(amount, commitment) {
+        if (!this.tokenMint) {
+            throw new Error("Token mint not configured");
+        }
+        const [factoryPda] = this.getFactoryPda();
+        const [mixerPoolPda] = this.getMixerPoolPda(types_1.AssetMode.TOKEN, amount);
+        const [mixerConfigPda] = this.getMixerConfigPda(types_1.AssetMode.TOKEN, amount);
+        const [merkleTreePda] = this.getMerkleTreePda(mixerConfigPda);
+        const userTokenAccount = await (0, spl_token_1.getAssociatedTokenAddress)(this.tokenMint, this.wallet.publicKey);
+        const factoryTokenAccount = await (0, spl_token_1.getAssociatedTokenAddress)(this.tokenMint, factoryPda, true // allowOwnerOffCurve
+        );
+        const commitmentBytes = Buffer.allocUnsafe(32);
+        const commitmentBigInt = commitment;
+        commitmentBytes.writeBigUInt64LE(commitmentBigInt & BigInt("0xFFFFFFFFFFFFFFFF"), 0);
+        commitmentBytes.writeBigUInt64LE((commitmentBigInt >> 64n) & BigInt("0xFFFFFFFFFFFFFFFF"), 8);
+        commitmentBytes.writeBigUInt64LE((commitmentBigInt >> 128n) & BigInt("0xFFFFFFFFFFFFFFFF"), 16);
+        commitmentBytes.writeBigUInt64LE((commitmentBigInt >> 192n) & BigInt("0xFFFFFFFFFFFFFFFF"), 24);
+        const tx = await this.factoryProgram.methods
+            .deposit(types_1.AssetMode.TOKEN, new anchor.BN(amount.toString()), Array.from(commitmentBytes))
+            .accounts({
+            factory: factoryPda,
+            payer: this.wallet.publicKey,
+            mixerProgram: this.mixerProgram.programId,
+            mixerPool: mixerPoolPda,
+            mixerConfig: mixerConfigPda,
+            merkleTree: merkleTreePda,
+            tokenMint: this.tokenMint,
+            userTokenAccount: userTokenAccount,
+            factoryTokenAccount: factoryTokenAccount,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        })
+            .rpc();
+        const signature = tx;
+        const txDetails = await this.connection.getTransaction(signature, {
+            commitment: "confirmed",
+        });
+        return {
+            txHash: signature,
+            blockTime: txDetails?.blockTime ?? undefined,
+        };
+    }
+    /**
+     * Withdraw from the mixer
+     */
+    async withdraw(instructionData, nullifierHash, amount, mode) {
+        const [factoryPda] = this.getFactoryPda();
+        const [mixerPoolPda] = this.getMixerPoolPda(mode, amount);
+        const [mixerConfigPda] = this.getMixerConfigPda(mode, amount);
+        const [merkleTreePda] = this.getMerkleTreePda(mixerConfigPda);
+        const nullifierHashBytes = Buffer.allocUnsafe(32);
+        const nullifierHashBigInt = nullifierHash;
+        nullifierHashBytes.writeBigUInt64LE(nullifierHashBigInt & BigInt("0xFFFFFFFFFFFFFFFF"), 0);
+        nullifierHashBytes.writeBigUInt64LE((nullifierHashBigInt >> 64n) & BigInt("0xFFFFFFFFFFFFFFFF"), 8);
+        nullifierHashBytes.writeBigUInt64LE((nullifierHashBigInt >> 128n) & BigInt("0xFFFFFFFFFFFFFFFF"), 16);
+        nullifierHashBytes.writeBigUInt64LE((nullifierHashBigInt >> 192n) & BigInt("0xFFFFFFFFFFFFFFFF"), 24);
+        const accounts = {
+            factory: factoryPda,
+            payer: this.wallet.publicKey,
+            mixerProgram: this.mixerProgram.programId,
+            mixerPool: mixerPoolPda,
+            mixerConfig: mixerConfigPda,
+            merkleTree: merkleTreePda,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        };
+        if (mode === types_1.AssetMode.TOKEN && this.tokenMint) {
+            const userTokenAccount = await (0, spl_token_1.getAssociatedTokenAddress)(this.tokenMint, this.wallet.publicKey);
+            const factoryTokenAccount = await (0, spl_token_1.getAssociatedTokenAddress)(this.tokenMint, factoryPda, true);
+            accounts.tokenMint = this.tokenMint;
+            accounts.userTokenAccount = userTokenAccount;
+            accounts.factoryTokenAccount = factoryTokenAccount;
+            accounts.tokenProgram = spl_token_1.TOKEN_PROGRAM_ID;
+        }
+        const tx = await this.factoryProgram.methods
+            .withdraw(mode, new anchor.BN(amount.toString()), Array.from(instructionData), Array.from(nullifierHashBytes))
+            .accounts(accounts)
+            .rpc();
+        const signature = tx;
+        const txDetails = await this.connection.getTransaction(signature, {
+            commitment: "confirmed",
+        });
+        return {
+            txHash: signature,
+            blockTime: txDetails?.blockTime ?? undefined,
+        };
+    }
+    /**
+     * Stake SOL
+     */
+    async stakeSol(amount) {
+        const [factoryPda] = this.getFactoryPda();
+        const tx = await this.factoryProgram.methods
+            .stakeEther(new anchor.BN(amount.toString()))
+            .accounts({
+            factory: factoryPda,
+            staker: this.wallet.publicKey,
+            stakingProgram: this.stakingProgram.programId,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        })
+            .rpc();
+        const signature = tx;
+        const txDetails = await this.connection.getTransaction(signature, {
+            commitment: "confirmed",
+        });
+        return {
+            txHash: signature,
+            blockTime: txDetails?.blockTime ?? undefined,
+        };
+    }
+    /**
+     * Stake tokens
+     */
+    async stakeToken(amount) {
+        if (!this.tokenMint) {
+            throw new Error("Token mint not configured");
+        }
+        const [factoryPda] = this.getFactoryPda();
+        const userTokenAccount = await (0, spl_token_1.getAssociatedTokenAddress)(this.tokenMint, this.wallet.publicKey);
+        const factoryTokenAccount = await (0, spl_token_1.getAssociatedTokenAddress)(this.tokenMint, factoryPda, true);
+        const tx = await this.factoryProgram.methods
+            .stakeToken(new anchor.BN(amount.toString()))
+            .accounts({
+            factory: factoryPda,
+            staker: this.wallet.publicKey,
+            stakingProgram: this.stakingProgram.programId,
+            tokenMint: this.tokenMint,
+            userTokenAccount: userTokenAccount,
+            factoryTokenAccount: factoryTokenAccount,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        })
+            .rpc();
+        const signature = tx;
+        const txDetails = await this.connection.getTransaction(signature, {
+            commitment: "confirmed",
+        });
+        return {
+            txHash: signature,
+            blockTime: txDetails?.blockTime ?? undefined,
+        };
+    }
+    /**
+     * Claim SOL rewards
+     */
+    async claimSol(seasonId) {
+        const [factoryPda] = this.getFactoryPda();
+        const tx = await this.factoryProgram.methods
+            .claimEth(new anchor.BN(seasonId.toString()))
+            .accounts({
+            factory: factoryPda,
+            staker: this.wallet.publicKey,
+            stakingProgram: this.stakingProgram.programId,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        })
+            .rpc();
+        const signature = tx;
+        const txDetails = await this.connection.getTransaction(signature, {
+            commitment: "confirmed",
+        });
+        return {
+            txHash: signature,
+            blockTime: txDetails?.blockTime ?? undefined,
+        };
+    }
+    /**
+     * Claim token rewards
+     */
+    async claimToken(seasonId) {
+        if (!this.tokenMint) {
+            throw new Error("Token mint not configured");
+        }
+        const [factoryPda] = this.getFactoryPda();
+        const userTokenAccount = await (0, spl_token_1.getAssociatedTokenAddress)(this.tokenMint, this.wallet.publicKey);
+        const factoryTokenAccount = await (0, spl_token_1.getAssociatedTokenAddress)(this.tokenMint, factoryPda, true);
+        const tx = await this.factoryProgram.methods
+            .claimToken(new anchor.BN(seasonId.toString()))
+            .accounts({
+            factory: factoryPda,
+            staker: this.wallet.publicKey,
+            stakingProgram: this.stakingProgram.programId,
+            tokenMint: this.tokenMint,
+            userTokenAccount: userTokenAccount,
+            factoryTokenAccount: factoryTokenAccount,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        })
+            .rpc();
+        const signature = tx;
+        const txDetails = await this.connection.getTransaction(signature, {
+            commitment: "confirmed",
+        });
+        return {
+            txHash: signature,
+            blockTime: txDetails?.blockTime ?? undefined,
+        };
+    }
+    /**
+     * Unstake SOL
+     */
+    async unstakeSol() {
+        const [factoryPda] = this.getFactoryPda();
+        const tx = await this.factoryProgram.methods
+            .unstakeEth()
+            .accounts({
+            factory: factoryPda,
+            staker: this.wallet.publicKey,
+            stakingProgram: this.stakingProgram.programId,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        })
+            .rpc();
+        const signature = tx;
+        const txDetails = await this.connection.getTransaction(signature, {
+            commitment: "confirmed",
+        });
+        return {
+            txHash: signature,
+            blockTime: txDetails?.blockTime ?? undefined,
+        };
+    }
+    /**
+     * Unstake tokens
+     */
+    async unstakeToken() {
+        if (!this.tokenMint) {
+            throw new Error("Token mint not configured");
+        }
+        const [factoryPda] = this.getFactoryPda();
+        const userTokenAccount = await (0, spl_token_1.getAssociatedTokenAddress)(this.tokenMint, this.wallet.publicKey);
+        const factoryTokenAccount = await (0, spl_token_1.getAssociatedTokenAddress)(this.tokenMint, factoryPda, true);
+        const tx = await this.factoryProgram.methods
+            .unstakeToken()
+            .accounts({
+            factory: factoryPda,
+            staker: this.wallet.publicKey,
+            stakingProgram: this.stakingProgram.programId,
+            tokenMint: this.tokenMint,
+            userTokenAccount: userTokenAccount,
+            factoryTokenAccount: factoryTokenAccount,
+            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        })
+            .rpc();
+        const signature = tx;
+        const txDetails = await this.connection.getTransaction(signature, {
+            commitment: "confirmed",
+        });
+        return {
+            txHash: signature,
+            blockTime: txDetails?.blockTime ?? undefined,
+        };
+    }
+    /**
+     * Get current stake season
+     */
+    async getCurrentStakeSeason() {
+        const [factoryPda] = this.getFactoryPda();
+        const factoryAccount = await this.factoryProgram.account.factory.fetch(factoryPda);
+        // Assuming factory account has currentStakeSeason field
+        // This may need adjustment based on actual account structure
+        return BigInt(factoryAccount.currentStakeSeason?.toString() || "0");
+    }
+    /**
+     * Get SOL balance
+     */
+    async getSolBalance(address) {
+        const balance = await this.connection.getBalance(address);
+        return BigInt(balance);
+    }
+    /**
+     * Get token balance
+     */
+    async getTokenBalance(address) {
+        if (!this.tokenMint) {
+            throw new Error("Token mint not configured");
+        }
+        const tokenAccount = await (0, spl_token_1.getAssociatedTokenAddress)(this.tokenMint, address);
+        try {
+            const accountInfo = await this.connection.getTokenAccountBalance(tokenAccount);
+            return BigInt(accountInfo.value.amount);
+        }
+        catch {
+            return 0n;
+        }
+    }
+    /**
+     * Deploy mixer instance
+     */
+    async deployMixer(mode, amount) {
+        const [factoryPda] = this.getFactoryPda();
+        const [mixerPoolPda] = this.getMixerPoolPda(mode, amount);
+        const [mixerConfigPda] = this.getMixerConfigPda(mode, amount);
+        const [merkleTreePda] = this.getMerkleTreePda(mixerConfigPda);
+        const accounts = {
+            factory: factoryPda,
+            payer: this.wallet.publicKey,
+            mixerProgram: this.mixerProgram.programId,
+            mixerPool: mixerPoolPda,
+            mixerConfig: mixerConfigPda,
+            merkleTree: merkleTreePda,
+            systemProgram: web3_js_1.SystemProgram.programId,
+        };
+        if (mode === types_1.AssetMode.TOKEN && this.tokenMint) {
+            const factoryTokenAccount = await (0, spl_token_1.getAssociatedTokenAddress)(this.tokenMint, factoryPda, true);
+            accounts.tokenMint = this.tokenMint;
+            accounts.factoryTokenAccount = factoryTokenAccount;
+            accounts.tokenProgram = spl_token_1.TOKEN_PROGRAM_ID;
+        }
+        const tx = await this.factoryProgram.methods
+            .deployMixer(mode, new anchor.BN(amount.toString()))
+            .accounts(accounts)
+            .rpc();
+        const signature = tx;
+        const txDetails = await this.connection.getTransaction(signature, {
+            commitment: "confirmed",
+        });
+        return {
+            txHash: signature,
+            blockTime: txDetails?.blockTime ?? undefined,
+        };
+    }
+    /**
+     * Set fee rate (admin function)
+     */
+    async setFeeRate(feeRate) {
+        const [factoryPda] = this.getFactoryPda();
+        const tx = await this.factoryProgram.methods
+            .setFeeRate(new anchor.BN(feeRate.toString()))
+            .accounts({
+            factory: factoryPda,
+            authority: this.wallet.publicKey,
+        })
+            .rpc();
+        const signature = tx;
+        const txDetails = await this.connection.getTransaction(signature, {
+            commitment: "confirmed",
+        });
+        return {
+            txHash: signature,
+            blockTime: txDetails?.blockTime ?? undefined,
+        };
+    }
+    /**
+     * Set staking season period (admin function)
+     */
+    async setStakingSeasonPeriod(period) {
+        const [factoryPda] = this.getFactoryPda();
+        const tx = await this.factoryProgram.methods
+            .setStakingSeasonPeriod(new anchor.BN(period.toString()))
+            .accounts({
+            factory: factoryPda,
+            authority: this.wallet.publicKey,
+        })
+            .rpc();
+        const signature = tx;
+        const txDetails = await this.connection.getTransaction(signature, {
+            commitment: "confirmed",
+        });
+        return {
+            txHash: signature,
+            blockTime: txDetails?.blockTime ?? undefined,
+        };
+    }
+    /**
+     * Start stake season (admin function)
+     */
+    async startStakeSeason() {
+        const [factoryPda] = this.getFactoryPda();
+        const tx = await this.factoryProgram.methods
+            .startStakeSeason()
+            .accounts({
+            factory: factoryPda,
+            authority: this.wallet.publicKey,
+            stakingProgram: this.stakingProgram.programId,
+        })
+            .rpc();
+        const signature = tx;
+        const txDetails = await this.connection.getTransaction(signature, {
+            commitment: "confirmed",
+        });
+        return {
+            txHash: signature,
+            blockTime: txDetails?.blockTime ?? undefined,
+        };
+    }
+    /**
+     * Set verifier address (admin function)
+     */
+    async setVerifier(verifierAddress) {
+        const [factoryPda] = this.getFactoryPda();
+        const tx = await this.factoryProgram.methods
+            .setVerifier(new web3_js_1.PublicKey(verifierAddress))
+            .accounts({
+            factory: factoryPda,
+            authority: this.wallet.publicKey,
+        })
+            .rpc();
+        const signature = tx;
+        const txDetails = await this.connection.getTransaction(signature, {
+            commitment: "confirmed",
+        });
+        return {
+            txHash: signature,
+            blockTime: txDetails?.blockTime ?? undefined,
+        };
+    }
+    /**
+     * Set hasher address (admin function)
+     */
+    async setHasher(hasherAddress) {
+        const [factoryPda] = this.getFactoryPda();
+        const tx = await this.factoryProgram.methods
+            .setHasher(new web3_js_1.PublicKey(hasherAddress))
+            .accounts({
+            factory: factoryPda,
+            authority: this.wallet.publicKey,
+        })
+            .rpc();
+        const signature = tx;
+        const txDetails = await this.connection.getTransaction(signature, {
+            commitment: "confirmed",
+        });
+        return {
+            txHash: signature,
+            blockTime: txDetails?.blockTime ?? undefined,
+        };
+    }
+    /**
+     * Calculate deposit amount including fees
+     */
+    async calculateDepositAmount(amount) {
+        const [factoryPda] = this.getFactoryPda();
+        const factoryAccount = await this.factoryProgram.account.factory.fetch(factoryPda);
+        const feeRate = BigInt(factoryAccount.feeRate?.toString() || "0");
+        // Calculate: amount + (amount * feeRate / 10000)
+        return amount + (amount * feeRate) / 10000n;
+    }
+    /**
+     * Get fee rate
+     */
+    async getFeeRate() {
+        const [factoryPda] = this.getFactoryPda();
+        const factoryAccount = await this.factoryProgram.account.factory.fetch(factoryPda);
+        return BigInt(factoryAccount.feeRate?.toString() || "0");
+    }
+    /**
+     * Get stake season information
+     */
+    async getStakeSeason(seasonId) {
+        const [factoryPda] = this.getFactoryPda();
+        // Fetch stake season from staking program
+        const seasonPda = web3_js_1.PublicKey.findProgramAddressSync([
+            Buffer.from("stake_season"),
+            new anchor.BN(seasonId.toString()).toArrayLike(Buffer, "be", 8),
+        ], this.stakingProgram.programId)[0];
+        try {
+            const seasonAccount = await this.stakingProgram.account.stakeSeason.fetch(seasonPda);
+            return {
+                seasonId: BigInt(seasonAccount.seasonId?.toString() || "0"),
+                startTimestamp: BigInt(seasonAccount.startTimestamp?.toString() || "0"),
+                endTimestamp: BigInt(seasonAccount.endTimestamp?.toString() || "0"),
+                totalStakedEthAmount: BigInt(seasonAccount.totalStakedEthAmount?.toString() || "0"),
+                totalStakedTokenAmount: BigInt(seasonAccount.totalStakedTokenAmount?.toString() || "0"),
+                totalRewardEthAmount: BigInt(seasonAccount.totalRewardEthAmount?.toString() || "0"),
+                totalRewardTokenAmount: BigInt(seasonAccount.totalRewardTokenAmount?.toString() || "0"),
+                totalEthWeightValue: BigInt(seasonAccount.totalEthWeightValue?.toString() || "0"),
+                totalTokenWeightValue: BigInt(seasonAccount.totalTokenWeightValue?.toString() || "0"),
+            };
+        }
+        catch {
+            throw new Error(`Stake season ${seasonId} not found`);
+        }
+    }
+    /**
+     * Get staker record
+     */
+    async getStakerRecord(address) {
+        const stakerPubkey = new web3_js_1.PublicKey(address);
+        const stakerRecordPda = web3_js_1.PublicKey.findProgramAddressSync([Buffer.from("staker_record"), stakerPubkey.toBuffer()], this.stakingProgram.programId)[0];
+        try {
+            const stakerRecord = await this.stakingProgram.account.stakerRecord.fetch(stakerRecordPda);
+            return {
+                ethStakedSeasonId: BigInt(stakerRecord.ethStakedSeasonId?.toString() || "0"),
+                tokenStakedSeasonId: BigInt(stakerRecord.tokenStakedSeasonId?.toString() || "0"),
+                ethStakedTimestamp: BigInt(stakerRecord.ethStakedTimestamp?.toString() || "0"),
+                tokenStakedTimestamp: BigInt(stakerRecord.tokenStakedTimestamp?.toString() || "0"),
+                stakedEthAmount: BigInt(stakerRecord.stakedEthAmount?.toString() || "0"),
+                stakedTokenAmount: BigInt(stakerRecord.stakedTokenAmount?.toString() || "0"),
+                ethWeightValue: BigInt(stakerRecord.ethWeightValue?.toString() || "0"),
+                tokenWeightValue: BigInt(stakerRecord.tokenWeightValue?.toString() || "0"),
+            };
+        }
+        catch {
+            throw new Error(`Staker record for ${address} not found`);
+        }
+    }
+    /**
+     * Check if address has claimed SOL for a season
+     */
+    async hasClaimedSol(address, seasonId) {
+        const stakerPubkey = new web3_js_1.PublicKey(address);
+        const claimPda = web3_js_1.PublicKey.findProgramAddressSync([
+            Buffer.from("season_claimed_eth"),
+            stakerPubkey.toBuffer(),
+            new anchor.BN(seasonId.toString()).toArrayLike(Buffer, "be", 8),
+        ], this.stakingProgram.programId)[0];
+        try {
+            await this.stakingProgram.account.seasonClaimedEth.fetch(claimPda);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Check if address has claimed tokens for a season
+     */
+    async hasClaimedToken(address, seasonId) {
+        const stakerPubkey = new web3_js_1.PublicKey(address);
+        const claimPda = web3_js_1.PublicKey.findProgramAddressSync([
+            Buffer.from("season_claimed_token"),
+            stakerPubkey.toBuffer(),
+            new anchor.BN(seasonId.toString()).toArrayLike(Buffer, "be", 8),
+        ], this.stakingProgram.programId)[0];
+        try {
+            await this.stakingProgram.account.seasonClaimedToken.fetch(claimPda);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get staking address (PDA)
+     */
+    async getStakingAddress() {
+        const [factoryPda] = this.getFactoryPda();
+        const factoryAccount = await this.factoryProgram.account.factory.fetch(factoryPda);
+        return factoryAccount.staking;
+    }
+}
+exports.AintiVirusSolana = AintiVirusSolana;