proof-of-take-sdk 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Proof of Take SDK
+ *
+ * TypeScript/JavaScript library for interacting with the Proof of Take Solana program
+ *
+ * @packageDocumentation
+ */
+export { createMiztake, getMiztakePdaForParams, } from "./instructions/createMiztake";
+export type { CreateMiztakeOptions, CreateMiztakeResult, } from "./instructions/createMiztake";
+export { initializeStatistics } from "./instructions/initializeStatistics";
+export { initializeSeasonSettings } from "./instructions/initializeSeasonSettings";
+export { initializeSeasonVault } from "./instructions/initializeSeasonVault";
+export { initializeEscrowVault } from "./instructions/initializeEscrowVault";
+export { joinSeason } from "./instructions/joinSeason";
+export type { JoinSeasonOptions } from "./instructions/joinSeason";
+export { confirmedPostOnX } from "./instructions/confirmedPostOnX";
+export type { ConfirmedPostOnXOptions } from "./instructions/confirmedPostOnX";
+export { claimWindowRewards } from "./instructions/claimWindowRewards";
+export type { ClaimWindowRewardsOptions } from "./instructions/claimWindowRewards";
+export { claimReferralPenaltyForWindow } from "./instructions/claimReferralPenaltyForWindow";
+export type { ClaimReferralPenaltyForWindowOptions } from "./instructions/claimReferralPenaltyForWindow";
+export { withdrawSeasonDeposit } from "./instructions/withdrawSeasonDeposit";
+export type { WithdrawSeasonDepositOptions } from "./instructions/withdrawSeasonDeposit";
+export { toggleSeasonPause } from "./instructions/toggleSeasonPause";
+export { updateSeasonAdmin } from "./instructions/updateSeasonAdmin";
+export { viewSeasonMembershipStatus } from "./instructions/viewSeasonMembershipStatus";
+export { viewWindowStatus } from "./instructions/viewWindowStatus";
+export { viewCurrentSeason } from "./instructions/viewCurrentSeason";
+export * from "./utils/pdas";
+export * from "./utils/constants";
+export * from "./utils/accountUpdates";
+export * from "./utils/programHelpers";
+export * from "./utils/signerHelpers";
+export * from "./utils/conversions";
+export * from "./utils/transactionBuilder";
+export * from "./utils/simulationHelpers";
+export * from "./utils/enumHelpers";
+export { PDAManager } from "./utils/pdaManager";
+export * from "./optimistic";
+export * from "./constants/season";
+export * from "./types";
+export * from "./types/instructionResults";
+export * from "./types/accountTypes";
+export type { ProofOfTake } from "./types/proof_of_take";
+export { IDL } from "./idl/idl";
+export { createProgram, createProgramWithId, getProgramReadOnly, } from "./client";
+export * from "./getters";
+export declare const VERSION = "1.0.0";

