proof-of-take-sdk 1.0.0

package/dist/utils/accountUpdates.js

@@ -0,0 +1,611 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCurrentTimestamp = getCurrentTimestamp;
+exports.createEmptyUserStats = createEmptyUserStats;
+exports.initializeUserStats = initializeUserStats;
+exports.updateUserStatsForMiztakeCreation = updateUserStatsForMiztakeCreation;
+exports.updateMiztakeStatisticsForCreation = updateMiztakeStatisticsForCreation;
+exports.initializeUserWindowParticipation = initializeUserWindowParticipation;
+exports.initializeRewardWindow = initializeRewardWindow;
+exports.updateMiztakeForSeasonUse = updateMiztakeForSeasonUse;
+exports.initializeSeasonMembership = initializeSeasonMembership;
+exports.updateSeasonForJoin = updateSeasonForJoin;
+exports.updateWindowForConfirmation = updateWindowForConfirmation;
+exports.updateParticipationForConfirmation = updateParticipationForConfirmation;
+exports.updateMembershipForConfirmation = updateMembershipForConfirmation;
+exports.updateSeasonForConfirmation = updateSeasonForConfirmation;
+exports.updateWindowForFinalization = updateWindowForFinalization;
+exports.updateParticipationForClaim = updateParticipationForClaim;
+exports.updateMembershipForClaim = updateMembershipForClaim;
+exports.initializeReferralPenaltyClaim = initializeReferralPenaltyClaim;
+exports.calculateWithdrawalAmount = calculateWithdrawalAmount;
+exports.updateSeasonSettingsForPauseToggle = updateSeasonSettingsForPauseToggle;
+exports.updateSeasonSettingsForAdminUpdate = updateSeasonSettingsForAdminUpdate;
+const anchor_1 = require("@coral-xyz/anchor");
+const types_1 = require("../types");
+const tierPenalty_1 = require("./tierPenalty");
+const pdas_1 = require("./pdas");
+const enumHelpers_1 = require("./enumHelpers");
+/**
+ * Get current Unix timestamp in SECONDS as BN
+ *
+ * Note:
+ * - Returns Unix timestamp in SECONDS (not milliseconds)
+ * - Matches Solana's Clock::unix_timestamp format
+ * - This is an approximate timestamp; the actual on-chain timestamp
+ *   will be set by the Solana runtime when the transaction is processed
+ *
+ * @returns Current Unix timestamp in seconds
+ */
+function getCurrentTimestamp(now) {
+    if (now)
+        return now;
+    return new anchor_1.BN(Math.floor(Date.now() / 1000)); // Convert JS milliseconds → seconds
+}
+/**
+ * Create an empty/initialized UserStats object
+ * Used when initializing a new user stats account
+ */
+function createEmptyUserStats(telegramId) {
+    return {
+        telegramId,
+        totalNumberOfMiztakes: new anchor_1.BN(0),
+        onchainFirstMiztakeAt: new anchor_1.BN(0),
+        onchainLastMiztakeAt: new anchor_1.BN(0),
+        bump: 0, // Will be set on-chain
+    };
+}
+/**
+ * Create a fully initialized UserStats account with PDA bump
+ * Mirrors the initialization logic from create_miztake.rs (lines 33-48)
+ *
+ * This function derives the PDA and returns a UserStats object exactly as it
+ * will appear on-chain after initialization.
+ *
+ * @param telegramId - Telegram ID of the user
+ * @returns Initialized UserStats object with proper bump seed
+ *
+ * @example
+ * ```typescript
+ * const userStats = initializeUserStats(new BN(123456789));
+ * // userStats is ready to be used for local state tracking
+ * // and matches exactly what will be created on-chain
+ * ```
+ */
+function initializeUserStats(telegramId) {
+    // Derive the PDA to get the bump seed (matching on-chain derivation)
+    const [, bump] = (0, pdas_1.getUserStatsPda)(telegramId);
+    // Initialize all fields to 0 as per create_miztake.rs
+    return {
+        telegramId, // user_stats.telegram_id = telegram_id
+        totalNumberOfMiztakes: new anchor_1.BN(0), // user_stats.total_number_of_miztakes = 0
+        onchainFirstMiztakeAt: new anchor_1.BN(0), // user_stats.onchain_first_miztake_at = 0
+        onchainLastMiztakeAt: new anchor_1.BN(0), // user_stats.onchain_last_miztake_at = 0
+        bump, // user_stats.bump = ctx.bumps.user_stats
+    };
+}
+/**
+ * Update UserStats after creating a miztake
+ * Mirrors the increment_miztakes logic from user_stats.rs
+ *
+ * @param userStats - Current user stats
+ * @param telegramId - Telegram ID for initialization check
+ * @param timestamp - Timestamp for the update in SECONDS (Unix timestamp)
+ * @returns Updated UserStats object
+ */
+function updateUserStatsForMiztakeCreation(userStats, telegramId, timestamp = getCurrentTimestamp()) {
+    // Check if this is a new UserStats account (needs initialization)
+    const isNew = userStats.telegramId.isZero() || !userStats.telegramId.eq(telegramId);
+    const stats = isNew ? initializeUserStats(telegramId) : { ...userStats };
+    // Apply increment_miztakes logic (lines 48-59 in user_stats.rs)
+    stats.totalNumberOfMiztakes = stats.totalNumberOfMiztakes.add(new anchor_1.BN(1));
+    // Set first miztake timestamp if this is the first one
+    if (stats.onchainFirstMiztakeAt.isZero()) {
+        stats.onchainFirstMiztakeAt = timestamp;
+    }
+    stats.onchainLastMiztakeAt = timestamp;
+    return stats;
+}
+/**
+ * Update MiztakeStatistics after creating a miztake
+ * Mirrors the increment_miztakes logic from miztake_statistics.rs
+ *
+ * @param statistics - Current miztake statistics
+ * @returns Updated MiztakeStatistics object and new miztake ID
+ *
+ * @throws Error if invalid statistics provided
+ */
+function updateMiztakeStatisticsForCreation(statistics) {
+    if (!statistics || !statistics.totalMiztakes) {
+        throw new Error("updateMiztakeStatisticsForCreation: Invalid statistics object");
+    }
+    const newMiztakeId = statistics.totalMiztakes.add(new anchor_1.BN(1));
+    return {
+        statistics: {
+            ...statistics,
+            totalMiztakes: newMiztakeId,
+        },
+        newMiztakeId,
+    };
+}
+/**
+ * Initialize or update UserWindowParticipation
+ * Mirrors the logic from create_miztake.rs (lines 109-139)
+ *
+ * @param user - User's public key
+ * @param seasonNumber - Season number
+ * @param windowNumber - Window number
+ * @param seasonMembershipId - Season membership ID
+ * @param miztakeId - The miztake ID to associate
+ * @returns Initialized/Updated UserWindowParticipation object
+ */
+function initializeUserWindowParticipation(user, seasonNumber, windowNumber, seasonMembershipId, miztakeId) {
+    const [, bump] = (0, pdas_1.getUserWindowParticipationPda)(user, seasonNumber, windowNumber, seasonMembershipId);
+    return {
+        user,
+        seasonNumber,
+        windowNumber,
+        seasonMembershipId,
+        postedSuccessfully: false,
+        claimedReward: false,
+        rewardAmount: new anchor_1.BN(0),
+        miztakeId,
+        bump,
+    };
+}
+/**
+ * Initialize RewardWindow
+ * Mirrors the logic from season_helpers::initialize_window
+ *
+ * @param seasonNumber - Season number
+ * @param windowNumber - Window number
+ * @param season - Current season state
+ * @param windowDuration - Duration of each window in seconds
+ * @returns Initialized RewardWindow object
+ */
+function initializeRewardWindow(seasonNumber, windowNumber, season, windowDuration) {
+    const [, bump] = (0, pdas_1.getRewardWindowPda)(seasonNumber, windowNumber);
+    const startedAt = season.startedAt.add(windowNumber.mul(windowDuration));
+    const endsAt = startedAt.add(windowDuration);
+    return {
+        seasonNumber,
+        windowNumber,
+        windowState: types_1.WindowState.Active,
+        startedAt,
+        endsAt,
+        totalMembersInSeason: season.totalMembers,
+        penaltyPool: new anchor_1.BN(0),
+        successfulPostersCount: new anchor_1.BN(0),
+        successfulStakeTotal: new anchor_1.BN(0),
+        rewardPerPoster: new anchor_1.BN(0),
+        isFinalized: false,
+        bump,
+    };
+}
+/**
+ * Update Miztake to mark it as used in a season/window
+ * Mirrors mark_as_used from miztake.rs
+ *
+ * @param miztake - Current miztake
+ * @param seasonNumber - Season number
+ * @param windowNumber - Window number
+ * @returns Updated Miztake object
+ */
+function updateMiztakeForSeasonUse(miztake, seasonNumber, windowNumber) {
+    return {
+        ...miztake,
+        usedInSeason: seasonNumber,
+        usedInWindow: windowNumber,
+    };
+}
+/**
+ * Update SeasonMembership after joining
+ * Mirrors the initialization from join_season.rs (lines 84-96)
+ *
+ * @param user - User's public key
+ * @param seasonMembershipId - Membership ID
+ * @param seasonNumber - Season number
+ * @param depositTier - Tier chosen at join time
+ * @param depositAmount - Active deposit amount (participates in rewards/penalties)
+ * @param depositEscrowedAmount - Escrowed deposit amount (always refundable)
+ * @param joinedAt - Timestamp when joined
+ * @param joinedWindowNumber - Window number when joined
+ * @returns Initialized SeasonMembership object
+ */
+function initializeSeasonMembership(user, seasonMembershipId, seasonNumber, depositTier, referrer, depositAmount, depositEscrowedAmount, joinedAt, joinedWindowNumber, bump) {
+    return {
+        id: seasonMembershipId,
+        owner: user,
+        referrer,
+        seasonNumber,
+        depositTier,
+        depositAmount,
+        depositEscrowedAmount,
+        joinedAt,
+        joinedWindowNumber,
+        successfulPostsCount: new anchor_1.BN(0),
+        totalRewardsClaimed: new anchor_1.BN(0),
+        totalPenaltiesPaid: new anchor_1.BN(0),
+        depositWithdrawn: false,
+        isActive: true,
+        bump,
+    };
+}
+/**
+ * Update Season after a user joins
+ * Mirrors the update from join_season.rs (lines 98-104)
+ *
+ * @param season - Current season
+ * @param depositActive - Active deposit amount added to season totals
+ * @returns Updated Season object
+ */
+function updateSeasonForJoin(season, depositActive, depositTier, joinedWindowNumber, totalWindowsPerSeason) {
+    // NOTE: On-chain (join_season.rs) updates eligible_stake_per_window ONLY for windows
+    // w >= joined_window_number. Earlier windows are not modified.
+    //
+    // Also note: older generated IDLs/types in this repo mention 80 windows, but the
+    // current Rust program uses a fixed 21-window schedule. We therefore:
+    // - Prefer the actual array length present on `season.eligibleStakePerWindow`
+    // - Otherwise fall back to `season.totalWindows` / `totalWindowsPerSeason` / 21.
+    const seasonLike = season;
+    const existingSchedule = Array.isArray(seasonLike.eligibleStakePerWindow)
+        ? seasonLike.eligibleStakePerWindow
+        : undefined;
+    const inferredTotalWindows = typeof totalWindowsPerSeason === "number" &&
+        Number.isFinite(totalWindowsPerSeason) &&
+        totalWindowsPerSeason > 0
+        ? totalWindowsPerSeason
+        : typeof seasonLike.totalWindows === "number" &&
+            Number.isFinite(seasonLike.totalWindows) &&
+            seasonLike.totalWindows > 0
+            ? seasonLike.totalWindows
+            : 21;
+    const scheduleLen = existingSchedule?.length ?? inferredTotalWindows;
+    const schedule = existingSchedule
+        ? existingSchedule.slice()
+        : Array.from({ length: scheduleLen }, () => new anchor_1.BN(0));
+    const next = {
+        ...season,
+        totalMembers: season.totalMembers.add(new anchor_1.BN(1)),
+        totalDepositsHeld: season.totalDepositsHeld.add(depositActive),
+        eligibleStakePerWindow: schedule,
+    };
+    const perWindowStake = (0, tierPenalty_1.getTierPenaltyPerWindow)(depositTier);
+    const startIdx = joinedWindowNumber.toNumber();
+    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) => {
+        if (i >= startIdx && i < endExclusive)
+            return v.add(perWindowStake);
+        return v;
+    });
+    const nextWithSchedule = {
+        ...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,
+    };
+}
+/**
+ * Update RewardWindow after post confirmation
+ * Mirrors confirmed_post_on_x.rs logic
+ *
+ * @param window - Current window
+ * @param isOnTime - Whether the post was on time
+ * @param penaltyAmount - Penalty amount if late (REQUIRED when isOnTime=false)
+ * @returns Updated RewardWindow object
+ *
+ * @throws Error if penaltyAmount missing when isOnTime is false
+ */
+function updateWindowForConfirmation(window, isOnTime, stakeAmount) {
+    if (isOnTime) {
+        if (!stakeAmount || stakeAmount.isZero()) {
+            throw new Error("updateWindowForConfirmation: stakeAmount is required when isOnTime is true");
+        }
+        return {
+            ...window,
+            successfulPostersCount: window.successfulPostersCount.add(new anchor_1.BN(1)),
+            successfulStakeTotal: window.successfulStakeTotal.add(stakeAmount),
+        };
+    }
+    else {
+        // penaltyPool is derived at finalization as X - Y; do not mutate here
+        return { ...window };
+    }
+}
+/**
+ * Update UserWindowParticipation after post confirmation
+ * Mirrors confirmed_post_on_x.rs logic
+ *
+ * @param participation - Current participation
+ * @param isOnTime - Whether the post was on time
+ * @returns Updated UserWindowParticipation object
+ */
+function updateParticipationForConfirmation(participation, isOnTime) {
+    return {
+        ...participation,
+        postedSuccessfully: isOnTime,
+    };
+}
+/**
+ * Update SeasonMembership after post confirmation
+ * Mirrors confirmed_post_on_x.rs logic
+ *
+ * @param membership - Current membership
+ * @param isOnTime - Whether the post was on time
+ * @param penaltyAmount - Penalty amount if late (REQUIRED when isOnTime=false)
+ * @returns Updated SeasonMembership object
+ *
+ * @throws Error if penaltyAmount missing when isOnTime is false
+ */
+function updateMembershipForConfirmation(membership, isOnTime, penaltyAmount) {
+    if (isOnTime) {
+        return {
+            ...membership,
+            successfulPostsCount: membership.successfulPostsCount.add(new anchor_1.BN(1)),
+        };
+    }
+    else {
+        if (!penaltyAmount || penaltyAmount.isZero()) {
+            throw new Error("updateMembershipForConfirmation: penaltyAmount is required when isOnTime is false");
+        }
+        return {
+            ...membership,
+            totalPenaltiesPaid: membership.totalPenaltiesPaid.add(penaltyAmount),
+        };
+    }
+}
+/**
+ * Update Season after post confirmation
+ * Mirrors confirmed_post_on_x.rs logic
+ *
+ * @param season - Current season
+ * @param isOnTime - Whether the post was on time
+ * @param penaltyAmount - Penalty amount if late (REQUIRED when isOnTime=false)
+ * @returns Updated Season object
+ *
+ * @throws Error if penaltyAmount missing when isOnTime is false
+ */
+function updateSeasonForConfirmation(season, isOnTime, _stakeAmount) {
+    if (isOnTime) {
+        return {
+            ...season,
+            totalSuccessfulPosts: season.totalSuccessfulPosts.add(new anchor_1.BN(1)),
+        };
+    }
+    else {
+        // totalPenaltiesCollected is updated at window finalization (X - Y), not here
+        return { ...season };
+    }
+}
+/**
+ * Finalize RewardWindow and calculate rewards
+ * Mirrors claim_window_rewards.rs finalization logic (lines 22-86)
+ *
+ * @param window - Current window
+ * @returns Updated finalized RewardWindow object
+ */
+function updateWindowForFinalization(window, eligibleStakeX) {
+    // penalty_pool is derived as X - Y.
+    const finalPenaltyPool = eligibleStakeX.gt(window.successfulStakeTotal)
+        ? eligibleStakeX.sub(window.successfulStakeTotal)
+        : new anchor_1.BN(0);
+    // Winners pool is 80% of missed penalties (the other 20% is claimable by referrer/admin).
+    const winnersPool = finalPenaltyPool.muln(80).divn(100);
+    // Calculate reward per poster
+    let rewardPerPoster = new anchor_1.BN(0);
+    if (window.successfulPostersCount.gt(new anchor_1.BN(0))) {
+        rewardPerPoster = winnersPool.div(window.successfulPostersCount);
+    }
+    return {
+        ...window,
+        penaltyPool: finalPenaltyPool,
+        rewardPerPoster,
+        isFinalized: true,
+        windowState: types_1.WindowState.Finalized,
+    };
+}
+/**
+ * Update UserWindowParticipation after claiming window rewards
+ * Mirrors claim_window_rewards.rs logic
+ *
+ * @param participation - Current participation
+ * @param rewardAmount - Reward amount claimed
+ * @returns Updated UserWindowParticipation object
+ */
+function updateParticipationForClaim(participation, rewardAmount) {
+    return {
+        ...participation,
+        claimedReward: true,
+        rewardAmount,
+    };
+}
+/**
+ * Update SeasonMembership after claiming window rewards
+ * Mirrors claim_window_rewards.rs logic (lines 156-165)
+ *
+ * @param membership - Current membership
+ * @param rewardAmount - Total reward amount
+ * (Penalties are tier-derived on-chain; settings no longer carry penalty_per_window.)
+ * @returns Updated SeasonMembership object
+ *
+ * @throws Error if invalid inputs provided
+ */
+function updateMembershipForClaim(membership, rewardAmount) {
+    if (!membership) {
+        throw new Error("updateMembershipForClaim: membership is required");
+    }
+    if (!rewardAmount || rewardAmount.isNeg()) {
+        throw new Error("updateMembershipForClaim: Invalid reward amount");
+    }
+    const tierPenaltyPerWindow = (0, tierPenalty_1.getTierPenaltyPerWindow)(membership.depositTier);
+    // Calculate refund to track (up to tier penalty per window)
+    const refundToTrack = rewardAmount.gt(tierPenaltyPerWindow)
+        ? tierPenaltyPerWindow
+        : rewardAmount;
+    return {
+        ...membership,
+        totalRewardsClaimed: membership.totalRewardsClaimed.add(refundToTrack),
+    };
+}
+/**
+ * Initialize ReferralPenaltyClaim
+ * Mirrors claim_referral_penalty_for_window.rs (write fields + amount calc)
+ *
+ * @param referredUser - The user who missed the window
+ * @param seasonNumber - Season number
+ * @param windowNumber - Window number
+ * @param seasonMembershipId - Referred user's membership id
+ * @param claimant - Referrer (or root admin if no referrer)
+ * @param perWindowPenalty - Tier penalty per window (base units)
+ * @param claimedAt - Unix timestamp in seconds (i64 on-chain, represented as BN in SDK)
+ */
+function initializeReferralPenaltyClaim(params) {
+    const [, bump] = (0, pdas_1.getReferralPenaltyClaimPda)(params.referredUser, params.seasonNumber, params.windowNumber, params.seasonMembershipId);
+    const claimedAt = getCurrentTimestamp(params.claimedAt);
+    const amount = params.perWindowPenalty.muln(20).divn(100);
+    return {
+        referredUser: params.referredUser,
+        seasonNumber: params.seasonNumber,
+        windowNumber: params.windowNumber,
+        seasonMembershipId: params.seasonMembershipId,
+        claimant: params.claimant,
+        amount,
+        claimedAt,
+        claimed: true,
+        bump,
+    };
+}
+// getTierPenaltyPerWindow moved to ./tierPenalty to avoid drift between SDK modules.
+/**
+ * Calculate withdrawal amount for season deposit
+ * Mirrors withdraw_season_deposit.rs logic (lines 55-87)
+ *
+ * @param membership - Current membership
+ * @param season - Current season
+ * @param settings - Season settings
+ * @returns Withdrawal amount and updated accounts
+ *
+ * @throws Error if invalid inputs provided
+ */
+function calculateWithdrawalAmount(membership, season, settings) {
+    // Input validation
+    if (!membership || !season || !settings) {
+        throw new Error("calculateWithdrawalAmount: membership, season, and settings are required");
+    }
+    if (!membership.depositAmount || membership.depositAmount.isNeg()) {
+        throw new Error("calculateWithdrawalAmount: Invalid deposit amount");
+    }
+    // Calculate windows available (match on-chain withdraw_season_deposit):
+    // windows_available = total_windows_per_season - joined_window_number
+    const totalWindows = new anchor_1.BN(settings.totalWindowsPerSeason);
+    const windowsAvailableCapped = totalWindows.gt(membership.joinedWindowNumber)
+        ? totalWindows.sub(membership.joinedWindowNumber)
+        : new anchor_1.BN(0);
+    // Calculate penalties both ways
+    // Protect against underflow if successfulPostsCount > windowsAvailable (shouldn't happen but be safe)
+    const missedWindows = windowsAvailableCapped.gt(membership.successfulPostsCount)
+        ? windowsAvailableCapped.sub(membership.successfulPostsCount)
+        : new anchor_1.BN(0);
+    const calculatedPenalties = missedWindows.mul((0, tierPenalty_1.getTierPenaltyPerWindow)(membership.depositTier));
+    const trackedPenalties = membership.totalPenaltiesPaid;
+    // Use larger value (Option C)
+    const finalPenalties = calculatedPenalties.gt(trackedPenalties)
+        ? calculatedPenalties
+        : trackedPenalties;
+    // Calculate withdrawal (deposit - penalties - already claimed refunds)
+    let withdrawalAmount = membership.depositAmount
+        .sub(finalPenalties)
+        .sub(membership.totalRewardsClaimed);
+    // Clamp to 0 if negative (user forfeited everything to penalties)
+    const clampedWithdrawalAmount = withdrawalAmount.gt(new anchor_1.BN(0))
+        ? withdrawalAmount
+        : new anchor_1.BN(0);
+    // Escrowed portion is always refunded in full at season end.
+    const totalWithdrawalAmount = clampedWithdrawalAmount.add(membership.depositEscrowedAmount);
+    // Update membership
+    const updatedMembership = {
+        ...membership,
+        depositEscrowedAmount: new anchor_1.BN(0),
+        depositWithdrawn: true,
+        isActive: false,
+    };
+    // Update season (if ended, finalize it)
+    let updatedSeason = season;
+    let updatedSettings = settings;
+    // Check if season is Active - use helper to handle both formats
+    if ((0, enumHelpers_1.isSeasonState)(season.seasonState, types_1.SeasonState.Active)) {
+        updatedSeason = {
+            ...season,
+            seasonState: types_1.SeasonState.Ended,
+            totalDepositsHeld: season.totalDepositsHeld.sub(clampedWithdrawalAmount), // Use CLAMPED amount
+        };
+        updatedSettings = {
+            ...settings,
+            completedSeasons: settings.completedSeasons.add(new anchor_1.BN(1)),
+        };
+    }
+    else {
+        updatedSeason = {
+            ...season,
+            totalDepositsHeld: season.totalDepositsHeld.sub(clampedWithdrawalAmount), // Use CLAMPED amount
+        };
+    }
+    return {
+        withdrawalAmount: totalWithdrawalAmount,
+        updatedMembership,
+        updatedSeason,
+        updatedSettings,
+    };
+}
+/**
+ * Update SeasonSettings after toggling pause
+ *
+ * @param settings - Current settings
+ * @returns Updated SeasonSettings object
+ */
+function updateSeasonSettingsForPauseToggle(settings) {
+    return {
+        ...settings,
+        isPaused: !settings.isPaused,
+    };
+}
+/**
+ * Update SeasonSettings after admin update
+ *
+ * @param settings - Current settings
+ * @param newAdmin - New admin public key
+ * @returns Updated SeasonSettings object
+ */
+function updateSeasonSettingsForAdminUpdate(settings, newAdmin) {
+    return {
+        ...settings,
+        admin: newAdmin,
+    };
+}

