@emblemvault/primitives-stake 0.5.1 → 0.7.1

package/dist/client.js

@@ -18,7 +18,7 @@
 import { PublicKey, SystemProgram, SYSVAR_RENT_PUBKEY, Transaction, TransactionInstruction, TransactionMessage, VersionedTransaction, } from '@solana/web3.js';
 import { TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID, createAssociatedTokenAccountIdempotentInstruction, getAssociatedTokenAddressSync, } from '@solana/spl-token';
 import { EmblemError, decodeSignedPayload, } from '@emblemvault/primitives-shared';
-import { decodeRewardDistributionAccount, decodeStakePoolAccount, decodeStakeVaultAccount, MULTIPLIER_SCALE, PENALTY_TAG_BURN, PENALTY_TAG_REDISTRIBUTE, PENALTY_TAG_TREASURY_PDA, REWARD_CADENCE_DAILY, REWARD_CADENCE_HOURLY, REWARD_CADENCE_WEEKLY, REWARD_FORMULA_LINEAR_V1, REWARD_FORMULA_TIME_WEIGHTED_V1, REWARD_SOURCE_TAG_DIST_VAULT, REWARD_SOURCE_TAG_SPLIT_RECIPIENT, STAKE_POOL_DISCRIMINATOR, STAKE_VAULT_DISCRIMINATOR, } from './codec.js';
+import { decodePlatformAccrualAccount, decodeRewardDistributionAccount, decodeStakePlatformConfigAccount, decodeStakePoolAccount, decodeStakeVaultAccount, MULTIPLIER_SCALE, PENALTY_TAG_BURN, PENALTY_TAG_REDISTRIBUTE, PENALTY_TAG_TREASURY_PDA, REWARD_CADENCE_DAILY, REWARD_CADENCE_HOURLY, REWARD_CADENCE_WEEKLY, REWARD_DIST_DISCRIMINATOR, REWARD_FORMULA_LINEAR_V1, REWARD_FORMULA_TIME_WEIGHTED_V1, REWARD_SOURCE_TAG_DIST_VAULT, REWARD_SOURCE_TAG_SPLIT_RECIPIENT, STAKE_POOL_DISCRIMINATOR, STAKE_VAULT_DISCRIMINATOR, } from './codec.js';
 import { deriveRewardDistPda, deriveStakePoolPda, deriveStakeVaultPda, STAKE_PROGRAM_ID, } from './pda.js';
 // =============================================================================
 // Anchor instruction discriminators
