proof-of-take-sdk 3.0.1 → 3.0.3

package/dist/instructions/withdrawSeasonDeposit.d.ts

@@ -1,6 +1,6 @@
 import { BN } from "@coral-xyz/anchor";
 import { Connection, PublicKey } from "@solana/web3.js";
-import { SeasonSettings, Season, SeasonMembership } from "../types";
+import { SeasonSettings, Season, SeasonMembership, TierNumber } from "../types";
 import { StandardInstructionResult } from "../types/instructionResults";
 type WithdrawSeasonDepositUpdatedAccounts = {
     seasonSettings?: SeasonSettings;
@@ -16,7 +16,7 @@ export interface WithdrawSeasonDepositOptions {
     userTokenAccount: PublicKey;
     seasonNumber: BN;
     /** Tier number: 1=copper, 2=silver, 3=gold, 4=platinum, 5=mithril */
-    tier: number;
+    tier: TierNumber;
     feePayer?: PublicKey;
     currentAccounts?: {
         seasonSettings?: SeasonSettings;

package/dist/types/anchorAccounts.d.ts

@@ -0,0 +1,18 @@
+import type { IdlAccounts } from "@coral-xyz/anchor";
+import type { ProofOfTake } from "./proof_of_take";
+/**
+ * Anchor-decoded on-chain account types derived from the IDL.
+ *
+ * Use these when dealing with `program.account.*.fetch()` results.
+ * (They reflect the exact current IDL, so drift is caught at compile time.)
+ */
+export type ProofOfTakeIdlAccounts = IdlAccounts<ProofOfTake>;
+export type AnchorMiztake = ProofOfTakeIdlAccounts["miztake"];
+export type AnchorMiztakeStatistics = ProofOfTakeIdlAccounts["miztakeStatistics"];
+export type AnchorUserStats = ProofOfTakeIdlAccounts["userStats"];
+export type AnchorSeasonSettings = ProofOfTakeIdlAccounts["seasonSettings"];
+export type AnchorSeason = ProofOfTakeIdlAccounts["season"];
+export type AnchorSeasonMembership = ProofOfTakeIdlAccounts["seasonMembership"];
+export type AnchorRewardWindow = ProofOfTakeIdlAccounts["rewardWindow"];
+export type AnchorUserWindowParticipation = ProofOfTakeIdlAccounts["userWindowParticipation"];
+export type AnchorReferralPenaltyClaim = ProofOfTakeIdlAccounts["referralPenaltyClaim"];

package/dist/types/anchorAccounts.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/anchorViews.d.ts

@@ -0,0 +1,11 @@
+import type { IdlTypes } from "@coral-xyz/anchor";
+import type { ProofOfTake } from "./proof_of_take";
+/**
+ * Anchor `.view()` return struct types derived from the IDL.
+ *
+ * Use these for `program.methods.*.view()` results.
+ */
+export type ProofOfTakeIdlTypes = IdlTypes<ProofOfTake>;
+export type AnchorCurrentSeasonView = ProofOfTakeIdlTypes["currentSeasonView"];
+export type AnchorSeasonMembershipStatusView = ProofOfTakeIdlTypes["seasonMembershipStatusView"];
+export type AnchorWindowStatusView = ProofOfTakeIdlTypes["windowStatusView"];

package/dist/types/anchorViews.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/instructionResults.d.ts

@@ -12,7 +12,7 @@ export interface InstructionResult {
  * Standard instruction result with PDAs and optional updated accounts
  * This is the unified return type for all instructions
  */
-export interface StandardInstructionResult<TPdas extends Record<string, PublicKey> = Record<string, PublicKey>, TAccounts = Record<string, unknown>, TMeta = Record<string, unknown>> extends InstructionResult {
+export interface StandardInstructionResult<TPdas extends Record<string, PublicKey> = Record<string, PublicKey>, TAccounts = never, TMeta = never> extends InstructionResult {
     /** Program-derived addresses created or used by this instruction */
     pdas?: TPdas;
     /** Optimistically updated account states (if current accounts were provided) */
@@ -21,24 +21,23 @@ export interface StandardInstructionResult<TPdas extends Record<string, PublicKe
     metadata?: TMeta;
 }
 /**
- * Legacy: Instruction result with PDA addresses
- * @deprecated Use StandardInstructionResult instead
+ * Helper type: same as StandardInstructionResult, but with required `pdas`.
+ * (Most instruction builders always compute/return their PDAs.)
  */
-export interface InstructionResultWithPdas extends InstructionResult {
-    pdas: Record<string, PublicKey>;
-}
+export type StandardInstructionResultWithPdas<TPdas extends Record<string, PublicKey>, TAccounts = never, TMeta = never> = StandardInstructionResult<TPdas, TAccounts, TMeta> & {
+    pdas: TPdas;
+};
 /**
- * Legacy: Instruction result with optimistically updated accounts
- * @deprecated Use StandardInstructionResult instead
+ * Helper type: required `pdas` and required `updatedAccounts`.
+ * (Used by builders that always provide optimistic updates, like createMiztake.)
  */
-export interface InstructionResultWithAccounts<T = Record<string, unknown>> extends InstructionResult {
-    updatedAccounts?: T;
-}
-/**
- * Legacy: Full instruction result with both PDAs and updated accounts
- * @deprecated Use StandardInstructionResult instead
- */
-export interface FullInstructionResult<T = Record<string, unknown>> extends InstructionResult {
-    pdas: Record<string, PublicKey>;
-    updatedAccounts?: T;
-}
+export type StandardInstructionResultWithPdasAndAccounts<TPdas extends Record<string, PublicKey>, TAccounts, TMeta = never> = StandardInstructionResult<TPdas, TAccounts, TMeta> & {
+    pdas: TPdas;
+    updatedAccounts: TAccounts;
+};
+/** @deprecated Use StandardInstructionResultWithPdas instead */
+export type InstructionResultWithPdas = StandardInstructionResultWithPdas<Record<string, PublicKey>>;
+/** @deprecated Use StandardInstructionResult instead */
+export type InstructionResultWithAccounts<T = unknown> = StandardInstructionResult<Record<string, PublicKey>, T>;
+/** @deprecated Use StandardInstructionResultWithPdas instead */
+export type FullInstructionResult<T = unknown> = StandardInstructionResultWithPdas<Record<string, PublicKey>, T>;

package/dist/types.d.ts

@@ -4,6 +4,35 @@ import { BN } from "@coral-xyz/anchor";
  * Type definitions for Proof of Take SDK
  */
 export type { ProofOfTake } from "./types/proof_of_take";
+export type { ProofOfTakeIdlAccounts, AnchorMiztake, AnchorMiztakeStatistics, AnchorUserStats, AnchorSeasonSettings, AnchorSeason, AnchorSeasonMembership, AnchorRewardWindow, AnchorUserWindowParticipation, AnchorReferralPenaltyClaim, } from "./types/anchorAccounts";
+export type { ProofOfTakeIdlTypes, AnchorCurrentSeasonView, AnchorSeasonMembershipStatusView, AnchorWindowStatusView, } from "./types/anchorViews";
+/**
+ * Helper for Anchor "unit enum" variants.
+ *
+ * Anchor represents enums as an object with a single key, e.g. `{ active: {} }`.
+ */
+type AnchorEnumVariant<K extends string> = {
+    [P in K]: Record<string, never>;
+};
+/**
+ * Tier number used across the program (and PDA seeds).
+ * 1=copper, 2=silver, 3=gold, 4=platinum, 5=mithril
+ */
+export type TierNumber = 1 | 2 | 3 | 4 | 5;
+/**
+ * Branded types for common on-chain invariants.
+ */
+export type Sha256HexString = string & {
+    readonly __brand: "Sha256HexString";
+};
+export type Bytes32 = Uint8Array & {
+    readonly __brand: "Bytes32";
+};
+/** Window index within a season schedule (0..20) */
+export type WindowIndex = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 | 18 | 19 | 20;
+export type WindowNumberLike = BN | WindowIndex;
+export type DepositTierName = "copper" | "silver" | "gold" | "platinum" | "mithril";
+export type SeasonNumberLike = BN | number;
 export interface CreateMiztakeParams {
     telegramId: BN;
     telegramUsername: string;
@@ -11,7 +40,8 @@ export interface CreateMiztakeParams {
     averageHash: string;
     differenceHash: string;
     waveletHash: string;
-    shaHash: string;
+    /** Accepts either a validated branded hash or a raw 64-char hex string (will be normalized). */
+    shaHash: Sha256HexString | string;
     computedAt: string;
 }
 export interface ClaimRewardParams {
@@ -51,7 +81,7 @@ export interface Miztake {
     averageHash: string;
     differenceHash: string;
     waveletHash: string;
-    shaHash: string;
+    shaHash: Sha256HexString;
     computedAt: string;
     creator: PublicKey;
     userStats: PublicKey;
@@ -70,6 +100,14 @@ export declare enum WindowState {
     Active = 1,
     Finalized = 2
 }
+/**
+ * Anchor enum formats returned by account fetches.
+ * We accept both the SDK numeric enums and Anchor object enums throughout the SDK.
+ */
+export type SeasonStateAnchor = AnchorEnumVariant<"uninitialized"> | AnchorEnumVariant<"active"> | AnchorEnumVariant<"ended">;
+export type WindowStateAnchor = AnchorEnumVariant<"uninitialized"> | AnchorEnumVariant<"active"> | AnchorEnumVariant<"finalized">;
+export type SeasonStateLike = SeasonState | SeasonStateAnchor | number;
+export type WindowStateLike = WindowState | WindowStateAnchor | number;
 /**
  * Season deposit tier (Anchor enum representation)
  *
@@ -87,6 +125,15 @@ export type SeasonDepositTier = {
 } | {
     mithril: Record<string, never>;
 };
+/**
+ * Fixed-length array helper for on-chain fixed-size arrays.
+ * (Used to tighten `[u64; 21]` schedule fields without forcing tuple literals everywhere.)
+ */
+export type FixedLengthArray<T, N extends number> = T[] & {
+    length: N;
+};
+/** On-chain `eligible_stake_per_window: [u64; 21]` */
+export type EligibleStakePerWindow = FixedLengthArray<BN, 21>;
 export interface SeasonSettings {
     completedSeasons: BN;
     seasonDuration: BN;
@@ -102,7 +149,7 @@ export interface SeasonSettings {
 }
 export interface Season {
     seasonNumber: BN;
-    seasonState: SeasonState;
+    seasonState: SeasonStateLike;
     startedAt: BN;
     endsAt: BN;
     totalWindows: number;
@@ -112,10 +159,11 @@ export interface Season {
     goldMembersCount: BN;
     platinumMembersCount: BN;
     mithrilMembersCount: BN;
-    eligibleStakePerWindow: BN[];
+    eligibleStakePerWindow: EligibleStakePerWindow;
     totalDepositsHeld: BN;
     totalSuccessfulPosts: BN;
     totalPenaltiesCollected: BN;
+    totalUnallocatedFunds: BN;
     bump: number;
 }
 export interface SeasonMembership {
@@ -139,7 +187,7 @@ export interface SeasonMembership {
 export interface RewardWindow {
     seasonNumber: BN;
     windowNumber: BN;
-    windowState: WindowState;
+    windowState: WindowStateLike;
     startedAt: BN;
     endsAt: BN;
     totalMembersInSeason: BN;

package/dist/utils/accountConverters.d.ts

@@ -0,0 +1,19 @@
+import { BN } from "@coral-xyz/anchor";
+import type { EligibleStakePerWindow, Miztake, MiztakeStatistics, ReferralPenaltyClaim, RewardWindow, Season, SeasonMembership, SeasonSettings, UserStats, UserWindowParticipation } from "../types";
+import type { AnchorMiztake, AnchorMiztakeStatistics, AnchorReferralPenaltyClaim, AnchorRewardWindow, AnchorSeason, AnchorSeasonMembership, AnchorSeasonSettings, AnchorUserStats, AnchorUserWindowParticipation } from "../types";
+/**
+ * Converters from Anchor-decoded account shapes (IDL-derived) to SDK-facing types.
+ *
+ * Why: it centralizes any representation differences (e.g. fixed arrays, enums),
+ * and makes IDL/account drift surface as compile errors in one place.
+ */
+export declare function toSdkMiztake(a: AnchorMiztake): Miztake;
+export declare function toSdkMiztakeStatistics(a: AnchorMiztakeStatistics): MiztakeStatistics;
+export declare function toSdkUserStats(a: AnchorUserStats): UserStats;
+export declare function toSdkSeasonSettings(a: AnchorSeasonSettings): SeasonSettings;
+export declare function toSdkSeason(a: AnchorSeason): Season;
+export declare function toSdkSeasonMembership(a: AnchorSeasonMembership): SeasonMembership;
+export declare function toSdkRewardWindow(a: AnchorRewardWindow): RewardWindow;
+export declare function toSdkUserWindowParticipation(a: AnchorUserWindowParticipation): UserWindowParticipation;
+export declare function toSdkReferralPenaltyClaim(a: AnchorReferralPenaltyClaim): ReferralPenaltyClaim;
+export declare function getEligibleStakeAtIndex(eligibleStakePerWindow: EligibleStakePerWindow, idx: number): BN;

package/dist/utils/accountConverters.js

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toSdkMiztake = toSdkMiztake;
+exports.toSdkMiztakeStatistics = toSdkMiztakeStatistics;
+exports.toSdkUserStats = toSdkUserStats;
+exports.toSdkSeasonSettings = toSdkSeasonSettings;
+exports.toSdkSeason = toSdkSeason;
+exports.toSdkSeasonMembership = toSdkSeasonMembership;
+exports.toSdkRewardWindow = toSdkRewardWindow;
+exports.toSdkUserWindowParticipation = toSdkUserWindowParticipation;
+exports.toSdkReferralPenaltyClaim = toSdkReferralPenaltyClaim;
+exports.getEligibleStakeAtIndex = getEligibleStakeAtIndex;
+const anchor_1 = require("@coral-xyz/anchor");
+const conversions_1 = require("./conversions");
+/**
+ * Converters from Anchor-decoded account shapes (IDL-derived) to SDK-facing types.
+ *
+ * Why: it centralizes any representation differences (e.g. fixed arrays, enums),
+ * and makes IDL/account drift surface as compile errors in one place.
+ */
+function toSdkMiztake(a) {
+    return {
+        id: a.id,
+        telegramId: a.telegramId,
+        telegramUsername: a.telegramUsername,
+        perceptualHash: a.perceptualHash,
+        averageHash: a.averageHash,
+        differenceHash: a.differenceHash,
+        waveletHash: a.waveletHash,
+        shaHash: (0, conversions_1.toSha256HexString)(a.shaHash),
+        computedAt: a.computedAt,
+        creator: a.creator,
+        userStats: a.userStats,
+        userKey: a.userKey,
+        onchainCreatedAt: a.onchainCreatedAt,
+        usedInSeason: a.usedInSeason,
+        usedInWindow: a.usedInWindow,
+    };
+}
+function toSdkMiztakeStatistics(a) {
+    return {
+        totalMiztakes: a.totalMiztakes,
+        bump: a.bump,
+    };
+}
+function toSdkUserStats(a) {
+    return {
+        telegramId: a.telegramId,
+        totalNumberOfMiztakes: a.totalNumberOfMiztakes,
+        onchainFirstMiztakeAt: a.onchainFirstMiztakeAt,
+        onchainLastMiztakeAt: a.onchainLastMiztakeAt,
+        bump: a.bump,
+    };
+}
+function toSdkSeasonSettings(a) {
+    return {
+        completedSeasons: a.completedSeasons,
+        seasonDuration: a.seasonDuration,
+        windowDuration: a.windowDuration,
+        totalWindowsPerSeason: a.totalWindowsPerSeason,
+        canInitializeNextSeason: a.canInitializeNextSeason,
+        lastSeasonEndsAt: a.lastSeasonEndsAt,
+        currentSeasonNumber: a.currentSeasonNumber,
+        admin: a.admin,
+        isPaused: a.isPaused,
+        maxMembersPerSeason: a.maxMembersPerSeason,
+        bump: a.bump,
+    };
+}
+function toSdkSeason(a) {
+    const eligibleStakePerWindow = (0, conversions_1.toEligibleStakePerWindow)(a.eligibleStakePerWindow);
+    return {
+        seasonNumber: a.seasonNumber,
+        seasonState: a.seasonState,
+        startedAt: a.startedAt,
+        endsAt: a.endsAt,
+        totalWindows: a.totalWindows,
+        totalMembers: a.totalMembers,
+        copperMembersCount: a.copperMembersCount,
+        silverMembersCount: a.silverMembersCount,
+        goldMembersCount: a.goldMembersCount,
+        platinumMembersCount: a.platinumMembersCount,
+        mithrilMembersCount: a.mithrilMembersCount,
+        eligibleStakePerWindow,
+        totalDepositsHeld: a.totalDepositsHeld,
+        totalSuccessfulPosts: a.totalSuccessfulPosts,
+        totalPenaltiesCollected: a.totalPenaltiesCollected,
+        totalUnallocatedFunds: a.totalUnallocatedFunds,
+        bump: a.bump,
+    };
+}
+function toSdkSeasonMembership(a) {
+    return {
+        owner: a.owner,
+        referrer: a.referrer,
+        seasonNumber: a.seasonNumber,
+        depositTier: a.depositTier,
+        depositAmount: a.depositAmount,
+        depositEscrowedAmount: a.depositEscrowedAmount,
+        joinedAt: a.joinedAt,
+        joinedWindowNumber: a.joinedWindowNumber,
+        successfulPostsCount: a.successfulPostsCount,
+        totalRewardsClaimed: a.totalRewardsClaimed,
+        totalPenaltiesPaid: a.totalPenaltiesPaid,
+        depositWithdrawn: a.depositWithdrawn,
+        isActive: a.isActive,
+        bump: a.bump,
+    };
+}
+function toSdkRewardWindow(a) {
+    return {
+        seasonNumber: a.seasonNumber,
+        windowNumber: a.windowNumber,
+        windowState: a.windowState,
+        startedAt: a.startedAt,
+        endsAt: a.endsAt,
+        totalMembersInSeason: a.totalMembersInSeason,
+        penaltyPool: a.penaltyPool,
+        successfulPostersCount: a.successfulPostersCount,
+        successfulStakeTotal: a.successfulStakeTotal,
+        rewardPerPoster: a.rewardPerPoster,
+        isFinalized: a.isFinalized,
+        bump: a.bump,
+    };
+}
+function toSdkUserWindowParticipation(a) {
+    return {
+        user: a.user,
+        seasonNumber: a.seasonNumber,
+        windowNumber: a.windowNumber,
+        postedSuccessfully: a.postedSuccessfully,
+        claimedReward: a.claimedReward,
+        rewardAmount: a.rewardAmount,
+        miztakeId: a.miztakeId,
+        bump: a.bump,
+    };
+}
+function toSdkReferralPenaltyClaim(a) {
+    return {
+        referredUser: a.referredUser,
+        seasonNumber: a.seasonNumber,
+        windowNumber: a.windowNumber,
+        claimant: a.claimant,
+        amount: a.amount,
+        claimedAt: a.claimedAt,
+        claimed: a.claimed,
+        bump: a.bump,
+    };
+}
+// Convenience for `[u64; 21]` arithmetic call sites
+function getEligibleStakeAtIndex(eligibleStakePerWindow, idx) {
+    return eligibleStakePerWindow[idx] ?? new anchor_1.BN(0);
+}

package/dist/utils/accountUpdates.d.ts

@@ -1,6 +1,6 @@
 import { BN } from "@coral-xyz/anchor";
 import { PublicKey } from "@solana/web3.js";
-import { Miztake, UserStats, MiztakeStatistics, SeasonSettings, Season, SeasonMembership, RewardWindow, UserWindowParticipation, SeasonDepositTier, ReferralPenaltyClaim } from "../types";
+import { Miztake, UserStats, MiztakeStatistics, SeasonSettings, Season, SeasonMembership, RewardWindow, UserWindowParticipation, SeasonDepositTier, ReferralPenaltyClaim, TierNumber } from "../types";
 /**
  * Get current Unix timestamp in SECONDS as BN
  *
@@ -98,7 +98,7 @@ export declare function updateMiztakeStatisticsForCreation(statistics: MiztakeSt
  * @param miztakeId - The miztake ID to associate
  * @returns Initialized/Updated UserWindowParticipation object
  */
-export declare function initializeUserWindowParticipation(user: PublicKey, seasonNumber: BN, windowNumber: BN, tier: number, miztakeId: BN): UserWindowParticipation;
+export declare function initializeUserWindowParticipation(user: PublicKey, seasonNumber: BN, windowNumber: BN, tier: TierNumber, miztakeId: BN): UserWindowParticipation;
 /**
  * Initialize RewardWindow
  * Mirrors the logic from season_helpers::initialize_window
@@ -234,7 +234,7 @@ export declare function initializeReferralPenaltyClaim(params: {
     referredUser: PublicKey;
     seasonNumber: BN;
     windowNumber: BN;
-    tier: number;
+    tier: TierNumber;
     claimant: PublicKey;
     perWindowPenalty: BN;
     claimedAt?: BN;

package/dist/utils/accountUpdates.js

@@ -24,7 +24,9 @@ exports.updateSeasonSettingsForPauseToggle = updateSeasonSettingsForPauseToggle;
 exports.updateSeasonSettingsForAdminUpdate = updateSeasonSettingsForAdminUpdate;
 const anchor_1 = require("@coral-xyz/anchor");
 const types_1 = require("../types");
+const depositTier_1 = require("./depositTier");
 const tierPenalty_1 = require("./tierPenalty");
+const conversions_1 = require("./conversions");
 const pdas_1 = require("./pdas");
 const enumHelpers_1 = require("./enumHelpers");
 /**
@@ -89,6 +91,7 @@ function expectedToBeLazyInitialized(params) {
         totalDepositsHeld: new anchor_1.BN(0),
         totalSuccessfulPosts: new anchor_1.BN(0),
         totalPenaltiesCollected: new anchor_1.BN(0),
+        totalUnallocatedFunds: new anchor_1.BN(0),
         bump,
     };
 }
@@ -309,9 +312,9 @@ function updateSeasonForJoin(season, depositActive, depositTier, joinedWindowNum
             ? seasonLike.totalWindows
             : 21;
     const scheduleLen = existingSchedule?.length ?? inferredTotalWindows;
-    const schedule = existingSchedule
+    const schedule = (existingSchedule
         ? existingSchedule.slice()
-        : Array.from({ length: scheduleLen }, () => new anchor_1.BN(0));
+        : Array.from({ length: scheduleLen }, () => new anchor_1.BN(0)));
     const next = {
         ...season,
         totalMembers: season.totalMembers.add(new anchor_1.BN(1)),
@@ -319,7 +322,14 @@ function updateSeasonForJoin(season, depositActive, depositTier, joinedWindowNum
         eligibleStakePerWindow: schedule,
     };
     const perWindowStake = (0, tierPenalty_1.getTierPenaltyPerWindow)(depositTier);
-    const startIdx = joinedWindowNumber.toNumber();
+    // Don't throw in optimistic flows if something is off; just skip schedule mutation.
+    let startIdx = scheduleLen; // default: no updates
+    try {
+        startIdx = (0, conversions_1.assertWindowIndex)(joinedWindowNumber);
+    }
+    catch {
+        startIdx = scheduleLen;
+    }
     const endExclusive = Math.min(inferredTotalWindows, next.eligibleStakePerWindow.length);
     // If inputs are out of range, don't try to mutate schedule (avoid throwing in optimistic path).
     const updatedSchedule = next.eligibleStakePerWindow.map((v, i) => {
@@ -331,34 +341,33 @@ function updateSeasonForJoin(season, depositActive, depositTier, joinedWindowNum
         ...next,
         eligibleStakePerWindow: updatedSchedule,
     };
-    if ("copper" in depositTier)
-        return {
-            ...nextWithSchedule,
-            copperMembersCount: season.copperMembersCount.add(new anchor_1.BN(1)),
-        };
-    if ("silver" in depositTier)
-        return {
-            ...nextWithSchedule,
-            silverMembersCount: season.silverMembersCount.add(new anchor_1.BN(1)),
-        };
-    if ("gold" in depositTier)
-        return {
-            ...nextWithSchedule,
-            goldMembersCount: season.goldMembersCount.add(new anchor_1.BN(1)),
-        };
-    if ("platinum" in depositTier)
-        return {
-            ...nextWithSchedule,
-            platinumMembersCount: season.platinumMembersCount.add(new anchor_1.BN(1)),
-        };
-    if ("mithril" in depositTier)
-        return {
-            ...nextWithSchedule,
-            mithrilMembersCount: season.mithrilMembersCount.add(new anchor_1.BN(1)),
-        };
-    return {
-        ...nextWithSchedule,
-    };
+    switch ((0, depositTier_1.getDepositTierName)(depositTier)) {
+        case "copper":
+            return {
+                ...nextWithSchedule,
+                copperMembersCount: season.copperMembersCount.add(new anchor_1.BN(1)),
+            };
+        case "silver":
+            return {
+                ...nextWithSchedule,
+                silverMembersCount: season.silverMembersCount.add(new anchor_1.BN(1)),
+            };
+        case "gold":
+            return {
+                ...nextWithSchedule,
+                goldMembersCount: season.goldMembersCount.add(new anchor_1.BN(1)),
+            };
+        case "platinum":
+            return {
+                ...nextWithSchedule,
+                platinumMembersCount: season.platinumMembersCount.add(new anchor_1.BN(1)),
+            };
+        case "mithril":
+            return {
+                ...nextWithSchedule,
+                mithrilMembersCount: season.mithrilMembersCount.add(new anchor_1.BN(1)),
+            };
+    }
 }
 /**
  * Update RewardWindow after post confirmation

package/dist/utils/conversions.d.ts

@@ -1,4 +1,5 @@
 import { BN } from "@coral-xyz/anchor";
+import type { Bytes32, Sha256HexString, EligibleStakePerWindow, WindowIndex, WindowNumberLike, SeasonNumberLike } from "../types";
 /**
  * Safely convert BN to number for u64 fields
  * Throws if the BN is larger than JavaScript's MAX_SAFE_INTEGER
@@ -22,4 +23,23 @@ export declare function bnToU64Safe(bn: BN): number | undefined;
  * IMPORTANT: The on-chain program uses the raw 32-byte digest as PDA seed
  * (`seeds = [b\"miztake\", sha_hash_bytes]`), NOT the ASCII prefix of the hex string.
  */
-export declare function sha256HexToBytes32(shaHex: string): Uint8Array;
+export declare function toSha256HexString(shaHex: Sha256HexString): Sha256HexString;
+export declare function toSha256HexString(shaHex: string): Sha256HexString;
+export declare function isSha256HexString(value: unknown): value is Sha256HexString;
+export declare function sha256HexToBytes32(shaHex: Sha256HexString | string): Bytes32;
+/**
+ * Validate a window index (0..20).
+ * Accepts BN (u64) or number; returns a narrowed WindowIndex.
+ */
+export declare function assertWindowIndex(value: BN | number): WindowIndex;
+/**
+ * Normalize a window number-like input to BN and validate it's within 0..20.
+ */
+export declare function toWindowNumberBn(value: WindowNumberLike): BN;
+/**
+ * Runtime check + safe cast for the on-chain `[u64; 21]` schedule.
+ *
+ * This avoids `as unknown as ...` casts at call sites.
+ */
+export declare function toEligibleStakePerWindow(value: readonly BN[]): EligibleStakePerWindow;
+export declare function toSeasonNumberBn(value: SeasonNumberLike): BN;

package/dist/utils/conversions.js

@@ -2,7 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.bnToU64 = bnToU64;
 exports.bnToU64Safe = bnToU64Safe;
+exports.toSha256HexString = toSha256HexString;
+exports.isSha256HexString = isSha256HexString;
 exports.sha256HexToBytes32 = sha256HexToBytes32;
+exports.assertWindowIndex = assertWindowIndex;
+exports.toWindowNumberBn = toWindowNumberBn;
+exports.toEligibleStakePerWindow = toEligibleStakePerWindow;
+exports.toSeasonNumberBn = toSeasonNumberBn;
 const anchor_1 = require("@coral-xyz/anchor");
 /**
  * Safely convert BN to number for u64 fields
@@ -31,23 +37,65 @@ function bnToU64Safe(bn) {
     }
     return bn.toNumber();
 }
-/**
- * Convert a 64-char SHA-256 hex string to a 32-byte Uint8Array.
- *
- * IMPORTANT: The on-chain program uses the raw 32-byte digest as PDA seed
- * (`seeds = [b\"miztake\", sha_hash_bytes]`), NOT the ASCII prefix of the hex string.
- */
-function sha256HexToBytes32(shaHex) {
+function toSha256HexString(shaHex) {
     if (typeof shaHex !== "string") {
-        throw new Error("sha256HexToBytes32: shaHex must be a string");
+        throw new Error("toSha256HexString: shaHex must be a string");
     }
     const normalized = shaHex.toLowerCase();
     if (!/^[0-9a-f]{64}$/.test(normalized)) {
-        throw new Error("sha256HexToBytes32: expected 64-char lowercase hex string");
+        throw new Error("toSha256HexString: expected 64-char hex string");
     }
+    return normalized;
+}
+function isSha256HexString(value) {
+    return (typeof value === "string" &&
+        /^[0-9a-f]{64}$/.test(value.toLowerCase()));
+}
+function sha256HexToBytes32(shaHex) {
+    const normalized = typeof shaHex === "string" ? toSha256HexString(shaHex) : shaHex;
     const buf = Buffer.from(normalized, "hex");
     if (buf.length !== 32) {
         throw new Error("sha256HexToBytes32: decoded length != 32");
     }
     return new Uint8Array(buf);
 }
+/**
+ * Validate a window index (0..20).
+ * Accepts BN (u64) or number; returns a narrowed WindowIndex.
+ */
+function assertWindowIndex(value) {
+    const n = typeof value === "number"
+        ? value
+        : value.toNumber(); // safe: window index is small in this program
+    if (!Number.isInteger(n) || n < 0 || n > 20) {
+        throw new Error("Invalid window index: must be an integer between 0 and 20");
+    }
+    return n;
+}
+/**
+ * Normalize a window number-like input to BN and validate it's within 0..20.
+ */
+function toWindowNumberBn(value) {
+    const bn = typeof value === "number" ? new anchor_1.BN(value) : value;
+    assertWindowIndex(bn);
+    return bn;
+}
+/**
+ * Runtime check + safe cast for the on-chain `[u64; 21]` schedule.
+ *
+ * This avoids `as unknown as ...` casts at call sites.
+ */
+function toEligibleStakePerWindow(value) {
+    if (value.length !== 21) {
+        throw new Error(`Invalid eligibleStakePerWindow length: expected 21, got ${value.length}`);
+    }
+    // We intentionally cast after validation.
+    return value;
+}
+function toSeasonNumberBn(value) {
+    const bn = typeof value === "number" ? new anchor_1.BN(value) : value;
+    if (bn.isNeg()) {
+        throw new Error("Invalid season number: must be >= 0");
+    }
+    return bn;
+}

package/dist/utils/depositTier.d.ts

@@ -0,0 +1,3 @@
+import { DepositTierName, SeasonDepositTier } from "../types";
+export declare function getDepositTierName(tier: SeasonDepositTier): DepositTierName;
+export declare function isDepositTier(tier: SeasonDepositTier, name: DepositTierName): boolean;