proof-of-take-sdk 1.0.0

package/dist/instructions/createMiztake.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMiztake = createMiztake;
+exports.getMiztakePdaForParams = getMiztakePdaForParams;
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+const types_1 = require("../types");
+const pdaManager_1 = require("../utils/pdaManager");
+const programHelpers_1 = require("../utils/programHelpers");
+const signerHelpers_1 = require("../utils/signerHelpers");
+const conversions_1 = require("../utils/conversions");
+const optimistic_1 = require("../optimistic");
+const enumHelpers_1 = require("../utils/enumHelpers");
+/**
+ * Create a new miztake
+ *
+ * Requires dual signature: user + admin
+ * User pays for miztake, user_stats, and user_window_participation accounts
+ * Admin pays for reward_window account (if needed)
+ *
+ * @param options - Create miztake options
+ * @returns Instructions, signers, PDAs, and optimistically updated accounts
+ *
+ * @example
+ * ```typescript
+ * const result = await createMiztake({
+ *   connection,
+ *   params,
+ *   user: userWallet.publicKey,
+ *   admin: adminWallet.publicKey,
+ *   seasonNumber: new BN(1),
+ *   windowNumber: new BN(5),
+ *   seasonMembershipId: new BN(123),
+ *   currentAccounts: {
+ *     userStats: currentUserStats,
+ *     miztakeStatistics: currentStats,
+ *     season: currentSeason,
+ *     seasonSettings: settings,
+ *   }
+ * });
+ * ```
+ */
+async function createMiztake(options) {
+    const program = (0, programHelpers_1.getProgram)(options.connection);
+    // Derive all PDAs using PDAManager
+    const pdas = pdaManager_1.PDAManager.deriveMiztakePdas({
+        shaHash: options.params.shaHash,
+        telegramId: options.params.telegramId,
+        seasonNumber: options.seasonNumber,
+        windowNumber: options.windowNumber,
+        seasonMembershipId: options.seasonMembershipId,
+        user: options.user,
+    });
+    // Build typed accounts object
+    const accounts = {
+        miztake: pdas.miztake,
+        userStats: pdas.userStats,
+        miztakeStatistics: pdas.miztakeStatistics,
+        seasonSettings: pdas.seasonSettings,
+        season: pdas.season,
+        seasonMembership: pdas.seasonMembership,
+        rewardWindow: pdas.rewardWindow,
+        userWindowParticipation: pdas.userWindowParticipation,
+        user: options.user,
+        admin: options.admin,
+        systemProgram: web3_js_1.SystemProgram.programId,
+    };
+    // Build instruction
+    const shaHashBytes = (0, conversions_1.sha256HexToBytes32)(options.params.shaHash);
+    const instruction = await program.methods
+        .createMiztake(
+    // Anchor expects BN for u64 args.
+    options.params.telegramId, options.params.telegramUsername, options.params.perceptualHash, options.params.averageHash, options.params.differenceHash, options.params.waveletHash, options.params.shaHash, Array.from(shaHashBytes), options.params.computedAt, options.seasonNumber, options.windowNumber, options.seasonMembershipId)
+        .accounts(accounts)
+        .instruction();
+    // Build signers
+    const signers = (0, signerHelpers_1.buildSigners)([
+        { publicKey: options.user, role: "user" },
+        { publicKey: options.admin, role: "admin" },
+    ], options.feePayer);
+    // OPTIMISTIC UPDATES
+    const now = (0, optimistic_1.getCurrentTimestamp)(options.now);
+    const curr = options.currentAccounts || {};
+    // 1. Update or initialize UserStats
+    const updatedUserStats = curr.userStats
+        ? (0, optimistic_1.updateUserStatsForMiztakeCreation)(curr.userStats, options.params.telegramId, now)
+        : undefined;
+    // 2. Update MiztakeStatistics
+    let updatedStatistics;
+    let newMiztakeId;
+    if (curr.miztakeStatistics) {
+        const result = (0, optimistic_1.updateMiztakeStatisticsForCreation)(curr.miztakeStatistics);
+        updatedStatistics = result.statistics;
+        newMiztakeId = result.newMiztakeId;
+    }
+    else {
+        newMiztakeId = new anchor_1.BN(1); // Placeholder
+    }
+    // 3. Initialize UserWindowParticipation
+    const updatedUserWindowParticipation = (0, optimistic_1.initializeUserWindowParticipation)(options.user, options.seasonNumber, options.windowNumber, options.seasonMembershipId, newMiztakeId);
+    // 4. Initialize RewardWindow if needed
+    let updatedRewardWindow;
+    if (curr.rewardWindow) {
+        // Use helper to handle both enum formats
+        if ((0, enumHelpers_1.isWindowState)(curr.rewardWindow.windowState, types_1.WindowState.Uninitialized) &&
+            curr.season &&
+            curr.seasonSettings) {
+            updatedRewardWindow = (0, optimistic_1.initializeRewardWindow)(options.seasonNumber, options.windowNumber, curr.season, curr.seasonSettings.windowDuration);
+        }
+        else {
+            updatedRewardWindow = curr.rewardWindow;
+        }
+    }
+    else if (curr.season && curr.seasonSettings) {
+        updatedRewardWindow = (0, optimistic_1.initializeRewardWindow)(options.seasonNumber, options.windowNumber, curr.season, curr.seasonSettings.windowDuration);
+    }
+    // 5. Build expected Miztake object
+    const miztake = {
+        id: newMiztakeId,
+        telegramId: options.params.telegramId,
+        telegramUsername: options.params.telegramUsername,
+        perceptualHash: options.params.perceptualHash,
+        averageHash: options.params.averageHash,
+        differenceHash: options.params.differenceHash,
+        waveletHash: options.params.waveletHash,
+        shaHash: options.params.shaHash,
+        computedAt: options.params.computedAt,
+        creator: options.user,
+        userStats: pdas.userStats,
+        userKey: options.user,
+        onchainCreatedAt: now,
+        usedInSeason: new anchor_1.BN(0),
+        usedInWindow: new anchor_1.BN(0),
+    };
+    return {
+        instructions: [instruction],
+        signers,
+        pdas,
+        updatedAccounts: {
+            miztake,
+            ...(updatedUserStats && { userStats: updatedUserStats }),
+            ...(updatedStatistics && { miztakeStatistics: updatedStatistics }),
+            ...(curr.seasonSettings && { seasonSettings: curr.seasonSettings }),
+            ...(curr.season && { season: curr.season }),
+            ...(curr.seasonMembership && { seasonMembership: curr.seasonMembership }),
+            ...(updatedRewardWindow && { rewardWindow: updatedRewardWindow }),
+            ...(updatedUserWindowParticipation && {
+                userWindowParticipation: updatedUserWindowParticipation,
+            }),
+        },
+    };
+}
+/**
+ * Get the miztake PDA that would be created for given parameters
+ * Useful for checking if a miztake already exists
+ */
+function getMiztakePdaForParams(params) {
+    return pdaManager_1.PDAManager.deriveMiztakePdas({
+        shaHash: params.shaHash,
+        telegramId: params.telegramId,
+        seasonNumber: new anchor_1.BN(0),
+        windowNumber: new anchor_1.BN(0),
+        seasonMembershipId: new anchor_1.BN(0),
+        user: web3_js_1.PublicKey.default,
+    }).miztake;
+}