@@ -26,15 +26,19 @@ import { deriveRewardDistPda, deriveStakePoolPda, deriveStakeVaultPda, STAKE_PRO
 const IX_CREATE_POOL = Buffer.from([
     0xe9, 0x92, 0xd1, 0x8e, 0xcf, 0x68, 0x40, 0xbc,
 ]);
-const IX_REGISTER_REWARD_VAULT = Buffer.from([
-    0xcb, 0x37, 0x29, 0x9c, 0xfc, 0x7f, 0xb9, 0xef,
-]);
+// Bundle 9+232 (2026-05-06): IX_REGISTER_REWARD_VAULT deleted with the
+// Tier 2 tombstone. Per-stream reward vaults are init'd via
+// IX_REGISTER_POOL_REWARD_MINT below.
 const IX_REGISTER_PENDING_ACTION_VAULT = Buffer.from([
     0x5b, 0x60, 0x22, 0xa1, 0x04, 0x7c, 0xa3, 0x62,
 ]);
 const IX_REGISTER_POOL_TOKEN_ACCOUNTS = Buffer.from([
     0x3c, 0xd3, 0x00, 0x47, 0x80, 0x7b, 0xc8, 0x52,
 ]);
+/** Bundle 9+232 (2026-05-06) — sha256("global:register_pool_reward_mint"). */
+const IX_REGISTER_POOL_REWARD_MINT = Buffer.from([
+    0xd3, 0xa8, 0x16, 0xd6, 0xda, 0xfb, 0xea, 0x78,
+]);
 const IX_STAKE = Buffer.from([
     0xce, 0xb0, 0xca, 0x12, 0xc8, 0xd1, 0xb3, 0x6c,
 ]);
@@ -47,6 +51,14 @@ const IX_CLAIM = Buffer.from([
 const IX_DISTRIBUTE_REWARDS = Buffer.from([
     0x61, 0x06, 0xe3, 0xff, 0x7c, 0xa5, 0x03, 0x94,
 ]);
+/** Bundle 9+232 (2026-05-06) — sha256("global:set_platform_fee_bps"). */
+const IX_SET_PLATFORM_FEE_BPS = Buffer.from([
+    0x99, 0x37, 0xb5, 0x3e, 0x41, 0xfc, 0xf7, 0xdb,
+]);
+/** Bundle 9+232 (2026-05-06) — sha256("global:emblem_claim_platform_fee"). */
+const IX_EMBLEM_CLAIM_PLATFORM_FEE = Buffer.from([
+    0x11, 0x6d, 0x7e, 0xd1, 0xd5, 0x67, 0xa7, 0x97,
+]);
 // ST-2 follow-on (2026-05-04): platform-config + emergency-halt ixs.
 // All discriminators verified via Node crypto sha256("global:<name>").subarray(0, 8).
 const IX_INIT_PLATFORM_CONFIG = Buffer.from([
@@ -166,13 +178,15 @@ function encodeRewardFormula(f) {
 function deriveVaultAuthority(programId) {
     return PublicKey.findProgramAddressSync([Buffer.from('vault-authority')], programId)[0];
 }
-function deriveRewardVault(vaultPubkey, programId) {
-    // Audit X-1 Pass 2: seed is now Pubkey (32 bytes), not String.
-    return PublicKey.findProgramAddressSync([Buffer.from('reward-vault'), vaultPubkey.toBuffer()], programId)[0];
+/** Bundle 9+232 (2026-05-06) — per-mint reward vault. Pre-bundle
+ *  single-arg helpers (`deriveRewardVault(vaultPubkey, ...)` and
+ *  `deriveRewardVaultForPool(pool, ...)`) are gone — the seed shape is
+ *  now `[b"reward-vault", pool, reward_mint]`. */
+function deriveRewardVaultForMint(poolPda, rewardMint, programId) {
+    return PublicKey.findProgramAddressSync([Buffer.from('reward-vault'), poolPda.toBytes(), rewardMint.toBytes()], programId)[0];
 }
-function deriveRewardVaultForPool(poolPda, programId) {
-    // staker-pool reward vault uses the pool PDA bytes as the vault id
-    return PublicKey.findProgramAddressSync([Buffer.from('reward-vault'), poolPda.toBytes()], programId)[0];
+function derivePlatformAccrualForMint(poolPda, rewardMint, programId) {
+    return PublicKey.findProgramAddressSync([Buffer.from('platform-accrual'), poolPda.toBytes(), rewardMint.toBytes()], programId)[0];
 }
 function derivePendingActionVault(configId, mint, actionType, programId) {
     return PublicKey.findProgramAddressSync([
@@ -223,14 +237,35 @@ export class EmblemStakeClient {
         });
         return { vaultPda: pda.toBase58(), bump };
     }
+    /** Bundle 9+232 (2026-05-06) — RewardDistribution PDA now per
+     *  `(pool, rewardMint, periodId)`. */
     deriveDistributionPda(args) {
         const { pda, bump } = deriveRewardDistPda({
             poolPda: args.poolPda,
+            rewardMint: args.rewardMint,
             periodId: args.periodId,
             programId: this.programId.toBase58(),
         });
         return { distributionPda: pda.toBase58(), bump };
     }
+    /** Bundle 9+232 (2026-05-06) — per-mint reward vault address. */
+    deriveRewardVaultPda(args) {
+        const [pda, bump] = PublicKey.findProgramAddressSync([
+            Buffer.from('reward-vault'),
+            new PublicKey(args.poolPda).toBytes(),
+            new PublicKey(args.rewardMint).toBytes(),
+        ], this.programId);
+        return { rewardVaultPda: pda.toBase58(), bump };
+    }
+    /** Bundle 9+232 (2026-05-06) — per-stream platform accrual PDA. */
+    derivePlatformAccrualPda(args) {
+        const [pda, bump] = PublicKey.findProgramAddressSync([
+            Buffer.from('platform-accrual'),
+            new PublicKey(args.poolPda).toBytes(),
+            new PublicKey(args.rewardMint).toBytes(),
+        ], this.programId);
+        return { accrualPda: pda.toBase58(), bump };
+    }
     /** ST-2 follow-on (2026-05-04). The stake program's PlatformConfig
      *  PDA is a singleton — same shape as launch + sell. */
     derivePlatformConfigPda() {
@@ -609,6 +644,16 @@ export class EmblemStakeClient {
             // Convert decimal multiplier (1.5) to fixed-point ×1000 (1500)
             multiplier: Math.round(t.multiplier * MULTIPLIER_SCALE),
         }));
+        // Bundle 9+232 (2026-05-06) — `create_pool`'s reward_mints arg is
+        // always encoded EMPTY here. The on-chain `create_pool` body only
+        // appends to `pool.reward_mints`; it does NOT init the per-mint
+        // reward-vault TokenAccount (that's `register_pool_reward_mint`'s
+        // job). If we wrote the mints here AND the caller chained
+        // register_pool_reward_mint per mint, the second ix would revert
+        // with StakePoolShapeInvalid (duplicate). So mints flow through the
+        // register-per-mint path exclusively, and `args.initialRewardMints`
+        // is consumed by the higher-level `createPool()` wrapper to build
+        // those follow-up ixs.
         const data = Buffer.concat([
             IX_CREATE_POOL,
             u32(poolId),
@@ -626,6 +671,8 @@ export class EmblemStakeClient {
             ...cfg.rewardSources.map(encodeRewardSource),
             Buffer.from([encodeRewardCadence(cfg.rewardCadence)]),
             Buffer.from([encodeRewardFormula(cfg.rewardFormula)]),
+            // Bundle 9+232 — reward_mints: Vec<Pubkey> always empty here.
+            u32(0),
         ]);
         return new TransactionInstruction({
             programId: this.programId,
@@ -638,31 +685,105 @@ export class EmblemStakeClient {
         });
     }
     /**
-     * Build the register_reward_vault instruction (Tier 2 settlement bucket).
-     * Audit X-1 Pass 2 (2026-05-03): `vaultId: string` → `vaultPubkey: Pubkey`.
-     * The caller picks the pubkey; the on-chain vault address is derived from
-     * `[b"reward-vault", vaultPubkey]`. Use `deriveDistributionVaultAddress`
-     * to compute that address from the same pubkey.
+     * Bundle 9+232 (2026-05-06) — register a reward token stream on an
+     * existing pool. Inits the per-mint reward vault PDA + the stream's
+     * PlatformAccrual PDA, and appends `reward_mint` to
+     * `pool.reward_mints`. Authority-only on chain (`has_one = authority`).
+     *
+     * Used by the `createPool()` self-submitting wrapper to chain one of
+     * these per `initialRewardMints` entry — but exposed here so callers
+     * can register additional streams later.
      */
-    buildRegisterRewardVaultIx(args) {
-        const mint = new PublicKey(args.mint);
-        const vaultPubkeyKey = new PublicKey(args.vaultPubkey);
+    buildRegisterPoolRewardMintIx(args) {
+        const poolKey = new PublicKey(args.poolPda);
+        const mintKey = new PublicKey(args.rewardMint);
         const vaultAuthority = deriveVaultAuthority(this.programId);
-        const vault = deriveRewardVault(vaultPubkeyKey, this.programId);
+        const rewardVault = deriveRewardVaultForMint(poolKey, mintKey, this.programId);
+        const platformAccrual = derivePlatformAccrualForMint(poolKey, mintKey, this.programId);
         return new TransactionInstruction({
             programId: this.programId,
             keys: [
-                { pubkey: new PublicKey(args.authority), isSigner: true, isWritable: true },
-                { pubkey: mint, isSigner: false, isWritable: false },
+                { pubkey: new PublicKey(args.payer), isSigner: true, isWritable: true },
+                { pubkey: new PublicKey(args.authority), isSigner: true, isWritable: false },
+                { pubkey: poolKey, isSigner: false, isWritable: true },
+                { pubkey: mintKey, isSigner: false, isWritable: false },
                 { pubkey: vaultAuthority, isSigner: false, isWritable: false },
-                { pubkey: vault, isSigner: false, isWritable: true },
+                { pubkey: rewardVault, isSigner: false, isWritable: true },
+                { pubkey: platformAccrual, isSigner: false, isWritable: true },
                 { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
                 { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
                 { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false },
             ],
-            data: Buffer.concat([IX_REGISTER_REWARD_VAULT, vaultPubkeyKey.toBuffer()]),
+            data: Buffer.concat([IX_REGISTER_POOL_REWARD_MINT, mintKey.toBuffer()]),
+        });
+    }
+    /**
+     * Bundle 9+232 (2026-05-06) — admin sets the protocol fee on reward
+     * distributions, in basis points. Capped at
+     * `STAKE_PLATFORM_FEE_BPS_MAX = 3_000` (30%) by the on-chain ix.
+     * Mainnet ships at 0.
+     */
+    buildSetPlatformFeeBpsIx(args) {
+        const { platformConfigPda } = this.derivePlatformConfigPda();
+        const data = Buffer.concat([IX_SET_PLATFORM_FEE_BPS, u16(args.feeBps)]);
+        return new TransactionInstruction({
+            programId: this.programId,
+            keys: [
+                { pubkey: new PublicKey(args.admin), isSigner: true, isWritable: false },
+                {
+                    pubkey: new PublicKey(platformConfigPda),
+                    isSigner: false,
+                    isWritable: true,
+                },
+            ],
+            data,
         });
     }
+    /**
+     * Bundle 9+232 (2026-05-06) — drain accrued platform fees from one
+     * reward stream's `PlatformAccrual.pending` into the admin's treasury
+     * ATA. Admin-signed (`has_one = admin` on `PlatformConfig`); body
+     * also asserts `treasury.owner == admin` so the admin can't route
+     * Emblem fees to a third-party wallet. Idempotent-error at
+     * `pending == 0` with `StakePlatformAccrualNothingPending (519)`.
+     */
+    buildEmblemClaimPlatformFeeIx(args) {
+        const poolKey = new PublicKey(args.poolPda);
+        const mintKey = new PublicKey(args.rewardMint);
+        const { platformConfigPda } = this.derivePlatformConfigPda();
+        const platformAccrual = derivePlatformAccrualForMint(poolKey, mintKey, this.programId);
+        const rewardVault = deriveRewardVaultForMint(poolKey, mintKey, this.programId);
+        const vaultAuthority = deriveVaultAuthority(this.programId);
+        const data = Buffer.concat([
+            IX_EMBLEM_CLAIM_PLATFORM_FEE,
+            mintKey.toBuffer(),
+        ]);
+        return new TransactionInstruction({
+            programId: this.programId,
+            keys: [
+                { pubkey: new PublicKey(args.admin), isSigner: true, isWritable: false },
+                {
+                    pubkey: new PublicKey(platformConfigPda),
+                    isSigner: false,
+                    isWritable: false,
+                },
+                { pubkey: poolKey, isSigner: false, isWritable: false },
+                { pubkey: platformAccrual, isSigner: false, isWritable: true },
+                { pubkey: rewardVault, isSigner: false, isWritable: true },
+                {
+                    pubkey: new PublicKey(args.treasuryTokenAccount),
+                    isSigner: false,
+                    isWritable: true,
+                },
+                { pubkey: vaultAuthority, isSigner: false, isWritable: false },
+                { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+            ],
+            data,
+        });
+    }
+    // Bundle 9+232 (2026-05-06): buildRegisterRewardVaultIx deleted with
+    // the Tier 2 tombstone. Use buildRegisterPoolRewardMintIx for per-stream
+    // reward vaults instead.
     /** Build the register_pending_action_vault instruction (Tier 3 settlement bucket). */
     buildRegisterPendingActionVaultIx(args) {
         const mint = new PublicKey(args.mint);
@@ -687,17 +808,15 @@ export class EmblemStakeClient {
             ]),
         });
     }
-    /** Address of the staker-pool reward vault (Tier 2 destination for StakerPool recipients). */
-    deriveStakerPoolRewardVault(poolPda) {
-        return deriveRewardVaultForPool(new PublicKey(poolPda), this.programId).toBase58();
-    }
     /**
-     * Address of a distribution-vault (Tier 2 destination for DistributionVault
-     * recipients). Audit X-1 Pass 2: arg is now Pubkey (was String). Pass the
-     * same pubkey you used for `buildRegisterRewardVaultIx({ vaultPubkey })`.
+     * Bundle 9+232 (2026-05-06) — per-mint reward vault address. Pre-bundle
+     * `deriveStakerPoolRewardVault(pool)` (single-stream) and
+     * `deriveDistributionVaultAddress(vaultPubkey)` (Tier 2 tombstone)
+     * helpers are gone — see `deriveRewardVaultPda` above for the canonical
+     * `(pool, rewardMint)` derivation.
      */
-    deriveDistributionVaultAddress(vaultPubkey) {
-        return deriveRewardVault(new PublicKey(vaultPubkey), this.programId).toBase58();
+    deriveStakerPoolRewardVault(args) {
+        return deriveRewardVaultForMint(new PublicKey(args.poolPda), new PublicKey(args.rewardMint), this.programId).toBase58();
     }
     /** Address of a Tier 3 pending-action vault. */
     derivePendingActionVaultAddress(args) {
@@ -720,20 +839,27 @@ export class EmblemStakeClient {
             new PublicKey(args.owner).toBytes(),
         ], this.programId)[0].toBase58();
     }
-    /** RewardDistribution PDA for a (pool, period_id) pair. */
+    /** Bundle 9+232 (2026-05-06) — RewardDistribution PDA for a
+     *  `(pool, rewardMint, periodId)` triple. */
     deriveRewardDistributionAddress(args) {
         const periodBytes = Buffer.alloc(4);
         periodBytes.writeUInt32LE(args.periodId, 0);
-        return PublicKey.findProgramAddressSync([Buffer.from('reward-dist'), new PublicKey(args.poolPda).toBytes(), periodBytes], this.programId)[0].toBase58();
+        return PublicKey.findProgramAddressSync([
+            Buffer.from('reward-dist'),
+            new PublicKey(args.poolPda).toBytes(),
+            new PublicKey(args.rewardMint).toBytes(),
+            periodBytes,
+        ], this.programId)[0].toBase58();
     }
     // ==========================================================================
     // Stake-flow ix builders
     // ==========================================================================
-    /** Build the register_pool_token_accounts ix. Permissionless; one-time per pool. */
+    /** Build the register_pool_token_accounts ix. Permissionless;
+     *  one-time per pool. Bundle 9+232 (2026-05-06) — principal-vault only;
+     *  per-mint reward vaults moved to `register_pool_reward_mint`. */
     buildRegisterPoolTokenAccountsIx(args) {
         const poolKey = new PublicKey(args.poolPda);
         const principalVault = new PublicKey(this.derivePrincipalVaultAddress(args.poolPda));
-        const rewardVault = new PublicKey(this.deriveStakerPoolRewardVault(args.poolPda));
         return new TransactionInstruction({
             programId: this.programId,
             keys: [
@@ -746,7 +872,6 @@ export class EmblemStakeClient {
                     isWritable: false,
                 },
                 { pubkey: principalVault, isSigner: false, isWritable: true },
-                { pubkey: rewardVault, isSigner: false, isWritable: true },
                 { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
                 { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
                 { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false },
@@ -846,16 +971,24 @@ export class EmblemStakeClient {
         });
     }
     /**
-     * Build the claim ix. The caller must pass RewardDistribution PDAs
-     * for every period from `last_claim_period` to `current_period - 1`
-     * inclusive in `remaining_accounts`.
+     * Build the claim ix. Bundle 9+232 (2026-05-06) — caller specifies
+     * `rewardMint` (the stream to claim against). The caller must pass
+     * RewardDistribution PDAs for every period from
+     * `vault.last_claim_periods[mint_idx]` to `pool.current_periods[mint_idx] - 1`
+     * inclusive in `remaining_accounts`. Per-stream PDAs are seeded with
+     * `(pool, rewardMint, periodId)`.
      */
     buildClaimIx(args) {
         const poolKey = new PublicKey(args.poolPda);
+        const mintKey = new PublicKey(args.rewardMint);
         const stakeVault = new PublicKey(this.deriveStakeVaultAddress({ poolPda: args.poolPda, owner: args.user }));
-        const rewardVault = new PublicKey(this.deriveStakerPoolRewardVault(args.poolPda));
+        const rewardVault = deriveRewardVaultForMint(poolKey, mintKey, this.programId);
         const distAccounts = args.periodIds.map((pid) => ({
-            pubkey: new PublicKey(this.deriveRewardDistributionAddress({ poolPda: args.poolPda, periodId: pid })),
+            pubkey: new PublicKey(this.deriveRewardDistributionAddress({
+                poolPda: args.poolPda,
+                rewardMint: args.rewardMint,
+                periodId: pid,
+            })),
             isSigner: false,
             isWritable: false,
         }));
@@ -879,20 +1012,28 @@ export class EmblemStakeClient {
                 { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
                 ...distAccounts,
             ],
-            data: IX_CLAIM,
+            // Bundle 9+232 — claim ix takes reward_mint: Pubkey arg.
+            data: Buffer.concat([IX_CLAIM, mintKey.toBuffer()]),
         });
     }
     /**
      * Build the distribute_rewards ix. Permissionless trigger — anyone
-     * pays tx fees to advance the period.
+     * pays tx fees to advance the period for one stream. Bundle 9+232
+     * (2026-05-06) — caller specifies `rewardMint`; ix data carries it
+     * + reads `PlatformConfig.fee_bps` to bookkeep the staker-pool /
+     * platform-accrual split.
      */
     buildDistributeRewardsIx(args) {
         const poolKey = new PublicKey(args.poolPda);
-        const rewardVault = new PublicKey(this.deriveStakerPoolRewardVault(args.poolPda));
+        const mintKey = new PublicKey(args.rewardMint);
+        const rewardVault = deriveRewardVaultForMint(poolKey, mintKey, this.programId);
         const distribution = new PublicKey(this.deriveRewardDistributionAddress({
             poolPda: args.poolPda,
+            rewardMint: args.rewardMint,
             periodId: args.periodId,
         }));
+        const { platformConfigPda } = this.derivePlatformConfigPda();
+        const platformAccrual = derivePlatformAccrualForMint(poolKey, mintKey, this.programId);
         return new TransactionInstruction({
             programId: this.programId,
             keys: [
@@ -900,9 +1041,15 @@ export class EmblemStakeClient {
                 { pubkey: poolKey, isSigner: false, isWritable: true },
                 { pubkey: rewardVault, isSigner: false, isWritable: false },
                 { pubkey: distribution, isSigner: false, isWritable: true },
+                {
+                    pubkey: new PublicKey(platformConfigPda),
+                    isSigner: false,
+                    isWritable: false,
+                },
+                { pubkey: platformAccrual, isSigner: false, isWritable: true },
                 { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
             ],
-            data: IX_DISTRIBUTE_REWARDS,
+            data: Buffer.concat([IX_DISTRIBUTE_REWARDS, mintKey.toBuffer()]),
         });
     }
     // ==========================================================================
@@ -919,6 +1066,16 @@ export class EmblemStakeClient {
      * pool, so we always include it. If it ever becomes a no-op for an
      * existing pool, this is still safe.
      */
+    /**
+     * Create a stake pool AND chain `register_pool_token_accounts` so the
+     * principal vault is initialized in the same call. Bundle 9+232
+     * (2026-05-06) — also chains one `register_pool_reward_mint` per
+     * entry in `args.initialRewardMints`, initializing each stream's
+     * reward vault + PlatformAccrual atomically with pool creation. If
+     * `initialRewardMints` is empty, no reward streams are registered;
+     * the pool authority can register them later via
+     * `registerPoolRewardMint()`.
+     */
     async createPool(args) {
         const signer = this.requireSigner('createPool');
         const { poolPda } = this.derivePoolPda({
@@ -935,20 +1092,85 @@ export class EmblemStakeClient {
             mint: args.config.asset,
         });
         const tx = new Transaction().add(createIx).add(registerIx);
+        const initialRewardMints = args.initialRewardMints ?? [];
+        for (const rewardMint of initialRewardMints) {
+            tx.add(this.buildRegisterPoolRewardMintIx({
+                payer: signer.publicKey,
+                authority: signer.publicKey,
+                poolPda,
+                rewardMint,
+            }));
+        }
         const txSignature = await this.signAndSubmit(tx, signer);
         return {
             poolPda,
             principalVaultPda: this.derivePrincipalVaultAddress(poolPda),
-            rewardVaultPda: this.deriveStakerPoolRewardVault(poolPda),
+            rewardVaultPdas: initialRewardMints.map((rewardMint) => ({
+                rewardMint,
+                rewardVaultPda: this.deriveStakerPoolRewardVault({ poolPda, rewardMint }),
+            })),
             txSignature,
         };
     }
-    async registerRewardVault(args) {
-        const signer = this.requireSigner('registerRewardVault');
-        const ix = this.buildRegisterRewardVaultIx({ ...args, authority: signer.publicKey });
+    /**
+     * Bundle 9+232 (2026-05-06) — register a new reward token stream on
+     * an existing pool. Authority-only on chain. Inits the per-mint
+     * reward vault PDA + PlatformAccrual; appends to `pool.reward_mints`.
+     */
+    async registerPoolRewardMint(args) {
+        const signer = this.requireSigner('registerPoolRewardMint');
+        const ix = this.buildRegisterPoolRewardMintIx({
+            payer: signer.publicKey,
+            authority: signer.publicKey,
+            poolPda: args.poolPda,
+            rewardMint: args.rewardMint,
+        });
+        const tx = new Transaction().add(ix);
+        const txSignature = await this.signAndSubmit(tx, signer);
+        return {
+            rewardVaultPda: this.deriveStakerPoolRewardVault(args),
+            accrualPda: this.derivePlatformAccrualPda(args).accrualPda,
+            txSignature,
+        };
+    }
+    /**
+     * Bundle 9+232 (2026-05-06) — admin updates Emblem's protocol fee
+     * on reward distributions. Capped at 30% by the on-chain ix.
+     * Mainnet ships at 0.
+     */
+    async setPlatformFeeBps(feeBps) {
+        const signer = this.requireSigner('setPlatformFeeBps');
+        const ix = this.buildSetPlatformFeeBpsIx({ admin: signer.publicKey, feeBps });
         const tx = new Transaction().add(ix);
         const txSignature = await this.signAndSubmit(tx, signer);
-        return { vaultPda: this.deriveDistributionVaultAddress(args.vaultPubkey), txSignature };
+        return { txSignature };
+    }
+    /**
+     * Bundle 9+232 (2026-05-06) — admin drains accrued platform fees from
+     * one reward stream into a treasury ATA. Auto-derives the canonical
+     * admin-owned ATA for `rewardMint` if `treasuryTokenAccount` is
+     * omitted, and prepends an idempotent ATA-create ix.
+     */
+    async emblemClaimPlatformFee(args) {
+        const signer = this.requireSigner('emblemClaimPlatformFee');
+        const tokenProgramId = await this.detectTokenProgramId(args.rewardMint);
+        const mintKey = new PublicKey(args.rewardMint);
+        const adminKey = new PublicKey(signer.publicKey);
+        const treasuryAta = args.treasuryTokenAccount ??
+            getAssociatedTokenAddressSync(mintKey, adminKey, true, tokenProgramId).toBase58();
+        const ataIx = createAssociatedTokenAccountIdempotentInstruction(adminKey, new PublicKey(treasuryAta), adminKey, mintKey, tokenProgramId);
+        const claimIx = this.buildEmblemClaimPlatformFeeIx({
+            admin: signer.publicKey,
+            poolPda: args.poolPda,
+            rewardMint: args.rewardMint,
+            treasuryTokenAccount: treasuryAta,
+        });
+        const tx = new Transaction().add(ataIx).add(claimIx);
+        const txSignature = await this.signAndSubmit(tx, signer);
+        return {
+            accrualPda: this.derivePlatformAccrualPda(args).accrualPda,
+            txSignature,
+        };
     }
     async registerPendingActionVault(args) {
         const signer = this.requireSigner('registerPendingActionVault');
@@ -1048,9 +1270,11 @@ export class EmblemStakeClient {
         return { txSignature };
     }
     /**
-     * Claim accrued rewards for one or more periods. Auto-derives the
-     * user's ATA from the pool's asset mint and prepends an idempotent
-     * ATA-create ix (covers first-time claimers).
+     * Claim accrued rewards for one stream over one or more periods.
+     * Bundle 9+232 (2026-05-06) — claim is per-reward-stream; caller
+     * specifies which `rewardMint` to pull. Auto-derives the user's ATA
+     * for `rewardMint` (NOT pool.asset — these may differ) and prepends
+     * an idempotent ATA-create ix.
      */
     async claimRewards(args) {
         const signer = this.requireSigner('claimRewards');
@@ -1058,8 +1282,11 @@ export class EmblemStakeClient {
         if (!pool) {
             throw new EmblemStakeError(EmblemError.MissingAccount, `Pool ${args.poolPda} not found`);
         }
-        const tokenProgramId = await this.detectTokenProgramId(pool.asset);
-        const mintKey = new PublicKey(pool.asset);
+        if (!pool.rewardMints.includes(args.rewardMint)) {
+            throw new EmblemStakeError(EmblemError.StakeRewardSourceInvalid, `Pool ${args.poolPda} has not registered reward mint ${args.rewardMint}; registered: [${pool.rewardMints.join(', ')}]`);
+        }
+        const tokenProgramId = await this.detectTokenProgramId(args.rewardMint);
+        const mintKey = new PublicKey(args.rewardMint);
         const ownerKey = new PublicKey(signer.publicKey);
         const userAta = args.userTokenAccount ??
             getAssociatedTokenAddressSync(mintKey, ownerKey, true, tokenProgramId).toBase58();
@@ -1067,6 +1294,7 @@ export class EmblemStakeClient {
         const claimIx = this.buildClaimIx({
             user: signer.publicKey,
             poolPda: args.poolPda,
+            rewardMint: args.rewardMint,
             userTokenAccount: userAta,
             periodIds: args.periodIds,
         });
@@ -1074,11 +1302,17 @@ export class EmblemStakeClient {
         const txSignature = await this.signAndSubmit(tx, signer);
         return { txSignature };
     }
+    /**
+     * Bundle 9+232 (2026-05-06) — advance one reward stream's period
+     * counter. Caller specifies `rewardMint`; the cadence floor + the
+     * platform-fee bookkeeping are per-stream.
+     */
     async distributeRewards(args) {
         const signer = this.requireSigner('distributeRewards');
         const ix = this.buildDistributeRewardsIx({
             payer: signer.publicKey,
             poolPda: args.poolPda,
+            rewardMint: args.rewardMint,
             periodId: args.periodId,
         });
         const tx = new Transaction().add(ix);
@@ -1086,11 +1320,69 @@ export class EmblemStakeClient {
         return {
             distributionPda: this.deriveRewardDistributionAddress({
                 poolPda: args.poolPda,
+                rewardMint: args.rewardMint,
                 periodId: args.periodId,
             }),
             txSignature,
         };
     }
+    /**
+     * Bundle 9+232 (2026-05-06) — discovery helper. Lists every
+     * RewardDistribution PDA for one pool, optionally filtered to a
+     * single reward mint. Mirrors launch SDK's `listLaunchesByCreator`
+     * pattern. Sorted by `(rewardMint, periodId ASC)` for deterministic
+     * pagination on the agent side.
+     */
+    async listDistributionsByPool(args) {
+        const poolKey = new PublicKey(args.poolPda);
+        // pool_pda field offset = disc(8) + bump(1) = 9.
+        const POOL_FIELD_OFFSET = 9;
+        const filters = [
+            { memcmp: { offset: 0, bytes: bs58Encode(REWARD_DIST_DISCRIMINATOR) } },
+            { memcmp: { offset: POOL_FIELD_OFFSET, bytes: poolKey.toBase58() } },
+        ];
+        if (args.rewardMint) {
+            // reward_mint at offset disc(8) + bump(1) + pool_pda(32) + period_id(4) +
+            //   total_distributed(8) + weighted_stake_at_snapshot(8) + distributed_at(8) = 69.
+            const REWARD_MINT_OFFSET = 69;
+            filters.push({
+                memcmp: { offset: REWARD_MINT_OFFSET, bytes: args.rewardMint },
+            });
+        }
+        const accounts = await this.connection.getProgramAccounts(this.programId, {
+            commitment: this.commitment,
+            filters,
+        });
+        const views = accounts.map((a) => {
+            const decoded = decodeRewardDistributionAccount(a.account.data);
+            return { ...decoded, distributionPda: a.pubkey.toBase58() };
+        });
+        views.sort((a, b) => {
+            if (a.rewardMint !== b.rewardMint) {
+                return a.rewardMint < b.rewardMint ? -1 : 1;
+            }
+            return a.periodId - b.periodId;
+        });
+        return views;
+    }
+    /** Bundle 9+232 (2026-05-06) — read PlatformAccrual for a stream. */
+    async getPlatformAccrual(args) {
+        const accrualPda = this.derivePlatformAccrualPda(args).accrualPda;
+        const info = await this.connection.getAccountInfo(new PublicKey(accrualPda), this.commitment);
+        if (!info)
+            return null;
+        const decoded = decodePlatformAccrualAccount(info.data);
+        return { accrualPda, pending: decoded.pending };
+    }
+    /** Bundle 9+232 (2026-05-06) — read PlatformConfig (singleton). */
+    async getPlatformConfig() {
+        const { platformConfigPda } = this.derivePlatformConfigPda();
+        const info = await this.connection.getAccountInfo(new PublicKey(platformConfigPda), this.commitment);
+        if (!info)
+            return null;
+        const decoded = decodeStakePlatformConfigAccount(info.data);
+        return { platformConfigPda, ...decoded };
+    }
     async signAndSubmit(tx, signer) {
         const { blockhash } = await this.connection.getLatestBlockhash(this.commitment);
         const payerKey = new PublicKey(signer.publicKey);