package/dist/utils/anchorHelpers.d.ts

@@ -0,0 +1,7 @@
+import { AnchorProvider, Idl } from "@coral-xyz/anchor";
+import { Commitment, Connection, PublicKey } from "@solana/web3.js";
+export declare function createReadOnlyProvider(connection: Connection, commitment?: Commitment): AnchorProvider;
+/**
+ * Ensure the given IDL has a stable `.address` (Anchor Program uses it as programId).
+ */
+export declare function withIdlAddress(idl: Idl, programId: PublicKey): Idl;

package/dist/utils/anchorHelpers.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReadOnlyProvider = createReadOnlyProvider;
+exports.withIdlAddress = withIdlAddress;
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+/**
+ * Anchor v0.32 uses a concrete Wallet class (NodeWallet) that requires a payer Keypair.
+ * We keep one in-memory wallet for "read-only" SDK usage (building instructions, `.view()`, etc.).
+ */
+const READONLY_WALLET = new anchor_1.Wallet(web3_js_1.Keypair.generate());
+function createReadOnlyProvider(connection, commitment = "confirmed") {
+    return new anchor_1.AnchorProvider(connection, READONLY_WALLET, { commitment });
+}
+/**
+ * Ensure the given IDL has a stable `.address` (Anchor Program uses it as programId).
+ */
+function withIdlAddress(idl, programId) {
+    // Anchor v0.32 Program ctor uses `idl.address` as the program id.
+    return { ...idl, address: programId.toBase58() };
+}

