@soltracer/nft-staking 0.1.0 → 0.2.1

package/dist/client.js

@@ -1,6 +1,6 @@
 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 { getStakeConfigPda, getStakePoolPda, getStakeEntryPda, getStakerAccountPda, getCollectionPda, getPoolAuthorityPda, getPoolSecondaryRewardsPda, getStakerSecondaryRewardsPda, getProjectPda, getUtilityConfigPda, getProgramRegistryPda, 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");
@@ -32,22 +32,70 @@ 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;
+}
 export class NftStakingClient {
     program;
     provider;
     tokenProgramCache = new Map();
     mintDecimalsCache = new Map();
-    constructor(program, provider) {
+    poolCache = new Map();
+    static POOL_CACHE_TTL = 30_000; // 30s
+    /** Project ID bound to this client. Set via `create()` options or `setProjectId()`. */
+    projectId;
+    constructor(program, provider, projectId) {
         this.program = program;
         this.provider = provider;
+        this.projectId = projectId;
     }
-    static create(provider) {
+    static create(provider, opts) {
         const program = new Program(NftStakingIDL, provider);
-        return new NftStakingClient(program, provider);
+        return new NftStakingClient(program, provider, opts?.projectId);
     }
-    static fromIdl(idl, provider) {
+    static fromIdl(idl, provider, opts) {
         const program = new Program(idl, provider);
-        return new NftStakingClient(program, provider);
+        return new NftStakingClient(program, provider, opts?.projectId);
+    }
+    /** Set the project ID for this client instance. Returns `this` for chaining. */
+    setProjectId(projectId) {
+        this.projectId = projectId;
+        return this;
+    }
+    /** Resolve projectId: use explicit param if given, else fall back to instance-level. Throws if neither is set. */
+    resolveProjectId(projectId) {
+        const pid = projectId ?? this.projectId;
+        if (pid === undefined)
+            throw new Error("projectId required: pass it explicitly or set via create()/setProjectId()");
+        return pid;
+    }
+    /** Fetch pool data with caching. Used internally to auto-resolve rewardMint, stakingMode, collectionMint. */
+    async getPoolData(projectId, poolId) {
+        const key = `${projectId}-${poolId}`;
+        const cached = this.poolCache.get(key);
+        if (cached && Date.now() - cached.fetchedAt < NftStakingClient.POOL_CACHE_TTL) {
+            return cached.data;
+        }
+        const pool = await this.fetchStakePool(projectId, poolId);
+        if (!pool)
+            throw new Error(`Pool ${poolId} not found for project ${projectId}`);
+        this.poolCache.set(key, { data: pool, fetchedAt: Date.now() });
+        return pool;
+    }
+    /** Invalidate cached pool data (call after pool mutations). */
+    invalidatePoolCache(poolId) {
+        if (poolId !== undefined) {
+            for (const key of this.poolCache.keys()) {
+                if (key.endsWith(`-${poolId}`))
+                    this.poolCache.delete(key);
+            }
+        }
+        else {
+            this.poolCache.clear();
+        }
     }
     /** Detect whether a mint is Token-2022 or SPL Token (cached). */
     async resolveTokenProgram(mint) {
@@ -94,6 +142,7 @@ export class NftStakingClient {
     resolveFeeAccounts(fee) {
         const programId = this.program.programId;
         const [feeConfig] = getFeeConfigPda(programId);
+        const [programRegistry] = getProgramRegistryPda(programId);
         const [treasury] = getTreasuryPda();
         let referralAccount = ADMIN_PROGRAM_ID;
         if (fee?.referralAccount) {
@@ -105,6 +154,7 @@ export class NftStakingClient {
         }
         return {
             feeConfig,
+            programRegistry,
             treasury,
             referralAccount,
             solUsdPriceFeed: NftStakingClient.PYTH_SOL_USD_FEED,
@@ -112,14 +162,16 @@ export class NftStakingClient {
         };
     }
     async fetchStakeConfig(projectId) {
-        const [pda] = getStakeConfigPda(projectId);
+        const pid = this.resolveProjectId(projectId);
+        const [pda] = getStakeConfigPda(pid);
         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 pid = this.resolveProjectId(projectId);
+        const [pda] = getStakePoolPda(pid, poolId);
         const raw = await this.program.account.stakePool.fetchNullable(pda);
         if (!raw)
             return null;
@@ -128,14 +180,14 @@ export class NftStakingClient {
         return this.applyPoolDecimals(pool, decimals);
     }
     async fetchStakeEntry(poolId, nftMint) {
-        const [pda] = getStakeEntryPda(poolId, nftMint);
+        const [pda] = getStakeEntryPda(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);
+        const [pda] = getStakerAccountPda(poolId, toPk(wallet));
         const raw = await this.program.account.stakerAccount.fetchNullable(pda);
         if (!raw)
             return null;
@@ -153,12 +205,13 @@ export class NftStakingClient {
     }
     /** Fetch all stake pools for a project by scanning pool IDs 0..totalPools-1. */
     async fetchAllPools(projectId) {
-        const config = await this.fetchStakeConfig(projectId);
+        const pid = this.resolveProjectId(projectId);
+        const config = await this.fetchStakeConfig(pid);
         if (!config)
             return [];
         const pools = [];
         for (let i = 0; i < config.totalPools; i++) {
-            const pool = await this.fetchStakePool(projectId, i);
+            const pool = await this.fetchStakePool(pid, i);
             if (pool)
                 pools.push(pool);
         }
@@ -166,8 +219,9 @@ export class NftStakingClient {
     }
     /** Fetch all active stake entries for a wallet in a specific pool via gPA. */
     async fetchStakeEntriesByOwner(_poolId, owner) {
+        const _owner = toPk(owner);
         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))
@@ -180,7 +234,7 @@ export class NftStakingClient {
     async fetchStakeEntriesForMints(poolId, nftMints) {
         if (nftMints.length === 0)
             return [];
-        const pdas = nftMints.map((mint) => getStakeEntryPda(poolId, mint)[0]);
+        const pdas = nftMints.map((mint) => getStakeEntryPda(poolId, toPk(mint))[0]);
         const accounts = await this.program.account.stakeEntry.fetchMultiple(pdas);
         return accounts
             .filter((a) => a !== null)
@@ -188,8 +242,9 @@ export class NftStakingClient {
             .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);
+    async fetchAllStakeEntriesByPool(poolId, projectId) {
+        const pid = this.resolveProjectId(projectId);
+        const [poolPda] = getStakePoolPda(pid, poolId);
         const entries = await this.program.account.stakeEntry.all([
             { memcmp: { offset: 8, bytes: poolPda.toBase58() } },
         ]);
@@ -215,18 +270,21 @@ export class NftStakingClient {
             .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);
+    async fetchAllStakersByPool(poolId, projectId) {
+        const pid = this.resolveProjectId(projectId);
+        const [poolPda] = getStakePoolPda(pid, 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);
+    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), _collMint.toBuffer()], this.program.programId);
+        const [project] = getProjectPda(pid);
         return this.program.methods
-            .closeLegacyCollection(new BN(projectId), collectionMint)
+            .closeLegacyCollection(new BN(pid), _collMint)
             .accountsStrict({
             collection,
             authority: this.provider.wallet.publicKey,
@@ -236,10 +294,11 @@ export class NftStakingClient {
             .instruction();
     }
     async initializeStakeConfig(projectId) {
-        const [config] = getStakeConfigPda(projectId);
-        const [project] = getProjectPda(projectId);
+        const pid = this.resolveProjectId(projectId);
+        const [config] = getStakeConfigPda(pid);
+        const [project] = getProjectPda(pid);
         return this.program.methods
-            .initializeStakeConfig(new BN(projectId))
+            .initializeStakeConfig(new BN(pid))
             .accountsStrict({
             config,
             authority: this.provider.wallet.publicKey,
@@ -249,15 +308,20 @@ export class NftStakingClient {
         })
             .instruction();
     }
-    async createStakePool(projectId, stakingMode, rewardConfig, lockConfigs, collectionMint, rewardEndAt = 0, maxStaked = 0) {
-        const config = await this.fetchStakeConfig(projectId);
+    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 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,
@@ -268,21 +332,23 @@ export class NftStakingClient {
             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 [configPda] = getStakeConfigPda(pid);
+        const [poolPda] = getStakePoolPda(pid, nextPoolId);
+        const [collectionConfigPda] = getCollectionPda(pid, _collMint);
         const [poolAuthority] = getPoolAuthorityPda(nextPoolId);
-        const rewardVault = getAta(poolAuthority, rewardConfig.rewardMint, tokenProgram);
+        const rewardVault = getAta(poolAuthority, _rewardMint, tokenProgram);
+        const [utilityConfig] = getUtilityConfigPda(pid, this.program.programId);
         return this.program.methods
-            .createStakePool(new BN(projectId), stakingMode, rawRewardConfig, rawLockConfigs, new BN(rewardEndAt), new BN(maxStaked))
+            .createStakePool(new BN(pid), stakingMode, rawRewardConfig, rawLockConfigs, new BN(rewardEndAt), new BN(maxStaked))
             .accountsStrict({
             config: configPda,
             pool: poolPda,
             collectionConfig: collectionConfigPda,
             poolAuthority,
-            collectionMint,
-            rewardMint: rewardConfig.rewardMint,
+            collectionMint: _collMint,
+            rewardMint: _rewardMint,
             rewardVault,
+            utilityConfig,
             projectManagementProgram: PROJECT_MANAGEMENT_PROGRAM_ID,
             authority: this.provider.wallet.publicKey,
             tokenProgram,
@@ -291,15 +357,26 @@ export class NftStakingClient {
         })
             .instruction();
     }
-    async updateStakePool(projectId, poolId, rewardConfig, lockConfigs, isActive, traitAuthority = null, canBurn = null, merkleRoot = null, gateType = null, rewardEndAt = null, maxStaked = null) {
+    async updateStakePool(poolId, updates = {}) {
+        const pid = this.resolveProjectId(updates.projectId);
+        const rewardConfig = updates.rewardConfig ?? null;
+        const lockConfigs = updates.lockConfigs ?? null;
+        const isActive = updates.isActive ?? 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;
         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,
@@ -307,7 +384,7 @@ export class NftStakingClient {
             };
         }
         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),
@@ -316,7 +393,7 @@ export class NftStakingClient {
             }));
         }
         else if (lockConfigs) {
-            const pool = await this.fetchStakePool(projectId, poolId);
+            const pool = await this.fetchStakePool(pid, poolId);
             const decimals = pool ? pool.rewardDecimals : 0;
             const multiplier = 10 ** decimals;
             rawLockConfigs = lockConfigs.map((lc) => ({
@@ -325,23 +402,27 @@ export class NftStakingClient {
                 earlyUnstakePenaltyBps: lc.earlyUnstakePenaltyBps,
             }));
         }
-        const [poolPda] = getStakePoolPda(projectId, poolId);
+        const [poolPda] = getStakePoolPda(pid, poolId);
         return this.program.methods
-            .updateStakePool(new BN(projectId), 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)
             .accountsStrict({
             pool: poolPda,
             authority: this.provider.wallet.publicKey,
         })
             .instruction();
     }
-    async fundRewardVault(projectId, poolId, amount, rewardMint, funderTokenAccount) {
+    /** Fund the primary reward vault. Auto-resolves rewardMint from pool if not provided. */
+    async fundRewardVault(poolId, amount, opts) {
+        const pid = this.resolveProjectId(opts?.projectId);
+        const pool = await this.getPoolData(pid, poolId);
+        const rewardMint = opts?.rewardMint ? toPk(opts.rewardMint) : new PublicKey(pool.rewardConfig.rewardMint);
         const tokenProgram = await this.resolveTokenProgram(rewardMint);
-        const [poolPda] = getStakePoolPda(projectId, poolId);
+        const [poolPda] = getStakePoolPda(pid, poolId);
         const [poolAuthority] = getPoolAuthorityPda(poolId);
         const rewardVault = getAta(poolAuthority, rewardMint, tokenProgram);
-        const funderAta = 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(projectId), new BN(poolId), amount)
+            .fundRewardVault(new BN(pid), new BN(poolId), toBN(amount))
             .accountsStrict({
             pool: poolPda,
             poolAuthority,
@@ -353,14 +434,18 @@ export class NftStakingClient {
         })
             .instruction();
     }
-    async withdrawRewardVault(projectId, poolId, amount, rewardMint, destinationTokenAccount) {
+    /** Withdraw from the primary reward vault. Auto-resolves rewardMint from pool if not provided. */
+    async withdrawRewardVault(poolId, amount, opts) {
+        const pid = this.resolveProjectId(opts?.projectId);
+        const pool = await this.getPoolData(pid, poolId);
+        const rewardMint = opts?.rewardMint ? toPk(opts.rewardMint) : new PublicKey(pool.rewardConfig.rewardMint);
         const tokenProgram = await this.resolveTokenProgram(rewardMint);
-        const [poolPda] = getStakePoolPda(projectId, poolId);
+        const [poolPda] = getStakePoolPda(pid, poolId);
         const [poolAuthority] = getPoolAuthorityPda(poolId);
         const rewardVault = getAta(poolAuthority, rewardMint, tokenProgram);
-        const destAta = 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(projectId), new BN(poolId), amount)
+            .withdrawRewardVault(new BN(pid), new BN(poolId), toBN(amount))
             .accountsStrict({
             pool: poolPda,
             poolAuthority,
@@ -372,50 +457,67 @@ export class NftStakingClient {
         })
             .instruction();
     }
-    async closeStakePool(projectId, poolId) {
-        const [poolPda] = getStakePoolPda(projectId, poolId);
+    async closeStakePool(poolId, projectId) {
+        const pid = this.resolveProjectId(projectId);
+        const [poolPda] = getStakePoolPda(pid, poolId);
         return this.program.methods
-            .closeStakePool(new BN(projectId), new BN(poolId))
+            .closeStakePool(new BN(pid), new BN(poolId))
             .accountsStrict({
             pool: poolPda,
+            rewardVault: null,
+            tokenProgram: null,
             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);
+    /** 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 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 nftTokenProgram = await this.resolveTokenProgram(_nftMint);
+        const stakerNftAccount = getAta(staker, _nftMint, nftTokenProgram);
         const isEscrow = stakingMode !== 1;
         const escrowNftAccount = isEscrow
-            ? getAta(poolAuthority, nftMint, nftTokenProgram)
+            ? getAta(poolAuthority, _nftMint, nftTokenProgram)
             : null;
-        const nftMetadata = getMetadataPda(nftMint);
-        const nftEdition = getEditionPda(nftMint);
-        const feeAccts = this.resolveFeeAccounts(fee);
+        const nftMetadata = getMetadataPda(_nftMint);
+        const nftEdition = getEditionPda(_nftMint);
+        const feeAccts = this.resolveFeeAccounts(opts?.fee);
+        const [project] = getProjectPda(pid);
+        const [utilityConfig] = getUtilityConfigPda(pid, this.program.programId);
         return this.program.methods
-            .stakeNft(new BN(projectId), new BN(poolId), nftMint, lockTierIndex, gateProof)
+            .stakeNft(new BN(pid), new BN(poolId), _nftMint, lockTierIndex, gateProof)
             .accountsStrict({
             pool: poolPda,
             stakeEntry,
             stakerAccount,
             poolAuthority,
-            nftMint,
+            nftMint: _nftMint,
             stakerNftAccount,
             escrowNftAccount,
             nftMetadata,
             nftEdition,
             mplTokenMetadataProgram: TOKEN_METADATA_PROGRAM_ID,
             sysvarInstructions: SYSVAR_INSTRUCTIONS_ID,
+            tokenRecord: null,
+            destinationTokenRecord: null,
+            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,
@@ -423,32 +525,37 @@ export class NftStakingClient {
         })
             .instruction();
     }
-    async unstakeNft(projectId, poolId, nftMint, rewardMint, stakingMode, fee) {
+    /** Unstake a legacy/pNFT. Auto-resolves rewardMint and stakingMode from pool. */
+    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 [poolPda] = getStakePoolPda(projectId, poolId);
-        const [stakeEntry] = getStakeEntryPda(poolId, nftMint);
+        const nftTokenProgram = await this.resolveTokenProgram(_nftMint);
+        const [poolPda] = getStakePoolPda(pid, 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 stakerNftAccount = getAta(staker, _nftMint, nftTokenProgram);
         const isEscrow = stakingMode !== 1;
         const escrowNftAccount = isEscrow
-            ? getAta(poolAuthority, nftMint, nftTokenProgram)
+            ? 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);
+        const nftMetadata = getMetadataPda(_nftMint);
+        const nftEdition = getEditionPda(_nftMint);
         return this.program.methods
-            .unstakeNft(new BN(projectId), new BN(poolId), nftMint)
+            .unstakeNft(new BN(pid), new BN(poolId), _nftMint)
             .accountsStrict({
             pool: poolPda,
             stakeEntry,
             stakerAccount,
             poolAuthority,
-            nftMint,
+            nftMint: _nftMint,
             stakerNftAccount,
             escrowNftAccount,
             rewardVault,
@@ -458,11 +565,8 @@ export class NftStakingClient {
             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,
+            tokenRecord: null,
+            destinationTokenRecord: null,
             staker,
             tokenProgram: nftTokenProgram,
             rewardTokenProgram,
@@ -471,18 +575,24 @@ export class NftStakingClient {
         })
             .instruction();
     }
-    async claimRewards(projectId, poolId, rewardMint, traitBonusRate = null, fee) {
+    /** Claim accrued rewards. Auto-resolves rewardMint from pool. */
+    async claimRewards(poolId, opts) {
+        const pid = this.resolveProjectId(opts?.projectId);
+        const pool = await this.getPoolData(pid, poolId);
+        const rewardMint = new PublicKey(pool.rewardConfig.rewardMint);
+        const traitBonusRate = opts?.traitBonusRate ?? null;
         const tokenProgram = await this.resolveTokenProgram(rewardMint);
-        const [poolPda] = getStakePoolPda(projectId, poolId);
+        const [poolPda] = getStakePoolPda(pid, 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);
+        const [stakeConfig] = getStakeConfigPda(pid);
+        const feeAccts = this.resolveFeeAccounts(opts?.fee);
+        const [project] = getProjectPda(pid);
         return this.program.methods
-            .claimRewards(new BN(projectId), new BN(poolId), traitBonusRate)
+            .claimRewards(new BN(pid), new BN(poolId), traitBonusRate)
             .accountsStrict({
             pool: poolPda,
             stakerAccount,
@@ -493,10 +603,12 @@ 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,
             tokenProgram,
             associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
@@ -504,61 +616,73 @@ export class NftStakingClient {
         })
             .instruction();
     }
-    async stakeCoreNft(projectId, poolId, nftAsset, collection, lockTierIndex, fee, gateProof = []) {
-        const [poolPda] = getStakePoolPda(projectId, poolId);
-        const [stakeEntry] = getStakeEntryPda(poolId, nftAsset);
+    /** 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 staker = this.provider.wallet.publicKey;
         const [stakerAccount] = getStakerAccountPda(poolId, staker);
         const [poolAuthority] = getPoolAuthorityPda(poolId);
-        const feeAccts = this.resolveFeeAccounts(fee);
+        const feeAccts = this.resolveFeeAccounts(opts?.fee);
+        const [project] = getProjectPda(pid);
+        const [utilityConfig] = getUtilityConfigPda(pid, this.program.programId);
         return this.program.methods
-            .stakeCoreNft(new BN(projectId), new BN(poolId), nftAsset, lockTierIndex, gateProof)
+            .stakeCoreNft(new BN(pid), new BN(poolId), _nftAsset, lockTierIndex, gateProof)
             .accountsStrict({
             pool: poolPda,
             stakeEntry,
             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,
             systemProgram: SystemProgram.programId,
         })
             .instruction();
     }
-    async unstakeCoreNft(projectId, poolId, nftAsset, collection, rewardMint, fee) {
+    /** 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(projectId, poolId);
-        const [stakeEntry] = getStakeEntryPda(poolId, nftAsset);
+        const [poolPda] = getStakePoolPda(pid, 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)
+            .unstakeCoreNft(new BN(pid), new BN(poolId), _nftAsset)
             .accountsStrict({
             pool: poolPda,
             stakeEntry,
             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,
             rewardTokenProgram,
             associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
@@ -567,26 +691,31 @@ export class NftStakingClient {
             .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 = []) {
+    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 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 [poolPda] = getStakePoolPda(pid, 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 feeAccts = this.resolveFeeAccounts(opts?.fee);
+        const [project] = getProjectPda(pid);
+        const [utilityConfig] = getUtilityConfigPda(pid, this.program.programId);
         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)
+            .stakeCnft(new BN(pid), new BN(poolId), nftAssetIdPk, cnftRootArr, cnftDataHashArr, cnftCreatorHashArr, new BN(cnftNonce), cnftIndex, gateProof)
             .accountsStrict({
             pool: poolPda,
             stakeEntry,
@@ -597,32 +726,37 @@ export class NftStakingClient {
             logWrapper: SPL_NOOP_PROGRAM_ID,
             compressionProgram: SPL_ACCOUNT_COMPRESSION_PROGRAM_ID,
             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,
             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) {
+    /** Unstake a compressed NFT (cNFT). Auto-resolves rewardMint from pool. */
+    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 nftAssetIdPk = new PublicKey(nftAssetId);
         const merkleTreePk = new PublicKey(merkleTree);
         const [treeConfigPk] = getTreeConfigPda(merkleTreePk);
-        const rewardMintPk = new PublicKey(rewardMint);
+        const rewardMintPk = new PublicKey(pool.rewardConfig.rewardMint);
         const cnftRootArr = base58HashToArray(cnftRoot);
         const cnftDataHashArr = base58HashToArray(cnftDataHash);
         const cnftCreatorHashArr = base58HashToArray(cnftCreatorHash);
-        const [poolPda] = getStakePoolPda(projectId, poolId);
+        const [poolPda] = getStakePoolPda(pid, 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) => ({
@@ -631,7 +765,7 @@ export class NftStakingClient {
             isWritable: false,
         }));
         return this.program.methods
-            .unstakeCnft(new BN(projectId), new BN(poolId), nftAssetIdPk, cnftRootArr, cnftDataHashArr, cnftCreatorHashArr, new BN(cnftNonce), cnftIndex)
+            .unstakeCnft(new BN(pid), new BN(poolId), nftAssetIdPk, cnftRootArr, cnftDataHashArr, cnftCreatorHashArr, new BN(cnftNonce), cnftIndex)
             .accountsStrict({
             pool: poolPda,
             stakeEntry,
@@ -645,11 +779,6 @@ 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,
             tokenProgram: TOKEN_PROGRAM_ID,
             associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
@@ -658,90 +787,109 @@ export class NftStakingClient {
             .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);
+    /** Burn a permanently-locked legacy/pNFT. Auto-resolves stakingMode from pool. */
+    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 [poolPda] = getStakePoolPda(pid, 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 feeAccts = this.resolveFeeAccounts(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;
         return this.program.methods
-            .burnStakedNft(new BN(projectId), new BN(poolId), nftMint)
+            .burnStakedNft(new BN(pid), new BN(poolId), _nftMint)
             .accountsStrict({
             pool: poolPda,
             stakeEntry,
             stakerAccount,
             poolAuthority,
-            nftMint,
+            nftMint: _nftMint,
             escrowNftAccount,
             stakerNftAccount,
             nftMetadata,
             nftEdition,
             mplTokenMetadataProgram: isWalletLock ? TOKEN_METADATA_PROGRAM_ID : null,
             sysvarInstructions: isWalletLock ? SYSVAR_INSTRUCTIONS_ID : null,
+            tokenRecord: null,
+            collectionMetadata: null,
             feeConfig: feeAccts.feeConfig,
+            programRegistry: feeAccts.programRegistry,
             treasury: feeAccts.treasury,
             referralAccount: feeAccts.referralAccount,
             solUsdPriceFeed: feeAccts.solUsdPriceFeed,
             adminProgram: feeAccts.adminProgram,
+            project,
             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);
+    /** 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 staker = this.provider.wallet.publicKey;
         const [stakerAccount] = getStakerAccountPda(poolId, staker);
         const [poolAuthority] = getPoolAuthorityPda(poolId);
-        const feeAccts = this.resolveFeeAccounts(fee);
+        const feeAccts = this.resolveFeeAccounts(opts?.fee);
+        const [project] = getProjectPda(pid);
         return this.program.methods
-            .burnStakedCoreNft(new BN(projectId), new BN(poolId), nftAsset)
+            .burnStakedCoreNft(new BN(pid), new BN(poolId), _nftAsset)
             .accountsStrict({
             pool: poolPda,
             stakeEntry,
             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,
             systemProgram: SystemProgram.programId,
         })
             .instruction();
     }
     /** Spend accrued points from a Points reward type pool. */
-    async spendPoints(projectId, poolId, amount, fee) {
-        const [poolPda] = getStakePoolPda(projectId, poolId);
+    async spendPoints(poolId, amount, opts) {
+        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(fee);
+        const feeAccts = this.resolveFeeAccounts(opts?.fee);
+        const [project] = getProjectPda(pid);
         return this.program.methods
-            .spendPoints(new BN(projectId), 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,
             systemProgram: SystemProgram.programId,
         })
@@ -755,25 +903,27 @@ export class NftStakingClient {
         return decodeAccount(raw);
     }
     async fetchStakerSecondaryRewards(poolId, wallet) {
-        const [pda] = getStakerSecondaryRewardsPda(poolId, wallet);
+        const [pda] = getStakerSecondaryRewardsPda(poolId, toPk(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);
+    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 tokenProgram = await this.resolveTokenProgram(_rewardMint);
+        const vault = getAta(poolAuthority, _rewardMint, tokenProgram);
         return this.program.methods
-            .addPoolSecondaryReward(new BN(projectId), new BN(poolId), baseRate, lockTierRates)
+            .addPoolSecondaryReward(new BN(pid), new BN(poolId), toBN(baseRate), lockTierRates.map(toBN))
             .accountsStrict({
             pool: poolPda,
             poolSecondary,
             poolAuthority,
-            secondaryRewardMint: rewardMint,
+            secondaryRewardMint: _rewardMint,
             secondaryVault: vault,
             authority: this.provider.wallet.publicKey,
             tokenProgram,
@@ -782,11 +932,12 @@ export class NftStakingClient {
         })
             .instruction();
     }
-    async removePoolSecondaryReward(projectId, poolId, rewardIndex) {
-        const [poolPda] = getStakePoolPda(projectId, poolId);
+    async removePoolSecondaryReward(poolId, rewardIndex, projectId) {
+        const pid = this.resolveProjectId(projectId);
+        const [poolPda] = getStakePoolPda(pid, poolId);
         const [poolSecondary] = getPoolSecondaryRewardsPda(poolId);
         return this.program.methods
-            .removePoolSecondaryReward(new BN(projectId), new BN(poolId), rewardIndex)
+            .removePoolSecondaryReward(new BN(pid), new BN(poolId), rewardIndex)
             .accountsStrict({
             pool: poolPda,
             poolSecondary,
@@ -794,55 +945,60 @@ export class NftStakingClient {
         })
             .instruction();
     }
-    async fundSecondaryVault(projectId, poolId, rewardIndex, amount, rewardMint, funderTokenAccount) {
-        const tokenProgram = await this.resolveTokenProgram(rewardMint);
-        const [poolPda] = getStakePoolPda(projectId, poolId);
+    async fundSecondaryVault(poolId, rewardIndex, amount, rewardMint, opts) {
+        const pid = this.resolveProjectId(opts?.projectId);
+        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 = funderTokenAccount ?? getAta(this.provider.wallet.publicKey, rewardMint, tokenProgram);
+        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(projectId), 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,
         })
             .instruction();
     }
-    async withdrawSecondaryVault(projectId, poolId, rewardIndex, amount, rewardMint, destinationTokenAccount) {
-        const tokenProgram = await this.resolveTokenProgram(rewardMint);
-        const [poolPda] = getStakePoolPda(projectId, poolId);
+    async withdrawSecondaryVault(poolId, rewardIndex, amount, rewardMint, opts) {
+        const pid = this.resolveProjectId(opts?.projectId);
+        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 = destinationTokenAccount ?? getAta(this.provider.wallet.publicKey, rewardMint, tokenProgram);
+        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(projectId), new BN(poolId), rewardIndex, amount)
+            .withdrawSecondaryVault(new BN(pid), new BN(poolId), rewardIndex, toBN(amount))
             .accountsStrict({
             pool: poolPda,
             poolSecondary,
             poolAuthority,
             secondaryVault: vault,
             destinationTokenAccount: destAta,
-            secondaryRewardMint: rewardMint,
+            secondaryRewardMint: _rewardMint,
             authority: this.provider.wallet.publicKey,
             tokenProgram,
         })
             .instruction();
     }
-    async initStakerSecondary(projectId, poolId) {
-        const [poolPda] = getStakePoolPda(projectId, poolId);
+    async initStakerSecondary(poolId, projectId) {
+        const pid = this.resolveProjectId(projectId);
+        const [poolPda] = getStakePoolPda(pid, 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))
+            .initStakerSecondary(new BN(pid), new BN(poolId))
             .accountsStrict({
             pool: poolPda,
             poolSecondary,
@@ -852,23 +1008,26 @@ export class NftStakingClient {
         })
             .instruction();
     }
-    async claimSecondaryRewards(projectId, poolId, secondaryRewards, fee) {
-        const [poolPda] = getStakePoolPda(projectId, poolId);
+    async claimSecondaryRewards(poolId, secondaryRewards, opts) {
+        const pid = this.resolveProjectId(opts?.projectId);
+        const [poolPda] = getStakePoolPda(pid, 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 feeAccts = this.resolveFeeAccounts(opts?.fee);
+        const [project] = getProjectPda(pid);
         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 });
+            const _srMint = toPk(sr.mint);
+            const tokenProgram = await this.resolveTokenProgram(_srMint);
+            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 }, { pubkey: tokenProgram, isSigner: false, isWritable: false });
         }
         return this.program.methods
-            .claimSecondaryRewards(new BN(projectId), new BN(poolId))
+            .claimSecondaryRewards(new BN(pid), new BN(poolId))
             .accountsStrict({
             pool: poolPda,
             poolSecondary,
@@ -876,10 +1035,12 @@ 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,
             associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
@@ -888,5 +1049,18 @@ export class NftStakingClient {
             .remainingAccounts(remainingAccounts)
             .instruction();
     }
+    async updatePoolSecondaryReward(poolId, rewardIndex, baseRate, lockTierRates, projectId) {
+        const pid = this.resolveProjectId(projectId);
+        const [poolPda] = getStakePoolPda(pid, poolId);
+        const [poolSecondary] = getPoolSecondaryRewardsPda(poolId);
+        return this.program.methods
+            .updatePoolSecondaryReward(new BN(pid), new BN(poolId), rewardIndex, toBN(baseRate), lockTierRates.map(toBN))
+            .accountsStrict({
+            pool: poolPda,
+            poolSecondary,
+            authority: this.provider.wallet.publicKey,
+        })
+            .instruction();
+    }
 }
 //# sourceMappingURL=client.js.map