package/dist/index.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * Proof of Take SDK
+ *
+ * TypeScript/JavaScript library for interacting with the Proof of Take Solana program
+ *
+ * @packageDocumentation
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = exports.getProgramReadOnly = exports.createProgramWithId = exports.createProgram = exports.IDL = exports.PDAManager = exports.viewCurrentSeason = exports.viewWindowStatus = exports.viewSeasonMembershipStatus = exports.updateSeasonAdmin = exports.toggleSeasonPause = exports.withdrawSeasonDeposit = exports.claimReferralPenaltyForWindow = exports.claimWindowRewards = exports.confirmedPostOnX = exports.joinSeason = exports.initializeEscrowVault = exports.initializeSeasonVault = exports.initializeSeasonSettings = exports.initializeStatistics = exports.getMiztakePdaForParams = exports.createMiztake = void 0;
+// Export all instructions
+// Core miztake instructions
+var createMiztake_1 = require("./instructions/createMiztake");
+Object.defineProperty(exports, "createMiztake", { enumerable: true, get: function () { return createMiztake_1.createMiztake; } });
+Object.defineProperty(exports, "getMiztakePdaForParams", { enumerable: true, get: function () { return createMiztake_1.getMiztakePdaForParams; } });
+var initializeStatistics_1 = require("./instructions/initializeStatistics");
+Object.defineProperty(exports, "initializeStatistics", { enumerable: true, get: function () { return initializeStatistics_1.initializeStatistics; } });
+// Season initialization instructions
+var initializeSeasonSettings_1 = require("./instructions/initializeSeasonSettings");
+Object.defineProperty(exports, "initializeSeasonSettings", { enumerable: true, get: function () { return initializeSeasonSettings_1.initializeSeasonSettings; } });
+var initializeSeasonVault_1 = require("./instructions/initializeSeasonVault");
+Object.defineProperty(exports, "initializeSeasonVault", { enumerable: true, get: function () { return initializeSeasonVault_1.initializeSeasonVault; } });
+var initializeEscrowVault_1 = require("./instructions/initializeEscrowVault");
+Object.defineProperty(exports, "initializeEscrowVault", { enumerable: true, get: function () { return initializeEscrowVault_1.initializeEscrowVault; } });
+// Season membership instructions
+var joinSeason_1 = require("./instructions/joinSeason");
+Object.defineProperty(exports, "joinSeason", { enumerable: true, get: function () { return joinSeason_1.joinSeason; } });
+var confirmedPostOnX_1 = require("./instructions/confirmedPostOnX");
+Object.defineProperty(exports, "confirmedPostOnX", { enumerable: true, get: function () { return confirmedPostOnX_1.confirmedPostOnX; } });
+var claimWindowRewards_1 = require("./instructions/claimWindowRewards");
+Object.defineProperty(exports, "claimWindowRewards", { enumerable: true, get: function () { return claimWindowRewards_1.claimWindowRewards; } });
+var claimReferralPenaltyForWindow_1 = require("./instructions/claimReferralPenaltyForWindow");
+Object.defineProperty(exports, "claimReferralPenaltyForWindow", { enumerable: true, get: function () { return claimReferralPenaltyForWindow_1.claimReferralPenaltyForWindow; } });
+var withdrawSeasonDeposit_1 = require("./instructions/withdrawSeasonDeposit");
+Object.defineProperty(exports, "withdrawSeasonDeposit", { enumerable: true, get: function () { return withdrawSeasonDeposit_1.withdrawSeasonDeposit; } });
+// Season admin instructions
+var toggleSeasonPause_1 = require("./instructions/toggleSeasonPause");
+Object.defineProperty(exports, "toggleSeasonPause", { enumerable: true, get: function () { return toggleSeasonPause_1.toggleSeasonPause; } });
+var updateSeasonAdmin_1 = require("./instructions/updateSeasonAdmin");
+Object.defineProperty(exports, "updateSeasonAdmin", { enumerable: true, get: function () { return updateSeasonAdmin_1.updateSeasonAdmin; } });
+// View instructions (read-only)
+var viewSeasonMembershipStatus_1 = require("./instructions/viewSeasonMembershipStatus");
+Object.defineProperty(exports, "viewSeasonMembershipStatus", { enumerable: true, get: function () { return viewSeasonMembershipStatus_1.viewSeasonMembershipStatus; } });
+var viewWindowStatus_1 = require("./instructions/viewWindowStatus");
+Object.defineProperty(exports, "viewWindowStatus", { enumerable: true, get: function () { return viewWindowStatus_1.viewWindowStatus; } });
+var viewCurrentSeason_1 = require("./instructions/viewCurrentSeason");
+Object.defineProperty(exports, "viewCurrentSeason", { enumerable: true, get: function () { return viewCurrentSeason_1.viewCurrentSeason; } });
+// Export utilities
+__exportStar(require("./utils/pdas"), exports);
+__exportStar(require("./utils/constants"), exports);
+__exportStar(require("./utils/accountUpdates"), exports);
+__exportStar(require("./utils/programHelpers"), exports);
+__exportStar(require("./utils/signerHelpers"), exports);
+__exportStar(require("./utils/conversions"), exports);
+__exportStar(require("./utils/transactionBuilder"), exports);
+__exportStar(require("./utils/simulationHelpers"), exports);
+__exportStar(require("./utils/enumHelpers"), exports);
+var pdaManager_1 = require("./utils/pdaManager");
+Object.defineProperty(exports, "PDAManager", { enumerable: true, get: function () { return pdaManager_1.PDAManager; } });
+// Export optimistic updates
+__exportStar(require("./optimistic"), exports);
+// Export constants
+__exportStar(require("./constants/season"), exports);
+// Export types
+__exportStar(require("./types"), exports);
+__exportStar(require("./types/instructionResults"), exports);
+__exportStar(require("./types/accountTypes"), exports);
+var idl_1 = require("./idl/idl");
+Object.defineProperty(exports, "IDL", { enumerable: true, get: function () { return idl_1.IDL; } });
+// Export client helpers
+var client_1 = require("./client");
+Object.defineProperty(exports, "createProgram", { enumerable: true, get: function () { return client_1.createProgram; } });
+Object.defineProperty(exports, "createProgramWithId", { enumerable: true, get: function () { return client_1.createProgramWithId; } });
+Object.defineProperty(exports, "getProgramReadOnly", { enumerable: true, get: function () { return client_1.getProgramReadOnly; } });
+// Export getters
+__exportStar(require("./getters"), exports);
+// Version
+exports.VERSION = "1.0.0";

