@soltracer/nft-staking 0.1.0

package/dist/client.js

@@ -0,0 +1,892 @@
+import { BN, Program } from "@coral-xyz/anchor";
+import { PublicKey, SystemProgram } from "@solana/web3.js";
+import { getStakeConfigPda, getStakePoolPda, getStakeEntryPda, getStakerAccountPda, getCollectionPda, getPoolAuthorityPda, getPoolSecondaryRewardsPda, getStakerSecondaryRewardsPda, getProjectPda, getAta, decodeAccount, getFeeConfigPda, getTreasuryPda, PROJECT_MANAGEMENT_PROGRAM_ID, ADMIN_PROGRAM_ID, TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID, MPL_CORE_PROGRAM_ID, } from "@soltracer/core";
+import NftStakingIDL from "./idl.json";
+/** Well-known program IDs for cNFT operations. */
+const BUBBLEGUM_PROGRAM_ID = new PublicKey("BGUMAp9Gq7iTEuizy4pqaxsTyUCBK68MDfK752saRPUY");
+const SPL_ACCOUNT_COMPRESSION_PROGRAM_ID = new PublicKey("cmtDvXumGCrqC1Age74AVPhSRVXJMd8PJS91L8KbNCK");
+const SPL_NOOP_PROGRAM_ID = new PublicKey("noopb9bkMVfRPU8AsbpTUg8AQkHtKwMYZiFUjNRtMmV");
+const TOKEN_METADATA_PROGRAM_ID = new PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
+/** Derive the Token Metadata PDA for a given mint. */
+function getMetadataPda(mint) {
+    const [pda] = PublicKey.findProgramAddressSync([new TextEncoder().encode("metadata"), TOKEN_METADATA_PROGRAM_ID.toBytes(), mint.toBytes()], TOKEN_METADATA_PROGRAM_ID);
+    return pda;
+}
+/** Derive the Master Edition PDA for a given mint. */
+function getEditionPda(mint) {
+    const [pda] = PublicKey.findProgramAddressSync([
+        new TextEncoder().encode("metadata"),
+        TOKEN_METADATA_PROGRAM_ID.toBytes(),
+        mint.toBytes(),
+        new TextEncoder().encode("edition"),
+    ], TOKEN_METADATA_PROGRAM_ID);
+    return pda;
+}
+/** Sysvar Instructions address. */
+const SYSVAR_INSTRUCTIONS_ID = new PublicKey("Sysvar1nstructions1111111111111111111111111");
+/** Decode a base58-encoded 32-byte hash into a number array. */
+function base58HashToArray(hash) {
+    return Array.from(new PublicKey(hash).toBytes());
+}
+/** Derive the Bubblegum tree config PDA from a merkle tree address. */
+function getTreeConfigPda(merkleTree) {
+    return PublicKey.findProgramAddressSync([merkleTree.toBytes()], BUBBLEGUM_PROGRAM_ID);
+}
+export class NftStakingClient {
+    program;
+    provider;
+    tokenProgramCache = new Map();
+    mintDecimalsCache = new Map();
+    constructor(program, provider) {
+        this.program = program;
+        this.provider = provider;
+    }
+    static create(provider) {
+        const program = new Program(NftStakingIDL, provider);
+        return new NftStakingClient(program, provider);
+    }
+    static fromIdl(idl, provider) {
+        const program = new Program(idl, provider);
+        return new NftStakingClient(program, provider);
+    }
+    /** Detect whether a mint is Token-2022 or SPL Token (cached). */
+    async resolveTokenProgram(mint) {
+        const key = mint.toBase58();
+        const cached = this.tokenProgramCache.get(key);
+        if (cached)
+            return cached;
+        const acct = await this.provider.connection.getAccountInfo(mint);
+        const result = acct?.owner.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : TOKEN_PROGRAM_ID;
+        this.tokenProgramCache.set(key, result);
+        return result;
+    }
+    /** Fetch the decimal precision of a token mint (cached). */
+    async getMintDecimals(mint) {
+        const key = mint.toBase58();
+        const cached = this.mintDecimalsCache.get(key);
+        if (cached !== undefined)
+            return cached;
+        const acct = await this.provider.connection.getAccountInfo(mint);
+        const decimals = acct ? (acct.data[44] ?? 0) : 0;
+        this.mintDecimalsCache.set(key, decimals);
+        return decimals;
+    }
+    /** Convert raw token amounts in a decoded StakePool to human-readable values. */
+    applyPoolDecimals(pool, decimals) {
+        const divisor = 10 ** decimals;
+        return {
+            ...pool,
+            rewardDecimals: decimals,
+            rewardConfig: {
+                ...pool.rewardConfig,
+                baseRate: pool.rewardConfig.baseRate / divisor,
+            },
+            totalClaimed: pool.totalClaimed / divisor,
+            lockConfigs: pool.lockConfigs.map((lc) => ({
+                ...lc,
+                rewardRate: lc.rewardRate / divisor,
+            })),
+        };
+    }
+    /** Hardcoded Pyth SOL/USD push oracle address (PriceUpdateV2). */
+    static PYTH_SOL_USD_FEED = new PublicKey("7UVimffxr9ow1uXYxsr4LHAcV58mLzhmwaeKvJ1pjLiE");
+    /** Resolve fee PDA accounts for fee CPI. */
+    resolveFeeAccounts(fee) {
+        const programId = this.program.programId;
+        const [feeConfig] = getFeeConfigPda(programId);
+        const [treasury] = getTreasuryPda();
+        let referralAccount = ADMIN_PROGRAM_ID;
+        if (fee?.referralAccount) {
+            try {
+                referralAccount = new PublicKey(fee.referralAccount);
+            }
+            catch {
+            }
+        }
+        return {
+            feeConfig,
+            treasury,
+            referralAccount,
+            solUsdPriceFeed: NftStakingClient.PYTH_SOL_USD_FEED,
+            adminProgram: ADMIN_PROGRAM_ID,
+        };
+    }
+    async fetchStakeConfig(projectId) {
+        const [pda] = getStakeConfigPda(projectId);
+        const raw = await this.program.account.stakePoolConfig.fetchNullable(pda);
+        if (!raw)
+            return null;
+        return decodeAccount(raw);
+    }
+    async fetchStakePool(projectId, poolId) {
+        const [pda] = getStakePoolPda(projectId, poolId);
+        const raw = await this.program.account.stakePool.fetchNullable(pda);
+        if (!raw)
+            return null;
+        const pool = decodeAccount(raw);
+        const decimals = await this.getMintDecimals(new PublicKey(pool.rewardConfig.rewardMint));
+        return this.applyPoolDecimals(pool, decimals);
+    }
+    async fetchStakeEntry(poolId, nftMint) {
+        const [pda] = getStakeEntryPda(poolId, nftMint);
+        const raw = await this.program.account.stakeEntry.fetchNullable(pda);
+        if (!raw)
+            return null;
+        return decodeAccount(raw);
+    }
+    async fetchStakerAccount(poolId, wallet, rewardDecimals) {
+        const [pda] = getStakerAccountPda(poolId, wallet);
+        const raw = await this.program.account.stakerAccount.fetchNullable(pda);
+        if (!raw)
+            return null;
+        const account = decodeAccount(raw);
+        if (rewardDecimals !== undefined && rewardDecimals > 0) {
+            const divisor = 10 ** rewardDecimals;
+            return {
+                ...account,
+                effectiveRate: account.effectiveRate / divisor,
+                accruedRewards: account.accruedRewards / divisor,
+                totalClaimed: account.totalClaimed / divisor,
+            };
+        }
+        return account;
+    }
+    /** Fetch all stake pools for a project by scanning pool IDs 0..totalPools-1. */
+    async fetchAllPools(projectId) {
+        const config = await this.fetchStakeConfig(projectId);
+        if (!config)
+            return [];
+        const pools = [];
+        for (let i = 0; i < config.totalPools; i++) {
+            const pool = await this.fetchStakePool(projectId, i);
+            if (pool)
+                pools.push(pool);
+        }
+        return pools;
+    }
+    /** Fetch all active stake entries for a wallet in a specific pool via gPA. */
+    async fetchStakeEntriesByOwner(_poolId, owner) {
+        const entries = await this.program.account.stakeEntry.all([
+            { memcmp: { offset: 72, bytes: owner.toBase58() } },
+        ]);
+        return entries
+            .map(({ account }) => decodeAccount(account))
+            .filter((e) => e.isActive);
+    }
+    /**
+     * Fetch active stake entries for specific NFT mints by deriving their PDAs.
+     * More reliable than gPA in browser environments.
+     */
+    async fetchStakeEntriesForMints(poolId, nftMints) {
+        if (nftMints.length === 0)
+            return [];
+        const pdas = nftMints.map((mint) => getStakeEntryPda(poolId, mint)[0]);
+        const accounts = await this.program.account.stakeEntry.fetchMultiple(pdas);
+        return accounts
+            .filter((a) => a !== null)
+            .map((a) => decodeAccount(a))
+            .filter((e) => e.isActive);
+    }
+    /** Fetch all stake entries for a pool via gPA with memcmp on pool pubkey. */
+    async fetchAllStakeEntriesByPool(projectId, poolId) {
+        const [poolPda] = getStakePoolPda(projectId, poolId);
+        const entries = await this.program.account.stakeEntry.all([
+            { memcmp: { offset: 8, bytes: poolPda.toBase58() } },
+        ]);
+        return entries.map(({ account }) => decodeAccount(account));
+    }
+    /**
+     * Fetch active stake entries for given mints across multiple pools.
+     * Uses PDA derivation + fetchMultiple (reliable in browser).
+     */
+    async fetchStakeEntriesAcrossPools(poolIds, nftMints) {
+        if (nftMints.length === 0 || poolIds.length === 0)
+            return [];
+        const pdas = [];
+        for (const poolId of poolIds) {
+            for (const mint of nftMints) {
+                pdas.push(getStakeEntryPda(poolId, mint)[0]);
+            }
+        }
+        const accounts = await this.program.account.stakeEntry.fetchMultiple(pdas);
+        return accounts
+            .filter((a) => a !== null)
+            .map((a) => decodeAccount(a))
+            .filter((e) => e.isActive);
+    }
+    /** Fetch all staker accounts for a pool via gPA with memcmp on pool pubkey. */
+    async fetchAllStakersByPool(projectId, poolId) {
+        const [poolPda] = getStakePoolPda(projectId, poolId);
+        const stakers = await this.program.account.stakerAccount.all([
+            { memcmp: { offset: 8, bytes: poolPda.toBase58() } },
+        ]);
+        return stakers.map(({ account }) => decodeAccount(account));
+    }
+    async closeLegacyCollection(projectId, collectionMint) {
+        const [collection] = PublicKey.findProgramAddressSync([Buffer.from("project_collection"), new BN(projectId).toArrayLike(Buffer, "le", 8), collectionMint.toBuffer()], this.program.programId);
+        const [project] = getProjectPda(projectId);
+        return this.program.methods
+            .closeLegacyCollection(new BN(projectId), collectionMint)
+            .accountsStrict({
+            collection,
+            authority: this.provider.wallet.publicKey,
+            project,
+            projectManagementProgram: PROJECT_MANAGEMENT_PROGRAM_ID,
+        })
+            .instruction();
+    }
+    async initializeStakeConfig(projectId) {
+        const [config] = getStakeConfigPda(projectId);
+        const [project] = getProjectPda(projectId);
+        return this.program.methods
+            .initializeStakeConfig(new BN(projectId))
+            .accountsStrict({
+            config,
+            authority: this.provider.wallet.publicKey,
+            project,
+            projectManagementProgram: PROJECT_MANAGEMENT_PROGRAM_ID,
+            systemProgram: SystemProgram.programId,
+        })
+            .instruction();
+    }
+    async createStakePool(projectId, stakingMode, rewardConfig, lockConfigs, collectionMint, rewardEndAt = 0, maxStaked = 0) {
+        const config = await this.fetchStakeConfig(projectId);
+        const nextPoolId = config ? config.totalPools : 0;
+        const tokenProgram = await this.resolveTokenProgram(rewardConfig.rewardMint);
+        const decimals = await this.getMintDecimals(rewardConfig.rewardMint);
+        const multiplier = 10 ** decimals;
+        const rawRewardConfig = {
+            rewardType: rewardConfig.rewardType,
+            rewardMint: rewardConfig.rewardMint,
+            baseRate: new BN(Math.round(rewardConfig.baseRate * multiplier)),
+            rateInterval: new BN(rewardConfig.rateInterval),
+            traitBonusMode: rewardConfig.traitBonusMode,
+            quantityThresholds: rewardConfig.quantityThresholds,
+        };
+        const rawLockConfigs = lockConfigs.map((lc) => ({
+            lockDuration: new BN(lc.lockDuration),
+            rewardRate: new BN(Math.round(lc.rewardRate * multiplier)),
+            earlyUnstakePenaltyBps: lc.earlyUnstakePenaltyBps,
+        }));
+        const [configPda] = getStakeConfigPda(projectId);
+        const [poolPda] = getStakePoolPda(projectId, nextPoolId);
+        const [collectionConfigPda] = getCollectionPda(projectId, collectionMint);
+        const [poolAuthority] = getPoolAuthorityPda(nextPoolId);
+        const rewardVault = getAta(poolAuthority, rewardConfig.rewardMint, tokenProgram);
+        return this.program.methods
+            .createStakePool(new BN(projectId), stakingMode, rawRewardConfig, rawLockConfigs, new BN(rewardEndAt), new BN(maxStaked))
+            .accountsStrict({
+            config: configPda,
+            pool: poolPda,
+            collectionConfig: collectionConfigPda,
+            poolAuthority,
+            collectionMint,
+            rewardMint: rewardConfig.rewardMint,
+            rewardVault,
+            projectManagementProgram: PROJECT_MANAGEMENT_PROGRAM_ID,
+            authority: this.provider.wallet.publicKey,
+            tokenProgram,
+            associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+            systemProgram: SystemProgram.programId,
+        })
+            .instruction();
+    }
+    async updateStakePool(projectId, poolId, rewardConfig, lockConfigs, isActive, traitAuthority = null, canBurn = null, merkleRoot = null, gateType = null, rewardEndAt = null, maxStaked = null) {
+        let rawRewardConfig = null;
+        let rawLockConfigs = null;
+        if (rewardConfig) {
+            const decimals = await this.getMintDecimals(rewardConfig.rewardMint);
+            const multiplier = 10 ** decimals;
+            rawRewardConfig = {
+                rewardType: rewardConfig.rewardType,
+                rewardMint: rewardConfig.rewardMint,
+                baseRate: new BN(Math.round(rewardConfig.baseRate * multiplier)),
+                rateInterval: new BN(rewardConfig.rateInterval),
+                traitBonusMode: rewardConfig.traitBonusMode,
+                quantityThresholds: rewardConfig.quantityThresholds,
+            };
+        }
+        if (lockConfigs && rewardConfig) {
+            const decimals = await this.getMintDecimals(rewardConfig.rewardMint);
+            const multiplier = 10 ** decimals;
+            rawLockConfigs = lockConfigs.map((lc) => ({
+                lockDuration: new BN(lc.lockDuration),
+                rewardRate: new BN(Math.round(lc.rewardRate * multiplier)),
+                earlyUnstakePenaltyBps: lc.earlyUnstakePenaltyBps,
+            }));
+        }
+        else if (lockConfigs) {
+            const pool = await this.fetchStakePool(projectId, poolId);
+            const decimals = pool ? pool.rewardDecimals : 0;
+            const multiplier = 10 ** decimals;
+            rawLockConfigs = lockConfigs.map((lc) => ({
+                lockDuration: new BN(lc.lockDuration),
+                rewardRate: new BN(Math.round(lc.rewardRate * multiplier)),
+                earlyUnstakePenaltyBps: lc.earlyUnstakePenaltyBps,
+            }));
+        }
+        const [poolPda] = getStakePoolPda(projectId, poolId);
+        return this.program.methods
+            .updateStakePool(new BN(projectId), new BN(poolId), rawRewardConfig, rawLockConfigs, isActive, traitAuthority, canBurn, merkleRoot, gateType, rewardEndAt, maxStaked)
+            .accountsStrict({
+            pool: poolPda,
+            authority: this.provider.wallet.publicKey,
+        })
+            .instruction();
+    }
+    async fundRewardVault(projectId, poolId, amount, rewardMint, funderTokenAccount) {
+        const tokenProgram = await this.resolveTokenProgram(rewardMint);
+        const [poolPda] = getStakePoolPda(projectId, poolId);
+        const [poolAuthority] = getPoolAuthorityPda(poolId);
+        const rewardVault = getAta(poolAuthority, rewardMint, tokenProgram);
+        const funderAta = funderTokenAccount ?? getAta(this.provider.wallet.publicKey, rewardMint, tokenProgram);
+        return this.program.methods
+            .fundRewardVault(new BN(projectId), new BN(poolId), amount)
+            .accountsStrict({
+            pool: poolPda,
+            poolAuthority,
+            rewardVault,
+            funderTokenAccount: funderAta,
+            rewardMint,
+            authority: this.provider.wallet.publicKey,
+            tokenProgram,
+        })
+            .instruction();
+    }
+    async withdrawRewardVault(projectId, poolId, amount, rewardMint, destinationTokenAccount) {
+        const tokenProgram = await this.resolveTokenProgram(rewardMint);
+        const [poolPda] = getStakePoolPda(projectId, poolId);
+        const [poolAuthority] = getPoolAuthorityPda(poolId);
+        const rewardVault = getAta(poolAuthority, rewardMint, tokenProgram);
+        const destAta = destinationTokenAccount ?? getAta(this.provider.wallet.publicKey, rewardMint, tokenProgram);
+        return this.program.methods
+            .withdrawRewardVault(new BN(projectId), new BN(poolId), amount)
+            .accountsStrict({
+            pool: poolPda,
+            poolAuthority,
+            rewardVault,
+            destinationTokenAccount: destAta,
+            rewardMint,
+            authority: this.provider.wallet.publicKey,
+            tokenProgram,
+        })
+            .instruction();
+    }
+    async closeStakePool(projectId, poolId) {
+        const [poolPda] = getStakePoolPda(projectId, poolId);
+        return this.program.methods
+            .closeStakePool(new BN(projectId), new BN(poolId))
+            .accountsStrict({
+            pool: poolPda,
+            authority: this.provider.wallet.publicKey,
+        })
+            .instruction();
+    }
+    async stakeNft(projectId, poolId, nftMint, stakingMode, lockTierIndex, fee, gateProof = []) {
+        const [poolPda] = getStakePoolPda(projectId, poolId);
+        const [stakeEntry] = getStakeEntryPda(poolId, nftMint);
+        const staker = this.provider.wallet.publicKey;
+        const [stakerAccount] = getStakerAccountPda(poolId, staker);
+        const [poolAuthority] = getPoolAuthorityPda(poolId);
+        const nftTokenProgram = await this.resolveTokenProgram(nftMint);
+        const stakerNftAccount = getAta(staker, nftMint, nftTokenProgram);
+        const isEscrow = stakingMode !== 1;
+        const escrowNftAccount = isEscrow
+            ? getAta(poolAuthority, nftMint, nftTokenProgram)
+            : null;
+        const nftMetadata = getMetadataPda(nftMint);
+        const nftEdition = getEditionPda(nftMint);
+        const feeAccts = this.resolveFeeAccounts(fee);
+        return this.program.methods
+            .stakeNft(new BN(projectId), new BN(poolId), nftMint, lockTierIndex, gateProof)
+            .accountsStrict({
+            pool: poolPda,
+            stakeEntry,
+            stakerAccount,
+            poolAuthority,
+            nftMint,
+            stakerNftAccount,
+            escrowNftAccount,
+            nftMetadata,
+            nftEdition,
+            mplTokenMetadataProgram: TOKEN_METADATA_PROGRAM_ID,
+            sysvarInstructions: SYSVAR_INSTRUCTIONS_ID,
+            feeConfig: feeAccts.feeConfig,
+            treasury: feeAccts.treasury,
+            referralAccount: feeAccts.referralAccount,
+            solUsdPriceFeed: feeAccts.solUsdPriceFeed,
+            adminProgram: feeAccts.adminProgram,
+            staker,
+            tokenProgram: nftTokenProgram,
+            associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+            systemProgram: SystemProgram.programId,
+        })
+            .instruction();
+    }
+    async unstakeNft(projectId, poolId, nftMint, rewardMint, stakingMode, fee) {
+        const rewardTokenProgram = await this.resolveTokenProgram(rewardMint);
+        const nftTokenProgram = await this.resolveTokenProgram(nftMint);
+        const [poolPda] = getStakePoolPda(projectId, poolId);
+        const [stakeEntry] = getStakeEntryPda(poolId, nftMint);
+        const staker = this.provider.wallet.publicKey;
+        const [stakerAccount] = getStakerAccountPda(poolId, staker);
+        const [poolAuthority] = getPoolAuthorityPda(poolId);
+        const stakerNftAccount = getAta(staker, nftMint, nftTokenProgram);
+        const isEscrow = stakingMode !== 1;
+        const escrowNftAccount = isEscrow
+            ? getAta(poolAuthority, nftMint, nftTokenProgram)
+            : null;
+        const rewardVault = getAta(poolAuthority, rewardMint, rewardTokenProgram);
+        const stakerRewardAccount = getAta(staker, rewardMint, rewardTokenProgram);
+        const nftMetadata = getMetadataPda(nftMint);
+        const nftEdition = getEditionPda(nftMint);
+        const feeAccts = this.resolveFeeAccounts(fee);
+        return this.program.methods
+            .unstakeNft(new BN(projectId), new BN(poolId), nftMint)
+            .accountsStrict({
+            pool: poolPda,
+            stakeEntry,
+            stakerAccount,
+            poolAuthority,
+            nftMint,
+            stakerNftAccount,
+            escrowNftAccount,
+            rewardVault,
+            stakerRewardAccount,
+            rewardMint,
+            nftMetadata,
+            nftEdition,
+            mplTokenMetadataProgram: TOKEN_METADATA_PROGRAM_ID,
+            sysvarInstructions: SYSVAR_INSTRUCTIONS_ID,
+            feeConfig: feeAccts.feeConfig,
+            treasury: feeAccts.treasury,
+            referralAccount: feeAccts.referralAccount,
+            solUsdPriceFeed: feeAccts.solUsdPriceFeed,
+            adminProgram: feeAccts.adminProgram,
+            staker,
+            tokenProgram: nftTokenProgram,
+            rewardTokenProgram,
+            associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+            systemProgram: SystemProgram.programId,
+        })
+            .instruction();
+    }
+    async claimRewards(projectId, poolId, rewardMint, traitBonusRate = null, fee) {
+        const tokenProgram = await this.resolveTokenProgram(rewardMint);
+        const [poolPda] = getStakePoolPda(projectId, poolId);
+        const staker = this.provider.wallet.publicKey;
+        const [stakerAccount] = getStakerAccountPda(poolId, staker);
+        const [poolAuthority] = getPoolAuthorityPda(poolId);
+        const rewardVault = getAta(poolAuthority, rewardMint, tokenProgram);
+        const stakerRewardAccount = getAta(staker, rewardMint, tokenProgram);
+        const [stakeConfig] = getStakeConfigPda(projectId);
+        const feeAccts = this.resolveFeeAccounts(fee);
+        return this.program.methods
+            .claimRewards(new BN(projectId), new BN(poolId), traitBonusRate)
+            .accountsStrict({
+            pool: poolPda,
+            stakerAccount,
+            poolAuthority,
+            rewardVault,
+            stakerRewardAccount,
+            rewardMint,
+            stakeConfig,
+            instructionsSysvar: new PublicKey("Sysvar1nstructions1111111111111111111111111"),
+            feeConfig: feeAccts.feeConfig,
+            treasury: feeAccts.treasury,
+            referralAccount: feeAccts.referralAccount,
+            solUsdPriceFeed: feeAccts.solUsdPriceFeed,
+            adminProgram: feeAccts.adminProgram,
+            staker,
+            tokenProgram,
+            associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+            systemProgram: SystemProgram.programId,
+        })
+            .instruction();
+    }
+    async stakeCoreNft(projectId, poolId, nftAsset, collection, lockTierIndex, fee, gateProof = []) {
+        const [poolPda] = getStakePoolPda(projectId, poolId);
+        const [stakeEntry] = getStakeEntryPda(poolId, nftAsset);
+        const staker = this.provider.wallet.publicKey;
+        const [stakerAccount] = getStakerAccountPda(poolId, staker);
+        const [poolAuthority] = getPoolAuthorityPda(poolId);
+        const feeAccts = this.resolveFeeAccounts(fee);
+        return this.program.methods
+            .stakeCoreNft(new BN(projectId), new BN(poolId), nftAsset, lockTierIndex, gateProof)
+            .accountsStrict({
+            pool: poolPda,
+            stakeEntry,
+            stakerAccount,
+            poolAuthority,
+            nftAsset,
+            collection,
+            mplCoreProgram: MPL_CORE_PROGRAM_ID,
+            feeConfig: feeAccts.feeConfig,
+            treasury: feeAccts.treasury,
+            referralAccount: feeAccts.referralAccount,
+            solUsdPriceFeed: feeAccts.solUsdPriceFeed,
+            adminProgram: feeAccts.adminProgram,
+            staker,
+            systemProgram: SystemProgram.programId,
+        })
+            .instruction();
+    }
+    async unstakeCoreNft(projectId, poolId, nftAsset, collection, rewardMint, fee) {
+        const rewardTokenProgram = await this.resolveTokenProgram(rewardMint);
+        const [poolPda] = getStakePoolPda(projectId, poolId);
+        const [stakeEntry] = getStakeEntryPda(poolId, nftAsset);
+        const staker = this.provider.wallet.publicKey;
+        const [stakerAccount] = getStakerAccountPda(poolId, staker);
+        const [poolAuthority] = getPoolAuthorityPda(poolId);
+        const rewardVault = getAta(poolAuthority, rewardMint, rewardTokenProgram);
+        const stakerRewardAccount = getAta(staker, rewardMint, rewardTokenProgram);
+        const feeAccts = this.resolveFeeAccounts(fee);
+        return this.program.methods
+            .unstakeCoreNft(new BN(projectId), new BN(poolId), nftAsset)
+            .accountsStrict({
+            pool: poolPda,
+            stakeEntry,
+            stakerAccount,
+            poolAuthority,
+            nftAsset,
+            collection,
+            mplCoreProgram: MPL_CORE_PROGRAM_ID,
+            rewardVault,
+            stakerRewardAccount,
+            rewardMint,
+            feeConfig: feeAccts.feeConfig,
+            treasury: feeAccts.treasury,
+            referralAccount: feeAccts.referralAccount,
+            solUsdPriceFeed: feeAccts.solUsdPriceFeed,
+            adminProgram: feeAccts.adminProgram,
+            staker,
+            rewardTokenProgram,
+            associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+            systemProgram: SystemProgram.programId,
+        })
+            .instruction();
+    }
+    /** Stake a compressed NFT (cNFT). All address/hash params accepted as strings. */
+    async stakeCnft(projectId, poolId, nftAssetId, merkleTree, cnftRoot, cnftDataHash, cnftCreatorHash, cnftNonce, cnftIndex, proofNodes, fee, gateProof = []) {
+        const nftAssetIdPk = new PublicKey(nftAssetId);
+        const merkleTreePk = new PublicKey(merkleTree);
+        const [treeConfigPk] = getTreeConfigPda(merkleTreePk);
+        const cnftRootArr = base58HashToArray(cnftRoot);
+        const cnftDataHashArr = base58HashToArray(cnftDataHash);
+        const cnftCreatorHashArr = base58HashToArray(cnftCreatorHash);
+        const [poolPda] = getStakePoolPda(projectId, poolId);
+        const [stakeEntry] = getStakeEntryPda(poolId, nftAssetIdPk);
+        const staker = this.provider.wallet.publicKey;
+        const [stakerAccount] = getStakerAccountPda(poolId, staker);
+        const [poolAuthority] = getPoolAuthorityPda(poolId);
+        const feeAccts = this.resolveFeeAccounts(fee);
+        const remainingAccounts = proofNodes.map((node) => ({
+            pubkey: new PublicKey(node),
+            isSigner: false,
+            isWritable: false,
+        }));
+        return this.program.methods
+            .stakeCnft(new BN(projectId), new BN(poolId), nftAssetIdPk, cnftRootArr, cnftDataHashArr, cnftCreatorHashArr, new BN(cnftNonce), cnftIndex, gateProof)
+            .accountsStrict({
+            pool: poolPda,
+            stakeEntry,
+            stakerAccount,
+            poolAuthority,
+            treeConfig: treeConfigPk,
+            merkleTree: merkleTreePk,
+            logWrapper: SPL_NOOP_PROGRAM_ID,
+            compressionProgram: SPL_ACCOUNT_COMPRESSION_PROGRAM_ID,
+            bubblegumProgram: BUBBLEGUM_PROGRAM_ID,
+            feeConfig: feeAccts.feeConfig,
+            treasury: feeAccts.treasury,
+            referralAccount: feeAccts.referralAccount,
+            solUsdPriceFeed: feeAccts.solUsdPriceFeed,
+            adminProgram: feeAccts.adminProgram,
+            staker,
+            systemProgram: SystemProgram.programId,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+    }
+    /** Unstake a compressed NFT (cNFT). Derives tree config and program IDs internally. */
+    async unstakeCnft(projectId, poolId, nftAssetId, merkleTree, rewardMint, cnftRoot, cnftDataHash, cnftCreatorHash, cnftNonce, cnftIndex, proofNodes, fee) {
+        const nftAssetIdPk = new PublicKey(nftAssetId);
+        const merkleTreePk = new PublicKey(merkleTree);
+        const [treeConfigPk] = getTreeConfigPda(merkleTreePk);
+        const rewardMintPk = new PublicKey(rewardMint);
+        const cnftRootArr = base58HashToArray(cnftRoot);
+        const cnftDataHashArr = base58HashToArray(cnftDataHash);
+        const cnftCreatorHashArr = base58HashToArray(cnftCreatorHash);
+        const [poolPda] = getStakePoolPda(projectId, poolId);
+        const [stakeEntry] = getStakeEntryPda(poolId, nftAssetIdPk);
+        const staker = this.provider.wallet.publicKey;
+        const [stakerAccount] = getStakerAccountPda(poolId, staker);
+        const [poolAuthority] = getPoolAuthorityPda(poolId);
+        const feeAccts = this.resolveFeeAccounts(fee);
+        const rewardVaultPk = getAta(poolAuthority, rewardMintPk);
+        const stakerRewardAccountPk = getAta(staker, rewardMintPk);
+        const remainingAccounts = proofNodes.map((node) => ({
+            pubkey: new PublicKey(node),
+            isSigner: false,
+            isWritable: false,
+        }));
+        return this.program.methods
+            .unstakeCnft(new BN(projectId), new BN(poolId), nftAssetIdPk, cnftRootArr, cnftDataHashArr, cnftCreatorHashArr, new BN(cnftNonce), cnftIndex)
+            .accountsStrict({
+            pool: poolPda,
+            stakeEntry,
+            stakerAccount,
+            poolAuthority,
+            treeConfig: treeConfigPk,
+            merkleTree: merkleTreePk,
+            logWrapper: SPL_NOOP_PROGRAM_ID,
+            compressionProgram: SPL_ACCOUNT_COMPRESSION_PROGRAM_ID,
+            bubblegumProgram: BUBBLEGUM_PROGRAM_ID,
+            rewardVault: rewardVaultPk,
+            stakerRewardAccount: stakerRewardAccountPk,
+            rewardMint: rewardMintPk,
+            feeConfig: feeAccts.feeConfig,
+            treasury: feeAccts.treasury,
+            referralAccount: feeAccts.referralAccount,
+            solUsdPriceFeed: feeAccts.solUsdPriceFeed,
+            adminProgram: feeAccts.adminProgram,
+            staker,
+            tokenProgram: TOKEN_PROGRAM_ID,
+            associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+            systemProgram: SystemProgram.programId,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+    }
+    /** Burn a permanently-locked legacy/pNFT. Destroys the NFT and closes the stake entry.
+     *  For Escrow mode, burns from escrow. For WalletLock, unfreezes then burns from wallet. */
+    async burnStakedNft(projectId, poolId, nftMint, stakingMode, fee) {
+        const nftTokenProgram = await this.resolveTokenProgram(nftMint);
+        const [poolPda] = getStakePoolPda(projectId, poolId);
+        const [stakeEntry] = getStakeEntryPda(poolId, nftMint);
+        const staker = this.provider.wallet.publicKey;
+        const [stakerAccount] = getStakerAccountPda(poolId, staker);
+        const [poolAuthority] = getPoolAuthorityPda(poolId);
+        const feeAccts = this.resolveFeeAccounts(fee);
+        const isWalletLock = stakingMode === 1;
+        const escrowNftAccount = isWalletLock ? null : getAta(poolAuthority, nftMint, nftTokenProgram);
+        const stakerNftAccount = isWalletLock ? getAta(staker, nftMint, nftTokenProgram) : null;
+        const nftMetadata = isWalletLock ? getMetadataPda(nftMint) : null;
+        const nftEdition = isWalletLock ? getEditionPda(nftMint) : null;
+        return this.program.methods
+            .burnStakedNft(new BN(projectId), new BN(poolId), nftMint)
+            .accountsStrict({
+            pool: poolPda,
+            stakeEntry,
+            stakerAccount,
+            poolAuthority,
+            nftMint,
+            escrowNftAccount,
+            stakerNftAccount,
+            nftMetadata,
+            nftEdition,
+            mplTokenMetadataProgram: isWalletLock ? TOKEN_METADATA_PROGRAM_ID : null,
+            sysvarInstructions: isWalletLock ? SYSVAR_INSTRUCTIONS_ID : null,
+            feeConfig: feeAccts.feeConfig,
+            treasury: feeAccts.treasury,
+            referralAccount: feeAccts.referralAccount,
+            solUsdPriceFeed: feeAccts.solUsdPriceFeed,
+            adminProgram: feeAccts.adminProgram,
+            staker,
+            tokenProgram: nftTokenProgram,
+            systemProgram: SystemProgram.programId,
+        })
+            .instruction();
+    }
+    /** Burn a permanently-locked Core NFT. Destroys the asset and closes the stake entry. */
+    async burnStakedCoreNft(projectId, poolId, nftAsset, collection, fee) {
+        const [poolPda] = getStakePoolPda(projectId, poolId);
+        const [stakeEntry] = getStakeEntryPda(poolId, nftAsset);
+        const staker = this.provider.wallet.publicKey;
+        const [stakerAccount] = getStakerAccountPda(poolId, staker);
+        const [poolAuthority] = getPoolAuthorityPda(poolId);
+        const feeAccts = this.resolveFeeAccounts(fee);
+        return this.program.methods
+            .burnStakedCoreNft(new BN(projectId), new BN(poolId), nftAsset)
+            .accountsStrict({
+            pool: poolPda,
+            stakeEntry,
+            stakerAccount,
+            poolAuthority,
+            nftAsset,
+            collection,
+            mplCoreProgram: MPL_CORE_PROGRAM_ID,
+            feeConfig: feeAccts.feeConfig,
+            treasury: feeAccts.treasury,
+            referralAccount: feeAccts.referralAccount,
+            solUsdPriceFeed: feeAccts.solUsdPriceFeed,
+            adminProgram: feeAccts.adminProgram,
+            staker,
+            systemProgram: SystemProgram.programId,
+        })
+            .instruction();
+    }
+    /** Spend accrued points from a Points reward type pool. */
+    async spendPoints(projectId, poolId, amount, fee) {
+        const [poolPda] = getStakePoolPda(projectId, poolId);
+        const staker = this.provider.wallet.publicKey;
+        const [stakerAccount] = getStakerAccountPda(poolId, staker);
+        const feeAccts = this.resolveFeeAccounts(fee);
+        return this.program.methods
+            .spendPoints(new BN(projectId), new BN(poolId), amount)
+            .accountsStrict({
+            pool: poolPda,
+            stakerAccount,
+            feeConfig: feeAccts.feeConfig,
+            treasury: feeAccts.treasury,
+            referralAccount: feeAccts.referralAccount,
+            solUsdPriceFeed: feeAccts.solUsdPriceFeed,
+            adminProgram: feeAccts.adminProgram,
+            staker,
+            systemProgram: SystemProgram.programId,
+        })
+            .instruction();
+    }
+    async fetchPoolSecondaryRewards(poolId) {
+        const [pda] = getPoolSecondaryRewardsPda(poolId);
+        const raw = await this.program.account.poolSecondaryRewards.fetchNullable(pda);
+        if (!raw)
+            return null;
+        return decodeAccount(raw);
+    }
+    async fetchStakerSecondaryRewards(poolId, wallet) {
+        const [pda] = getStakerSecondaryRewardsPda(poolId, wallet);
+        const raw = await this.program.account.stakerSecondaryRewards.fetchNullable(pda);
+        if (!raw)
+            return null;
+        return decodeAccount(raw);
+    }
+    async addPoolSecondaryReward(projectId, poolId, rewardMint, baseRate, lockTierRates) {
+        const [poolPda] = getStakePoolPda(projectId, poolId);
+        const [poolSecondary] = getPoolSecondaryRewardsPda(poolId);
+        const [poolAuthority] = getPoolAuthorityPda(poolId);
+        const tokenProgram = await this.resolveTokenProgram(rewardMint);
+        const vault = getAta(poolAuthority, rewardMint, tokenProgram);
+        return this.program.methods
+            .addPoolSecondaryReward(new BN(projectId), new BN(poolId), baseRate, lockTierRates)
+            .accountsStrict({
+            pool: poolPda,
+            poolSecondary,
+            poolAuthority,
+            secondaryRewardMint: rewardMint,
+            secondaryVault: vault,
+            authority: this.provider.wallet.publicKey,
+            tokenProgram,
+            associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+            systemProgram: SystemProgram.programId,
+        })
+            .instruction();
+    }
+    async removePoolSecondaryReward(projectId, poolId, rewardIndex) {
+        const [poolPda] = getStakePoolPda(projectId, poolId);
+        const [poolSecondary] = getPoolSecondaryRewardsPda(poolId);
+        return this.program.methods
+            .removePoolSecondaryReward(new BN(projectId), new BN(poolId), rewardIndex)
+            .accountsStrict({
+            pool: poolPda,
+            poolSecondary,
+            authority: this.provider.wallet.publicKey,
+        })
+            .instruction();
+    }
+    async fundSecondaryVault(projectId, poolId, rewardIndex, amount, rewardMint, funderTokenAccount) {
+        const tokenProgram = await this.resolveTokenProgram(rewardMint);
+        const [poolPda] = getStakePoolPda(projectId, poolId);
+        const [poolSecondary] = getPoolSecondaryRewardsPda(poolId);
+        const [poolAuthority] = getPoolAuthorityPda(poolId);
+        const vault = getAta(poolAuthority, rewardMint, tokenProgram);
+        const funderAta = funderTokenAccount ?? getAta(this.provider.wallet.publicKey, rewardMint, tokenProgram);
+        return this.program.methods
+            .fundSecondaryVault(new BN(projectId), new BN(poolId), rewardIndex, amount)
+            .accountsStrict({
+            pool: poolPda,
+            poolSecondary,
+            poolAuthority,
+            secondaryVault: vault,
+            funderTokenAccount: funderAta,
+            secondaryRewardMint: rewardMint,
+            authority: this.provider.wallet.publicKey,
+            tokenProgram,
+        })
+            .instruction();
+    }
+    async withdrawSecondaryVault(projectId, poolId, rewardIndex, amount, rewardMint, destinationTokenAccount) {
+        const tokenProgram = await this.resolveTokenProgram(rewardMint);
+        const [poolPda] = getStakePoolPda(projectId, poolId);
+        const [poolSecondary] = getPoolSecondaryRewardsPda(poolId);
+        const [poolAuthority] = getPoolAuthorityPda(poolId);
+        const vault = getAta(poolAuthority, rewardMint, tokenProgram);
+        const destAta = destinationTokenAccount ?? getAta(this.provider.wallet.publicKey, rewardMint, tokenProgram);
+        return this.program.methods
+            .withdrawSecondaryVault(new BN(projectId), new BN(poolId), rewardIndex, amount)
+            .accountsStrict({
+            pool: poolPda,
+            poolSecondary,
+            poolAuthority,
+            secondaryVault: vault,
+            destinationTokenAccount: destAta,
+            secondaryRewardMint: rewardMint,
+            authority: this.provider.wallet.publicKey,
+            tokenProgram,
+        })
+            .instruction();
+    }
+    async initStakerSecondary(projectId, poolId) {
+        const [poolPda] = getStakePoolPda(projectId, poolId);
+        const [poolSecondary] = getPoolSecondaryRewardsPda(poolId);
+        const staker = this.provider.wallet.publicKey;
+        const [stakerSecondary] = getStakerSecondaryRewardsPda(poolId, staker);
+        return this.program.methods
+            .initStakerSecondary(new BN(projectId), new BN(poolId))
+            .accountsStrict({
+            pool: poolPda,
+            poolSecondary,
+            stakerSecondary,
+            staker,
+            systemProgram: SystemProgram.programId,
+        })
+            .instruction();
+    }
+    async claimSecondaryRewards(projectId, poolId, secondaryRewards, fee) {
+        const [poolPda] = getStakePoolPda(projectId, poolId);
+        const [poolSecondary] = getPoolSecondaryRewardsPda(poolId);
+        const staker = this.provider.wallet.publicKey;
+        const [stakerAccount] = getStakerAccountPda(poolId, staker);
+        const [stakerSecondary] = getStakerSecondaryRewardsPda(poolId, staker);
+        const [poolAuthority] = getPoolAuthorityPda(poolId);
+        const feeAccts = this.resolveFeeAccounts(fee);
+        const remainingAccounts = [];
+        for (const sr of secondaryRewards) {
+            const tokenProgram = await this.resolveTokenProgram(sr.mint);
+            const vault = getAta(poolAuthority, sr.mint, tokenProgram);
+            const stakerAta = getAta(staker, sr.mint, tokenProgram);
+            remainingAccounts.push({ pubkey: vault, isSigner: false, isWritable: true }, { pubkey: stakerAta, isSigner: false, isWritable: true }, { pubkey: sr.mint, isSigner: false, isWritable: false }, { pubkey: tokenProgram, isSigner: false, isWritable: false });
+        }
+        return this.program.methods
+            .claimSecondaryRewards(new BN(projectId), new BN(poolId))
+            .accountsStrict({
+            pool: poolPda,
+            poolSecondary,
+            stakerAccount,
+            stakerSecondary,
+            poolAuthority,
+            feeConfig: feeAccts.feeConfig,
+            treasury: feeAccts.treasury,
+            referralAccount: feeAccts.referralAccount,
+            solUsdPriceFeed: feeAccts.solUsdPriceFeed,
+            adminProgram: feeAccts.adminProgram,
+            staker,
+            tokenProgram: TOKEN_PROGRAM_ID,
+            associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+            systemProgram: SystemProgram.programId,
+        })
+            .remainingAccounts(remainingAccounts)
+            .instruction();
+    }
+}
+//# sourceMappingURL=client.js.map