package/dist/instructions/initializeEscrowVault.d.ts

@@ -0,0 +1,15 @@
+import { Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { SignerInfo } from "../utils/signerHelpers";
+/**
+ * Initialize season escrow vault
+ *
+ * Single signer: admin (pays for account creation)
+ * This initializes the token vault for escrowed (protected) deposits.
+ */
+export declare function initializeEscrowVault(connection: Connection, admin: PublicKey, feePayer?: PublicKey): Promise<{
+    instructions: TransactionInstruction[];
+    signers: SignerInfo[];
+    pdas: {
+        vault: PublicKey;
+    };
+}>;

package/dist/instructions/initializeEscrowVault.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeEscrowVault = initializeEscrowVault;
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const pdas_1 = require("../utils/pdas");
+const constants_1 = require("../utils/constants");
+const programHelpers_1 = require("../utils/programHelpers");
+const signerHelpers_1 = require("../utils/signerHelpers");
+/**
+ * Initialize season escrow vault
+ *
+ * Single signer: admin (pays for account creation)
+ * This initializes the token vault for escrowed (protected) deposits.
+ */
+async function initializeEscrowVault(connection, admin, feePayer) {
+    const program = (0, programHelpers_1.getProgram)(connection);
+    const [vaultPda] = (0, pdas_1.getSeasonEscrowVaultPda)();
+    const accounts = {
+        seasonEscrowVault: vaultPda,
+        mizdMint: constants_1.MIZD_TOKEN_MINT,
+        admin,
+        tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+        systemProgram: web3_js_1.SystemProgram.programId,
+    };
+    const instruction = await program.methods
+        .initializeEscrowVault()
+        .accounts(accounts)
+        .instruction();
+    const signers = (0, signerHelpers_1.buildSigners)([{ publicKey: admin, role: "admin" }], feePayer);
+    return {
+        instructions: [instruction],
+        signers,
+        pdas: { vault: vaultPda },
+    };
+}

package/dist/instructions/initializeSeasonSettings.d.ts

@@ -0,0 +1,20 @@
+import { Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { SignerInfo } from "../utils/signerHelpers";
+/**
+ * Initialize season settings
+ *
+ * Single signer: admin (pays for account creation)
+ * This initializes the global season settings account
+ *
+ * @param connection - Solana connection
+ * @param admin - Admin public key (must sign and pays for account)
+ * @param feePayer - Optional separate fee payer for transaction fees
+ * @returns Instructions, signers array, and season settings PDA
+ */
+export declare function initializeSeasonSettings(connection: Connection, admin: PublicKey, feePayer?: PublicKey): Promise<{
+    instructions: TransactionInstruction[];
+    signers: SignerInfo[];
+    pdas: {
+        seasonSettings: PublicKey;
+    };
+}>;

package/dist/instructions/initializeSeasonSettings.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeSeasonSettings = initializeSeasonSettings;
+const web3_js_1 = require("@solana/web3.js");
+const pdas_1 = require("../utils/pdas");
+const programHelpers_1 = require("../utils/programHelpers");
+const signerHelpers_1 = require("../utils/signerHelpers");
+/**
+ * Initialize season settings
+ *
+ * Single signer: admin (pays for account creation)
+ * This initializes the global season settings account
+ *
+ * @param connection - Solana connection
+ * @param admin - Admin public key (must sign and pays for account)
+ * @param feePayer - Optional separate fee payer for transaction fees
+ * @returns Instructions, signers array, and season settings PDA
+ */
+async function initializeSeasonSettings(connection, admin, feePayer) {
+    const program = (0, programHelpers_1.getProgram)(connection);
+    const [seasonSettingsPda] = (0, pdas_1.getSeasonSettingsPda)();
+    const accounts = {
+        seasonSettings: seasonSettingsPda,
+        admin: admin,
+        systemProgram: web3_js_1.SystemProgram.programId,
+    };
+    const instruction = await program.methods
+        .initializeSeasonSettings()
+        .accounts(accounts)
+        .instruction();
+    const signers = (0, signerHelpers_1.buildSigners)([{ publicKey: admin, role: "admin" }], feePayer);
+    return {
+        instructions: [instruction],
+        signers,
+        pdas: {
+            seasonSettings: seasonSettingsPda,
+        },
+    };
+}

package/dist/instructions/initializeSeasonVault.d.ts

@@ -0,0 +1,20 @@
+import { Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { SignerInfo } from "../utils/signerHelpers";
+/**
+ * Initialize season deposit vault
+ *
+ * Single signer: admin (pays for account creation)
+ * This initializes the token vault for season deposits
+ *
+ * @param connection - Solana connection
+ * @param admin - Admin public key (must sign and pays for account)
+ * @param feePayer - Optional separate fee payer for transaction fees
+ * @returns Instructions, signers array, and vault PDA
+ */
+export declare function initializeSeasonVault(connection: Connection, admin: PublicKey, feePayer?: PublicKey): Promise<{
+    instructions: TransactionInstruction[];
+    signers: SignerInfo[];
+    pdas: {
+        vault: PublicKey;
+    };
+}>;

package/dist/instructions/initializeSeasonVault.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeSeasonVault = initializeSeasonVault;
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const pdas_1 = require("../utils/pdas");
+const constants_1 = require("../utils/constants");
+const programHelpers_1 = require("../utils/programHelpers");
+const signerHelpers_1 = require("../utils/signerHelpers");
+/**
+ * Initialize season deposit vault
+ *
+ * Single signer: admin (pays for account creation)
+ * This initializes the token vault for season deposits
+ *
+ * @param connection - Solana connection
+ * @param admin - Admin public key (must sign and pays for account)
+ * @param feePayer - Optional separate fee payer for transaction fees
+ * @returns Instructions, signers array, and vault PDA
+ */
+async function initializeSeasonVault(connection, admin, feePayer) {
+    const program = (0, programHelpers_1.getProgram)(connection);
+    const [vaultPda] = (0, pdas_1.getSeasonDepositVaultPda)();
+    const accounts = {
+        seasonDepositVault: vaultPda,
+        mizdMint: constants_1.MIZD_TOKEN_MINT,
+        admin: admin,
+        tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+        systemProgram: web3_js_1.SystemProgram.programId,
+    };
+    const instruction = await program.methods
+        .initializeSeasonVault()
+        .accounts(accounts)
+        .instruction();
+    const signers = (0, signerHelpers_1.buildSigners)([{ publicKey: admin, role: "admin" }], feePayer);
+    return {
+        instructions: [instruction],
+        signers,
+        pdas: {
+            vault: vaultPda,
+        },
+    };
+}

package/dist/instructions/initializeStatistics.d.ts

@@ -0,0 +1,32 @@
+import { Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
+/**
+ * Initialize the global statistics PDA
+ *
+ * ADMIN ONLY - Must be called once before program can be used
+ *
+ * @param connection - Solana connection
+ * @param admin - Admin public key (must match ADMIN_PUBLIC_KEY)
+ * @param payer - Public key paying for account creation (can be same as admin)
+ * @returns Instructions, signers, and created PDA
+ *
+ * @example
+ * ```typescript
+ * const { instructions, signers, miztakeStatisticsPda } = await initializeStatistics(
+ *   connection,
+ *   adminWallet.publicKey,
+ *   adminWallet.publicKey // Admin pays for creation
+ * );
+ * ```
+ */
+export declare function initializeStatistics(connection: Connection, admin: PublicKey, payer?: PublicKey): Promise<{
+    instructions: TransactionInstruction[];
+    signers: {
+        publicKey: PublicKey;
+        role: string;
+    }[];
+    miztakeStatisticsPda: PublicKey;
+}>;
+/**
+ * Check if statistics are already initialized
+ */
+export declare function isInitialized(connection: Connection): Promise<boolean>;

package/dist/instructions/initializeStatistics.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeStatistics = initializeStatistics;
+exports.isInitialized = isInitialized;
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+const pdas_1 = require("../utils/pdas");
+const idl_1 = require("../idl/idl");
+const anchorHelpers_1 = require("../utils/anchorHelpers");
+/**
+ * Initialize the global statistics PDA
+ *
+ * ADMIN ONLY - Must be called once before program can be used
+ *
+ * @param connection - Solana connection
+ * @param admin - Admin public key (must match ADMIN_PUBLIC_KEY)
+ * @param payer - Public key paying for account creation (can be same as admin)
+ * @returns Instructions, signers, and created PDA
+ *
+ * @example
+ * ```typescript
+ * const { instructions, signers, miztakeStatisticsPda } = await initializeStatistics(
+ *   connection,
+ *   adminWallet.publicKey,
+ *   adminWallet.publicKey // Admin pays for creation
+ * );
+ * ```
+ */
+async function initializeStatistics(connection, admin, payer) {
+    // Create program instance
+    const provider = (0, anchorHelpers_1.createReadOnlyProvider)(connection);
+    const program = new anchor_1.Program(idl_1.IDL, provider);
+    const actualPayer = payer || admin;
+    // Derive PDA
+    const [miztakeStatisticsPda] = (0, pdas_1.getMiztakeStatisticsPda)();
+    // Build instruction
+    const accounts = {
+        miztakeStatistics: miztakeStatisticsPda,
+        admin,
+        payer: actualPayer,
+        systemProgram: web3_js_1.SystemProgram.programId,
+    };
+    const instruction = await program.methods
+        .initializeStatistics()
+        .accounts(accounts)
+        .instruction();
+    // Build signers list
+    const signers = [{ publicKey: admin, role: "admin" }];
+    if (actualPayer.toBase58() !== admin.toBase58()) {
+        signers.push({ publicKey: actualPayer, role: "payer" });
+    }
+    return {
+        instructions: [instruction],
+        signers,
+        miztakeStatisticsPda, // Created by this instruction
+    };
+}
+/**
+ * Check if statistics are already initialized
+ */
+async function isInitialized(connection) {
+    try {
+        // Create program instance
+        const provider = (0, anchorHelpers_1.createReadOnlyProvider)(connection);
+        const program = new anchor_1.Program(idl_1.IDL, provider);
+        const [statisticsPda] = (0, pdas_1.getMiztakeStatisticsPda)();
+        await program.account.miztakeStatistics.fetch(statisticsPda);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/instructions/joinSeason.d.ts

@@ -0,0 +1,50 @@
+import { BN } from "@coral-xyz/anchor";
+import { Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { Season, SeasonMembership, SeasonSettings, SeasonDepositTier } from "../types";
+import { SignerInfo } from "../utils/signerHelpers";
+/**
+ * Options for joinSeason instruction
+ */
+export interface JoinSeasonOptions {
+    connection: Connection;
+    user: PublicKey;
+    userTokenAccount: PublicKey;
+    seasonMembershipId: BN;
+    seasonNumber: BN;
+    depositTier: SeasonDepositTier;
+    /** Optional referrer (PublicKey.default means no referrer) */
+    referrer?: PublicKey;
+    /** Optional injected timestamp (seconds) for optimistic state calculation */
+    now?: BN;
+    feePayer?: PublicKey;
+    currentAccounts?: {
+        seasonSettings?: SeasonSettings;
+        season?: Season;
+    };
+}
+/**
+ * Join a season
+ *
+ * Single signer: user (pays for accounts and transfers full tier deposit)
+ * User pays for season (if needed) and membership accounts
+ * Transfers full tier deposit from user to vault, then escrows the pre-join portion
+ *
+ * @param options - Join season options
+ * @returns Instructions, signers, PDAs, and optimistically created/updated accounts
+ */
+export declare function joinSeason(options: JoinSeasonOptions): Promise<{
+    instructions: TransactionInstruction[];
+    signers: SignerInfo[];
+    pdas: {
+        seasonSettings: PublicKey;
+        season: PublicKey;
+        seasonMembership: PublicKey;
+        seasonDepositVault: PublicKey;
+        seasonEscrowVault: PublicKey;
+    };
+    updatedAccounts?: {
+        seasonSettings?: SeasonSettings;
+        season?: Season;
+        seasonMembership?: SeasonMembership;
+    };
+}>;

package/dist/instructions/joinSeason.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.joinSeason = joinSeason;
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const types_1 = require("../types");
+const pdaManager_1 = require("../utils/pdaManager");
+const constants_1 = require("../utils/constants");
+const programHelpers_1 = require("../utils/programHelpers");
+const signerHelpers_1 = require("../utils/signerHelpers");
+const optimistic_1 = require("../optimistic");
+const pdas_1 = require("../utils/pdas");
+/**
+ * Join a season
+ *
+ * Single signer: user (pays for accounts and transfers full tier deposit)
+ * User pays for season (if needed) and membership accounts
+ * Transfers full tier deposit from user to vault, then escrows the pre-join portion
+ *
+ * @param options - Join season options
+ * @returns Instructions, signers, PDAs, and optimistically created/updated accounts
+ */
+async function joinSeason(options) {
+    const program = (0, programHelpers_1.getProgram)(options.connection);
+    const pdas = pdaManager_1.PDAManager.deriveJoinSeasonPdas({
+        user: options.user,
+        seasonNumber: options.seasonNumber,
+        seasonMembershipId: options.seasonMembershipId,
+    });
+    const accounts = {
+        seasonSettings: pdas.seasonSettings,
+        season: pdas.season,
+        seasonMembership: pdas.seasonMembership,
+        seasonDepositVault: pdas.seasonDepositVault,
+        seasonEscrowVault: pdas.seasonEscrowVault,
+        mizdMint: constants_1.MIZD_TOKEN_MINT,
+        userTokenAccount: options.userTokenAccount,
+        user: options.user,
+        tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+        systemProgram: web3_js_1.SystemProgram.programId,
+    };
+    const instruction = await program.methods
+        // Anchor expects BN for u64 args.
+        .joinSeason(options.seasonMembershipId, options.seasonNumber, options.depositTier, options.referrer ?? web3_js_1.PublicKey.default)
+        .accounts(accounts)
+        .instruction();
+    const signers = (0, signerHelpers_1.buildSigners)([{ publicKey: options.user, role: "user" }], options.feePayer);
+    // OPTIMISTIC UPDATES
+    const curr = options.currentAccounts || {};
+    const now = (0, optimistic_1.getCurrentTimestamp)(options.now);
+    let newSeasonMembership;
+    let updatedSeason;
+    if (curr.seasonSettings) {
+        const [, bump] = (0, pdas_1.getSeasonMembershipPda)(options.user, options.seasonMembershipId);
+        // Mirror on-chain join_season.rs:
+        // current_window = (now - season.started_at) / window_duration (integer division)
+        // joined_window_number = current_window (after bounds checks)
+        const totalWindows = curr.seasonSettings.totalWindowsPerSeason;
+        const perWindowPenalty = getTierPenaltyPerWindow(options.depositTier);
+        const depositFull = perWindowPenalty.muln(totalWindows);
+        let joinedWindowNumber = new anchor_1.BN(0);
+        if (curr.season) {
+            if (curr.season.seasonState === types_1.SeasonState.Uninitialized) {
+                // On-chain: season is initialized with started_at = now, so elapsed = 0 -> current_window = 0
+                joinedWindowNumber = new anchor_1.BN(0);
+            }
+            else if (curr.seasonSettings.windowDuration &&
+                !curr.seasonSettings.windowDuration.isZero()) {
+                const startedAt = curr.season.startedAt;
+                const elapsed = now.gte(startedAt) ? now.sub(startedAt) : new anchor_1.BN(0);
+                joinedWindowNumber = elapsed.div(curr.seasonSettings.windowDuration);
+            }
+        }
+        // If this would fail on-chain (current_window >= total_windows), skip optimistic updates.
+        if (joinedWindowNumber.gte(new anchor_1.BN(totalWindows))) {
+            return {
+                instructions: [instruction],
+                signers,
+                pdas,
+            };
+        }
+        const depositEscrowed = perWindowPenalty.mul(joinedWindowNumber);
+        const depositActive = depositFull.sub(depositEscrowed);
+        newSeasonMembership = (0, optimistic_1.initializeSeasonMembership)(options.user, options.seasonMembershipId, options.seasonNumber, options.depositTier, options.referrer ?? web3_js_1.PublicKey.default, depositActive, depositEscrowed, now, joinedWindowNumber, bump);
+        if (curr.season) {
+            updatedSeason = (0, optimistic_1.updateSeasonForJoin)(curr.season, depositActive, options.depositTier, joinedWindowNumber, totalWindows);
+        }
+    }
+    return {
+        instructions: [instruction],
+        signers,
+        pdas,
+        ...(curr.seasonSettings || updatedSeason || newSeasonMembership
+            ? {
+                updatedAccounts: {
+                    ...(curr.seasonSettings && { seasonSettings: curr.seasonSettings }),
+                    ...(updatedSeason && { season: updatedSeason }),
+                    ...(newSeasonMembership && {
+                        seasonMembership: newSeasonMembership,
+                    }),
+                },
+            }
+            : {}),
+    };
+}
+function getTierPenaltyPerWindow(tier) {
+    // Base units (7 decimals): 1 MIZD = 10_000_000
+    if ("copper" in tier)
+        return new anchor_1.BN(1000000); // 0.1 MIZD
+    if ("silver" in tier)
+        return new anchor_1.BN(10000000); // 1 MIZD
+    if ("gold" in tier)
+        return new anchor_1.BN(100000000); // 10 MIZD
+    if ("platinum" in tier)
+        return new anchor_1.BN(1000000000); // 100 MIZD
+    if ("mithril" in tier)
+        return new anchor_1.BN(10000000000); // 1,000 MIZD
+    throw new Error("Unknown depositTier");
+}

package/dist/instructions/toggleSeasonPause.d.ts

@@ -0,0 +1,22 @@
+import { Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { SeasonSettings } from "../types";
+import { SignerInfo } from "../utils/signerHelpers";
+/**
+ * Toggle season system pause
+ *
+ * Single signer: admin (season admin)
+ * Toggles the isPaused flag on season settings
+ *
+ * @param connection - Solana connection
+ * @param admin - Season admin's public key
+ * @param feePayer - Optional separate fee payer for transaction fees
+ * @param seasonSettings - Optional season settings (returns updated version)
+ * @returns Instructions, signers, and optimistically updated settings
+ */
+export declare function toggleSeasonPause(connection: Connection, admin: PublicKey, feePayer?: PublicKey, seasonSettings?: SeasonSettings): Promise<{
+    instructions: TransactionInstruction[];
+    signers: SignerInfo[];
+    updatedAccounts?: {
+        seasonSettings: SeasonSettings;
+    };
+}>;