@styxstack/whisperdrop-sdk 1.0.0

package/LICENSE

@@ -0,0 +1,17 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   Copyright 2024-2026 @moonmanquark (Bluefoot Labs)
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,199 @@
+# @styxstack/whisperdrop-sdk
+
+TypeScript SDK for **WhisperDrop** - Privacy-Preserving Airdrops on Solana.
+
+[![npm version](https://badge.fury.io/js/@styx-stack%2Fwhisperdrop-sdk.svg)](https://www.npmjs.com/package/@styxstack/whisperdrop-sdk)
+[![License: Apache-2.0](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+## Features
+
+- 🔒 **Privacy-Preserving** - Recipient lists never published on-chain
+- 🌳 **Merkle Proofs** - Efficient verification for 1M+ recipients
+- 🎫 **Token Gating** - SPL, Token-2022, NFT, and cNFT support
+- ⏰ **Time-Locked** - Automatic expiry with reclaim
+- âš¡ **Ultra-Efficient** - ~5K compute units per claim
+
+## Installation
+
+```bash
+npm install @styxstack/whisperdrop-sdk @solana/web3.js
+```
+
+## Quick Start
+
+```typescript
+import { Connection, Keypair, PublicKey } from '@solana/web3.js';
+import { 
+    WhisperDrop, 
+    buildMerkleTree, 
+    generateCampaignId, 
+    generateNonce,
+    GateType 
+} from '@styxstack/whisperdrop-sdk';
+
+const connection = new Connection('https://api.mainnet-beta.solana.com');
+const whisperdrop = new WhisperDrop(connection);
+
+// 1. Create allocations
+const allocations = [
+    { recipient: new PublicKey('...'), amount: 1000n, nonce: generateNonce() },
+    { recipient: new PublicKey('...'), amount: 2000n, nonce: generateNonce() },
+    // ... up to 1M+ recipients
+];
+
+// 2. Build Merkle tree
+const campaignId = generateCampaignId();
+const { root, proofs } = buildMerkleTree(campaignId, allocations);
+
+// 3. Initialize campaign with Token-2022 gating
+const { campaignPDA, escrowPDA } = await whisperdrop.initCampaign(
+    authority,
+    tokenMint,
+    {
+        campaignId,
+        merkleRoot: root,
+        expiryUnix: BigInt(Date.now() / 1000 + 86400 * 30), // 30 days
+        gateType: GateType.Token22Holder,
+        gateMint: membershipToken, // Require Token-2022 token to claim
+    }
+);
+
+// 4. Recipients claim with proof
+const proof = proofs.get(recipient.publicKey.toBase58())!;
+await whisperdrop.claim(
+    payer,
+    recipient,
+    campaignPDA,
+    allocation,
+    proof,
+    recipientATA,
+    gateTokenAccount // Token-2022 token account
+);
+```
+
+## Token Gating
+
+WhisperDrop supports selective claiming based on multiple token standards:
+
+### SPL Token (Original Token Program)
+
+```typescript
+// Require any amount of SPL token
+{ gateType: GateType.SplTokenHolder, gateMint: tokenMint }
+
+// Require minimum balance
+{ gateType: GateType.SplMinBalance, gateMint: tokenMint, gateAmount: 1000_000_000n }
+```
+
+### Token-2022 (Token Extensions)
+
+```typescript
+// Require any amount of Token-2022 token
+{ gateType: GateType.Token22Holder, gateMint: token22Mint }
+
+// Require minimum balance
+{ gateType: GateType.Token22MinBalance, gateMint: token22Mint, gateAmount: 500_000_000n }
+```
+
+### NFT (Metaplex Standard)
+
+```typescript
+// Require specific NFT
+{ gateType: GateType.NftHolder, gateMint: nftMint }
+
+// Require NFT from collection
+{ gateType: GateType.NftCollection, gateMint: collectionMint }
+```
+
+### cNFT (Compressed NFT via Bubblegum)
+
+```typescript
+// Require specific cNFT (asset ID as mint)
+{ gateType: GateType.CnftHolder, gateMint: assetId }
+
+// Require cNFT from collection
+{ gateType: GateType.CnftCollection, gateMint: collectionId }
+```
+
+### GateType.NftCollection
+Must hold an NFT from a specific collection (future: Metaplex verification).
+
+## API Reference
+
+### WhisperDrop Class
+
+```typescript
+const wd = new WhisperDrop(connection, programId?);
+```
+
+#### `initCampaign(authority, mint, config)`
+Initialize a new airdrop campaign.
+
+#### `claim(payer, recipient, campaignPDA, allocation, proof, recipientATA, gateTokenAccount?)`
+Claim tokens with Merkle proof.
+
+#### `reclaim(authority, campaignPDA, authorityATA)`
+Reclaim remaining tokens after expiry.
+
+#### `hasClaimed(campaignPDA, recipient)`
+Check if recipient has already claimed.
+
+#### `getCampaign(campaignPDA)`
+Get campaign state.
+
+### Merkle Tree Utilities
+
+```typescript
+import { 
+    buildMerkleTree,
+    verifyMerkleProof,
+    computeLeafHash,
+    computeNodeHash,
+} from '@styxstack/whisperdrop-sdk';
+```
+
+### PDA Derivation
+
+```typescript
+import {
+    deriveCampaignPDA,
+    deriveEscrowPDA,
+    deriveNullifierPDA,
+} from '@styxstack/whisperdrop-sdk';
+```
+
+## Program IDs
+
+| Network | Program ID |
+|---------|------------|
+| **Mainnet** | `GhstFNnEbixAGQgLnWg1nWetJQgGfSUMhnxdBA6hWu5e` |
+| Devnet | `BPM5VuX9YrG7CgueWGxtqQZBQwMTacc315ppWCtTCJ5q` |
+
+## Use Cases
+
+### 1. NFT Holder Airdrops
+Airdrop tokens only to holders of your NFT collection.
+
+### 2. Staker Rewards
+Distribute rewards to users who stake above a threshold.
+
+### 3. Community Rewards
+Private distribution to community members without revealing the list.
+
+### 4. Retroactive Airdrops
+Reward early users without publishing their addresses.
+
+## Security
+
+- **Nullifiers** prevent double-claiming
+- **Time-locked reclaim** protects unclaimed funds
+- **Immutable Merkle root** ensures allocation integrity
+- **PDA escrow** for secure token custody
+
+## License
+
+Apache-2.0
+
+---
+
+Built by [@moonmanquark](https://github.com/moonmanquark) at **Bluefoot Labs**

package/dist/index.d.mts

@@ -0,0 +1,175 @@
+import { PublicKey, Connection, Keypair } from '@solana/web3.js';
+
+/**
+ * @styxstack/whisperdrop-sdk
+ *
+ * TypeScript SDK for WhisperDrop - Privacy-Preserving Airdrops on Solana
+ *
+ * Features:
+ * - Merkle tree generation and proof creation
+ * - Token-gated claiming (NFT, token balance)
+ * - Campaign creation and management
+ * - Claim and reclaim operations
+ *
+ * @author @moonmanquark (Bluefoot Labs)
+ * @license Apache-2.0
+ */
+
+/** Mainnet Program ID */
+declare const WHISPERDROP_PROGRAM_ID: PublicKey;
+/** Devnet Program ID */
+declare const WHISPERDROP_DEVNET_PROGRAM_ID: PublicKey;
+/** Token Program ID (SPL Token) */
+declare const TOKEN_PROGRAM_ID: PublicKey;
+/** Token-2022 Program ID */
+declare const TOKEN_2022_PROGRAM_ID: PublicKey;
+/** Metaplex Token Metadata Program ID */
+declare const METADATA_PROGRAM_ID: PublicKey;
+/** Bubblegum (cNFT) Program ID */
+declare const BUBBLEGUM_PROGRAM_ID: PublicKey;
+/**
+ * Gate type for selective claiming
+ *
+ * Supports multiple token standards:
+ * - SPL Token (original Solana token program)
+ * - Token-2022 (Token Extensions)
+ * - NFT (Metaplex standard)
+ * - cNFT (Compressed NFT via Bubblegum)
+ */
+declare enum GateType {
+    /** No gate - anyone with valid proof can claim */
+    None = 0,
+    /** Must hold any amount of SPL token */
+    SplTokenHolder = 1,
+    /** Must hold minimum balance of SPL token */
+    SplMinBalance = 2,
+    /** Must hold any amount of Token-2022 token */
+    Token22Holder = 3,
+    /** Must hold minimum balance of Token-2022 token */
+    Token22MinBalance = 4,
+    /** Must hold specific NFT */
+    NftHolder = 5,
+    /** Must hold NFT from verified collection */
+    NftCollection = 6,
+    /** Must hold specific cNFT */
+    CnftHolder = 7,
+    /** Must hold cNFT from collection */
+    CnftCollection = 8
+}
+/**
+ * Helper to determine which token program a gate type uses
+ */
+declare function getTokenProgramForGate(gateType: GateType): PublicKey | null;
+/**
+ * Check if gate type requires minimum balance check
+ */
+declare function requiresMinBalance(gateType: GateType): boolean;
+/**
+ * Check if gate type is for compressed NFTs
+ */
+declare function isCnftGate(gateType: GateType): boolean;
+/** Recipient allocation for Merkle tree */
+interface Allocation {
+    recipient: PublicKey;
+    amount: bigint;
+    nonce: Uint8Array;
+}
+/** Campaign configuration */
+interface CampaignConfig {
+    campaignId: Uint8Array;
+    merkleRoot: Uint8Array;
+    expiryUnix: bigint;
+    gateType?: GateType;
+    gateMint?: PublicKey;
+    gateAmount?: bigint;
+}
+/** Merkle proof for claiming */
+interface MerkleProof {
+    allocation: Allocation;
+    proof: Uint8Array[];
+}
+/** Campaign state (on-chain) */
+interface Campaign {
+    authority: PublicKey;
+    mint: PublicKey;
+    campaignId: Uint8Array;
+    merkleRoot: Uint8Array;
+    expiryUnix: bigint;
+    gateType: GateType;
+    gateMint: PublicKey;
+    gateAmount: bigint;
+}
+/**
+ * Compute leaf hash for an allocation
+ */
+declare function computeLeafHash(campaignId: Uint8Array, recipient: PublicKey, amount: bigint, nonce: Uint8Array): Uint8Array;
+/**
+ * Compute node hash (sorted pair)
+ */
+declare function computeNodeHash(left: Uint8Array, right: Uint8Array): Uint8Array;
+/**
+ * Build Merkle tree from allocations
+ * Returns root hash and all proofs
+ */
+declare function buildMerkleTree(campaignId: Uint8Array, allocations: Allocation[]): {
+    root: Uint8Array;
+    proofs: Map<string, Uint8Array[]>;
+};
+/**
+ * Verify Merkle proof
+ */
+declare function verifyMerkleProof(campaignId: Uint8Array, allocation: Allocation, proof: Uint8Array[], root: Uint8Array): boolean;
+/**
+ * Derive campaign PDA
+ */
+declare function deriveCampaignPDA(campaignId: Uint8Array, programId?: PublicKey): [PublicKey, number];
+/**
+ * Derive escrow PDA
+ */
+declare function deriveEscrowPDA(campaignPDA: PublicKey, programId?: PublicKey): [PublicKey, number];
+/**
+ * Derive nullifier PDA
+ */
+declare function deriveNullifierPDA(campaignPDA: PublicKey, recipient: PublicKey, programId?: PublicKey): [PublicKey, number];
+/**
+ * WhisperDrop SDK
+ */
+declare class WhisperDrop {
+    connection: Connection;
+    programId: PublicKey;
+    constructor(connection: Connection, programId?: PublicKey);
+    /**
+     * Initialize a new airdrop campaign
+     */
+    initCampaign(authority: Keypair, mint: PublicKey, config: CampaignConfig): Promise<{
+        signature: string;
+        campaignPDA: PublicKey;
+        escrowPDA: PublicKey;
+    }>;
+    /**
+     * Claim tokens with Merkle proof
+     */
+    claim(payer: Keypair, recipient: Keypair, campaignPDA: PublicKey, allocation: Allocation, proof: Uint8Array[], recipientATA: PublicKey, gateTokenAccount?: PublicKey): Promise<string>;
+    /**
+     * Reclaim remaining tokens after expiry
+     */
+    reclaim(authority: Keypair, campaignPDA: PublicKey, authorityATA: PublicKey): Promise<string>;
+    /**
+     * Check if recipient has already claimed
+     */
+    hasClaimed(campaignPDA: PublicKey, recipient: PublicKey): Promise<boolean>;
+    /**
+     * Get campaign state
+     */
+    getCampaign(campaignPDA: PublicKey): Promise<Campaign | null>;
+}
+/**
+ * Generate random nonce for allocation
+ */
+declare function generateNonce(): Uint8Array;
+/**
+ * Generate campaign ID
+ */
+declare function generateCampaignId(): Uint8Array;
+
+export { type Allocation, BUBBLEGUM_PROGRAM_ID, type Campaign, type CampaignConfig, GateType, METADATA_PROGRAM_ID, type MerkleProof, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID, WHISPERDROP_DEVNET_PROGRAM_ID, WHISPERDROP_PROGRAM_ID, WhisperDrop, buildMerkleTree, computeLeafHash, computeNodeHash, WhisperDrop as default, deriveCampaignPDA, deriveEscrowPDA, deriveNullifierPDA, generateCampaignId, generateNonce, getTokenProgramForGate, isCnftGate, requiresMinBalance, verifyMerkleProof };

package/dist/index.d.ts

@@ -0,0 +1,175 @@
+import { PublicKey, Connection, Keypair } from '@solana/web3.js';
+
+/**
+ * @styxstack/whisperdrop-sdk
+ *
+ * TypeScript SDK for WhisperDrop - Privacy-Preserving Airdrops on Solana
+ *
+ * Features:
+ * - Merkle tree generation and proof creation
+ * - Token-gated claiming (NFT, token balance)
+ * - Campaign creation and management
+ * - Claim and reclaim operations
+ *
+ * @author @moonmanquark (Bluefoot Labs)
+ * @license Apache-2.0
+ */
+
+/** Mainnet Program ID */
+declare const WHISPERDROP_PROGRAM_ID: PublicKey;
+/** Devnet Program ID */
+declare const WHISPERDROP_DEVNET_PROGRAM_ID: PublicKey;
+/** Token Program ID (SPL Token) */
+declare const TOKEN_PROGRAM_ID: PublicKey;
+/** Token-2022 Program ID */
+declare const TOKEN_2022_PROGRAM_ID: PublicKey;
+/** Metaplex Token Metadata Program ID */
+declare const METADATA_PROGRAM_ID: PublicKey;
+/** Bubblegum (cNFT) Program ID */
+declare const BUBBLEGUM_PROGRAM_ID: PublicKey;
+/**
+ * Gate type for selective claiming
+ *
+ * Supports multiple token standards:
+ * - SPL Token (original Solana token program)
+ * - Token-2022 (Token Extensions)
+ * - NFT (Metaplex standard)
+ * - cNFT (Compressed NFT via Bubblegum)
+ */
+declare enum GateType {
+    /** No gate - anyone with valid proof can claim */
+    None = 0,
+    /** Must hold any amount of SPL token */
+    SplTokenHolder = 1,
+    /** Must hold minimum balance of SPL token */
+    SplMinBalance = 2,
+    /** Must hold any amount of Token-2022 token */
+    Token22Holder = 3,
+    /** Must hold minimum balance of Token-2022 token */
+    Token22MinBalance = 4,
+    /** Must hold specific NFT */
+    NftHolder = 5,
+    /** Must hold NFT from verified collection */
+    NftCollection = 6,
+    /** Must hold specific cNFT */
+    CnftHolder = 7,
+    /** Must hold cNFT from collection */
+    CnftCollection = 8
+}
+/**
+ * Helper to determine which token program a gate type uses
+ */
+declare function getTokenProgramForGate(gateType: GateType): PublicKey | null;
+/**
+ * Check if gate type requires minimum balance check
+ */
+declare function requiresMinBalance(gateType: GateType): boolean;
+/**
+ * Check if gate type is for compressed NFTs
+ */
+declare function isCnftGate(gateType: GateType): boolean;
+/** Recipient allocation for Merkle tree */
+interface Allocation {
+    recipient: PublicKey;
+    amount: bigint;
+    nonce: Uint8Array;
+}
+/** Campaign configuration */
+interface CampaignConfig {
+    campaignId: Uint8Array;
+    merkleRoot: Uint8Array;
+    expiryUnix: bigint;
+    gateType?: GateType;
+    gateMint?: PublicKey;
+    gateAmount?: bigint;
+}
+/** Merkle proof for claiming */
+interface MerkleProof {
+    allocation: Allocation;
+    proof: Uint8Array[];
+}
+/** Campaign state (on-chain) */
+interface Campaign {
+    authority: PublicKey;
+    mint: PublicKey;
+    campaignId: Uint8Array;
+    merkleRoot: Uint8Array;
+    expiryUnix: bigint;
+    gateType: GateType;
+    gateMint: PublicKey;
+    gateAmount: bigint;
+}
+/**
+ * Compute leaf hash for an allocation
+ */
+declare function computeLeafHash(campaignId: Uint8Array, recipient: PublicKey, amount: bigint, nonce: Uint8Array): Uint8Array;
+/**
+ * Compute node hash (sorted pair)
+ */
+declare function computeNodeHash(left: Uint8Array, right: Uint8Array): Uint8Array;
+/**
+ * Build Merkle tree from allocations
+ * Returns root hash and all proofs
+ */
+declare function buildMerkleTree(campaignId: Uint8Array, allocations: Allocation[]): {
+    root: Uint8Array;
+    proofs: Map<string, Uint8Array[]>;
+};
+/**
+ * Verify Merkle proof
+ */
+declare function verifyMerkleProof(campaignId: Uint8Array, allocation: Allocation, proof: Uint8Array[], root: Uint8Array): boolean;
+/**
+ * Derive campaign PDA
+ */
+declare function deriveCampaignPDA(campaignId: Uint8Array, programId?: PublicKey): [PublicKey, number];
+/**
+ * Derive escrow PDA
+ */
+declare function deriveEscrowPDA(campaignPDA: PublicKey, programId?: PublicKey): [PublicKey, number];
+/**
+ * Derive nullifier PDA
+ */
+declare function deriveNullifierPDA(campaignPDA: PublicKey, recipient: PublicKey, programId?: PublicKey): [PublicKey, number];
+/**
+ * WhisperDrop SDK
+ */
+declare class WhisperDrop {
+    connection: Connection;
+    programId: PublicKey;
+    constructor(connection: Connection, programId?: PublicKey);
+    /**
+     * Initialize a new airdrop campaign
+     */
+    initCampaign(authority: Keypair, mint: PublicKey, config: CampaignConfig): Promise<{
+        signature: string;
+        campaignPDA: PublicKey;
+        escrowPDA: PublicKey;
+    }>;
+    /**
+     * Claim tokens with Merkle proof
+     */
+    claim(payer: Keypair, recipient: Keypair, campaignPDA: PublicKey, allocation: Allocation, proof: Uint8Array[], recipientATA: PublicKey, gateTokenAccount?: PublicKey): Promise<string>;
+    /**
+     * Reclaim remaining tokens after expiry
+     */
+    reclaim(authority: Keypair, campaignPDA: PublicKey, authorityATA: PublicKey): Promise<string>;
+    /**
+     * Check if recipient has already claimed
+     */
+    hasClaimed(campaignPDA: PublicKey, recipient: PublicKey): Promise<boolean>;
+    /**
+     * Get campaign state
+     */
+    getCampaign(campaignPDA: PublicKey): Promise<Campaign | null>;
+}
+/**
+ * Generate random nonce for allocation
+ */
+declare function generateNonce(): Uint8Array;
+/**
+ * Generate campaign ID
+ */
+declare function generateCampaignId(): Uint8Array;
+
+export { type Allocation, BUBBLEGUM_PROGRAM_ID, type Campaign, type CampaignConfig, GateType, METADATA_PROGRAM_ID, type MerkleProof, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID, WHISPERDROP_DEVNET_PROGRAM_ID, WHISPERDROP_PROGRAM_ID, WhisperDrop, buildMerkleTree, computeLeafHash, computeNodeHash, WhisperDrop as default, deriveCampaignPDA, deriveEscrowPDA, deriveNullifierPDA, generateCampaignId, generateNonce, getTokenProgramForGate, isCnftGate, requiresMinBalance, verifyMerkleProof };

package/dist/index.js

@@ -0,0 +1,372 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BUBBLEGUM_PROGRAM_ID: () => BUBBLEGUM_PROGRAM_ID,
+  GateType: () => GateType,
+  METADATA_PROGRAM_ID: () => METADATA_PROGRAM_ID,
+  TOKEN_2022_PROGRAM_ID: () => TOKEN_2022_PROGRAM_ID,
+  TOKEN_PROGRAM_ID: () => TOKEN_PROGRAM_ID,
+  WHISPERDROP_DEVNET_PROGRAM_ID: () => WHISPERDROP_DEVNET_PROGRAM_ID,
+  WHISPERDROP_PROGRAM_ID: () => WHISPERDROP_PROGRAM_ID,
+  WhisperDrop: () => WhisperDrop,
+  buildMerkleTree: () => buildMerkleTree,
+  computeLeafHash: () => computeLeafHash,
+  computeNodeHash: () => computeNodeHash,
+  default: () => index_default,
+  deriveCampaignPDA: () => deriveCampaignPDA,
+  deriveEscrowPDA: () => deriveEscrowPDA,
+  deriveNullifierPDA: () => deriveNullifierPDA,
+  generateCampaignId: () => generateCampaignId,
+  generateNonce: () => generateNonce,
+  getTokenProgramForGate: () => getTokenProgramForGate,
+  isCnftGate: () => isCnftGate,
+  requiresMinBalance: () => requiresMinBalance,
+  verifyMerkleProof: () => verifyMerkleProof
+});
+module.exports = __toCommonJS(index_exports);
+var import_web3 = require("@solana/web3.js");
+var import_sha256 = require("@noble/hashes/sha256");
+var WHISPERDROP_PROGRAM_ID = new import_web3.PublicKey("GhstFNnEbixAGQgLnWg1nWetJQgGfSUMhnxdBA6hWu5e");
+var WHISPERDROP_DEVNET_PROGRAM_ID = new import_web3.PublicKey("BPM5VuX9YrG7CgueWGxtqQZBQwMTacc315ppWCtTCJ5q");
+var TOKEN_PROGRAM_ID = new import_web3.PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+var TOKEN_2022_PROGRAM_ID = new import_web3.PublicKey("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
+var METADATA_PROGRAM_ID = new import_web3.PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
+var BUBBLEGUM_PROGRAM_ID = new import_web3.PublicKey("BGUMAp9Gq7iTEuizy4pqaxsTyUCBK68MDfK752saRPUY");
+var SEED_CAMPAIGN = Buffer.from("wd_campaign");
+var SEED_ESCROW = Buffer.from("wd_escrow");
+var SEED_NULLIFIER = Buffer.from("wd_null");
+var LEAF_DOMAIN = Buffer.from("whisperdrop:leaf:v1");
+var NODE_DOMAIN = Buffer.from("whisperdrop:node:v1");
+var TAG_INIT_CAMPAIGN = 0;
+var TAG_CLAIM = 1;
+var TAG_RECLAIM = 2;
+var GateType = /* @__PURE__ */ ((GateType2) => {
+  GateType2[GateType2["None"] = 0] = "None";
+  GateType2[GateType2["SplTokenHolder"] = 1] = "SplTokenHolder";
+  GateType2[GateType2["SplMinBalance"] = 2] = "SplMinBalance";
+  GateType2[GateType2["Token22Holder"] = 3] = "Token22Holder";
+  GateType2[GateType2["Token22MinBalance"] = 4] = "Token22MinBalance";
+  GateType2[GateType2["NftHolder"] = 5] = "NftHolder";
+  GateType2[GateType2["NftCollection"] = 6] = "NftCollection";
+  GateType2[GateType2["CnftHolder"] = 7] = "CnftHolder";
+  GateType2[GateType2["CnftCollection"] = 8] = "CnftCollection";
+  return GateType2;
+})(GateType || {});
+function getTokenProgramForGate(gateType) {
+  switch (gateType) {
+    case 1 /* SplTokenHolder */:
+    case 2 /* SplMinBalance */:
+    case 5 /* NftHolder */:
+    case 6 /* NftCollection */:
+      return TOKEN_PROGRAM_ID;
+    case 3 /* Token22Holder */:
+    case 4 /* Token22MinBalance */:
+      return TOKEN_2022_PROGRAM_ID;
+    case 7 /* CnftHolder */:
+    case 8 /* CnftCollection */:
+      return null;
+    default:
+      return null;
+  }
+}
+function requiresMinBalance(gateType) {
+  return gateType === 2 /* SplMinBalance */ || gateType === 4 /* Token22MinBalance */;
+}
+function isCnftGate(gateType) {
+  return gateType === 7 /* CnftHolder */ || gateType === 8 /* CnftCollection */;
+}
+function computeLeafHash(campaignId, recipient, amount, nonce) {
+  const amountBytes = Buffer.alloc(8);
+  amountBytes.writeBigUInt64LE(amount);
+  const data = Buffer.concat([
+    LEAF_DOMAIN,
+    Buffer.from(campaignId),
+    recipient.toBytes(),
+    amountBytes,
+    Buffer.from(nonce)
+  ]);
+  return (0, import_sha256.sha256)(data);
+}
+function computeNodeHash(left, right) {
+  const [first, second] = Buffer.compare(Buffer.from(left), Buffer.from(right)) <= 0 ? [left, right] : [right, left];
+  return (0, import_sha256.sha256)(Buffer.concat([
+    NODE_DOMAIN,
+    Buffer.from(first),
+    Buffer.from(second)
+  ]));
+}
+function buildMerkleTree(campaignId, allocations) {
+  if (allocations.length === 0) {
+    throw new Error("Cannot build tree with no allocations");
+  }
+  const leaves = allocations.map(
+    (a) => computeLeafHash(campaignId, a.recipient, a.amount, a.nonce)
+  );
+  let currentLevel = leaves;
+  const tree = [currentLevel];
+  while (currentLevel.length > 1) {
+    const nextLevel = [];
+    for (let i = 0; i < currentLevel.length; i += 2) {
+      const left = currentLevel[i];
+      const right = currentLevel[i + 1] || left;
+      nextLevel.push(computeNodeHash(left, right));
+    }
+    tree.push(nextLevel);
+    currentLevel = nextLevel;
+  }
+  const root = tree[tree.length - 1][0];
+  const proofs = /* @__PURE__ */ new Map();
+  for (let leafIndex = 0; leafIndex < allocations.length; leafIndex++) {
+    const proof = [];
+    let index = leafIndex;
+    for (let level = 0; level < tree.length - 1; level++) {
+      const isLeft = index % 2 === 0;
+      const siblingIndex = isLeft ? index + 1 : index - 1;
+      if (siblingIndex < tree[level].length) {
+        proof.push(tree[level][siblingIndex]);
+      } else {
+        proof.push(tree[level][index]);
+      }
+      index = Math.floor(index / 2);
+    }
+    proofs.set(allocations[leafIndex].recipient.toBase58(), proof);
+  }
+  return { root, proofs };
+}
+function verifyMerkleProof(campaignId, allocation, proof, root) {
+  let current = computeLeafHash(
+    campaignId,
+    allocation.recipient,
+    allocation.amount,
+    allocation.nonce
+  );
+  for (const sibling of proof) {
+    current = computeNodeHash(current, sibling);
+  }
+  return Buffer.from(current).equals(Buffer.from(root));
+}
+function deriveCampaignPDA(campaignId, programId = WHISPERDROP_PROGRAM_ID) {
+  return import_web3.PublicKey.findProgramAddressSync(
+    [SEED_CAMPAIGN, Buffer.from(campaignId)],
+    programId
+  );
+}
+function deriveEscrowPDA(campaignPDA, programId = WHISPERDROP_PROGRAM_ID) {
+  return import_web3.PublicKey.findProgramAddressSync(
+    [SEED_ESCROW, campaignPDA.toBytes()],
+    programId
+  );
+}
+function deriveNullifierPDA(campaignPDA, recipient, programId = WHISPERDROP_PROGRAM_ID) {
+  return import_web3.PublicKey.findProgramAddressSync(
+    [SEED_NULLIFIER, campaignPDA.toBytes(), recipient.toBytes()],
+    programId
+  );
+}
+var WhisperDrop = class {
+  constructor(connection, programId) {
+    this.connection = connection;
+    this.programId = programId || WHISPERDROP_PROGRAM_ID;
+  }
+  /**
+   * Initialize a new airdrop campaign
+   */
+  async initCampaign(authority, mint, config) {
+    const [campaignPDA] = deriveCampaignPDA(config.campaignId, this.programId);
+    const [escrowPDA] = deriveEscrowPDA(campaignPDA, this.programId);
+    const expiryBuf = Buffer.alloc(8);
+    expiryBuf.writeBigInt64LE(config.expiryUnix);
+    const gateAmountBuf = Buffer.alloc(8);
+    gateAmountBuf.writeBigUInt64LE(config.gateAmount || 0n);
+    const data = Buffer.concat([
+      Buffer.from([TAG_INIT_CAMPAIGN]),
+      Buffer.from(config.campaignId),
+      Buffer.from(config.merkleRoot),
+      expiryBuf,
+      Buffer.from([config.gateType || 0 /* None */]),
+      (config.gateMint || import_web3.PublicKey.default).toBytes(),
+      gateAmountBuf
+    ]);
+    const instruction = new import_web3.TransactionInstruction({
+      programId: this.programId,
+      keys: [
+        { pubkey: authority.publicKey, isSigner: true, isWritable: true },
+        { pubkey: campaignPDA, isSigner: false, isWritable: true },
+        { pubkey: escrowPDA, isSigner: false, isWritable: true },
+        { pubkey: mint, isSigner: false, isWritable: false },
+        { pubkey: import_web3.SystemProgram.programId, isSigner: false, isWritable: false },
+        { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: import_web3.SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false }
+      ],
+      data
+    });
+    const tx = new import_web3.Transaction().add(instruction);
+    const signature = await (0, import_web3.sendAndConfirmTransaction)(this.connection, tx, [authority]);
+    return { signature, campaignPDA, escrowPDA };
+  }
+  /**
+   * Claim tokens with Merkle proof
+   */
+  async claim(payer, recipient, campaignPDA, allocation, proof, recipientATA, gateTokenAccount) {
+    const [escrowPDA] = deriveEscrowPDA(campaignPDA, this.programId);
+    const [nullifierPDA] = deriveNullifierPDA(campaignPDA, recipient.publicKey, this.programId);
+    const amountBuf = Buffer.alloc(8);
+    amountBuf.writeBigUInt64LE(allocation.amount);
+    const proofData = Buffer.concat(proof.map((p) => Buffer.from(p)));
+    const data = Buffer.concat([
+      Buffer.from([TAG_CLAIM]),
+      amountBuf,
+      Buffer.from(allocation.nonce),
+      Buffer.from([proof.length]),
+      proofData
+    ]);
+    const keys = [
+      { pubkey: payer.publicKey, isSigner: true, isWritable: true },
+      { pubkey: recipient.publicKey, isSigner: true, isWritable: false },
+      { pubkey: campaignPDA, isSigner: false, isWritable: false },
+      { pubkey: escrowPDA, isSigner: false, isWritable: true },
+      { pubkey: recipientATA, isSigner: false, isWritable: true },
+      { pubkey: nullifierPDA, isSigner: false, isWritable: true },
+      { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+      { pubkey: import_web3.SystemProgram.programId, isSigner: false, isWritable: false }
+    ];
+    if (gateTokenAccount) {
+      keys.push({ pubkey: gateTokenAccount, isSigner: false, isWritable: false });
+    }
+    const instruction = new import_web3.TransactionInstruction({
+      programId: this.programId,
+      keys,
+      data
+    });
+    const tx = new import_web3.Transaction().add(instruction);
+    const signers = payer.publicKey.equals(recipient.publicKey) ? [payer] : [payer, recipient];
+    return await (0, import_web3.sendAndConfirmTransaction)(this.connection, tx, signers);
+  }
+  /**
+   * Reclaim remaining tokens after expiry
+   */
+  async reclaim(authority, campaignPDA, authorityATA) {
+    const [escrowPDA] = deriveEscrowPDA(campaignPDA, this.programId);
+    const data = Buffer.from([TAG_RECLAIM]);
+    const instruction = new import_web3.TransactionInstruction({
+      programId: this.programId,
+      keys: [
+        { pubkey: authority.publicKey, isSigner: true, isWritable: false },
+        { pubkey: campaignPDA, isSigner: false, isWritable: false },
+        { pubkey: escrowPDA, isSigner: false, isWritable: true },
+        { pubkey: authorityATA, isSigner: false, isWritable: true },
+        { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false }
+      ],
+      data
+    });
+    const tx = new import_web3.Transaction().add(instruction);
+    return await (0, import_web3.sendAndConfirmTransaction)(this.connection, tx, [authority]);
+  }
+  /**
+   * Check if recipient has already claimed
+   */
+  async hasClaimed(campaignPDA, recipient) {
+    const [nullifierPDA] = deriveNullifierPDA(campaignPDA, recipient, this.programId);
+    const account = await this.connection.getAccountInfo(nullifierPDA);
+    return account !== null && account.data.length > 0;
+  }
+  /**
+   * Get campaign state
+   */
+  async getCampaign(campaignPDA) {
+    const account = await this.connection.getAccountInfo(campaignPDA);
+    if (!account) return null;
+    const data = account.data;
+    if (data.length < 180 || data[0] !== 1) return null;
+    let offset = 1;
+    const authority = new import_web3.PublicKey(data.slice(offset, offset + 32));
+    offset += 32;
+    const mint = new import_web3.PublicKey(data.slice(offset, offset + 32));
+    offset += 32;
+    const campaignId = data.slice(offset, offset + 32);
+    offset += 32;
+    const merkleRoot = data.slice(offset, offset + 32);
+    offset += 32;
+    const expiryUnix = data.readBigInt64LE(offset);
+    offset += 8;
+    offset += 2;
+    const gateType = data[offset];
+    offset += 1;
+    const gateMint = new import_web3.PublicKey(data.slice(offset, offset + 32));
+    offset += 32;
+    const gateAmount = data.readBigUInt64LE(offset);
+    return {
+      authority,
+      mint,
+      campaignId,
+      merkleRoot,
+      expiryUnix,
+      gateType,
+      gateMint,
+      gateAmount
+    };
+  }
+};
+function generateNonce() {
+  return crypto.getRandomValues(new Uint8Array(16));
+}
+function generateCampaignId() {
+  return crypto.getRandomValues(new Uint8Array(32));
+}
+var index_default = WhisperDrop;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BUBBLEGUM_PROGRAM_ID,
+  GateType,
+  METADATA_PROGRAM_ID,
+  TOKEN_2022_PROGRAM_ID,
+  TOKEN_PROGRAM_ID,
+  WHISPERDROP_DEVNET_PROGRAM_ID,
+  WHISPERDROP_PROGRAM_ID,
+  WhisperDrop,
+  buildMerkleTree,
+  computeLeafHash,
+  computeNodeHash,
+  deriveCampaignPDA,
+  deriveEscrowPDA,
+  deriveNullifierPDA,
+  generateCampaignId,
+  generateNonce,
+  getTokenProgramForGate,
+  isCnftGate,
+  requiresMinBalance,
+  verifyMerkleProof
+});
+/**
+* @styxstack/whisperdrop-sdk
+* 
+* TypeScript SDK for WhisperDrop - Privacy-Preserving Airdrops on Solana
+* 
+* Features:
+* - Merkle tree generation and proof creation
+* - Token-gated claiming (NFT, token balance)
+* - Campaign creation and management
+* - Claim and reclaim operations
+* 
+* @author @moonmanquark (Bluefoot Labs)
+* @license Apache-2.0
+*/

package/dist/index.mjs

@@ -0,0 +1,335 @@
+// src/index.ts
+import {
+  PublicKey,
+  Transaction,
+  TransactionInstruction,
+  SystemProgram,
+  SYSVAR_RENT_PUBKEY,
+  sendAndConfirmTransaction
+} from "@solana/web3.js";
+import { sha256 } from "@noble/hashes/sha256";
+var WHISPERDROP_PROGRAM_ID = new PublicKey("GhstFNnEbixAGQgLnWg1nWetJQgGfSUMhnxdBA6hWu5e");
+var WHISPERDROP_DEVNET_PROGRAM_ID = new PublicKey("BPM5VuX9YrG7CgueWGxtqQZBQwMTacc315ppWCtTCJ5q");
+var TOKEN_PROGRAM_ID = new PublicKey("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+var TOKEN_2022_PROGRAM_ID = new PublicKey("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb");
+var METADATA_PROGRAM_ID = new PublicKey("metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s");
+var BUBBLEGUM_PROGRAM_ID = new PublicKey("BGUMAp9Gq7iTEuizy4pqaxsTyUCBK68MDfK752saRPUY");
+var SEED_CAMPAIGN = Buffer.from("wd_campaign");
+var SEED_ESCROW = Buffer.from("wd_escrow");
+var SEED_NULLIFIER = Buffer.from("wd_null");
+var LEAF_DOMAIN = Buffer.from("whisperdrop:leaf:v1");
+var NODE_DOMAIN = Buffer.from("whisperdrop:node:v1");
+var TAG_INIT_CAMPAIGN = 0;
+var TAG_CLAIM = 1;
+var TAG_RECLAIM = 2;
+var GateType = /* @__PURE__ */ ((GateType2) => {
+  GateType2[GateType2["None"] = 0] = "None";
+  GateType2[GateType2["SplTokenHolder"] = 1] = "SplTokenHolder";
+  GateType2[GateType2["SplMinBalance"] = 2] = "SplMinBalance";
+  GateType2[GateType2["Token22Holder"] = 3] = "Token22Holder";
+  GateType2[GateType2["Token22MinBalance"] = 4] = "Token22MinBalance";
+  GateType2[GateType2["NftHolder"] = 5] = "NftHolder";
+  GateType2[GateType2["NftCollection"] = 6] = "NftCollection";
+  GateType2[GateType2["CnftHolder"] = 7] = "CnftHolder";
+  GateType2[GateType2["CnftCollection"] = 8] = "CnftCollection";
+  return GateType2;
+})(GateType || {});
+function getTokenProgramForGate(gateType) {
+  switch (gateType) {
+    case 1 /* SplTokenHolder */:
+    case 2 /* SplMinBalance */:
+    case 5 /* NftHolder */:
+    case 6 /* NftCollection */:
+      return TOKEN_PROGRAM_ID;
+    case 3 /* Token22Holder */:
+    case 4 /* Token22MinBalance */:
+      return TOKEN_2022_PROGRAM_ID;
+    case 7 /* CnftHolder */:
+    case 8 /* CnftCollection */:
+      return null;
+    default:
+      return null;
+  }
+}
+function requiresMinBalance(gateType) {
+  return gateType === 2 /* SplMinBalance */ || gateType === 4 /* Token22MinBalance */;
+}
+function isCnftGate(gateType) {
+  return gateType === 7 /* CnftHolder */ || gateType === 8 /* CnftCollection */;
+}
+function computeLeafHash(campaignId, recipient, amount, nonce) {
+  const amountBytes = Buffer.alloc(8);
+  amountBytes.writeBigUInt64LE(amount);
+  const data = Buffer.concat([
+    LEAF_DOMAIN,
+    Buffer.from(campaignId),
+    recipient.toBytes(),
+    amountBytes,
+    Buffer.from(nonce)
+  ]);
+  return sha256(data);
+}
+function computeNodeHash(left, right) {
+  const [first, second] = Buffer.compare(Buffer.from(left), Buffer.from(right)) <= 0 ? [left, right] : [right, left];
+  return sha256(Buffer.concat([
+    NODE_DOMAIN,
+    Buffer.from(first),
+    Buffer.from(second)
+  ]));
+}
+function buildMerkleTree(campaignId, allocations) {
+  if (allocations.length === 0) {
+    throw new Error("Cannot build tree with no allocations");
+  }
+  const leaves = allocations.map(
+    (a) => computeLeafHash(campaignId, a.recipient, a.amount, a.nonce)
+  );
+  let currentLevel = leaves;
+  const tree = [currentLevel];
+  while (currentLevel.length > 1) {
+    const nextLevel = [];
+    for (let i = 0; i < currentLevel.length; i += 2) {
+      const left = currentLevel[i];
+      const right = currentLevel[i + 1] || left;
+      nextLevel.push(computeNodeHash(left, right));
+    }
+    tree.push(nextLevel);
+    currentLevel = nextLevel;
+  }
+  const root = tree[tree.length - 1][0];
+  const proofs = /* @__PURE__ */ new Map();
+  for (let leafIndex = 0; leafIndex < allocations.length; leafIndex++) {
+    const proof = [];
+    let index = leafIndex;
+    for (let level = 0; level < tree.length - 1; level++) {
+      const isLeft = index % 2 === 0;
+      const siblingIndex = isLeft ? index + 1 : index - 1;
+      if (siblingIndex < tree[level].length) {
+        proof.push(tree[level][siblingIndex]);
+      } else {
+        proof.push(tree[level][index]);
+      }
+      index = Math.floor(index / 2);
+    }
+    proofs.set(allocations[leafIndex].recipient.toBase58(), proof);
+  }
+  return { root, proofs };
+}
+function verifyMerkleProof(campaignId, allocation, proof, root) {
+  let current = computeLeafHash(
+    campaignId,
+    allocation.recipient,
+    allocation.amount,
+    allocation.nonce
+  );
+  for (const sibling of proof) {
+    current = computeNodeHash(current, sibling);
+  }
+  return Buffer.from(current).equals(Buffer.from(root));
+}
+function deriveCampaignPDA(campaignId, programId = WHISPERDROP_PROGRAM_ID) {
+  return PublicKey.findProgramAddressSync(
+    [SEED_CAMPAIGN, Buffer.from(campaignId)],
+    programId
+  );
+}
+function deriveEscrowPDA(campaignPDA, programId = WHISPERDROP_PROGRAM_ID) {
+  return PublicKey.findProgramAddressSync(
+    [SEED_ESCROW, campaignPDA.toBytes()],
+    programId
+  );
+}
+function deriveNullifierPDA(campaignPDA, recipient, programId = WHISPERDROP_PROGRAM_ID) {
+  return PublicKey.findProgramAddressSync(
+    [SEED_NULLIFIER, campaignPDA.toBytes(), recipient.toBytes()],
+    programId
+  );
+}
+var WhisperDrop = class {
+  constructor(connection, programId) {
+    this.connection = connection;
+    this.programId = programId || WHISPERDROP_PROGRAM_ID;
+  }
+  /**
+   * Initialize a new airdrop campaign
+   */
+  async initCampaign(authority, mint, config) {
+    const [campaignPDA] = deriveCampaignPDA(config.campaignId, this.programId);
+    const [escrowPDA] = deriveEscrowPDA(campaignPDA, this.programId);
+    const expiryBuf = Buffer.alloc(8);
+    expiryBuf.writeBigInt64LE(config.expiryUnix);
+    const gateAmountBuf = Buffer.alloc(8);
+    gateAmountBuf.writeBigUInt64LE(config.gateAmount || 0n);
+    const data = Buffer.concat([
+      Buffer.from([TAG_INIT_CAMPAIGN]),
+      Buffer.from(config.campaignId),
+      Buffer.from(config.merkleRoot),
+      expiryBuf,
+      Buffer.from([config.gateType || 0 /* None */]),
+      (config.gateMint || PublicKey.default).toBytes(),
+      gateAmountBuf
+    ]);
+    const instruction = new TransactionInstruction({
+      programId: this.programId,
+      keys: [
+        { pubkey: authority.publicKey, isSigner: true, isWritable: true },
+        { pubkey: campaignPDA, isSigner: false, isWritable: true },
+        { pubkey: escrowPDA, isSigner: false, isWritable: true },
+        { pubkey: mint, isSigner: false, isWritable: false },
+        { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+        { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+        { pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false }
+      ],
+      data
+    });
+    const tx = new Transaction().add(instruction);
+    const signature = await sendAndConfirmTransaction(this.connection, tx, [authority]);
+    return { signature, campaignPDA, escrowPDA };
+  }
+  /**
+   * Claim tokens with Merkle proof
+   */
+  async claim(payer, recipient, campaignPDA, allocation, proof, recipientATA, gateTokenAccount) {
+    const [escrowPDA] = deriveEscrowPDA(campaignPDA, this.programId);
+    const [nullifierPDA] = deriveNullifierPDA(campaignPDA, recipient.publicKey, this.programId);
+    const amountBuf = Buffer.alloc(8);
+    amountBuf.writeBigUInt64LE(allocation.amount);
+    const proofData = Buffer.concat(proof.map((p) => Buffer.from(p)));
+    const data = Buffer.concat([
+      Buffer.from([TAG_CLAIM]),
+      amountBuf,
+      Buffer.from(allocation.nonce),
+      Buffer.from([proof.length]),
+      proofData
+    ]);
+    const keys = [
+      { pubkey: payer.publicKey, isSigner: true, isWritable: true },
+      { pubkey: recipient.publicKey, isSigner: true, isWritable: false },
+      { pubkey: campaignPDA, isSigner: false, isWritable: false },
+      { pubkey: escrowPDA, isSigner: false, isWritable: true },
+      { pubkey: recipientATA, isSigner: false, isWritable: true },
+      { pubkey: nullifierPDA, isSigner: false, isWritable: true },
+      { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false },
+      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false }
+    ];
+    if (gateTokenAccount) {
+      keys.push({ pubkey: gateTokenAccount, isSigner: false, isWritable: false });
+    }
+    const instruction = new TransactionInstruction({
+      programId: this.programId,
+      keys,
+      data
+    });
+    const tx = new Transaction().add(instruction);
+    const signers = payer.publicKey.equals(recipient.publicKey) ? [payer] : [payer, recipient];
+    return await sendAndConfirmTransaction(this.connection, tx, signers);
+  }
+  /**
+   * Reclaim remaining tokens after expiry
+   */
+  async reclaim(authority, campaignPDA, authorityATA) {
+    const [escrowPDA] = deriveEscrowPDA(campaignPDA, this.programId);
+    const data = Buffer.from([TAG_RECLAIM]);
+    const instruction = new TransactionInstruction({
+      programId: this.programId,
+      keys: [
+        { pubkey: authority.publicKey, isSigner: true, isWritable: false },
+        { pubkey: campaignPDA, isSigner: false, isWritable: false },
+        { pubkey: escrowPDA, isSigner: false, isWritable: true },
+        { pubkey: authorityATA, isSigner: false, isWritable: true },
+        { pubkey: TOKEN_PROGRAM_ID, isSigner: false, isWritable: false }
+      ],
+      data
+    });
+    const tx = new Transaction().add(instruction);
+    return await sendAndConfirmTransaction(this.connection, tx, [authority]);
+  }
+  /**
+   * Check if recipient has already claimed
+   */
+  async hasClaimed(campaignPDA, recipient) {
+    const [nullifierPDA] = deriveNullifierPDA(campaignPDA, recipient, this.programId);
+    const account = await this.connection.getAccountInfo(nullifierPDA);
+    return account !== null && account.data.length > 0;
+  }
+  /**
+   * Get campaign state
+   */
+  async getCampaign(campaignPDA) {
+    const account = await this.connection.getAccountInfo(campaignPDA);
+    if (!account) return null;
+    const data = account.data;
+    if (data.length < 180 || data[0] !== 1) return null;
+    let offset = 1;
+    const authority = new PublicKey(data.slice(offset, offset + 32));
+    offset += 32;
+    const mint = new PublicKey(data.slice(offset, offset + 32));
+    offset += 32;
+    const campaignId = data.slice(offset, offset + 32);
+    offset += 32;
+    const merkleRoot = data.slice(offset, offset + 32);
+    offset += 32;
+    const expiryUnix = data.readBigInt64LE(offset);
+    offset += 8;
+    offset += 2;
+    const gateType = data[offset];
+    offset += 1;
+    const gateMint = new PublicKey(data.slice(offset, offset + 32));
+    offset += 32;
+    const gateAmount = data.readBigUInt64LE(offset);
+    return {
+      authority,
+      mint,
+      campaignId,
+      merkleRoot,
+      expiryUnix,
+      gateType,
+      gateMint,
+      gateAmount
+    };
+  }
+};
+function generateNonce() {
+  return crypto.getRandomValues(new Uint8Array(16));
+}
+function generateCampaignId() {
+  return crypto.getRandomValues(new Uint8Array(32));
+}
+var index_default = WhisperDrop;
+export {
+  BUBBLEGUM_PROGRAM_ID,
+  GateType,
+  METADATA_PROGRAM_ID,
+  TOKEN_2022_PROGRAM_ID,
+  TOKEN_PROGRAM_ID,
+  WHISPERDROP_DEVNET_PROGRAM_ID,
+  WHISPERDROP_PROGRAM_ID,
+  WhisperDrop,
+  buildMerkleTree,
+  computeLeafHash,
+  computeNodeHash,
+  index_default as default,
+  deriveCampaignPDA,
+  deriveEscrowPDA,
+  deriveNullifierPDA,
+  generateCampaignId,
+  generateNonce,
+  getTokenProgramForGate,
+  isCnftGate,
+  requiresMinBalance,
+  verifyMerkleProof
+};
+/**
+* @styxstack/whisperdrop-sdk
+* 
+* TypeScript SDK for WhisperDrop - Privacy-Preserving Airdrops on Solana
+* 
+* Features:
+* - Merkle tree generation and proof creation
+* - Token-gated claiming (NFT, token balance)
+* - Campaign creation and management
+* - Claim and reclaim operations
+* 
+* @author @moonmanquark (Bluefoot Labs)
+* @license Apache-2.0
+*/

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@styxstack/whisperdrop-sdk",
+  "version": "1.0.0",
+  "description": "TypeScript SDK for WhisperDrop - Privacy-Preserving Airdrops on Solana",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "solana",
+    "airdrop",
+    "privacy",
+    "merkle",
+    "token-gating",
+    "nft",
+    "web3",
+    "whisperdrop"
+  ],
+  "author": "@moonmanquark <Bluefoot Labs>",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/QuarksBlueFoot/StyxStack.git",
+    "directory": "packages/whisperdrop-sdk"
+  },
+  "homepage": "https://github.com/QuarksBlueFoot/StyxStack/tree/main/packages/whisperdrop-sdk#readme",
+  "peerDependencies": {
+    "@solana/web3.js": "^1.87.0 || ^2.0.0"
+  },
+  "dependencies": {
+    "@noble/hashes": "^1.5.0"
+  },
+  "devDependencies": {
+    "@solana/web3.js": "^1.98.0",
+    "@solana/spl-token": "^0.4.0",
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0",
+    "vitest": "^2.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  }
+}