@soltracer/nft-staking 0.1.0 → 0.2.0

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, 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");
@@ -37,17 +37,59 @@ export class NftStakingClient {
     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) {
@@ -112,14 +154,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;
@@ -153,12 +197,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);
         }
@@ -188,8 +233,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 +261,20 @@ 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 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 [project] = getProjectPda(pid);
         return this.program.methods
-            .closeLegacyCollection(new BN(projectId), collectionMint)
+            .closeLegacyCollection(new BN(pid), collectionMint)
             .accountsStrict({
             collection,
             authority: this.provider.wallet.publicKey,
@@ -236,10 +284,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,8 +298,11 @@ 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 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);
@@ -268,13 +320,14 @@ 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, collectionMint);
         const [poolAuthority] = getPoolAuthorityPda(nextPoolId);
         const rewardVault = getAta(poolAuthority, rewardConfig.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,
@@ -283,6 +336,7 @@ export class NftStakingClient {
             collectionMint,
             rewardMint: rewardConfig.rewardMint,
             rewardVault,
+            utilityConfig,
             projectManagementProgram: PROJECT_MANAGEMENT_PROGRAM_ID,
             authority: this.provider.wallet.publicKey,
             tokenProgram,
@@ -291,7 +345,17 @@ 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;
+        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) {
@@ -316,7 +380,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 +389,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 ?? 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 ?? 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), amount)
             .accountsStrict({
             pool: poolPda,
             poolAuthority,
@@ -353,14 +421,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 ?? 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 ?? 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), amount)
             .accountsStrict({
             pool: poolPda,
             poolAuthority,
@@ -372,18 +444,25 @@ 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,
             authority: this.provider.wallet.publicKey,
         })
             .instruction();
     }
