@soltracer/nft-staking 0.2.0 → 0.2.3

package/dist/client.js

@@ -1,6 +1,7 @@
 import { BN, Program } from "@coral-xyz/anchor";
 import { PublicKey, SystemProgram } from "@solana/web3.js";
-import { getStakeConfigPda, getStakePoolPda, getStakeEntryPda, getStakerAccountPda, getCollectionPda, getPoolAuthorityPda, getPoolSecondaryRewardsPda, getStakerSecondaryRewardsPda, getProjectPda, getUtilityConfigPda, 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 { getStakeConfigPda, getStakePoolPda, getStakeEntryPda, getNftStakeLockPda, getStakerAccountPda, getUserProfilePda, getCollectionPda, getPoolAuthorityPda, getPoolSecondaryRewardsPda, getStakerSecondaryRewardsPda, getProjectPda, getUtilityConfigPda, getAta, decodeAccount, PROJECT_MANAGEMENT_PROGRAM_ID, TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID, ASSOCIATED_TOKEN_PROGRAM_ID, MPL_CORE_PROGRAM_ID, } from "@soltracer/core";
+import { ProjectReferralCache, resolveFeeAccounts, } from "@soltracer/cpi-accounts";
 import NftStakingIDL from "./idl.json";
 /** Well-known program IDs for cNFT operations. */
 const BUBBLEGUM_PROGRAM_ID = new PublicKey("BGUMAp9Gq7iTEuizy4pqaxsTyUCBK68MDfK752saRPUY");
@@ -22,6 +23,23 @@ function getEditionPda(mint) {
     ], TOKEN_METADATA_PROGRAM_ID);
     return pda;
 }