package/dist/utils/constants.d.ts

@@ -0,0 +1,21 @@
+import { PublicKey } from "@solana/web3.js";
+/**
+ * Proof of Miztake Program Constants
+ */
+export declare const PROGRAM_ID: PublicKey;
+export declare const ADMIN_PUBLIC_KEY: PublicKey;
+export declare const MIZD_TOKEN_MINT: PublicKey;
+export declare const DEFAULT_FEE_RECIPIENT: PublicKey;
+export declare const MIZTAKE_STATISTICS_SEED = "miztake_statistics";
+export declare const TOKEN_VAULT_SEED = "token_vault";
+export declare const USER_STATS_SEED = "user_stats";
+export declare const MIZTAKE_SEED = "miztake";
+export declare const REFERRAL_PENALTY_CLAIM_SEED = "referral_penalty_claim";
+export declare const DEFAULT_MIZTAKE_FEE = 100000;
+export declare const DEFAULT_MAX_CLAIMABLE = 10000000000;
+export declare const MIN_FEE = 10000;
+export declare const MAX_FEE = 10000000;
+export declare const MIN_MAX_CLAIMABLE = 1000000;
+export declare const MAX_MAX_CLAIMABLE = 1000000000000;
+export declare const MAX_USERNAME_LENGTH = 21;
+export declare const MIN_HASH_LENGTH = 32;

