@soltracer/nft-staking 0.3.1 → 0.4.0

package/dist/traitProof.d.ts

@@ -1,21 +1,36 @@
 /**
  * Trait-bonus proof builder for NFT-staking `claim_rewards`.
  *
- * The on-chain Ed25519 message embeds `staker.total_claimed` (a strictly
- * monotonic nonce). Callers MUST read the live `StakerAccount.totalClaimed`
- * immediately before signing.
- *
- * Message layout — 80 bytes, little-endian where applicable:
+ * Design summary
+ * --------------
+ * The on-chain `claim_rewards` instruction accepts a SINGLE u64
+ * `traitBonusRate` per claim. When `pool.reward_config.trait_bonus_enabled`
+ * is `true`, that rate is added directly to the staker's effective rate for
+ * the accrual window. The chain has zero per-NFT or per-trait awareness —
+ * ALL bonus math (trait lookups, per-NFT multipliers, caps, etc.) happens
+ * off-chain in the project's trait-authority server, which signs the final
+ * aggregated rate.
+ *
+ * Why per-NFT (not per-staker) multipliers
+ * ----------------------------------------
+ * An older design exposed a `BaseMultiplier` mode on-chain that multiplied
+ * the staker's ENTIRE effective rate (all NFTs combined). That meant a
+ * single "Mythic 2x" NFT doubled rewards for every plain NFT in the same
+ * claim — cross-contamination across NFTs. The new model evaluates each
+ * NFT's bonuses independently, applies its own optional multiplier to its
+ * own bonus sum, then sums those isolated per-NFT bonuses into the single
+ * signed `u64`. One NFT's multiplier never touches another NFT's reward.
+ *
+ * Ed25519 message layout — 80 bytes (LE where applicable):
  *
  *   [0..32]   pool                 (PublicKey bytes)
  *   [32..64]  staker wallet        (PublicKey bytes)
- *   [64..72]  trait_bonus_rate u64 (LE)
- *   [72..80]  total_claimed   u64  (LE)
+ *   [64..72]  traitBonusRate u64   (LE)
+ *   [72..80]  totalClaimed   u64   (LE — strictly monotonic replay nonce)
  *
- * Sign this byte payload with the pool's trait-authority Ed25519 keypair
- * (or the global trait authority) and prepend an Ed25519 instruction with
- * the signature, expected pubkey, and message to the same transaction that
- * invokes `claimRewards(..., traitBonusRate)`.
+ * Sign with the pool's trait-authority Ed25519 keypair (or the global
+ * `stakeConfig.authority` when the pool has no override) and prepend the
+ * Ed25519 precompile instruction in the same transaction as `claimRewards`.
  */
 import { type PkInput, type BnInput } from "@soltracer/core";
 /** Fixed message length consumed by the on-chain Ed25519 verifier. */