+/**
+ * Derive the Token Record PDA for a programmable NFT (pNFT). The token
+ * record exists per (mint, tokenAccount) pair and is required as a
+ * mutable account for pNFT lock/unlock CPIs.
+ *
+ *   seeds = ["metadata", MPL_TOKEN_METADATA, mint, "token_record", tokenAccount]
+ */
+function getTokenRecordPda(mint, tokenAccount) {
+    const [pda] = PublicKey.findProgramAddressSync([
+        new TextEncoder().encode("metadata"),
+        TOKEN_METADATA_PROGRAM_ID.toBytes(),
+        mint.toBytes(),
+        new TextEncoder().encode("token_record"),
+        tokenAccount.toBytes(),
+    ], 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. */
@@ -32,13 +50,59 @@ function base58HashToArray(hash) {
 function getTreeConfigPda(merkleTree) {
     return PublicKey.findProgramAddressSync([merkleTree.toBytes()], BUBBLEGUM_PROGRAM_ID);
 }
+function toPk(v) {
+    return typeof v === "string" ? new PublicKey(v) : v;
+}
+function toBN(v) {
+    return typeof v === "number" ? new BN(v) : v;
+}
+function normalizeQuantityBonus(input) {
+    const bonusType = input.bonusType ?? 0;
+    return {
+        minCount: input.minCount,
+        bonusType,
+        target: input.target ?? 0,
+        bonusBps: input.bonusBps ?? 0,
+        fixedAmount: toBN(input.fixedAmount ?? 0),
+    };
+}
+function amountWithDecimals(raw, decimals) {
+    const divisor = 10 ** decimals;
+    return { raw, ui: decimals > 0 ? raw / divisor : raw, decimals };
+}
+function applyQuantityBonusRaw(reward, thresholds, stakedCount, target) {
+    if (reward <= 0)
+        return 0;
+    let best = null;
+    for (const threshold of thresholds) {
+        if ((threshold.target ?? 0) !== target || stakedCount < threshold.minCount)
+            continue;
+        if (!best) {
+            best = threshold;
+            continue;
+        }
+        const bestFixed = Number(best.fixedAmount ?? 0);
+        const nextFixed = Number(threshold.fixedAmount ?? 0);
+        if (threshold.minCount > best.minCount ||
+            (threshold.minCount === best.minCount &&
+                nextFixed >= bestFixed &&
+                (threshold.bonusBps ?? 0) >= (best.bonusBps ?? 0))) {
+            best = threshold;
+        }
+    }
+    if (!best)
+        return reward;
+    if ((best.bonusType ?? 0) === 1)
+        return reward + Number(best.fixedAmount ?? 0);
+    return Math.floor((reward * (10_000 + (best.bonusBps ?? 0))) / 10_000);
+}
 export class NftStakingClient {
     program;
     provider;
     tokenProgramCache = new Map();
     mintDecimalsCache = new Map();
     poolCache = new Map();
-    static POOL_CACHE_TTL = 30_000; // 30s
+    static POOL_CACHE_TTL = 30_000;
     /** Project ID bound to this client. Set via `create()` options or `setProjectId()`. */
     projectId;
     constructor(program, provider, projectId) {
@@ -79,6 +143,13 @@ export class NftStakingClient {
         this.poolCache.set(key, { data: pool, fetchedAt: Date.now() });
         return pool;
     }
+    async fetchRawStakePool(projectId, poolId) {
+        const [pda] = getStakePoolPda(projectId, poolId);
+        const raw = await this.program.account.stakePool.fetchNullable(pda);
+        if (!raw)
+            return null;
+        return decodeAccount(raw);
+    }
     /** Invalidate cached pool data (call after pool mutations). */
     invalidatePoolCache(poolId) {
         if (poolId !== undefined) {
@@ -98,10 +169,30 @@ export class NftStakingClient {
         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;
+        const result = acct?.owner.equals(TOKEN_2022_PROGRAM_ID)
+            ? TOKEN_2022_PROGRAM_ID
+            : TOKEN_PROGRAM_ID;
         this.tokenProgramCache.set(key, result);
         return result;
     }
+    /**
+     * Resolve programmable-NFT token-record PDAs for a (mint, source, dest)
+     * triple. Detection: derive the SOURCE token record PDA and probe the
+     * account on-chain. A token-record account only exists for pNFTs, so its
+     * presence is a reliable, version-agnostic detector (and is what the
+     * mpl-token-metadata clients use). Returns `{ tokenRecord: null,
+     * destinationTokenRecord: null }` for legacy NFTs, otherwise the pair of
+     * PDAs. `destination` may be null for transfer-mode stakes (no escrow).
+     */
+    async resolvePNftTokenRecords(mint, source, destination) {
+        const sourceRecord = getTokenRecordPda(mint, source);
+        const info = await this.provider.connection.getAccountInfo(sourceRecord);
+        if (!info) {
+            return { tokenRecord: null, destinationTokenRecord: null };
+        }
+        const destinationRecord = destination ? getTokenRecordPda(mint, destination) : null;
+        return { tokenRecord: sourceRecord, destinationTokenRecord: destinationRecord };
+    }
     /** Fetch the decimal precision of a token mint (cached). */
     async getMintDecimals(mint) {
         const key = mint.toBase58();
@@ -130,28 +221,17 @@ export class NftStakingClient {
             })),
         };
     }
-    /** 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,
-        };
+    /** Cache of project_id -> referral pubkey (or null = no referral). */
+    projectReferralCache = new ProjectReferralCache();
+    /** Resolve fee PDA accounts for fee CPI. Auto-supplies referral from project if not provided. */
+    async resolveFeeAccounts(pid, fee) {
+        return resolveFeeAccounts({
+            connection: this.provider.connection,
+            utilityProgramId: this.program.programId,
+            projectId: pid,
+            fee,
+            referralCache: this.projectReferralCache,
+        });
     }
     async fetchStakeConfig(projectId) {
         const pid = this.resolveProjectId(projectId);
@@ -171,15 +251,17 @@ export class NftStakingClient {
         const decimals = await this.getMintDecimals(new PublicKey(pool.rewardConfig.rewardMint));
         return this.applyPoolDecimals(pool, decimals);
     }
-    async fetchStakeEntry(poolId, nftMint) {
-        const [pda] = getStakeEntryPda(poolId, nftMint);
+    async fetchStakeEntry(poolId, nftMint, projectId) {
+        const pid = this.resolveProjectId(projectId);
+        const [pda] = getStakeEntryPda(pid, poolId, toPk(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);
+    async fetchStakerAccount(poolId, wallet, rewardDecimals, projectId) {
+        const pid = this.resolveProjectId(projectId);
+        const [pda] = getStakerAccountPda(pid, poolId, toPk(wallet));
         const raw = await this.program.account.stakerAccount.fetchNullable(pda);
         if (!raw)
             return null;
@@ -210,22 +292,224 @@ export class NftStakingClient {
         return pools;
     }
     /** Fetch all active stake entries for a wallet in a specific pool via gPA. */
-    async fetchStakeEntriesByOwner(_poolId, owner) {
+    async fetchStakeEntriesByOwner(poolId, owner, projectId) {
+        const pid = this.resolveProjectId(projectId);
+        const _owner = toPk(owner);
+        const [poolPda] = getStakePoolPda(pid, poolId);
         const entries = await this.program.account.stakeEntry.all([
-            { memcmp: { offset: 72, bytes: owner.toBase58() } },
+            { memcmp: { offset: 72, bytes: _owner.toBase58() } },
         ]);
         return entries
             .map(({ account }) => decodeAccount(account))
-            .filter((e) => e.isActive);
+            .filter((e) => e.isActive && new PublicKey(e.pool).equals(poolPda));
+    }
+    async fetchTokenAccountAmount(account) {
+        try {
+            const balance = await this.provider.connection.getTokenAccountBalance(account);
+            return Number(balance.value.amount);
+        }
+        catch {
+            return null;
+        }
+    }
+    isEntryClaimDeferred(pool, entry, now) {
+        if (entry.lockTierIndex === 255 || entry.lockExpiresAt <= 0 || now >= entry.lockExpiresAt) {
+            return false;
+        }
+        return Boolean(pool.lockConfigs[entry.lockTierIndex]?.claimOnlyAtEnd);
+    }
+    splitAccruedByRates(accrued, claimableRate, totalRate) {
+        if (accrued <= 0)
+            return [0, 0];
+        if (totalRate <= 0)
+            return [accrued, 0];
+        const claimable = Math.floor((accrued * claimableRate) / totalRate);
+        return [claimable, accrued - claimable];
+    }
+    pendingFromRate(rate, interval, rewardEndAt, lastUpdateAt, now) {
+        if (rate <= 0 || interval <= 0)
+            return 0;
+        const effectiveNow = rewardEndAt > 0 && now > rewardEndAt ? rewardEndAt : now;
+        const elapsed = Math.max(0, effectiveNow - lastUpdateAt);
+        return Math.floor((elapsed * rate) / interval);
+    }
+    resolveSecondaryDecimals(mint, index, overrides) {
+        if (!overrides)
+            return undefined;
+        if (Array.isArray(overrides))
+            return overrides[index];
+        return overrides[mint];
+    }
+    /**
+     * Build a display-ready reward summary for a staker in one pool.
+     *
+     * Current on-chain primary and secondary claims are still blocked while
+     * `claimLockedUntil` is active. This helper partitions estimated accruals
+     * into claimable versus claim-at-end buckets from active StakeEntry rates so
+     * UIs can show what is available now and what remains locked.
+     */
+    async fetchStakerRewardSummary(poolId, wallet, opts = {}) {
+        const pid = this.resolveProjectId(opts.projectId);
+        const _wallet = toPk(wallet);
+        const now = opts.now ?? Math.floor(Date.now() / 1000);
+        const pool = await this.fetchRawStakePool(pid, poolId);
+        if (!pool)
+            return null;
+        const rewardMint = new PublicKey(pool.rewardConfig.rewardMint);
+        const rewardDecimals = opts.rewardDecimals ?? (await this.getMintDecimals(rewardMint));
+        const staker = await this.fetchStakerAccount(poolId, _wallet, undefined, pid);
+        const entries = opts.entries ?? (await this.fetchStakeEntriesByOwner(poolId, _wallet, pid));
+        const activeEntries = entries.filter((entry) => entry.isActive);
+        const claimableEntries = activeEntries.filter((entry) => !this.isEntryClaimDeferred(pool, entry, now));
+        const unclaimableEntries = activeEntries.filter((entry) => this.isEntryClaimDeferred(pool, entry, now));
+        const claimableRate = claimableEntries.reduce((sum, entry) => sum + entry.rateContribution, 0);
+        const unclaimableRate = unclaimableEntries.reduce((sum, entry) => sum + entry.rateContribution, 0);
+        const totalRate = claimableRate + unclaimableRate;
+        const stakerRate = staker?.effectiveRate ?? 0;
+        const settledPrimary = staker?.accruedRewards ?? 0;
+        const [claimableSettledPrimary, unclaimableSettledPrimary] = this.splitAccruedByRates(settledPrimary, claimableRate, totalRate || stakerRate);
+        const pendingClaimablePrimary = staker
+            ? this.pendingFromRate(claimableRate, pool.rewardConfig.rateInterval, pool.rewardEndAt, staker.lastUpdateAt, now)
+            : 0;
+        const pendingUnclaimablePrimary = staker
+            ? this.pendingFromRate(unclaimableRate, pool.rewardConfig.rateInterval, pool.rewardEndAt, staker.lastUpdateAt, now)
+            : 0;
+        const claimableBasePrimary = claimableSettledPrimary + pendingClaimablePrimary;
+        const unclaimableBasePrimary = unclaimableSettledPrimary + pendingUnclaimablePrimary;
+        const quantityThresholds = pool.rewardConfig.quantityThresholds;
+        const stakedCount = staker?.stakedCount ?? activeEntries.length;
+        const claimablePayoutPrimary = applyQuantityBonusRaw(claimableBasePrimary, quantityThresholds, stakedCount, 0);
+        const unclaimablePayoutPrimary = applyQuantityBonusRaw(unclaimableBasePrimary, quantityThresholds, stakedCount, 0);
+        let primaryVaultBalance;
+        if (opts.includeVaultBalances) {
+            const [poolAuthority] = getPoolAuthorityPda(pid, poolId);
+            const tokenProgram = await this.resolveTokenProgram(rewardMint);
+            const rewardVault = getAta(poolAuthority, rewardMint, tokenProgram);
+            const rawBalance = await this.fetchTokenAccountAmount(rewardVault);
+            primaryVaultBalance =
+                rawBalance == null ? null : amountWithDecimals(rawBalance, rewardDecimals);
+        }
+        const secondary = [];
+        const poolSecondary = await this.fetchPoolSecondaryRewards(poolId, pid);
+        const stakerSecondary = await this.fetchStakerSecondaryRewards(poolId, _wallet, pid);
+        if (poolSecondary && stakerSecondary) {
+            const [poolAuthority] = getPoolAuthorityPda(pid, poolId);
+            for (let index = 0; index < poolSecondary.rewards.length; index++) {
+                const reward = poolSecondary.rewards[index];
+                if (!reward)
+                    continue;
+                const mint = reward.rewardMint;
+                const decimals = this.resolveSecondaryDecimals(mint, index, opts.secondaryRewardDecimals) ??
+                    (await this.getMintDecimals(new PublicKey(mint)));
+                const secondaryClaimableRate = claimableEntries.reduce((sum, entry) => sum + (entry.secondaryRateContributions[index] ?? 0), 0);
+                const secondaryUnclaimableRate = unclaimableEntries.reduce((sum, entry) => sum + (entry.secondaryRateContributions[index] ?? 0), 0);
+                const secondaryTotalRate = secondaryClaimableRate + secondaryUnclaimableRate;
+                const settledSecondary = stakerSecondary.accruedRewards[index] ?? 0;
+                const [claimableSettledSecondary, unclaimableSettledSecondary] = this.splitAccruedByRates(settledSecondary, secondaryClaimableRate, secondaryTotalRate || stakerSecondary.effectiveRate[index] || 0);
+                const isRetired = Boolean(reward.isRetired);
+                const retiredAtRaw = reward.retiredAt;
+                const retiredAt = typeof retiredAtRaw === "number"
+                    ? retiredAtRaw
+                    : retiredAtRaw &&
+                        typeof retiredAtRaw.toNumber === "function"
+                        ? retiredAtRaw.toNumber()
+                        : Number(retiredAtRaw ?? 0);
+                // STAKE-FRESH-2026-05-11 (F-H3): for retired slots, pending accrues
+                // only up to `retiredAt`. Pre-fix the SDK zeroed pending entirely,
+                // hiding the legitimately-owed pre-retire window from the UI; now we
+                // mirror the on-chain cap so the displayed claimable matches what
+                // `claim_secondary_rewards` will actually pay out.
+                const cappedNow = isRetired && retiredAt > 0 && retiredAt < now ? retiredAt : now;
+                const pendingClaimableSecondary = staker
+                    ? this.pendingFromRate(secondaryClaimableRate, pool.rewardConfig.rateInterval, pool.rewardEndAt, staker.lastUpdateAt, cappedNow)
+                    : 0;
+                const pendingUnclaimableSecondary = staker
+                    ? this.pendingFromRate(secondaryUnclaimableRate, pool.rewardConfig.rateInterval, pool.rewardEndAt, staker.lastUpdateAt, cappedNow)
+                    : 0;
+                const claimableBaseSecondary = claimableSettledSecondary + pendingClaimableSecondary;
+                const unclaimableBaseSecondary = unclaimableSettledSecondary + pendingUnclaimableSecondary;
+                const claimablePayoutSecondary = applyQuantityBonusRaw(claimableBaseSecondary, quantityThresholds, stakedCount, 1);
+                const unclaimablePayoutSecondary = applyQuantityBonusRaw(unclaimableBaseSecondary, quantityThresholds, stakedCount, 1);
+                // STAKE-FRESH-2026-05-11 (F-H3): a retired slot is "tombstoned" once
+                // there is nothing left to claim AND nothing left to accrue (true by
+                // definition while retired). Hide from default output so the UI
+                // "deprecated reward disappears after claim" naturally.
+                const tombstoned = isRetired &&
+                    claimablePayoutSecondary === 0 &&
+                    unclaimablePayoutSecondary === 0 &&
+                    (stakerSecondary.accruedRewards[index] ?? 0) === 0;
+                if (tombstoned && !opts.includeTombstoned) {
+                    continue;
+                }
+                let secondaryVaultBalance;
+                if (opts.includeVaultBalances) {
+                    const mintPk = new PublicKey(mint);
+                    const tokenProgram = await this.resolveTokenProgram(mintPk);
+                    const vault = getAta(poolAuthority, mintPk, tokenProgram);
+                    const rawBalance = await this.fetchTokenAccountAmount(vault);
+                    secondaryVaultBalance =
+                        rawBalance == null ? null : amountWithDecimals(rawBalance, decimals);
+                }
+                secondary.push({
+                    index,
+                    rewardMint: mint,
+                    rewardDecimals: decimals,
+                    isRetired,
+                    retiredAt,
+                    tombstoned,
+                    totalAccrued: amountWithDecimals(claimablePayoutSecondary + unclaimablePayoutSecondary, decimals),
+                    claimable: amountWithDecimals(claimablePayoutSecondary, decimals),
+                    unclaimable: amountWithDecimals(unclaimablePayoutSecondary, decimals),
+                    claimableBase: amountWithDecimals(claimableBaseSecondary, decimals),
+                    unclaimableBase: amountWithDecimals(unclaimableBaseSecondary, decimals),
+                    claimableRate: secondaryClaimableRate,
+                    unclaimableRate: secondaryUnclaimableRate,
+                    totalRate: secondaryTotalRate,
+                    vaultBalance: secondaryVaultBalance,
+                });
+            }
+        }
+        return {
+            poolId,
+            wallet: _wallet.toBase58(),
+            generatedAt: now,
+            rewardMint: rewardMint.toBase58(),
+            rewardDecimals,
+            primary: {
+                totalAccrued: amountWithDecimals(claimablePayoutPrimary + unclaimablePayoutPrimary, rewardDecimals),
+                claimable: amountWithDecimals(claimablePayoutPrimary, rewardDecimals),
+                unclaimable: amountWithDecimals(unclaimablePayoutPrimary, rewardDecimals),
+                claimableBase: amountWithDecimals(claimableBasePrimary, rewardDecimals),
+                unclaimableBase: amountWithDecimals(unclaimableBasePrimary, rewardDecimals),
+                claimableRate,
+                unclaimableRate,
+                totalRate,
+                claimLockedUntil: staker?.claimLockedUntil ?? 0,
+                claimTransactionBlocked: Boolean(staker?.claimLockedUntil && now < staker.claimLockedUntil),
+                vaultBalance: primaryVaultBalance,
+            },
+            secondary,
+            entries: {
+                totalActive: activeEntries.length,
+                claimableActive: claimableEntries.length,
+                unclaimableActive: unclaimableEntries.length,
+            },
+            notes: [
+                "Raw amounts are base units; ui amounts are divided by rewardDecimals.",
+                "claimable/unclaimable splits are estimated from active StakeEntry rate contributions.",
+                "Current on-chain primary and secondary claim instructions are still blocked while claimLockedUntil is active.",
+            ],
+        };
     }
     /**
      * Fetch active stake entries for specific NFT mints by deriving their PDAs.
      * More reliable than gPA in browser environments.
      */
-    async fetchStakeEntriesForMints(poolId, nftMints) {
+    async fetchStakeEntriesForMints(poolId, nftMints, projectId) {
         if (nftMints.length === 0)
             return [];
-        const pdas = nftMints.map((mint) => getStakeEntryPda(poolId, mint)[0]);
+        const pid = this.resolveProjectId(projectId);
+        const pdas = nftMints.map((mint) => getStakeEntryPda(pid, poolId, toPk(mint))[0]);
         const accounts = await this.program.account.stakeEntry.fetchMultiple(pdas);
         return accounts
             .filter((a) => a !== null)
@@ -245,13 +529,14 @@ export class NftStakingClient {
      * Fetch active stake entries for given mints across multiple pools.
      * Uses PDA derivation + fetchMultiple (reliable in browser).
      */
-    async fetchStakeEntriesAcrossPools(poolIds, nftMints) {
+    async fetchStakeEntriesAcrossPools(poolIds, nftMints, projectId) {
         if (nftMints.length === 0 || poolIds.length === 0)
             return [];
+        const pid = this.resolveProjectId(projectId);
         const pdas = [];
         for (const poolId of poolIds) {
             for (const mint of nftMints) {
-                pdas.push(getStakeEntryPda(poolId, mint)[0]);
+                pdas.push(getStakeEntryPda(pid, poolId, mint)[0]);
             }
         }
         const accounts = await this.program.account.stakeEntry.fetchMultiple(pdas);
@@ -270,11 +555,16 @@ export class NftStakingClient {
         return stakers.map(({ account }) => decodeAccount(account));
     }
     async closeLegacyCollection(collectionMint, projectId) {
+        const _collMint = toPk(collectionMint);
         const pid = this.resolveProjectId(projectId);
-        const [collection] = PublicKey.findProgramAddressSync([Buffer.from("project_collection"), new BN(pid).toArrayLike(Buffer, "le", 8), collectionMint.toBuffer()], this.program.programId);
+        const [collection] = PublicKey.findProgramAddressSync([
+            Buffer.from("project_collection"),
+            new BN(pid).toArrayLike(Buffer, "le", 8),
+            _collMint.toBuffer(),
+        ], this.program.programId);
         const [project] = getProjectPda(pid);
         return this.program.methods
-            .closeLegacyCollection(new BN(pid), collectionMint)
+            .closeLegacyCollection(new BN(pid), _collMint)
             .accountsStrict({
             collection,
             authority: this.provider.wallet.publicKey,
@@ -299,44 +589,50 @@ export class NftStakingClient {
             .instruction();
     }
     async createStakePool(stakingMode, rewardConfig, lockConfigs, collectionMint, opts) {
+        const _collMint = toPk(collectionMint);
+        const _rewardMint = toPk(rewardConfig.rewardMint);
         const pid = this.resolveProjectId(opts?.projectId);
         const rewardEndAt = opts?.rewardEndAt ?? 0;
         const maxStaked = opts?.maxStaked ?? 0;
+        const allowUnlockedStaking = opts?.allowUnlockedStaking ?? true;
         const config = await this.fetchStakeConfig(pid);
         const nextPoolId = config ? config.totalPools : 0;
-        const tokenProgram = await this.resolveTokenProgram(rewardConfig.rewardMint);
-        const decimals = await this.getMintDecimals(rewardConfig.rewardMint);
+        const tokenProgram = await this.resolveTokenProgram(_rewardMint);
+        const decimals = await this.getMintDecimals(_rewardMint);
         const multiplier = 10 ** decimals;
         const rawRewardConfig = {
             rewardType: rewardConfig.rewardType,
-            rewardMint: rewardConfig.rewardMint,
+            rewardMint: _rewardMint,
             baseRate: new BN(Math.round(rewardConfig.baseRate * multiplier)),
             rateInterval: new BN(rewardConfig.rateInterval),
             traitBonusMode: rewardConfig.traitBonusMode,
-            quantityThresholds: rewardConfig.quantityThresholds,
+            quantityThresholds: rewardConfig.quantityThresholds.map(normalizeQuantityBonus),
         };
         const rawLockConfigs = lockConfigs.map((lc) => ({
             lockDuration: new BN(lc.lockDuration),
             rewardRate: new BN(Math.round(lc.rewardRate * multiplier)),
             earlyUnstakePenaltyBps: lc.earlyUnstakePenaltyBps,
+            claimOnlyAtEnd: lc.claimOnlyAtEnd,
         }));
         const [configPda] = getStakeConfigPda(pid);
         const [poolPda] = getStakePoolPda(pid, nextPoolId);
-        const [collectionConfigPda] = getCollectionPda(pid, collectionMint);
-        const [poolAuthority] = getPoolAuthorityPda(nextPoolId);
-        const rewardVault = getAta(poolAuthority, rewardConfig.rewardMint, tokenProgram);
+        const [collectionConfigPda] = getCollectionPda(pid, _collMint);
+        const [poolAuthority] = getPoolAuthorityPda(pid, nextPoolId);
+        const rewardVault = getAta(poolAuthority, _rewardMint, tokenProgram);
+        const [project] = getProjectPda(pid);
         const [utilityConfig] = getUtilityConfigPda(pid, this.program.programId);
         return this.program.methods
-            .createStakePool(new BN(pid), stakingMode, rawRewardConfig, rawLockConfigs, new BN(rewardEndAt), new BN(maxStaked))
+            .createStakePool(new BN(pid), stakingMode, rawRewardConfig, rawLockConfigs, new BN(rewardEndAt), new BN(maxStaked), allowUnlockedStaking)
             .accountsStrict({
             config: configPda,
             pool: poolPda,
             collectionConfig: collectionConfigPda,
             poolAuthority,
-            collectionMint,
-            rewardMint: rewardConfig.rewardMint,
+            collectionMint: _collMint,
+            rewardMint: _rewardMint,
             rewardVault,
             utilityConfig,
+            project,
             projectManagementProgram: PROJECT_MANAGEMENT_PROGRAM_ID,
             authority: this.provider.wallet.publicKey,
             tokenProgram,
@@ -350,33 +646,36 @@ export class NftStakingClient {
         const rewardConfig = updates.rewardConfig ?? null;
         const lockConfigs = updates.lockConfigs ?? null;
         const isActive = updates.isActive ?? null;
-        const traitAuthority = updates.traitAuthority ?? null;
+        const traitAuthority = updates.traitAuthority != null ? toPk(updates.traitAuthority) : null;
         const canBurn = updates.canBurn ?? null;
         const merkleRoot = updates.merkleRoot ?? null;
         const gateType = updates.gateType ?? null;
         const rewardEndAt = updates.rewardEndAt != null ? new BN(updates.rewardEndAt) : null;
         const maxStaked = updates.maxStaked != null ? new BN(updates.maxStaked) : null;
+        const allowUnlockedStaking = updates.allowUnlockedStaking ?? null;
         let rawRewardConfig = null;
         let rawLockConfigs = null;
         if (rewardConfig) {
-            const decimals = await this.getMintDecimals(rewardConfig.rewardMint);
+            const _rMint = toPk(rewardConfig.rewardMint);
+            const decimals = await this.getMintDecimals(_rMint);
             const multiplier = 10 ** decimals;
             rawRewardConfig = {
                 rewardType: rewardConfig.rewardType,
-                rewardMint: rewardConfig.rewardMint,
+                rewardMint: _rMint,
                 baseRate: new BN(Math.round(rewardConfig.baseRate * multiplier)),
                 rateInterval: new BN(rewardConfig.rateInterval),
                 traitBonusMode: rewardConfig.traitBonusMode,
-                quantityThresholds: rewardConfig.quantityThresholds,
+                quantityThresholds: rewardConfig.quantityThresholds.map(normalizeQuantityBonus),
             };
         }
         if (lockConfigs && rewardConfig) {
-            const decimals = await this.getMintDecimals(rewardConfig.rewardMint);
+            const decimals = await this.getMintDecimals(toPk(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,
+                claimOnlyAtEnd: lc.claimOnlyAtEnd,
             }));
         }
         else if (lockConfigs) {
@@ -387,13 +686,17 @@ export class NftStakingClient {
                 lockDuration: new BN(lc.lockDuration),
                 rewardRate: new BN(Math.round(lc.rewardRate * multiplier)),
                 earlyUnstakePenaltyBps: lc.earlyUnstakePenaltyBps,
+                claimOnlyAtEnd: lc.claimOnlyAtEnd,
             }));
         }
         const [poolPda] = getStakePoolPda(pid, poolId);
+        const [project] = getProjectPda(pid);
         return this.program.methods
-            .updateStakePool(new BN(pid), new BN(poolId), rawRewardConfig, rawLockConfigs, isActive, traitAuthority, canBurn, merkleRoot, gateType, rewardEndAt, maxStaked)
+            .updateStakePool(new BN(pid), new BN(poolId), rawRewardConfig, rawLockConfigs, isActive, traitAuthority, canBurn, merkleRoot, gateType, rewardEndAt, maxStaked, allowUnlockedStaking)
             .accountsStrict({
             pool: poolPda,
+            project,
+            projectManagementProgram: PROJECT_MANAGEMENT_PROGRAM_ID,
             authority: this.provider.wallet.publicKey,
         })
             .instruction();
@@ -402,14 +705,18 @@ export class NftStakingClient {
     async fundRewardVault(poolId, amount, opts) {
         const pid = this.resolveProjectId(opts?.projectId);
         const pool = await this.getPoolData(pid, poolId);
-        const rewardMint = opts?.rewardMint ?? new PublicKey(pool.rewardConfig.rewardMint);
+        const rewardMint = opts?.rewardMint
+            ? toPk(opts.rewardMint)
+            : new PublicKey(pool.rewardConfig.rewardMint);
         const tokenProgram = await this.resolveTokenProgram(rewardMint);
         const [poolPda] = getStakePoolPda(pid, poolId);
-        const [poolAuthority] = getPoolAuthorityPda(poolId);
+        const [poolAuthority] = getPoolAuthorityPda(pid, poolId);
         const rewardVault = getAta(poolAuthority, rewardMint, tokenProgram);
-        const funderAta = opts?.funderTokenAccount ?? getAta(this.provider.wallet.publicKey, rewardMint, tokenProgram);
+        const funderAta = opts?.funderTokenAccount
+            ? toPk(opts.funderTokenAccount)
+            : getAta(this.provider.wallet.publicKey, rewardMint, tokenProgram);
         return this.program.methods
-            .fundRewardVault(new BN(pid), new BN(poolId), amount)
+            .fundRewardVault(new BN(pid), new BN(poolId), toBN(amount))
             .accountsStrict({
             pool: poolPda,
             poolAuthority,
@@ -425,16 +732,23 @@ export class NftStakingClient {
     async withdrawRewardVault(poolId, amount, opts) {
         const pid = this.resolveProjectId(opts?.projectId);
         const pool = await this.getPoolData(pid, poolId);
-        const rewardMint = opts?.rewardMint ?? new PublicKey(pool.rewardConfig.rewardMint);
+        const rewardMint = opts?.rewardMint
+            ? toPk(opts.rewardMint)
+            : new PublicKey(pool.rewardConfig.rewardMint);
         const tokenProgram = await this.resolveTokenProgram(rewardMint);
         const [poolPda] = getStakePoolPda(pid, poolId);
-        const [poolAuthority] = getPoolAuthorityPda(poolId);
+        const [project] = getProjectPda(pid);
+        const [poolAuthority] = getPoolAuthorityPda(pid, poolId);
         const rewardVault = getAta(poolAuthority, rewardMint, tokenProgram);
-        const destAta = opts?.destinationTokenAccount ?? getAta(this.provider.wallet.publicKey, rewardMint, tokenProgram);
+        const destAta = opts?.destinationTokenAccount
+            ? toPk(opts.destinationTokenAccount)
+            : getAta(this.provider.wallet.publicKey, rewardMint, tokenProgram);
         return this.program.methods
-            .withdrawRewardVault(new BN(pid), new BN(poolId), amount)
+            .withdrawRewardVault(new BN(pid), new BN(poolId), toBN(amount))
             .accountsStrict({
             pool: poolPda,
+            project,
+            projectManagementProgram: PROJECT_MANAGEMENT_PROGRAM_ID,
             poolAuthority,
             rewardVault,
             destinationTokenAccount: destAta,
@@ -447,58 +761,70 @@ export class NftStakingClient {
     async closeStakePool(poolId, projectId) {
         const pid = this.resolveProjectId(projectId);
         const [poolPda] = getStakePoolPda(pid, poolId);
+        const [project] = getProjectPda(pid);
         return this.program.methods
             .closeStakePool(new BN(pid), new BN(poolId))
             .accountsStrict({
             pool: poolPda,
+            project,
+            projectManagementProgram: PROJECT_MANAGEMENT_PROGRAM_ID,
+            rewardVault: null,
+            tokenProgram: null,
             authority: this.provider.wallet.publicKey,
         })
             .instruction();
     }
     /** Stake a legacy/pNFT. Auto-resolves stakingMode from pool. */
     async stakeNft(poolId, nftMint, opts) {
+        const _nftMint = toPk(nftMint);
         const pid = this.resolveProjectId(opts?.projectId);
         const pool = await this.getPoolData(pid, poolId);
         const stakingMode = pool.stakingMode;
         const lockTierIndex = opts?.lockTierIndex ?? null;
         const gateProof = opts?.gateProof ?? [];
         const [poolPda] = getStakePoolPda(pid, poolId);
-        const [stakeEntry] = getStakeEntryPda(poolId, nftMint);
+        const [stakeEntry] = getStakeEntryPda(pid, poolId, _nftMint);
+        const [stakeLock] = getNftStakeLockPda(_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 [stakerAccount] = getStakerAccountPda(pid, poolId, staker);
+        const [userProfile] = getUserProfilePda(staker);
+        const [poolAuthority] = getPoolAuthorityPda(pid, 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(opts?.fee);
+        const escrowNftAccount = isEscrow ? getAta(poolAuthority, _nftMint, nftTokenProgram) : null;
+        const nftMetadata = getMetadataPda(_nftMint);
+        const nftEdition = getEditionPda(_nftMint);
+        const { tokenRecord, destinationTokenRecord } = await this.resolvePNftTokenRecords(_nftMint, stakerNftAccount, escrowNftAccount);
+        const feeAccts = await this.resolveFeeAccounts(pid, opts?.fee);
+        const [project] = getProjectPda(pid);
         const [utilityConfig] = getUtilityConfigPda(pid, this.program.programId);
         return this.program.methods
-            .stakeNft(new BN(pid), new BN(poolId), nftMint, lockTierIndex, gateProof)
+            .stakeNft(new BN(pid), new BN(poolId), _nftMint, lockTierIndex, gateProof)
             .accountsStrict({
             pool: poolPda,
             stakeEntry,
+            stakeLock,
             stakerAccount,
             poolAuthority,
-            nftMint,
+            nftMint: _nftMint,
             stakerNftAccount,
             escrowNftAccount,
             nftMetadata,
             nftEdition,
             mplTokenMetadataProgram: TOKEN_METADATA_PROGRAM_ID,
             sysvarInstructions: SYSVAR_INSTRUCTIONS_ID,
-            tokenRecord: null,
-            destinationTokenRecord: null,
+            tokenRecord,
+            destinationTokenRecord,
+            userProfile,
             utilityConfig,
             feeConfig: feeAccts.feeConfig,
+            programRegistry: feeAccts.programRegistry,
             treasury: feeAccts.treasury,
             referralAccount: feeAccts.referralAccount,
             solUsdPriceFeed: feeAccts.solUsdPriceFeed,
             adminProgram: feeAccts.adminProgram,
+            project,
             staker,
             tokenProgram: nftTokenProgram,
             associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
@@ -506,37 +832,99 @@ export class NftStakingClient {
         })
             .instruction();
     }
-    /** Unstake a legacy/pNFT. Auto-resolves rewardMint and stakingMode from pool. */
+    /**
+     * Resolve the staker's remaining StakeEntry PDAs (excluding the entry being
+     * closed) for the on-chain claim-lock recompute. Used by `unstakeNft`,
+     * `unstakeCoreNft`, `unstakeCnft`, `burnStakedNft`, `burnStakedCoreNft`.
+     *
+     * - `undefined`: auto-discover via `fetchAllStakeEntriesByPool` (one RPC).
+     * - `null`: skip recompute (existing `claim_locked_until` is left as-is).
+     * - `PublicKey[]`: use exactly this list (filtered to exclude the closed entry).
+     */
+    async resolveRemainingStakeEntries(poolId, pid, staker, excludeStakeEntry, explicit) {
+        if (explicit === null)
+            return null;
+        if (explicit !== undefined) {
+            return explicit.filter((pk) => !pk.equals(excludeStakeEntry));
+        }
+        try {
+            const all = await this.fetchAllStakeEntriesByPool(poolId, pid);
+            return all
+                .filter((e) => e.isActive && new PublicKey(e.owner).equals(staker))
+                .map((e) => getStakeEntryPda(pid, poolId, new PublicKey(e.nftMint))[0])
+                .filter((pk) => !pk.equals(excludeStakeEntry));
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Unstake a previously staked NFT.
+     *
+     * Pass `opts.remainingStakeEntries` (the staker's other active StakeEntry
+     * PDAs in this pool, NOT including the one being unstaked) so the on-chain
+     * handler can recompute `claim_locked_until` from scratch. If omitted, the
+     * existing `claim_locked_until` is left unchanged on the staker account —
+     * the staker stays behind their lock until either it expires naturally or
+     * they retry the call with the full set of remaining entries. This default
+     * is intentionally conservative; client UIs should always supply the list
+     * to avoid stranding stakers behind a phantom lock.
+     *
+     * If `opts.remainingStakeEntries === undefined`, the SDK will attempt to
+     * auto-discover them via `fetchAllStakeEntriesByPool` (one extra RPC
+     * call). Pass `null` to opt out of discovery entirely.
+     */
     async unstakeNft(poolId, nftMint, opts) {
+        const _nftMint = toPk(nftMint);
         const pid = this.resolveProjectId(opts?.projectId);
         const pool = await this.getPoolData(pid, poolId);
         const rewardMint = new PublicKey(pool.rewardConfig.rewardMint);
         const stakingMode = pool.stakingMode;
         const rewardTokenProgram = await this.resolveTokenProgram(rewardMint);
-        const nftTokenProgram = await this.resolveTokenProgram(nftMint);
+        const nftTokenProgram = await this.resolveTokenProgram(_nftMint);
         const [poolPda] = getStakePoolPda(pid, poolId);
-        const [stakeEntry] = getStakeEntryPda(poolId, nftMint);
+        const [stakeEntry] = getStakeEntryPda(pid, poolId, _nftMint);
+        const [stakeLock] = getNftStakeLockPda(_nftMint);
         const staker = this.provider.wallet.publicKey;
-        const [stakerAccount] = getStakerAccountPda(poolId, staker);
-        const [poolAuthority] = getPoolAuthorityPda(poolId);
-        const stakerNftAccount = getAta(staker, nftMint, nftTokenProgram);
+        const [stakerAccount] = getStakerAccountPda(pid, poolId, staker);
+        const [userProfile] = getUserProfilePda(staker);
+        const [poolAuthority] = getPoolAuthorityPda(pid, poolId);
+        const stakerNftAccount = getAta(staker, _nftMint, nftTokenProgram);
         const isEscrow = stakingMode !== 1;
-        const escrowNftAccount = isEscrow
-            ? getAta(poolAuthority, nftMint, nftTokenProgram)
-            : null;
+        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(opts?.fee);
+        const nftMetadata = getMetadataPda(_nftMint);
+        const nftEdition = getEditionPda(_nftMint);
+        const { tokenRecord, destinationTokenRecord } = await this.resolvePNftTokenRecords(_nftMint, 
+        // For unstake, the *source* of the NFT is the escrow when escrowed,
+        // otherwise the staker's wallet ATA (with the staker_account PDA as
+        // delegate).
+        escrowNftAccount ?? stakerNftAccount, escrowNftAccount ? stakerNftAccount : null);
+        // entry has secondary rates), then the remaining StakeEntry PDAs for
+        // the claim-lock recompute.
+        const entry = await this.fetchStakeEntry(poolId, _nftMint, pid);
+        const hasSecondary = entry?.secondaryRateContributions?.some((r) => r > 0n) ?? false;
+        const remainingAccounts = [];
+        if (hasSecondary) {
+            const [stakerSecondary] = getStakerSecondaryRewardsPda(pid, poolId, staker);
+            remainingAccounts.push({ pubkey: stakerSecondary, isSigner: false, isWritable: true });
+        }
+        let stakeEntryList = await this.resolveRemainingStakeEntries(poolId, pid, staker, stakeEntry, opts?.remainingStakeEntries);
+        if (stakeEntryList) {
+            for (const pk of stakeEntryList) {
+                remainingAccounts.push({ pubkey: pk, isSigner: false, isWritable: false });
+            }
+        }
         return this.program.methods
-            .unstakeNft(new BN(pid), new BN(poolId), nftMint)
+            .unstakeNft(new BN(pid), new BN(poolId), _nftMint)
             .accountsStrict({
             pool: poolPda,
             stakeEntry,
+            stakeLock,
             stakerAccount,
             poolAuthority,
-            nftMint,
+            nftMint: _nftMint,
             stakerNftAccount,
             escrowNftAccount,
             rewardVault,
@@ -546,19 +934,16 @@ export class NftStakingClient {
             nftEdition,
             mplTokenMetadataProgram: TOKEN_METADATA_PROGRAM_ID,
             sysvarInstructions: SYSVAR_INSTRUCTIONS_ID,
-            tokenRecord: null,
-            destinationTokenRecord: null,
-            feeConfig: feeAccts.feeConfig,
-            treasury: feeAccts.treasury,
-            referralAccount: feeAccts.referralAccount,
-            solUsdPriceFeed: feeAccts.solUsdPriceFeed,
-            adminProgram: feeAccts.adminProgram,
+            tokenRecord,
+            destinationTokenRecord,
             staker,
+            userProfile,
             tokenProgram: nftTokenProgram,
             rewardTokenProgram,
             associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
             systemProgram: SystemProgram.programId,
         })
+            .remainingAccounts(remainingAccounts)
             .instruction();
     }
     /** Claim accrued rewards. Auto-resolves rewardMint from pool. */
@@ -570,12 +955,14 @@ export class NftStakingClient {
         const tokenProgram = await this.resolveTokenProgram(rewardMint);
         const [poolPda] = getStakePoolPda(pid, poolId);
         const staker = this.provider.wallet.publicKey;
-        const [stakerAccount] = getStakerAccountPda(poolId, staker);
-        const [poolAuthority] = getPoolAuthorityPda(poolId);
+        const [stakerAccount] = getStakerAccountPda(pid, poolId, staker);
+        const [userProfile] = getUserProfilePda(staker);
+        const [poolAuthority] = getPoolAuthorityPda(pid, poolId);
         const rewardVault = getAta(poolAuthority, rewardMint, tokenProgram);
         const stakerRewardAccount = getAta(staker, rewardMint, tokenProgram);
         const [stakeConfig] = getStakeConfigPda(pid);
-        const feeAccts = this.resolveFeeAccounts(opts?.fee);
+        const feeAccts = await this.resolveFeeAccounts(pid, opts?.fee);
+        const [project] = getProjectPda(pid);
         return this.program.methods
             .claimRewards(new BN(pid), new BN(poolId), traitBonusRate)
             .accountsStrict({
@@ -588,11 +975,14 @@ export class NftStakingClient {
             stakeConfig,
             instructionsSysvar: new PublicKey("Sysvar1nstructions1111111111111111111111111"),
             feeConfig: feeAccts.feeConfig,
+            programRegistry: feeAccts.programRegistry,
             treasury: feeAccts.treasury,
             referralAccount: feeAccts.referralAccount,
             solUsdPriceFeed: feeAccts.solUsdPriceFeed,
             adminProgram: feeAccts.adminProgram,
+            project,
             staker,
+            userProfile,
             tokenProgram,
             associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
             systemProgram: SystemProgram.programId,
@@ -601,84 +991,107 @@ export class NftStakingClient {
     }
     /** Stake a Core NFT. Auto-resolves collection from pool. */
     async stakeCoreNft(poolId, nftAsset, opts) {
+        const _nftAsset = toPk(nftAsset);
         const pid = this.resolveProjectId(opts?.projectId);
         const pool = await this.getPoolData(pid, poolId);
         const collection = new PublicKey(pool.collectionMint);
         const lockTierIndex = opts?.lockTierIndex ?? null;
         const gateProof = opts?.gateProof ?? [];
         const [poolPda] = getStakePoolPda(pid, poolId);
-        const [stakeEntry] = getStakeEntryPda(poolId, nftAsset);
+        const [stakeEntry] = getStakeEntryPda(pid, poolId, _nftAsset);
+        const [stakeLock] = getNftStakeLockPda(_nftAsset);
         const staker = this.provider.wallet.publicKey;
-        const [stakerAccount] = getStakerAccountPda(poolId, staker);
-        const [poolAuthority] = getPoolAuthorityPda(poolId);
-        const feeAccts = this.resolveFeeAccounts(opts?.fee);
+        const [stakerAccount] = getStakerAccountPda(pid, poolId, staker);
+        const [userProfile] = getUserProfilePda(staker);
+        const [poolAuthority] = getPoolAuthorityPda(pid, poolId);
+        const feeAccts = await this.resolveFeeAccounts(pid, opts?.fee);
+        const [project] = getProjectPda(pid);
         const [utilityConfig] = getUtilityConfigPda(pid, this.program.programId);
         return this.program.methods
-            .stakeCoreNft(new BN(pid), new BN(poolId), nftAsset, lockTierIndex, gateProof)
+            .stakeCoreNft(new BN(pid), new BN(poolId), _nftAsset, lockTierIndex, gateProof)
             .accountsStrict({
             pool: poolPda,
             stakeEntry,
+            stakeLock,
             stakerAccount,
             poolAuthority,
-            nftAsset,
+            nftAsset: _nftAsset,
             collection,
             mplCoreProgram: MPL_CORE_PROGRAM_ID,
             utilityConfig,
             feeConfig: feeAccts.feeConfig,
+            programRegistry: feeAccts.programRegistry,
             treasury: feeAccts.treasury,
             referralAccount: feeAccts.referralAccount,
             solUsdPriceFeed: feeAccts.solUsdPriceFeed,
             adminProgram: feeAccts.adminProgram,
+            project,
             staker,
+            userProfile,
             systemProgram: SystemProgram.programId,
         })
             .instruction();
     }
     /** Unstake a Core NFT. Auto-resolves collection and rewardMint from pool. */
     async unstakeCoreNft(poolId, nftAsset, opts) {
+        const _nftAsset = toPk(nftAsset);
         const pid = this.resolveProjectId(opts?.projectId);
         const pool = await this.getPoolData(pid, poolId);
         const collection = new PublicKey(pool.collectionMint);
         const rewardMint = new PublicKey(pool.rewardConfig.rewardMint);
         const rewardTokenProgram = await this.resolveTokenProgram(rewardMint);
         const [poolPda] = getStakePoolPda(pid, poolId);
-        const [stakeEntry] = getStakeEntryPda(poolId, nftAsset);
+        const [stakeEntry] = getStakeEntryPda(pid, poolId, _nftAsset);
+        const [stakeLock] = getNftStakeLockPda(_nftAsset);
         const staker = this.provider.wallet.publicKey;
-        const [stakerAccount] = getStakerAccountPda(poolId, staker);
-        const [poolAuthority] = getPoolAuthorityPda(poolId);
+        const [stakerAccount] = getStakerAccountPda(pid, poolId, staker);
+        const [userProfile] = getUserProfilePda(staker);
+        const [poolAuthority] = getPoolAuthorityPda(pid, poolId);
         const rewardVault = getAta(poolAuthority, rewardMint, rewardTokenProgram);
         const stakerRewardAccount = getAta(staker, rewardMint, rewardTokenProgram);
-        const feeAccts = this.resolveFeeAccounts(opts?.fee);
+        // Build remaining_accounts (optional secondary + staker's other active
+        // StakeEntry PDAs).
+        const entry = await this.fetchStakeEntry(poolId, _nftAsset, pid);
+        const hasSecondary = entry?.secondaryRateContributions?.some((r) => r > 0n) ?? false;
+        const remainingAccounts = [];
+        if (hasSecondary) {
+            const [stakerSecondary] = getStakerSecondaryRewardsPda(pid, poolId, staker);
+            remainingAccounts.push({ pubkey: stakerSecondary, isSigner: false, isWritable: true });
+        }
+        const stakeEntryList = await this.resolveRemainingStakeEntries(poolId, pid, staker, stakeEntry, opts?.remainingStakeEntries);
+        if (stakeEntryList) {
+            for (const pk of stakeEntryList) {
+                remainingAccounts.push({ pubkey: pk, isSigner: false, isWritable: false });
+            }
+        }
         return this.program.methods
-            .unstakeCoreNft(new BN(pid), new BN(poolId), nftAsset)
+            .unstakeCoreNft(new BN(pid), new BN(poolId), _nftAsset)
             .accountsStrict({
             pool: poolPda,
             stakeEntry,
+            stakeLock,
             stakerAccount,
             poolAuthority,
-            nftAsset,
+            nftAsset: _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,
+            userProfile,
             rewardTokenProgram,
             associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
             systemProgram: SystemProgram.programId,
         })
+            .remainingAccounts(remainingAccounts)
             .instruction();
     }
     /** Stake a compressed NFT (cNFT). All address/hash params accepted as strings. */
     async stakeCnft(poolId, cnftParams, opts) {
         const pid = this.resolveProjectId(opts?.projectId);
         const gateProof = opts?.gateProof ?? [];
-        const { nftAssetId, merkleTree, cnftRoot, cnftDataHash, cnftCreatorHash, cnftNonce, cnftIndex, proofNodes } = cnftParams;
+        const { nftAssetId, merkleTree, cnftRoot, cnftDataHash, cnftCreatorHash, cnftNonce, cnftIndex, proofNodes, } = cnftParams;
         const nftAssetIdPk = new PublicKey(nftAssetId);
         const merkleTreePk = new PublicKey(merkleTree);
         const [treeConfigPk] = getTreeConfigPda(merkleTreePk);
@@ -686,11 +1099,14 @@ export class NftStakingClient {
         const cnftDataHashArr = base58HashToArray(cnftDataHash);
         const cnftCreatorHashArr = base58HashToArray(cnftCreatorHash);
         const [poolPda] = getStakePoolPda(pid, poolId);
-        const [stakeEntry] = getStakeEntryPda(poolId, nftAssetIdPk);
+        const [stakeEntry] = getStakeEntryPda(pid, poolId, nftAssetIdPk);
+        const [stakeLock] = getNftStakeLockPda(nftAssetIdPk);
         const staker = this.provider.wallet.publicKey;
-        const [stakerAccount] = getStakerAccountPda(poolId, staker);
-        const [poolAuthority] = getPoolAuthorityPda(poolId);
-        const feeAccts = this.resolveFeeAccounts(opts?.fee);
+        const [stakerAccount] = getStakerAccountPda(pid, poolId, staker);
+        const [userProfile] = getUserProfilePda(staker);
+        const [poolAuthority] = getPoolAuthorityPda(pid, poolId);
+        const feeAccts = await this.resolveFeeAccounts(pid, opts?.fee);
+        const [project] = getProjectPda(pid);
         const [utilityConfig] = getUtilityConfigPda(pid, this.program.programId);
         const remainingAccounts = proofNodes.map((node) => ({
             pubkey: new PublicKey(node),
@@ -702,6 +1118,7 @@ export class NftStakingClient {
             .accountsStrict({
             pool: poolPda,
             stakeEntry,
+            stakeLock,
             stakerAccount,
             poolAuthority,
             treeConfig: treeConfigPk,
@@ -711,11 +1128,14 @@ export class NftStakingClient {
             bubblegumProgram: BUBBLEGUM_PROGRAM_ID,
             utilityConfig,
             feeConfig: feeAccts.feeConfig,
+            programRegistry: feeAccts.programRegistry,
             treasury: feeAccts.treasury,
             referralAccount: feeAccts.referralAccount,
             solUsdPriceFeed: feeAccts.solUsdPriceFeed,
             adminProgram: feeAccts.adminProgram,
+            project,
             staker,
+            userProfile,
             systemProgram: SystemProgram.programId,
         })
             .remainingAccounts(remainingAccounts)
@@ -725,7 +1145,7 @@ export class NftStakingClient {
     async unstakeCnft(poolId, cnftParams, opts) {
         const pid = this.resolveProjectId(opts?.projectId);
         const pool = await this.getPoolData(pid, poolId);
-        const { nftAssetId, merkleTree, cnftRoot, cnftDataHash, cnftCreatorHash, cnftNonce, cnftIndex, proofNodes } = cnftParams;
+        const { nftAssetId, merkleTree, cnftRoot, cnftDataHash, cnftCreatorHash, cnftNonce, cnftIndex, proofNodes, } = cnftParams;
         const nftAssetIdPk = new PublicKey(nftAssetId);
         const merkleTreePk = new PublicKey(merkleTree);
         const [treeConfigPk] = getTreeConfigPda(merkleTreePk);
@@ -734,23 +1154,45 @@ export class NftStakingClient {
         const cnftDataHashArr = base58HashToArray(cnftDataHash);
         const cnftCreatorHashArr = base58HashToArray(cnftCreatorHash);
         const [poolPda] = getStakePoolPda(pid, poolId);
-        const [stakeEntry] = getStakeEntryPda(poolId, nftAssetIdPk);
+        const [stakeEntry] = getStakeEntryPda(pid, poolId, nftAssetIdPk);
+        const [stakeLock] = getNftStakeLockPda(nftAssetIdPk);
         const staker = this.provider.wallet.publicKey;
-        const [stakerAccount] = getStakerAccountPda(poolId, staker);
-        const [poolAuthority] = getPoolAuthorityPda(poolId);
-        const feeAccts = this.resolveFeeAccounts(opts?.fee);
+        const [stakerAccount] = getStakerAccountPda(pid, poolId, staker);
+        const [userProfile] = getUserProfilePda(staker);
+        const [poolAuthority] = getPoolAuthorityPda(pid, poolId);
         const rewardVaultPk = getAta(poolAuthority, rewardMintPk);
         const stakerRewardAccountPk = getAta(staker, rewardMintPk);
-        const remainingAccounts = proofNodes.map((node) => ({
-            pubkey: new PublicKey(node),
-            isSigner: false,
-            isWritable: false,
-        }));
+        // cNFT layout for remaining_accounts is
+        //   [<staker_secondary if has_secondary>, <proof nodes...>, <trailing
+        //    StakeEntry PDAs for claim-lock recompute>]
+        // The on-chain handler tail-walks for program-owned accounts to find
+        // stake entries.
+        const entry = await this.fetchStakeEntry(poolId, nftAssetIdPk, pid);
+        const hasSecondary = entry?.secondaryRateContributions?.some((r) => r > 0n) ?? false;
+        const remainingAccounts = [];
+        if (hasSecondary) {
+            const [stakerSecondary] = getStakerSecondaryRewardsPda(pid, poolId, staker);
+            remainingAccounts.push({ pubkey: stakerSecondary, isSigner: false, isWritable: true });
+        }
+        for (const node of proofNodes) {
+            remainingAccounts.push({
+                pubkey: new PublicKey(node),
+                isSigner: false,
+                isWritable: false,
+            });
+        }
+        const stakeEntryList = await this.resolveRemainingStakeEntries(poolId, pid, staker, stakeEntry, opts?.remainingStakeEntries);
+        if (stakeEntryList) {
+            for (const pk of stakeEntryList) {
+                remainingAccounts.push({ pubkey: pk, isSigner: false, isWritable: false });
+            }
+        }
         return this.program.methods
             .unstakeCnft(new BN(pid), new BN(poolId), nftAssetIdPk, cnftRootArr, cnftDataHashArr, cnftCreatorHashArr, new BN(cnftNonce), cnftIndex)
             .accountsStrict({
             pool: poolPda,
             stakeEntry,
+            stakeLock,
             stakerAccount,
             poolAuthority,
             treeConfig: treeConfigPk,
@@ -761,12 +1203,8 @@ export class NftStakingClient {
             rewardVault: rewardVaultPk,
             stakerRewardAccount: stakerRewardAccountPk,
             rewardMint: rewardMintPk,
-            feeConfig: feeAccts.feeConfig,
-            treasury: feeAccts.treasury,
-            referralAccount: feeAccts.referralAccount,
-            solUsdPriceFeed: feeAccts.solUsdPriceFeed,
-            adminProgram: feeAccts.adminProgram,
             staker,
+            userProfile,
             tokenProgram: TOKEN_PROGRAM_ID,
             associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
             systemProgram: SystemProgram.programId,
@@ -774,31 +1212,57 @@ export class NftStakingClient {
             .remainingAccounts(remainingAccounts)
             .instruction();
     }
-    /** Burn a permanently-locked legacy/pNFT. Auto-resolves stakingMode from pool. */
+    /**
+     * Burn a permanently-locked legacy/pNFT. Auto-resolves stakingMode from pool.
+     *
+     * Pass `opts.remainingStakeEntries` so the on-chain handler can recompute
+     * `claim_locked_until`. See `unstakeNft` for full semantics. Default: SDK
+     * auto-discovers remaining entries via gPA.
+     */
     async burnStakedNft(poolId, nftMint, opts) {
+        const _nftMint = toPk(nftMint);
         const pid = this.resolveProjectId(opts?.projectId);
         const pool = await this.getPoolData(pid, poolId);
         const stakingMode = pool.stakingMode;
-        const nftTokenProgram = await this.resolveTokenProgram(nftMint);
+        const nftTokenProgram = await this.resolveTokenProgram(_nftMint);
         const [poolPda] = getStakePoolPda(pid, poolId);
-        const [stakeEntry] = getStakeEntryPda(poolId, nftMint);
+        const [stakeEntry] = getStakeEntryPda(pid, poolId, _nftMint);
+        const [stakeLock] = getNftStakeLockPda(_nftMint);
         const staker = this.provider.wallet.publicKey;
-        const [stakerAccount] = getStakerAccountPda(poolId, staker);
-        const [poolAuthority] = getPoolAuthorityPda(poolId);
-        const feeAccts = this.resolveFeeAccounts(opts?.fee);
+        const [stakerAccount] = getStakerAccountPda(pid, poolId, staker);
+        const [userProfile] = getUserProfilePda(staker);
+        const [poolAuthority] = getPoolAuthorityPda(pid, poolId);
+        const feeAccts = await this.resolveFeeAccounts(pid, opts?.fee);
+        const [project] = getProjectPda(pid);
         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;
+        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;
+        // Assemble remaining_accounts (secondary slot first when applicable,
+        // then remaining StakeEntry PDAs).
+        const entry = await this.fetchStakeEntry(poolId, _nftMint, pid);
+        const hasSecondary = entry?.secondaryRateContributions?.some((r) => r > 0n) ?? false;
+        const remainingAccounts = [];
+        if (hasSecondary) {
+            const [stakerSecondary] = getStakerSecondaryRewardsPda(pid, poolId, staker);
+            remainingAccounts.push({ pubkey: stakerSecondary, isSigner: false, isWritable: true });
+        }
+        let stakeEntryList = await this.resolveRemainingStakeEntries(poolId, pid, staker, stakeEntry, opts?.remainingStakeEntries);
+        if (stakeEntryList) {
+            for (const pk of stakeEntryList) {
+                remainingAccounts.push({ pubkey: pk, isSigner: false, isWritable: false });
+            }
+        }
         return this.program.methods
-            .burnStakedNft(new BN(pid), new BN(poolId), nftMint)
+            .burnStakedNft(new BN(pid), new BN(poolId), _nftMint)
             .accountsStrict({
             pool: poolPda,
             stakeEntry,
+            stakeLock,
             stakerAccount,
             poolAuthority,
-            nftMint,
+            nftMint: _nftMint,
             escrowNftAccount,
             stakerNftAccount,
             nftMetadata,
@@ -808,45 +1272,72 @@ export class NftStakingClient {
             tokenRecord: null,
             collectionMetadata: null,
             feeConfig: feeAccts.feeConfig,
+            programRegistry: feeAccts.programRegistry,
             treasury: feeAccts.treasury,
             referralAccount: feeAccts.referralAccount,
             solUsdPriceFeed: feeAccts.solUsdPriceFeed,
             adminProgram: feeAccts.adminProgram,
+            project,
             staker,
+            userProfile,
             tokenProgram: nftTokenProgram,
             systemProgram: SystemProgram.programId,
         })
+            .remainingAccounts(remainingAccounts)
             .instruction();
     }
     /** Burn a permanently-locked Core NFT. Auto-resolves collection from pool. */
     async burnStakedCoreNft(poolId, nftAsset, opts) {
+        const _nftAsset = toPk(nftAsset);
         const pid = this.resolveProjectId(opts?.projectId);
         const pool = await this.getPoolData(pid, poolId);
         const collection = new PublicKey(pool.collectionMint);
         const [poolPda] = getStakePoolPda(pid, poolId);
-        const [stakeEntry] = getStakeEntryPda(poolId, nftAsset);
+        const [stakeEntry] = getStakeEntryPda(pid, poolId, _nftAsset);
+        const [stakeLock] = getNftStakeLockPda(_nftAsset);
         const staker = this.provider.wallet.publicKey;
-        const [stakerAccount] = getStakerAccountPda(poolId, staker);
-        const [poolAuthority] = getPoolAuthorityPda(poolId);
-        const feeAccts = this.resolveFeeAccounts(opts?.fee);
+        const [stakerAccount] = getStakerAccountPda(pid, poolId, staker);
+        const [userProfile] = getUserProfilePda(staker);
+        const [poolAuthority] = getPoolAuthorityPda(pid, poolId);
+        const feeAccts = await this.resolveFeeAccounts(pid, opts?.fee);
+        const [project] = getProjectPda(pid);
+        // Build remaining_accounts (secondary + stake entries).
+        const entry = await this.fetchStakeEntry(poolId, _nftAsset, pid);
+        const hasSecondary = entry?.secondaryRateContributions?.some((r) => r > 0n) ?? false;
+        const remainingAccounts = [];
+        if (hasSecondary) {
+            const [stakerSecondary] = getStakerSecondaryRewardsPda(pid, poolId, staker);
+            remainingAccounts.push({ pubkey: stakerSecondary, isSigner: false, isWritable: true });
+        }
+        const stakeEntryList = await this.resolveRemainingStakeEntries(poolId, pid, staker, stakeEntry, opts?.remainingStakeEntries);
+        if (stakeEntryList) {
+            for (const pk of stakeEntryList) {
+                remainingAccounts.push({ pubkey: pk, isSigner: false, isWritable: false });
+            }
+        }
         return this.program.methods
-            .burnStakedCoreNft(new BN(pid), new BN(poolId), nftAsset)
+            .burnStakedCoreNft(new BN(pid), new BN(poolId), _nftAsset)
             .accountsStrict({
             pool: poolPda,
             stakeEntry,
+            stakeLock,
             stakerAccount,
             poolAuthority,
-            nftAsset,
+            nftAsset: _nftAsset,
             collection,
             mplCoreProgram: MPL_CORE_PROGRAM_ID,
             feeConfig: feeAccts.feeConfig,
+            programRegistry: feeAccts.programRegistry,
             treasury: feeAccts.treasury,
             referralAccount: feeAccts.referralAccount,
             solUsdPriceFeed: feeAccts.solUsdPriceFeed,
             adminProgram: feeAccts.adminProgram,
+            project,
             staker,
+            userProfile,
             systemProgram: SystemProgram.programId,
         })
+            .remainingAccounts(remainingAccounts)
             .instruction();
     }
     /** Spend accrued points from a Points reward type pool. */
@@ -854,32 +1345,39 @@ export class NftStakingClient {
         const pid = this.resolveProjectId(opts?.projectId);
         const [poolPda] = getStakePoolPda(pid, poolId);
         const staker = this.provider.wallet.publicKey;
-        const [stakerAccount] = getStakerAccountPda(poolId, staker);
-        const feeAccts = this.resolveFeeAccounts(opts?.fee);
+        const [stakerAccount] = getStakerAccountPda(pid, poolId, staker);
+        const [userProfile] = getUserProfilePda(staker);
+        const feeAccts = await this.resolveFeeAccounts(pid, opts?.fee);
+        const [project] = getProjectPda(pid);
         return this.program.methods
-            .spendPoints(new BN(pid), new BN(poolId), amount)
+            .spendPoints(new BN(pid), new BN(poolId), toBN(amount))
             .accountsStrict({
             pool: poolPda,
             stakerAccount,
             feeConfig: feeAccts.feeConfig,
+            programRegistry: feeAccts.programRegistry,
             treasury: feeAccts.treasury,
             referralAccount: feeAccts.referralAccount,
             solUsdPriceFeed: feeAccts.solUsdPriceFeed,
             adminProgram: feeAccts.adminProgram,
+            project,
             staker,
+            userProfile,
             systemProgram: SystemProgram.programId,
         })
             .instruction();
     }
-    async fetchPoolSecondaryRewards(poolId) {
-        const [pda] = getPoolSecondaryRewardsPda(poolId);
+    async fetchPoolSecondaryRewards(poolId, projectId) {
+        const pid = this.resolveProjectId(projectId);
+        const [pda] = getPoolSecondaryRewardsPda(pid, 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);
+    async fetchStakerSecondaryRewards(poolId, wallet, projectId) {
+        const pid = this.resolveProjectId(projectId);
+        const [pda] = getStakerSecondaryRewardsPda(pid, poolId, toPk(wallet));
         const raw = await this.program.account.stakerSecondaryRewards.fetchNullable(pda);
         if (!raw)
             return null;
@@ -887,18 +1385,22 @@ export class NftStakingClient {
     }
     async addPoolSecondaryReward(poolId, rewardMint, baseRate, lockTierRates, projectId) {
         const pid = this.resolveProjectId(projectId);
+        const _rewardMint = toPk(rewardMint);
         const [poolPda] = getStakePoolPda(pid, poolId);
-        const [poolSecondary] = getPoolSecondaryRewardsPda(poolId);
-        const [poolAuthority] = getPoolAuthorityPda(poolId);
-        const tokenProgram = await this.resolveTokenProgram(rewardMint);
-        const vault = getAta(poolAuthority, rewardMint, tokenProgram);
+        const [project] = getProjectPda(pid);
+        const [poolSecondary] = getPoolSecondaryRewardsPda(pid, poolId);
+        const [poolAuthority] = getPoolAuthorityPda(pid, poolId);
+        const tokenProgram = await this.resolveTokenProgram(_rewardMint);
+        const vault = getAta(poolAuthority, _rewardMint, tokenProgram);
         return this.program.methods
-            .addPoolSecondaryReward(new BN(pid), new BN(poolId), baseRate, lockTierRates)
+            .addPoolSecondaryReward(new BN(pid), new BN(poolId), toBN(baseRate), lockTierRates.map(toBN))
             .accountsStrict({
             pool: poolPda,
+            project,
+            projectManagementProgram: PROJECT_MANAGEMENT_PROGRAM_ID,
             poolSecondary,
             poolAuthority,
-            secondaryRewardMint: rewardMint,
+            secondaryRewardMint: _rewardMint,
             secondaryVault: vault,
             authority: this.provider.wallet.publicKey,
             tokenProgram,
@@ -910,11 +1412,14 @@ export class NftStakingClient {
     async removePoolSecondaryReward(poolId, rewardIndex, projectId) {
         const pid = this.resolveProjectId(projectId);
         const [poolPda] = getStakePoolPda(pid, poolId);
-        const [poolSecondary] = getPoolSecondaryRewardsPda(poolId);
+        const [project] = getProjectPda(pid);
+        const [poolSecondary] = getPoolSecondaryRewardsPda(pid, poolId);
         return this.program.methods
             .removePoolSecondaryReward(new BN(pid), new BN(poolId), rewardIndex)
             .accountsStrict({
             pool: poolPda,
+            project,
+            projectManagementProgram: PROJECT_MANAGEMENT_PROGRAM_ID,
             poolSecondary,
             authority: this.provider.wallet.publicKey,
         })
@@ -922,21 +1427,24 @@ export class NftStakingClient {
     }
     async fundSecondaryVault(poolId, rewardIndex, amount, rewardMint, opts) {
         const pid = this.resolveProjectId(opts?.projectId);
-        const tokenProgram = await this.resolveTokenProgram(rewardMint);
+        const _rewardMint = toPk(rewardMint);
+        const tokenProgram = await this.resolveTokenProgram(_rewardMint);
         const [poolPda] = getStakePoolPda(pid, poolId);
-        const [poolSecondary] = getPoolSecondaryRewardsPda(poolId);
-        const [poolAuthority] = getPoolAuthorityPda(poolId);
-        const vault = getAta(poolAuthority, rewardMint, tokenProgram);
-        const funderAta = opts?.funderTokenAccount ?? getAta(this.provider.wallet.publicKey, rewardMint, tokenProgram);
+        const [poolSecondary] = getPoolSecondaryRewardsPda(pid, poolId);
+        const [poolAuthority] = getPoolAuthorityPda(pid, poolId);
+        const vault = getAta(poolAuthority, _rewardMint, tokenProgram);
+        const funderAta = opts?.funderTokenAccount
+            ? toPk(opts.funderTokenAccount)
+            : getAta(this.provider.wallet.publicKey, _rewardMint, tokenProgram);
         return this.program.methods
-            .fundSecondaryVault(new BN(pid), new BN(poolId), rewardIndex, amount)
+            .fundSecondaryVault(new BN(pid), new BN(poolId), rewardIndex, toBN(amount))
             .accountsStrict({
             pool: poolPda,
             poolSecondary,
             poolAuthority,
             secondaryVault: vault,
             funderTokenAccount: funderAta,
-            secondaryRewardMint: rewardMint,
+            secondaryRewardMint: _rewardMint,
             authority: this.provider.wallet.publicKey,
             tokenProgram,
         })
@@ -944,21 +1452,27 @@ export class NftStakingClient {
     }
     async withdrawSecondaryVault(poolId, rewardIndex, amount, rewardMint, opts) {
         const pid = this.resolveProjectId(opts?.projectId);
-        const tokenProgram = await this.resolveTokenProgram(rewardMint);
+        const _rewardMint = toPk(rewardMint);
+        const tokenProgram = await this.resolveTokenProgram(_rewardMint);
         const [poolPda] = getStakePoolPda(pid, poolId);
-        const [poolSecondary] = getPoolSecondaryRewardsPda(poolId);
-        const [poolAuthority] = getPoolAuthorityPda(poolId);
-        const vault = getAta(poolAuthority, rewardMint, tokenProgram);
-        const destAta = opts?.destinationTokenAccount ?? getAta(this.provider.wallet.publicKey, rewardMint, tokenProgram);
+        const [project] = getProjectPda(pid);
+        const [poolSecondary] = getPoolSecondaryRewardsPda(pid, poolId);
+        const [poolAuthority] = getPoolAuthorityPda(pid, poolId);
+        const vault = getAta(poolAuthority, _rewardMint, tokenProgram);
+        const destAta = opts?.destinationTokenAccount
+            ? toPk(opts.destinationTokenAccount)
+            : getAta(this.provider.wallet.publicKey, _rewardMint, tokenProgram);
         return this.program.methods
-            .withdrawSecondaryVault(new BN(pid), new BN(poolId), rewardIndex, amount)
+            .withdrawSecondaryVault(new BN(pid), new BN(poolId), rewardIndex, toBN(amount))
             .accountsStrict({
             pool: poolPda,
+            project,
+            projectManagementProgram: PROJECT_MANAGEMENT_PROGRAM_ID,
             poolSecondary,
             poolAuthority,
             secondaryVault: vault,
             destinationTokenAccount: destAta,
-            secondaryRewardMint: rewardMint,
+            secondaryRewardMint: _rewardMint,
             authority: this.provider.wallet.publicKey,
             tokenProgram,
         })
@@ -967,9 +1481,9 @@ export class NftStakingClient {
     async initStakerSecondary(poolId, projectId) {
         const pid = this.resolveProjectId(projectId);
         const [poolPda] = getStakePoolPda(pid, poolId);
-        const [poolSecondary] = getPoolSecondaryRewardsPda(poolId);
+        const [poolSecondary] = getPoolSecondaryRewardsPda(pid, poolId);
         const staker = this.provider.wallet.publicKey;
-        const [stakerSecondary] = getStakerSecondaryRewardsPda(poolId, staker);
+        const [stakerSecondary] = getStakerSecondaryRewardsPda(pid, poolId, staker);
         return this.program.methods
             .initStakerSecondary(new BN(pid), new BN(poolId))
             .accountsStrict({
@@ -984,18 +1498,26 @@ export class NftStakingClient {
     async claimSecondaryRewards(poolId, secondaryRewards, opts) {
         const pid = this.resolveProjectId(opts?.projectId);
         const [poolPda] = getStakePoolPda(pid, poolId);
-        const [poolSecondary] = getPoolSecondaryRewardsPda(poolId);
+        const [poolSecondary] = getPoolSecondaryRewardsPda(pid, 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(opts?.fee);
+        const [stakerAccount] = getStakerAccountPda(pid, poolId, staker);
+        const [stakerSecondary] = getStakerSecondaryRewardsPda(pid, poolId, staker);
+        const [userProfile] = getUserProfilePda(staker);
+        const [poolAuthority] = getPoolAuthorityPda(pid, poolId);
+        const feeAccts = await this.resolveFeeAccounts(pid, opts?.fee);
+        const [project] = getProjectPda(pid);
         const remainingAccounts = [];
+        let sharedTokenProgram = null;
         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 });
+            const _srMint = toPk(sr.mint);
+            const tokenProgram = await this.resolveTokenProgram(_srMint);
+            if (sharedTokenProgram && !sharedTokenProgram.equals(tokenProgram)) {
+                throw new Error("claimSecondaryRewards requires all secondary mints in one transaction to use the same token program");
+            }
+            sharedTokenProgram = tokenProgram;
+            const vault = getAta(poolAuthority, _srMint, tokenProgram);
+            const stakerAta = getAta(staker, _srMint, tokenProgram);
+            remainingAccounts.push({ pubkey: vault, isSigner: false, isWritable: true }, { pubkey: stakerAta, isSigner: false, isWritable: true }, { pubkey: _srMint, isSigner: false, isWritable: false });
         }
         return this.program.methods
             .claimSecondaryRewards(new BN(pid), new BN(poolId))
@@ -1006,17 +1528,36 @@ export class NftStakingClient {
             stakerSecondary,
             poolAuthority,
             feeConfig: feeAccts.feeConfig,
+            programRegistry: feeAccts.programRegistry,
             treasury: feeAccts.treasury,
             referralAccount: feeAccts.referralAccount,
             solUsdPriceFeed: feeAccts.solUsdPriceFeed,
             adminProgram: feeAccts.adminProgram,
+            project,
             staker,
-            tokenProgram: TOKEN_PROGRAM_ID,
+            userProfile,
+            tokenProgram: sharedTokenProgram ?? TOKEN_PROGRAM_ID,
             associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
             systemProgram: SystemProgram.programId,
         })
             .remainingAccounts(remainingAccounts)
             .instruction();
     }
+    async updatePoolSecondaryReward(poolId, rewardIndex, baseRate, lockTierRates, projectId) {
+        const pid = this.resolveProjectId(projectId);
+        const [poolPda] = getStakePoolPda(pid, poolId);
+        const [project] = getProjectPda(pid);
+        const [poolSecondary] = getPoolSecondaryRewardsPda(pid, poolId);
+        return this.program.methods
+            .updatePoolSecondaryReward(new BN(pid), new BN(poolId), rewardIndex, toBN(baseRate), lockTierRates.map(toBN))
+            .accountsStrict({
+            pool: poolPda,
+            project,
+            projectManagementProgram: PROJECT_MANAGEMENT_PROGRAM_ID,
+            poolSecondary,
+            authority: this.provider.wallet.publicKey,
+        })
+            .instruction();
+    }
 }
 //# sourceMappingURL=client.js.map