-    async stakeNft(projectId, poolId, nftMint, stakingMode, lockTierIndex, fee, gateProof = []) {
-        const [poolPda] = getStakePoolPda(projectId, poolId);
+    /** Stake a legacy/pNFT. Auto-resolves stakingMode from pool. */
+    async stakeNft(poolId, nftMint, opts) {
+        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);
@@ -396,9 +475,10 @@ export class NftStakingClient {
             : null;
         const nftMetadata = getMetadataPda(nftMint);
         const nftEdition = getEditionPda(nftMint);
-        const feeAccts = this.resolveFeeAccounts(fee);
+        const feeAccts = this.resolveFeeAccounts(opts?.fee);
+        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,
@@ -411,6 +491,9 @@ export class NftStakingClient {
             nftEdition,
             mplTokenMetadataProgram: TOKEN_METADATA_PROGRAM_ID,
             sysvarInstructions: SYSVAR_INSTRUCTIONS_ID,
+            tokenRecord: null,
+            destinationTokenRecord: null,
+            utilityConfig,
             feeConfig: feeAccts.feeConfig,
             treasury: feeAccts.treasury,
             referralAccount: feeAccts.referralAccount,
@@ -423,10 +506,15 @@ 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 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 [poolPda] = getStakePoolPda(pid, poolId);
         const [stakeEntry] = getStakeEntryPda(poolId, nftMint);
         const staker = this.provider.wallet.publicKey;
         const [stakerAccount] = getStakerAccountPda(poolId, staker);
@@ -440,9 +528,9 @@ export class NftStakingClient {
         const stakerRewardAccount = getAta(staker, rewardMint, rewardTokenProgram);
         const nftMetadata = getMetadataPda(nftMint);
         const nftEdition = getEditionPda(nftMint);
-        const feeAccts = this.resolveFeeAccounts(fee);
+        const feeAccts = this.resolveFeeAccounts(opts?.fee);
         return this.program.methods
-            .unstakeNft(new BN(projectId), new BN(poolId), nftMint)
+            .unstakeNft(new BN(pid), new BN(poolId), nftMint)
             .accountsStrict({
             pool: poolPda,
             stakeEntry,
@@ -458,6 +546,8 @@ 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,
@@ -471,18 +561,23 @@ 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);
         return this.program.methods
-            .claimRewards(new BN(projectId), new BN(poolId), traitBonusRate)
+            .claimRewards(new BN(pid), new BN(poolId), traitBonusRate)
             .accountsStrict({
             pool: poolPda,
             stakerAccount,
@@ -504,15 +599,22 @@ export class NftStakingClient {
         })
             .instruction();
     }
-    async stakeCoreNft(projectId, poolId, nftAsset, collection, lockTierIndex, fee, gateProof = []) {
-        const [poolPda] = getStakePoolPda(projectId, poolId);
+    /** Stake a Core NFT. Auto-resolves collection from pool. */
+    async stakeCoreNft(poolId, nftAsset, opts) {
+        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 [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,
@@ -521,6 +623,7 @@ export class NftStakingClient {
             nftAsset,
             collection,
             mplCoreProgram: MPL_CORE_PROGRAM_ID,
+            utilityConfig,
             feeConfig: feeAccts.feeConfig,
             treasury: feeAccts.treasury,
             referralAccount: feeAccts.referralAccount,
@@ -531,18 +634,23 @@ export class NftStakingClient {
         })
             .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 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 [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);
+        const feeAccts = this.resolveFeeAccounts(opts?.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,
@@ -567,26 +675,30 @@ 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 [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,6 +709,7 @@ export class NftStakingClient {
             logWrapper: SPL_NOOP_PROGRAM_ID,
             compressionProgram: SPL_ACCOUNT_COMPRESSION_PROGRAM_ID,
             bubblegumProgram: BUBBLEGUM_PROGRAM_ID,
+            utilityConfig,
             feeConfig: feeAccts.feeConfig,
             treasury: feeAccts.treasury,
             referralAccount: feeAccts.referralAccount,
@@ -608,21 +721,24 @@ export class NftStakingClient {
             .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 feeAccts = this.resolveFeeAccounts(opts?.fee);
         const rewardVaultPk = getAta(poolAuthority, rewardMintPk);
         const stakerRewardAccountPk = getAta(staker, rewardMintPk);
         const remainingAccounts = proofNodes.map((node) => ({
@@ -631,7 +747,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,
@@ -658,23 +774,25 @@ 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) {
+    /** Burn a permanently-locked legacy/pNFT. Auto-resolves stakingMode from pool. */
+    async burnStakedNft(poolId, nftMint, opts) {
+        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(projectId, poolId);
+        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 isWalletLock = stakingMode === 1;
         const escrowNftAccount = isWalletLock ? null : getAta(poolAuthority, nftMint, nftTokenProgram);
         const stakerNftAccount = isWalletLock ? getAta(staker, nftMint, nftTokenProgram) : null;
         const nftMetadata = isWalletLock ? getMetadataPda(nftMint) : null;
         const nftEdition = isWalletLock ? getEditionPda(nftMint) : null;
         return this.program.methods
-            .burnStakedNft(new BN(projectId), new BN(poolId), nftMint)
+            .burnStakedNft(new BN(pid), new BN(poolId), nftMint)
             .accountsStrict({
             pool: poolPda,
             stakeEntry,
@@ -687,6 +805,8 @@ export class NftStakingClient {
             nftEdition,
             mplTokenMetadataProgram: isWalletLock ? TOKEN_METADATA_PROGRAM_ID : null,
             sysvarInstructions: isWalletLock ? SYSVAR_INSTRUCTIONS_ID : null,
+            tokenRecord: null,
+            collectionMetadata: null,
             feeConfig: feeAccts.feeConfig,
             treasury: feeAccts.treasury,
             referralAccount: feeAccts.referralAccount,
@@ -698,16 +818,19 @@ export class NftStakingClient {
         })
             .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);
+    /** Burn a permanently-locked Core NFT. Auto-resolves collection from pool. */
+    async burnStakedCoreNft(poolId, nftAsset, opts) {
+        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);
         return this.program.methods
-            .burnStakedCoreNft(new BN(projectId), new BN(poolId), nftAsset)
+            .burnStakedCoreNft(new BN(pid), new BN(poolId), nftAsset)
             .accountsStrict({
             pool: poolPda,
             stakeEntry,
@@ -727,13 +850,14 @@ export class NftStakingClient {
             .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);
         return this.program.methods
-            .spendPoints(new BN(projectId), new BN(poolId), amount)
+            .spendPoints(new BN(pid), new BN(poolId), amount)
             .accountsStrict({
             pool: poolPda,
             stakerAccount,
@@ -761,14 +885,15 @@ export class NftStakingClient {
             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 [poolPda] = getStakePoolPda(pid, poolId);
         const [poolSecondary] = getPoolSecondaryRewardsPda(poolId);
         const [poolAuthority] = getPoolAuthorityPda(poolId);
         const tokenProgram = await this.resolveTokenProgram(rewardMint);
         const vault = getAta(poolAuthority, rewardMint, tokenProgram);
         return this.program.methods
-            .addPoolSecondaryReward(new BN(projectId), new BN(poolId), baseRate, lockTierRates)
+            .addPoolSecondaryReward(new BN(pid), new BN(poolId), baseRate, lockTierRates)
             .accountsStrict({
             pool: poolPda,
             poolSecondary,
@@ -782,11 +907,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,15 +920,16 @@ export class NftStakingClient {
         })
             .instruction();
     }
-    async fundSecondaryVault(projectId, poolId, rewardIndex, amount, rewardMint, funderTokenAccount) {
+    async fundSecondaryVault(poolId, rewardIndex, amount, rewardMint, opts) {
+        const pid = this.resolveProjectId(opts?.projectId);
         const tokenProgram = await this.resolveTokenProgram(rewardMint);
-        const [poolPda] = getStakePoolPda(projectId, poolId);
+        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 funderAta = 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, amount)
             .accountsStrict({
             pool: poolPda,
             poolSecondary,
@@ -815,15 +942,16 @@ export class NftStakingClient {
         })
             .instruction();
     }
-    async withdrawSecondaryVault(projectId, poolId, rewardIndex, amount, rewardMint, destinationTokenAccount) {
+    async withdrawSecondaryVault(poolId, rewardIndex, amount, rewardMint, opts) {
+        const pid = this.resolveProjectId(opts?.projectId);
         const tokenProgram = await this.resolveTokenProgram(rewardMint);
-        const [poolPda] = getStakePoolPda(projectId, poolId);
+        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 destAta = 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, amount)
             .accountsStrict({
             pool: poolPda,
             poolSecondary,
@@ -836,13 +964,14 @@ export class NftStakingClient {
         })
             .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,14 +981,15 @@ 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 remainingAccounts = [];
         for (const sr of secondaryRewards) {
             const tokenProgram = await this.resolveTokenProgram(sr.mint);
@@ -868,7 +998,7 @@ export class NftStakingClient {
             remainingAccounts.push({ pubkey: vault, isSigner: false, isWritable: true }, { pubkey: stakerAta, isSigner: false, isWritable: true }, { pubkey: sr.mint, isSigner: false, isWritable: false }, { pubkey: tokenProgram, isSigner: false, isWritable: false });
         }
         return this.program.methods
-            .claimSecondaryRewards(new BN(projectId), new BN(poolId))
+            .claimSecondaryRewards(new BN(pid), new BN(poolId))
             .accountsStrict({
             pool: poolPda,
             poolSecondary,