package/dist/utils/constants.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MIN_HASH_LENGTH = exports.MAX_USERNAME_LENGTH = exports.MAX_MAX_CLAIMABLE = exports.MIN_MAX_CLAIMABLE = exports.MAX_FEE = exports.MIN_FEE = exports.DEFAULT_MAX_CLAIMABLE = exports.DEFAULT_MIZTAKE_FEE = exports.REFERRAL_PENALTY_CLAIM_SEED = exports.MIZTAKE_SEED = exports.USER_STATS_SEED = exports.TOKEN_VAULT_SEED = exports.MIZTAKE_STATISTICS_SEED = exports.DEFAULT_FEE_RECIPIENT = exports.MIZD_TOKEN_MINT = exports.ADMIN_PUBLIC_KEY = exports.PROGRAM_ID = void 0;
+const web3_js_1 = require("@solana/web3.js");
+/**
+ * Proof of Miztake Program Constants
+ */
+// Program ID
+exports.PROGRAM_ID = new web3_js_1.PublicKey("takeA82AwosboZgG7HQx8D3dGLbbbPUyQCva9HpLJBr");
+// Admin public key
+exports.ADMIN_PUBLIC_KEY = new web3_js_1.PublicKey("Lude4DE3jDXVViJ3s7bUfPXdXy8Zq7G1stMwHNQrc2s");
+// MIZD Token Mint
+exports.MIZD_TOKEN_MINT = new web3_js_1.PublicKey("mizdS9fDNUKWZcXBeRhJoJQHJJmsTeF4fFRyPdXWv99");
+// Default fee recipient
+exports.DEFAULT_FEE_RECIPIENT = new web3_js_1.PublicKey("Dkhu2VgGPfvXPVuohG2fPfryRacWMpNBJXvRGF1dhzUh");
+// Seeds for PDAs
+exports.MIZTAKE_STATISTICS_SEED = "miztake_statistics";
+exports.TOKEN_VAULT_SEED = "token_vault";
+exports.USER_STATS_SEED = "user_stats";
+exports.MIZTAKE_SEED = "miztake";
+exports.REFERRAL_PENALTY_CLAIM_SEED = "referral_penalty_claim";
+// Default values
+exports.DEFAULT_MIZTAKE_FEE = 100000; // 0.0001 SOL in lamports
+exports.DEFAULT_MAX_CLAIMABLE = 10000000000; // 1000 tokens with 7 decimals
+// Limits
+exports.MIN_FEE = 10000; // 0.00001 SOL
+exports.MAX_FEE = 10000000; // 0.01 SOL
+exports.MIN_MAX_CLAIMABLE = 1000000; // 0.1 tokens
+exports.MAX_MAX_CLAIMABLE = 1000000000000; // 100,000 tokens
+exports.MAX_USERNAME_LENGTH = 21;
+exports.MIN_HASH_LENGTH = 32;