package/dist/instructions/claimReferralPenaltyForWindow.d.ts

@@ -0,0 +1,38 @@
+import { BN } from "@coral-xyz/anchor";
+import { Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { SignerInfo } from "../utils/signerHelpers";
+import { ReferralPenaltyClaim, SeasonMembership, UserWindowParticipation } from "../types";
+export interface ClaimReferralPenaltyForWindowOptions {
+    connection: Connection;
+    /** Referrer (or root admin if no referrer) */
+    claimant: PublicKey;
+    /** Token account owned by claimant (receives the 20% payout) */
+    recipientTokenAccount: PublicKey;
+    referredUser: PublicKey;
+    seasonNumber: BN;
+    windowNumber: BN;
+    seasonMembershipId: BN;
+    feePayer?: PublicKey;
+    /**
+     * Optional timestamp override (Unix seconds) for optimistic `claimedAt`.
+     * If omitted, SDK uses `Date.now()` (seconds).
+     */
+    now?: BN;
+    /**
+     * Current on-chain account snapshots for optimistic updates.
+     * If provided, SDK returns `updatedAccounts` that should match on-chain results.
+     */
+    currentAccounts?: {
+        seasonMembership?: SeasonMembership;
+        userWindowParticipation?: UserWindowParticipation;
+    };
+}
+export declare function claimReferralPenaltyForWindow(options: ClaimReferralPenaltyForWindowOptions): Promise<{
+    instructions: TransactionInstruction[];
+    signers: SignerInfo[];
+    updatedAccounts?: {
+        userWindowParticipation?: UserWindowParticipation;
+        referralPenaltyClaim?: ReferralPenaltyClaim;
+        seasonMembership?: SeasonMembership;
+    };
+}>;

package/dist/instructions/claimReferralPenaltyForWindow.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claimReferralPenaltyForWindow = claimReferralPenaltyForWindow;
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+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 tierPenalty_1 = require("../utils/tierPenalty");
+async function claimReferralPenaltyForWindow(options) {
+    const program = (0, programHelpers_1.getProgram)(options.connection);
+    const pdas = pdaManager_1.PDAManager.deriveClaimReferralPenaltyForWindowPdas({
+        referredUser: options.referredUser,
+        seasonNumber: options.seasonNumber,
+        windowNumber: options.windowNumber,
+        referredSeasonMembershipId: options.seasonMembershipId,
+    });
+    const accounts = {
+        seasonSettings: pdas.seasonSettings,
+        season: pdas.season,
+        seasonMembership: pdas.seasonMembership,
+        userWindowParticipation: pdas.userWindowParticipation,
+        referralPenaltyClaim: pdas.referralPenaltyClaim,
+        seasonDepositVault: pdas.seasonDepositVault,
+        mizdMint: constants_1.MIZD_TOKEN_MINT,
+        recipientTokenAccount: options.recipientTokenAccount,
+        claimant: options.claimant,
+        tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+        systemProgram: web3_js_1.SystemProgram.programId,
+    };
+    const instruction = await program.methods
+        .claimReferralPenaltyForWindow(
+    // Anchor expects BN for u64 args.
+    options.seasonNumber, options.windowNumber, options.referredUser, options.seasonMembershipId)
+        .accounts(accounts)
+        .instruction();
+    const signers = (0, signerHelpers_1.buildSigners)([{ publicKey: options.claimant, role: "claimant" }], options.feePayer);
+    // OPTIMISTIC UPDATES
+    let updatedAccounts = undefined;
+    const curr = options.currentAccounts;
+    if (curr?.seasonMembership) {
+        const claimedAt = (0, optimistic_1.getCurrentTimestamp)(options.now);
+        // The program `init_if_needed` for participation; if caller doesn't provide it, assume it doesn't exist.
+        const participation = curr.userWindowParticipation ??
+            (0, optimistic_1.initializeUserWindowParticipation)(options.referredUser, options.seasonNumber, options.windowNumber, options.seasonMembershipId, new anchor_1.BN(0) // miztake_id = 0 for total no-show windows
+            );
+        // Keep this in sync with on-chain: membership.deposit_tier.penalty_per_window_amount()
+        const perWindowPenalty = (0, tierPenalty_1.getTierPenaltyPerWindow)(curr.seasonMembership.depositTier);
+        const claim = (0, optimistic_1.initializeReferralPenaltyClaim)({
+            referredUser: options.referredUser,
+            seasonNumber: options.seasonNumber,
+            windowNumber: options.windowNumber,
+            seasonMembershipId: options.seasonMembershipId,
+            claimant: options.claimant,
+            perWindowPenalty,
+            claimedAt,
+        });
+        updatedAccounts = {
+            seasonMembership: curr.seasonMembership,
+            userWindowParticipation: participation,
+            referralPenaltyClaim: claim,
+        };
+    }
+    return {
+        instructions: [instruction],
+        signers,
+        ...(updatedAccounts && { updatedAccounts }),
+    };
+}

package/dist/instructions/claimWindowRewards.d.ts

@@ -0,0 +1,48 @@
+import { BN } from "@coral-xyz/anchor";
+import { Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { SeasonSettings, Season, RewardWindow, UserWindowParticipation, SeasonMembership } from "../types";
+import { SignerInfo } from "../utils/signerHelpers";
+type ClaimWindowRewardsUpdatedAccounts = {
+    seasonSettings?: SeasonSettings;
+    season?: Season;
+    rewardWindow?: RewardWindow;
+    userWindowParticipation?: UserWindowParticipation;
+    seasonMembership?: SeasonMembership;
+};
+/**
+ * Options for claimWindowRewards instruction
+ */
+export interface ClaimWindowRewardsOptions {
+    connection: Connection;
+    user: PublicKey;
+    userTokenAccount: PublicKey;
+    /** Referrer token account to receive referral share (only used when membership.referrer != default) */
+    referrerTokenAccount?: PublicKey;
+    seasonNumber: BN;
+    windowNumber: BN;
+    seasonMembershipId: BN;
+    feePayer?: PublicKey;
+    currentAccounts?: {
+        seasonSettings?: SeasonSettings;
+        season?: Season;
+        rewardWindow?: RewardWindow;
+        userWindowParticipation?: UserWindowParticipation;
+        seasonMembership?: SeasonMembership;
+    };
+}
+/**
+ * Claim window rewards
+ *
+ * Single signer: user
+ * Transfers reward tokens from vault to user
+ * May finalize window on first claim
+ *
+ * @param options - Claim window rewards options
+ * @returns Instructions, signers, and optimistically updated accounts
+ */
+export declare function claimWindowRewards(options: ClaimWindowRewardsOptions): Promise<{
+    instructions: TransactionInstruction[];
+    signers: SignerInfo[];
+    updatedAccounts?: ClaimWindowRewardsUpdatedAccounts;
+}>;
+export {};

package/dist/instructions/claimWindowRewards.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claimWindowRewards = claimWindowRewards;
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const pdaManager_1 = require("../utils/pdaManager");
+const constants_1 = require("../utils/constants");
+const tierPenalty_1 = require("../utils/tierPenalty");
+const programHelpers_1 = require("../utils/programHelpers");
+const signerHelpers_1 = require("../utils/signerHelpers");
+const optimistic_1 = require("../optimistic");
+/**
+ * Claim window rewards
+ *
+ * Single signer: user
+ * Transfers reward tokens from vault to user
+ * May finalize window on first claim
+ *
+ * @param options - Claim window rewards options
+ * @returns Instructions, signers, and optimistically updated accounts
+ */
+async function claimWindowRewards(options) {
+    const program = (0, programHelpers_1.getProgram)(options.connection);
+    const pdas = pdaManager_1.PDAManager.deriveClaimWindowRewardsPdas({
+        user: options.user,
+        seasonNumber: options.seasonNumber,
+        windowNumber: options.windowNumber,
+        seasonMembershipId: options.seasonMembershipId,
+    });
+    const accounts = {
+        seasonSettings: pdas.seasonSettings,
+        season: pdas.season,
+        rewardWindow: pdas.rewardWindow,
+        userWindowParticipation: pdas.userWindowParticipation,
+        seasonMembership: pdas.seasonMembership,
+        seasonDepositVault: pdas.seasonDepositVault,
+        mizdMint: constants_1.MIZD_TOKEN_MINT,
+        userTokenAccount: options.userTokenAccount,
+        // Always provide something; on-chain will only validate/use when referrer exists.
+        referrerTokenAccount: options.referrerTokenAccount ?? options.userTokenAccount,
+        user: options.user,
+        tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+    };
+    const instruction = await program.methods
+        // Anchor expects BN for u64 args.
+        .claimWindowRewards(options.seasonNumber, options.windowNumber)
+        .accounts(accounts)
+        .instruction();
+    const signers = (0, signerHelpers_1.buildSigners)([{ publicKey: options.user, role: "user" }], options.feePayer);
+    // OPTIMISTIC UPDATES
+    const curr = options.currentAccounts || {};
+    let updatedAccounts = undefined;
+    if (curr.rewardWindow && curr.seasonSettings && curr.season) {
+        const idx = options.windowNumber.toNumber();
+        const eligibleStakeX = curr.season.eligibleStakePerWindow[idx] ?? new anchor_1.BN(0);
+        const updatedRewardWindow = !curr.rewardWindow.isFinalized
+            ? (0, optimistic_1.updateWindowForFinalization)(curr.rewardWindow, eligibleStakeX)
+            : curr.rewardWindow;
+        const rewardAmount = updatedRewardWindow.rewardPerPoster;
+        const hasReferrer = !!curr.seasonMembership &&
+            !curr.seasonMembership.referrer.equals(web3_js_1.PublicKey.default);
+        const tierPenaltyPerWindow = curr.seasonMembership
+            ? (0, tierPenalty_1.getTierPenaltyPerWindow)(curr.seasonMembership.depositTier)
+            : new anchor_1.BN(0);
+        const bonus = rewardAmount.gt(tierPenaltyPerWindow)
+            ? rewardAmount.sub(tierPenaltyPerWindow)
+            : new anchor_1.BN(0);
+        const referralCut = hasReferrer ? bonus.divn(10) : new anchor_1.BN(0);
+        const userRewardAmount = rewardAmount.sub(referralCut);
+        const updatedSeason = !curr.rewardWindow.isFinalized
+            ? {
+                ...curr.season,
+                totalPenaltiesCollected: curr.season.totalPenaltiesCollected.add(updatedRewardWindow.penaltyPool),
+            }
+            : curr.season;
+        updatedAccounts = {
+            ...(curr.seasonSettings && { seasonSettings: curr.seasonSettings }),
+            season: updatedSeason,
+            rewardWindow: updatedRewardWindow,
+            ...(curr.userWindowParticipation && {
+                userWindowParticipation: (0, optimistic_1.updateParticipationForClaim)(curr.userWindowParticipation, userRewardAmount),
+            }),
+            ...(curr.seasonMembership && {
+                seasonMembership: (0, optimistic_1.updateMembershipForClaim)(curr.seasonMembership, userRewardAmount),
+            }),
+        };
+    }
+    return {
+        instructions: [instruction],
+        signers,
+        ...(updatedAccounts && { updatedAccounts }),
+    };
+}

package/dist/instructions/confirmedPostOnX.d.ts

@@ -0,0 +1,51 @@
+import { BN } from "@coral-xyz/anchor";
+import { Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { SeasonSettings, SeasonMembership, Season, RewardWindow, UserWindowParticipation, Miztake } from "../types";
+import { SignerInfo } from "../utils/signerHelpers";
+type ConfirmedPostOnXUpdatedAccounts = {
+    seasonSettings?: SeasonSettings;
+    seasonMembership?: SeasonMembership;
+    season?: Season;
+    rewardWindow?: RewardWindow;
+    userWindowParticipation?: UserWindowParticipation;
+    miztake?: Miztake;
+};
+/**
+ * Options for confirmedPostOnX instruction
+ */
+export interface ConfirmedPostOnXOptions {
+    connection: Connection;
+    adminKey: PublicKey;
+    user: PublicKey;
+    seasonMembershipId: BN;
+    windowNumber: BN;
+    /** SHA-256 hex string (64 chars). On-chain expects the raw 32-byte digest. */
+    miztakeShaHash: string;
+    feePayer?: PublicKey;
+    /** Whether the post is on time (needed for optimistic updates) */
+    isOnTime?: boolean;
+    currentAccounts?: {
+        seasonSettings?: SeasonSettings;
+        seasonMembership?: SeasonMembership;
+        season?: Season;
+        rewardWindow?: RewardWindow;
+        userWindowParticipation?: UserWindowParticipation;
+        miztake?: Miztake;
+    };
+}
+/**
+ * Confirm a post on X (Twitter)
+ *
+ * Single signer: admin (season admin, not root admin)
+ * No token transfers
+ * Updates multiple accounts based on whether post was on time
+ *
+ * @param options - Confirmed post on X options
+ * @returns Instructions, signers, and optimistically updated accounts
+ */
+export declare function confirmedPostOnX(options: ConfirmedPostOnXOptions): Promise<{
+    instructions: TransactionInstruction[];
+    signers: SignerInfo[];
+    updatedAccounts?: ConfirmedPostOnXUpdatedAccounts;
+}>;
+export {};

package/dist/instructions/confirmedPostOnX.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.confirmedPostOnX = confirmedPostOnX;
+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 tierPenalty_1 = require("../utils/tierPenalty");
+const optimistic_1 = require("../optimistic");
+/**
+ * Confirm a post on X (Twitter)
+ *
+ * Single signer: admin (season admin, not root admin)
+ * No token transfers
+ * Updates multiple accounts based on whether post was on time
+ *
+ * @param options - Confirmed post on X options
+ * @returns Instructions, signers, and optimistically updated accounts
+ */
+async function confirmedPostOnX(options) {
+    const program = (0, programHelpers_1.getProgram)(options.connection);
+    const curr = options.currentAccounts || {};
+    if (!curr.seasonMembership) {
+        throw new Error("seasonMembership required for confirmedPostOnX");
+    }
+    const seasonNumber = curr.seasonMembership.seasonNumber;
+    const pdas = pdaManager_1.PDAManager.deriveConfirmedPostPdas({
+        user: options.user,
+        seasonNumber,
+        windowNumber: options.windowNumber,
+        seasonMembershipId: options.seasonMembershipId,
+        miztakeShaHash: options.miztakeShaHash,
+    });
+    const accounts = {
+        seasonSettings: pdas.seasonSettings,
+        seasonMembership: pdas.seasonMembership,
+        season: pdas.season,
+        rewardWindow: pdas.rewardWindow,
+        userWindowParticipation: pdas.userWindowParticipation,
+        miztake: pdas.miztake,
+        admin: options.adminKey,
+    };
+    const instruction = await program.methods
+        .confirmedPostOnX(options.user, 
+    // Anchor expects BN for u64 args.
+    options.seasonMembershipId, options.windowNumber, Array.from((0, conversions_1.sha256HexToBytes32)(options.miztakeShaHash)))
+        .accounts(accounts)
+        .instruction();
+    const signers = (0, signerHelpers_1.buildSigners)([{ publicKey: options.adminKey, role: "admin" }], options.feePayer);
+    // OPTIMISTIC UPDATES
+    let updatedAccounts = undefined;
+    if (options.isOnTime !== undefined && curr.seasonSettings) {
+        const stakeAmount = (0, tierPenalty_1.getTierPenaltyPerWindow)(curr.seasonMembership.depositTier);
+        updatedAccounts = {
+            ...(curr.seasonSettings && { seasonSettings: curr.seasonSettings }),
+            ...(curr.rewardWindow && {
+                rewardWindow: (0, optimistic_1.updateWindowForConfirmation)(curr.rewardWindow, options.isOnTime, stakeAmount),
+            }),
+            ...(curr.userWindowParticipation && {
+                userWindowParticipation: (0, optimistic_1.updateParticipationForConfirmation)(curr.userWindowParticipation, options.isOnTime),
+            }),
+            ...(curr.seasonMembership && {
+                seasonMembership: (0, optimistic_1.updateMembershipForConfirmation)(curr.seasonMembership, options.isOnTime, stakeAmount),
+            }),
+            ...(curr.season && {
+                season: (0, optimistic_1.updateSeasonForConfirmation)(curr.season, options.isOnTime, stakeAmount),
+            }),
+            ...(curr.miztake && {
+                miztake: (0, optimistic_1.updateMiztakeForSeasonUse)(curr.miztake, seasonNumber, options.windowNumber),
+            }),
+        };
+    }
+    return {
+        instructions: [instruction],
+        signers,
+        ...(updatedAccounts && { updatedAccounts }),
+    };
+}

package/dist/instructions/createMiztake.d.ts

@@ -0,0 +1,90 @@
+import { BN } from "@coral-xyz/anchor";
+import { Connection, PublicKey } from "@solana/web3.js";
+import { CreateMiztakeParams, Miztake, UserStats, MiztakeStatistics, SeasonSettings, Season, SeasonMembership, RewardWindow, UserWindowParticipation } from "../types";
+import { SignerInfo } from "../utils/signerHelpers";
+/**
+ * Options for createMiztake instruction
+ */
+export interface CreateMiztakeOptions {
+    connection: Connection;
+    params: CreateMiztakeParams;
+    user: PublicKey;
+    admin: PublicKey;
+    seasonNumber: BN;
+    windowNumber: BN;
+    seasonMembershipId: BN;
+    /** Optional injected timestamp (seconds) for optimistic state calculation */
+    now?: BN;
+    feePayer?: PublicKey;
+    currentAccounts?: {
+        userStats?: UserStats;
+        miztakeStatistics?: MiztakeStatistics;
+        seasonSettings?: SeasonSettings;
+        season?: Season;
+        seasonMembership?: SeasonMembership;
+        rewardWindow?: RewardWindow;
+        userWindowParticipation?: UserWindowParticipation;
+    };
+}
+/**
+ * Result from createMiztake instruction
+ */
+export interface CreateMiztakeResult {
+    instructions: import("@solana/web3.js").TransactionInstruction[];
+    signers: SignerInfo[];
+    pdas: {
+        miztake: PublicKey;
+        userStats: PublicKey;
+        miztakeStatistics: PublicKey;
+        seasonSettings: PublicKey;
+        season: PublicKey;
+        seasonMembership: PublicKey;
+        rewardWindow: PublicKey;
+        userWindowParticipation: PublicKey;
+    };
+    updatedAccounts: {
+        miztake: Miztake;
+        userStats?: UserStats;
+        miztakeStatistics?: MiztakeStatistics;
+        seasonSettings?: SeasonSettings;
+        season?: Season;
+        seasonMembership?: SeasonMembership;
+        rewardWindow?: RewardWindow;
+        userWindowParticipation?: UserWindowParticipation;
+    };
+}
+/**
+ * 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,
+ *   }
+ * });
+ * ```
+ */
+export declare function createMiztake(options: CreateMiztakeOptions): Promise<CreateMiztakeResult>;
+/**
+ * Get the miztake PDA that would be created for given parameters
+ * Useful for checking if a miztake already exists
+ */
+export declare function getMiztakePdaForParams(params: CreateMiztakeParams): PublicKey;