@@ -23,8 +38,8 @@ export declare const TRAIT_PROOF_MSG_LEN = 80;
 /**
  * Build the 80-byte trait-proof message exactly as the on-chain handler
  * reconstructs it. `totalClaimed` must be the LIVE value of
- * `StakerAccount.totalClaimed` (i.e. fetched within the same client tx
- * preparation window — otherwise the signature will be rejected).
+ * `StakerAccount.totalClaimed` (fetched within the same tx prep window —
+ * otherwise the signature is rejected once the nonce advances).
  */
 export declare function buildTraitProofMessage(params: {
     pool: PkInput;
@@ -34,262 +49,173 @@ export declare function buildTraitProofMessage(params: {
     totalClaimed: BnInput;
 }): Buffer;
 /**
- * Example (off-chain trait-authority server):
- *
- * ```ts
- * import nacl from "tweetnacl"
- * import { Ed25519Program } from "@solana/web3.js"
- * import { buildTraitProofMessage } from "@soltracer/nft-staking"
- *
- * const message = buildTraitProofMessage({
- *   pool,
- *   wallet: staker,
- *   traitBonusRate,
- *   totalClaimed: stakerAccount.totalClaimed,
- * })
- * const signature = nacl.sign.detached(message, traitAuthority.secretKey)
- * const ed25519Ix = Ed25519Program.createInstructionWithPublicKey({
- *   publicKey: traitAuthority.publicKey.toBytes(),
- *   message,
- *   signature,
- * })
- * const claimIx = await client.claimRewards(poolId, { traitBonusRate })
- * await provider.sendAndConfirm(new Transaction().add(ed25519Ix, claimIx))
- * ```
- */
-/**
- * Mode-aware trait-bonus rate aggregator.
- *
- * The on-chain `claim_rewards` instruction accepts a **single** `u64`
- * `traitBonusRate` per claim — the chain knows nothing about per-trait
- * granularity. Aggregation across N staked NFTs (each with M traits) is the
- * trait-authority server's responsibility.
- *
- * Intended backend flow:
- *
- *   1. Client sends `{ wallet, poolId, mints: [..] }` to your API.
- *   2. API validates `mints` are currently staked by `wallet` in `pool`
- *      (e.g. via `fetchStakeEntriesByOwner`) and DROPS any it cannot prove.
- *   3. API resolves each surviving NFT's trait list from its own metadata
- *      source (off-chain JSON, on-chain metaplex data, indexer, etc.).
- *   4. API looks up each `(traitType, value)` pair in the project's bonus
- *      catalog. Unmatched traits contribute nothing.
- *   5. API sums the matched bonuses according to the pool's
- *      `rewardConfig.traitBonusMode` and signs the resulting `u64`.
- *
- * Modes:
- *
- * - `0` / `None` — proofs disabled. Always returns `0n`.
- * - `1` / `FixedExtra` — bonuses are **absolute reward per `rateInterval`**.
- *   Summed and added on top of the staker's effective rate for the accrual
- *   window. Catalog entries MUST use `fixedExtra`.
- * - `2` / `BaseMultiplier` — bonuses are **BPS over the staker's current
- *   `effective_rate`** (which already includes lock-tier rates). `10_000`
- *   means +100% (2x base). Summed BPS apply once to the staker rate.
- *   Catalog entries MUST use `bonusBps`.
- *
- * Catalog entries with both `bonusBps` and `fixedExtra` set, or with the wrong
- * field for the active mode, are rejected. Mints can repeat the same trait
- * type/value — each NFT contributes independently.
- *
- * @returns `{ traitBonusRate, perNft }` where `perNft` is the per-mint
- * breakdown (useful for receipts, debugging, or surfacing a tooltip in the UI).
- *
- * @example
- * ```ts
- * // Backend after ownership validation:
- * const result = computeTraitBonusRate({
- *   traitBonusMode: pool.rewardConfig.traitBonusMode as 0 | 1 | 2,
- *   catalog: [
- *     { traitType: "Background", value: "Mythic",     bonusBps: 2500 },
- *     { traitType: "Eyes",       value: "Laser",      bonusBps: 1000 },
- *     { traitType: "Head",       value: "Gold Crown", bonusBps:  500 },
- *   ],
- *   nfts: validatedStakedNfts, // [{ mint, traits: [{ traitType, value }] }, ..]
- * })
- *
- * const message = buildTraitProofMessage({
- *   pool, wallet,
- *   traitBonusRate: result.traitBonusRate,
- *   totalClaimed: stakerAccount.totalClaimed,
- * })
- * ```
+ * One catalog row. Each `(traitType, value)` pair maps to ONE absolute bonus
+ * amount measured in the same units as `rewardConfig.baseRate` (raw token
+ * units per `rateInterval`). To express the catalog in human units, multiply
+ * by `10 ** rewardDecimals` before passing it in.
+ *
+ * Example: catalog row `{ traitType: "Rarity", value: "Mythic", bonus: 25n }`
+ * with a `rateInterval` of 86_400s means "this trait adds 25 raw reward
+ * units per day to the NFT that carries it".
  */
-export type TraitBonusCatalogEntry = {
+export interface TraitBonusCatalogEntry {
     traitType: string;
     value: string;
-    /** Bonus BPS — required when `traitBonusMode === 2` (BaseMultiplier). */
-    bonusBps?: number | bigint;
-    /** Extra reward per `rateInterval` — required when `traitBonusMode === 1` (FixedExtra). */
-    fixedExtra?: number | bigint;
-};
-export type NftTraitInput = {
-    mint: PkInput | string;
-    /** Ordered or unordered list of an NFT's traits, after ownership validation. */
-    traits: ReadonlyArray<{
+    /** Raw reward units per `rateInterval` to add for this trait. */
+    bonus: bigint;
+}
+/**
+ * Storage-agnostic store interface — implement with Prisma, Drizzle, Firestore,
+ * in-memory, etc.
+ *
+ * Catalog rows are keyed by **NFT collection mint**, NOT by pool id. A single
+ * collection can be wired into many pools (e.g. a 30-day pool and a 90-day
+ * pool over the same collection) and they all share one set of trait bonuses.
+ * The pool only contributes the trait-bonus *enable flag* and the signing
+ * authority; the bonus values themselves are a property of the collection.
+ */
+export interface TraitBonusStore {
+    /**
+     * Return every catalog entry that applies to an NFT collection.
+     *
+     * `collectionMint` is `pool.collectionMint` (base58). For pools with no
+     * configured collection (open-set pools), pass the empty string or call
+     * with `Pubkey::default().toBase58()` — the store can return `[]`.
+     */
+    listForCollection(collectionMint: string): Promise<TraitBonusCatalogEntry[]>;
+}
+/**
+ * In-memory catalog suitable for tests and small static configurations.
+ * Keys are collection mints (base58).
+ */
+export declare class InMemoryTraitBonusStore implements TraitBonusStore {
+    private readonly entriesByCollection;
+    constructor(entriesByCollection: Map<string, TraitBonusCatalogEntry[]>);
+    static from(entries: Record<string, TraitBonusCatalogEntry[]>): InMemoryTraitBonusStore;
+    listForCollection(collectionMint: string): Promise<TraitBonusCatalogEntry[]>;
+}
+/** Traits attached to a single staked NFT. */
+export interface NftTraitInput {
+    /** Mint of the staked NFT (string only used for diagnostics). */
+    mint: string;
+    /** Trait pairs in `[traitType, value]` form. */
+    traits: Array<{
         traitType: string;
         value: string;
     }>;
-};
-export type ComputeTraitBonusResult = {
-    /** Aggregated u64 rate to sign and include in the claim. */
+    /**
+     * Optional per-NFT multiplier in BPS applied ONLY to this NFT's own bonus
+     * total. 10_000 = 1× (no change). 20_000 = 2× this NFT's bonus. Multipliers
+     * NEVER cross NFTs — they cannot inflate another NFT's reward.
+     *
+     * Leave undefined (or 10_000) for plain NFTs. Project teams that want to
+     * reward rare NFTs disproportionately apply it here.
+     */
+    multiplierBps?: number;
+}
+export interface PerNftBonus {
+    mint: string;
+    /** Sum of catalog bonuses matched on this NFT, after any per-NFT multiplier. */
+    bonus: bigint;
+}
+export interface TraitBonusComputation {
+    /** Final aggregated `u64` to feed into the signed message and `claimRewards`. */
     traitBonusRate: bigint;
-    /** Per-NFT breakdown (mint → total bonus contributed + matched-trait count). */
-    perNft: Array<{
-        mint: string;
-        bonus: bigint;
-        matchedTraits: number;
-    }>;
-};
-export declare function computeTraitBonusRate(params: {
-    traitBonusMode: 0 | 1 | 2;
-    catalog: ReadonlyArray<TraitBonusCatalogEntry>;
-    nfts: ReadonlyArray<NftTraitInput>;
-}): ComputeTraitBonusResult;
+    /** Per-NFT breakdown — useful for surfacing "you earned X from this NFT" in UI. */
+    perNft: PerNftBonus[];
+}
 /**
- * @deprecated Use `computeTraitBonusRate` instead — it accepts the real per-NFT
- * trait input and a bonus catalog, mirroring the backend flow. Retained for
- * call sites that already pre-resolved a flat bonus array.
+ * Aggregate trait bonuses into a single absolute `u64` rate.
+ *
+ * Algorithm (per NFT, independently):
+ *   1. For every `(traitType, value)` on the NFT, look it up in `catalog`.
+ *   2. Sum every matched `bonus`. Unmatched traits contribute 0.
+ *   3. If `multiplierBps` is set, multiply the NFT's bonus sum by it / 10_000.
+ *      (Floor division — bonuses are integer raw units.)
+ *
+ * Final result = sum of per-NFT bonuses. A multiplier on one NFT cannot
+ * touch another NFT's contribution, eliminating the cross-contamination bug
+ * present in the old on-chain `BaseMultiplier` mode.
  */
-export declare function aggregateTraitBonusRate(traits: ReadonlyArray<{
-    bonusBps?: number | bigint;
-    fixedExtra?: number | bigint;
-}>, traitBonusMode: 0 | 1 | 2): bigint;
+export declare function computeTraitBonusRate(params: {
+    catalog: TraitBonusCatalogEntry[];
+    nfts: NftTraitInput[];
+}): TraitBonusComputation;
 /**
- * Storage adapter for a project's trait-bonus catalog.
- *
- * The SDK does not care where you persist this data — Prisma, Drizzle, raw
- * Postgres, Mongo, KV, in-memory, REST — implement this interface against
- * whatever backs your admin UI. Each `(traitType, value)` row carries the
- * bonus for that pair.
+ * Resolve the trait list for a staked mint. Implementations typically read
+ * from off-chain metadata, an indexer, or a cached project DB.
  */
-export interface TraitBonusStore {
-    /**
-     * Return every catalog entry for a given pool. The orchestrator does not
-     * filter by trait — it expects the full set so unmatched traits naturally
-     * contribute nothing.
-     */
-    list(params: {
-        poolId: number;
-        projectId?: string | number;
-    }): Promise<TraitBonusCatalogEntry[]>;
-}
+export type NftTraitResolver = (mint: string) => Promise<{
+    traits: Array<{
+        traitType: string;
+        value: string;
+    }>;
+    multiplierBps?: number;
+}>;
 /**
- * Resolves the on-chain trait list for a given NFT mint.
+ * Confirm that a given mint is currently staked by `wallet` in `poolId`.
  *
- * Wire this to whatever your project uses as a source of truth: an indexer,
- * Metaplex on-chain metadata, your own collection JSON, an internal DB, etc.
- * Returning an empty array is fine — that NFT simply contributes no bonus.
+ * MUST return `false` for any mint not actively staked by the caller —
+ * otherwise a malicious client could submit a list of NFTs they do not own
+ * and have your server sign a bonus rate that the on-chain pool will accept.
  */
-export type NftTraitResolver = (mint: string) => Promise<ReadonlyArray<{
-    traitType: string;
-    value: string;
-}>>;
-/** Validates which `requestedMints` are actually staked in `poolId` by `wallet`. */
 export type StakedOwnershipResolver = (params: {
     wallet: string;
-    poolId: number;
-    requestedMints: ReadonlyArray<string>;
-}) => Promise<ReadonlyArray<string>>;
-export type PreparedTraitProof = {
-    /** Aggregated u64 rate ready to sign. */
+    poolId: number | bigint;
+    mint: string;
+}) => Promise<boolean>;
+export interface PrepareTraitProofInput {
+    /** Pool that will receive the claim. */
+    pool: PkInput;
+    /** Wallet doing the claim. */
+    wallet: PkInput;
+    /** Live `StakerAccount.totalClaimed` — read immediately before signing. */
+    totalClaimed: BnInput;
+    /** Pool id — only used for the ownership / stake-state lookup. */
+    poolId: number | bigint;
+    /**
+     * Collection mint configured on the pool (`StakePool.collectionMint`,
+     * base58). The catalog is fetched by this key so the same bonuses apply
+     * across every pool that stakes this collection. Pass an empty string for
+     * open-set pools (the store should return `[]`).
+     */
+    collectionMint: string;
+    /** Mints the client claims to be staking. Each is verified individually. */
+    mints: string[];
+    store: TraitBonusStore;
+    resolveTraits: NftTraitResolver;
+    isStakedBy: StakedOwnershipResolver;
+}
+export interface PrepareTraitProofResult {
+    /** The 80-byte message ready for Ed25519 signing. */
+    message: Buffer;
+    /** Aggregated `u64` rate — pass to `claimRewards({ traitBonusRate })`. */
     traitBonusRate: bigint;
-    /** Mints the user requested that survived ownership validation. */
-    validatedMints: string[];
-    /** Mints the user requested that were rejected (not staked). */
+    /** Per-NFT breakdown, including mints that survived ownership verification. */
+    perNft: PerNftBonus[];
+    /** Mints that the client supplied but were rejected as not actively staked. */
     rejectedMints: string[];
-    /** Per-NFT contribution breakdown (useful for UI tooltips / audit logs). */
-    perNft: ComputeTraitBonusResult["perNft"];
-    /** Convenience: the raw 80-byte message to feed into `nacl.sign.detached`. */
-    message: Buffer;
-};
+}
 /**
- * End-to-end backend orchestrator for the trait-proof flow.
+ * Full backend orchestration: ownership-verify each mint, resolve traits,
+ * aggregate via `computeTraitBonusRate`, and build the signed message.
  *
- * Combines the four user-supplied dependencies — ownership validation, trait
- * resolution, the bonus-catalog store, and the on-chain staker nonce — into
- * the single signable payload the on-chain claim instruction expects.
+ * The server is expected to sign `result.message` with the trait-authority
+ * Ed25519 keypair, return both the signature and `traitBonusRate` to the
+ * client, and the client forwards both into the `claimRewards` tx.
+ */
+export declare function prepareTraitProof(input: PrepareTraitProofInput): Promise<PrepareTraitProofResult>;
+/**
+ * Adapter — turn an `NftStakingClient.fetchStakeEntriesByOwner` style call
+ * into a `StakedOwnershipResolver`. Pass in your already-constructed client.
  *
- * @example
  * ```ts
- * import {
- *   prepareTraitProof,
- *   type TraitBonusStore,
- * } from "@soltracer/nft-staking"
- *
- * // 1) Implement the store against your DB once (any DB works).
- * const traitBonusStore: TraitBonusStore = {
- *   async list({ poolId, projectId }) {
- *     const rows = await prisma.traitBonusConfig.findMany({
- *       where: { poolId, ...(projectId ? { projectId: String(projectId) } : {}) },
- *     })
- *     return rows.map((r) => ({
- *       traitType: r.traitType,
- *       value: r.traitValue,
- *       // pool is BaseMultiplier? use bonusBps. FixedExtra? use fixedExtra.
- *       bonusBps: r.bonusAmount,
- *     }))
- *   },
- * }
- *
- * // 2) Prepare the proof on each claim request.
- * const prepared = await prepareTraitProof({
- *   client,                       // NftStakingClient
- *   pool,                         // already-fetched StakePool (has rewardConfig + address)
- *   wallet: req.wallet,
- *   requestedMints: req.mints,
- *   store: traitBonusStore,
- *   resolveTraits: (mint) => catalog.getTraits(mint),
- * })
- *
- * // 3) Sign and respond.
- * const signature = nacl.sign.detached(prepared.message, traitAuthority.secretKey)
- * return {
- *   traitBonusRate: prepared.traitBonusRate.toString(),
- *   signature: Buffer.from(signature).toString("base64"),
- *   perNft: prepared.perNft,
- *   rejectedMints: prepared.rejectedMints,
- * }
+ * const isStakedBy = ownershipFromClient(client)
  * ```
  */
-export declare function prepareTraitProof(params: {
-    /** Pool config — must expose `address` and `rewardConfig.traitBonusMode`. */
-    pool: {
-        address: PkInput;
-        rewardConfig: {
-            traitBonusMode: number;
-        };
-    };
-    /** Project ID hint forwarded to the store (DB scoping, optional). */
-    projectId?: string | number;
-    poolId?: number;
-    wallet: PkInput;
-    requestedMints: ReadonlyArray<string>;
-    /** Storage adapter for the bonus catalog. */
-    store: TraitBonusStore;
-    /** Resolves trait list for a single mint. */
-    resolveTraits: NftTraitResolver;
-    /**
-     * Validates which `requestedMints` are actually staked in this pool by
-     * `wallet`. If omitted, the orchestrator trusts the caller — DO NOT skip
-     * this in production. The SDK can drive this for you when you pass a
-     * `client` and `poolId` (see `ownershipFromClient`).
-     */
-    validateOwnership: StakedOwnershipResolver;
-    /**
-     * Current `StakerAccount.totalClaimed` nonce. MUST be the live value;
-     * advance-then-sign in the same request to avoid same-second replay.
-     */
-    totalClaimed: BnInput;
-}): Promise<PreparedTraitProof>;
-/**
- * Convenience `StakedOwnershipResolver` that uses an `NftStakingClient` to
- * walk the wallet's stake entries and only allow mints currently staked in
- * `poolId`. Wire this into `prepareTraitProof({ validateOwnership })` if you
- * don't already have your own stake index.
- */
 export declare function ownershipFromClient(client: {
-    fetchStakeEntriesByOwner: (poolId: number, wallet: PkInput) => Promise<Array<{
+    fetchStakeEntriesByOwner: (owner: PkInput, poolId?: number) => Promise<Array<{
+        poolId: number;
         nftMint: {
             toBase58(): string;
         };

package/dist/traitProof.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"traitProof.d.ts","sourceRoot":"","sources":["../src/traitProof.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"traitProof.d.ts","sourceRoot":"","sources":["../src/traitProof.ts"],"names":[],"mappings":"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"}