@dropsy/airdrop 0.2.7 → 0.4.0

package/dist/index.cjs

@@ -0,0 +1,2544 @@
+"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, {
+  AIRDROP_CONFIG_DISCRIMINATOR: () => AIRDROP_CONFIG_DISCRIMINATOR,
+  AIRDROP_DISCRIMINATOR: () => AIRDROP_DISCRIMINATOR,
+  AIRDROP_MASTER_DISCRIMINATOR: () => AIRDROP_MASTER_DISCRIMINATOR,
+  BITMAP_ACCOUNT_DISCRIMINATOR: () => BITMAP_ACCOUNT_DISCRIMINATOR,
+  CLAIM_AIRDROP_DISCRIMINATOR: () => CLAIM_AIRDROP_DISCRIMINATOR,
+  CREATE_AIRDROP_DISCRIMINATOR: () => CREATE_AIRDROP_DISCRIMINATOR,
+  CREATE_BITMAP_DISCRIMINATOR: () => CREATE_BITMAP_DISCRIMINATOR,
+  DEPOSIT_TOKENS_DISCRIMINATOR: () => DEPOSIT_TOKENS_DISCRIMINATOR,
+  DROPSY_AIRDROP_ERROR__ACTION_FEE_TOO_HIGH: () => DROPSY_AIRDROP_ERROR__ACTION_FEE_TOO_HIGH,
+  DROPSY_AIRDROP_ERROR__ACTIVE_BITMAPS_EXIST: () => DROPSY_AIRDROP_ERROR__ACTIVE_BITMAPS_EXIST,
+  DROPSY_AIRDROP_ERROR__AIRDROP_ENDED: () => DROPSY_AIRDROP_ERROR__AIRDROP_ENDED,
+  DROPSY_AIRDROP_ERROR__AIRDROP_NOT_ENDED: () => DROPSY_AIRDROP_ERROR__AIRDROP_NOT_ENDED,
+  DROPSY_AIRDROP_ERROR__AIRDROP_NOT_STARTED: () => DROPSY_AIRDROP_ERROR__AIRDROP_NOT_STARTED,
+  DROPSY_AIRDROP_ERROR__ALREADY_CLAIMED: () => DROPSY_AIRDROP_ERROR__ALREADY_CLAIMED,
+  DROPSY_AIRDROP_ERROR__BITMAP_AIRDROP_MISMATCH: () => DROPSY_AIRDROP_ERROR__BITMAP_AIRDROP_MISMATCH,
+  DROPSY_AIRDROP_ERROR__BITMAP_COUNT_UNDERFLOW: () => DROPSY_AIRDROP_ERROR__BITMAP_COUNT_UNDERFLOW,
+  DROPSY_AIRDROP_ERROR__BITMAP_TOO_LARGE: () => DROPSY_AIRDROP_ERROR__BITMAP_TOO_LARGE,
+  DROPSY_AIRDROP_ERROR__CLAIM_FEE_TOO_HIGH: () => DROPSY_AIRDROP_ERROR__CLAIM_FEE_TOO_HIGH,
+  DROPSY_AIRDROP_ERROR__CREATE_FEE_TOO_HIGH: () => DROPSY_AIRDROP_ERROR__CREATE_FEE_TOO_HIGH,
+  DROPSY_AIRDROP_ERROR__DESTINATION_MINT_MISMATCH: () => DROPSY_AIRDROP_ERROR__DESTINATION_MINT_MISMATCH,
+  DROPSY_AIRDROP_ERROR__DURATION_TOO_SHORT: () => DROPSY_AIRDROP_ERROR__DURATION_TOO_SHORT,
+  DROPSY_AIRDROP_ERROR__IMMUTABLE_AIRDROP: () => DROPSY_AIRDROP_ERROR__IMMUTABLE_AIRDROP,
+  DROPSY_AIRDROP_ERROR__IMMUTABLE_FIELD: () => DROPSY_AIRDROP_ERROR__IMMUTABLE_FIELD,
+  DROPSY_AIRDROP_ERROR__INSUFFICIENT_DEPOSIT: () => DROPSY_AIRDROP_ERROR__INSUFFICIENT_DEPOSIT,
+  DROPSY_AIRDROP_ERROR__INSUFFICIENT_FUNDS_FOR_FEE: () => DROPSY_AIRDROP_ERROR__INSUFFICIENT_FUNDS_FOR_FEE,
+  DROPSY_AIRDROP_ERROR__INSUFFICIENT_VAULT_FUNDS: () => DROPSY_AIRDROP_ERROR__INSUFFICIENT_VAULT_FUNDS,
+  DROPSY_AIRDROP_ERROR__INVALID_ADMIN: () => DROPSY_AIRDROP_ERROR__INVALID_ADMIN,
+  DROPSY_AIRDROP_ERROR__INVALID_AFFILIATE_PDA: () => DROPSY_AIRDROP_ERROR__INVALID_AFFILIATE_PDA,
+  DROPSY_AIRDROP_ERROR__INVALID_AIRDROP_PDA: () => DROPSY_AIRDROP_ERROR__INVALID_AIRDROP_PDA,
+  DROPSY_AIRDROP_ERROR__INVALID_AIRDROP_VERSION: () => DROPSY_AIRDROP_ERROR__INVALID_AIRDROP_VERSION,
+  DROPSY_AIRDROP_ERROR__INVALID_AIRDROP_VESTING_VERSION: () => DROPSY_AIRDROP_ERROR__INVALID_AIRDROP_VESTING_VERSION,
+  DROPSY_AIRDROP_ERROR__INVALID_AMOUNT: () => DROPSY_AIRDROP_ERROR__INVALID_AMOUNT,
+  DROPSY_AIRDROP_ERROR__INVALID_BITMAP_ACCOUNT: () => DROPSY_AIRDROP_ERROR__INVALID_BITMAP_ACCOUNT,
+  DROPSY_AIRDROP_ERROR__INVALID_BITMAP_INDEX: () => DROPSY_AIRDROP_ERROR__INVALID_BITMAP_INDEX,
+  DROPSY_AIRDROP_ERROR__INVALID_DELEGATE_PERMISSION: () => DROPSY_AIRDROP_ERROR__INVALID_DELEGATE_PERMISSION,
+  DROPSY_AIRDROP_ERROR__INVALID_DESTINATION_OWNER: () => DROPSY_AIRDROP_ERROR__INVALID_DESTINATION_OWNER,
+  DROPSY_AIRDROP_ERROR__INVALID_END_TIME: () => DROPSY_AIRDROP_ERROR__INVALID_END_TIME,
+  DROPSY_AIRDROP_ERROR__INVALID_FEE_VAULT: () => DROPSY_AIRDROP_ERROR__INVALID_FEE_VAULT,
+  DROPSY_AIRDROP_ERROR__INVALID_FEE_VAULT_CURVE: () => DROPSY_AIRDROP_ERROR__INVALID_FEE_VAULT_CURVE,
+  DROPSY_AIRDROP_ERROR__INVALID_FEE_VAULT_OWNER: () => DROPSY_AIRDROP_ERROR__INVALID_FEE_VAULT_OWNER,
+  DROPSY_AIRDROP_ERROR__INVALID_MINT: () => DROPSY_AIRDROP_ERROR__INVALID_MINT,
+  DROPSY_AIRDROP_ERROR__INVALID_MINT_OWNER: () => DROPSY_AIRDROP_ERROR__INVALID_MINT_OWNER,
+  DROPSY_AIRDROP_ERROR__INVALID_MUTABILITY: () => DROPSY_AIRDROP_ERROR__INVALID_MUTABILITY,
+  DROPSY_AIRDROP_ERROR__INVALID_OWNER: () => DROPSY_AIRDROP_ERROR__INVALID_OWNER,
+  DROPSY_AIRDROP_ERROR__INVALID_PARENT_ACCOUNT: () => DROPSY_AIRDROP_ERROR__INVALID_PARENT_ACCOUNT,
+  DROPSY_AIRDROP_ERROR__INVALID_PDA: () => DROPSY_AIRDROP_ERROR__INVALID_PDA,
+  DROPSY_AIRDROP_ERROR__INVALID_PERCENTAGE: () => DROPSY_AIRDROP_ERROR__INVALID_PERCENTAGE,
+  DROPSY_AIRDROP_ERROR__INVALID_PROOF: () => DROPSY_AIRDROP_ERROR__INVALID_PROOF,
+  DROPSY_AIRDROP_ERROR__INVALID_PUB_KEY: () => DROPSY_AIRDROP_ERROR__INVALID_PUB_KEY,
+  DROPSY_AIRDROP_ERROR__INVALID_TIMESTAMP: () => DROPSY_AIRDROP_ERROR__INVALID_TIMESTAMP,
+  DROPSY_AIRDROP_ERROR__INVALID_TOTAL: () => DROPSY_AIRDROP_ERROR__INVALID_TOTAL,
+  DROPSY_AIRDROP_ERROR__INVALID_TREASURY_ACCOUNT: () => DROPSY_AIRDROP_ERROR__INVALID_TREASURY_ACCOUNT,
+  DROPSY_AIRDROP_ERROR__INVALID_VAULT_AUTHORITY: () => DROPSY_AIRDROP_ERROR__INVALID_VAULT_AUTHORITY,
+  DROPSY_AIRDROP_ERROR__INVALID_VESTING_SCHEDULE: () => DROPSY_AIRDROP_ERROR__INVALID_VESTING_SCHEDULE,
+  DROPSY_AIRDROP_ERROR__INVALID_VESTING_TYPE: () => DROPSY_AIRDROP_ERROR__INVALID_VESTING_TYPE,
+  DROPSY_AIRDROP_ERROR__MINT_HAS_FREEZE_AUTHORITY: () => DROPSY_AIRDROP_ERROR__MINT_HAS_FREEZE_AUTHORITY,
+  DROPSY_AIRDROP_ERROR__MINT_IS_FROZEN: () => DROPSY_AIRDROP_ERROR__MINT_IS_FROZEN,
+  DROPSY_AIRDROP_ERROR__MINT_IS_NOT_INITIALIZED: () => DROPSY_AIRDROP_ERROR__MINT_IS_NOT_INITIALIZED,
+  DROPSY_AIRDROP_ERROR__MINT_MISMATCH: () => DROPSY_AIRDROP_ERROR__MINT_MISMATCH,
+  DROPSY_AIRDROP_ERROR__MISSING_BITMAP_PDA: () => DROPSY_AIRDROP_ERROR__MISSING_BITMAP_PDA,
+  DROPSY_AIRDROP_ERROR__NFT_NOT_ALLOWED: () => DROPSY_AIRDROP_ERROR__NFT_NOT_ALLOWED,
+  DROPSY_AIRDROP_ERROR__NON_ZERO_VALUE_REQUIRED: () => DROPSY_AIRDROP_ERROR__NON_ZERO_VALUE_REQUIRED,
+  DROPSY_AIRDROP_ERROR__OVERFLOW: () => DROPSY_AIRDROP_ERROR__OVERFLOW,
+  DROPSY_AIRDROP_ERROR__OWNER_MISMATCH: () => DROPSY_AIRDROP_ERROR__OWNER_MISMATCH,
+  DROPSY_AIRDROP_ERROR__SOURCE_ACCOUNT_FROZEN: () => DROPSY_AIRDROP_ERROR__SOURCE_ACCOUNT_FROZEN,
+  DROPSY_AIRDROP_ERROR__SOURCE_HAS_CLOSE_AUTHORITY: () => DROPSY_AIRDROP_ERROR__SOURCE_HAS_CLOSE_AUTHORITY,
+  DROPSY_AIRDROP_ERROR__SOURCE_HAS_DELEGATE: () => DROPSY_AIRDROP_ERROR__SOURCE_HAS_DELEGATE,
+  DROPSY_AIRDROP_ERROR__TOO_MANY_BITMAPS: () => DROPSY_AIRDROP_ERROR__TOO_MANY_BITMAPS,
+  DROPSY_AIRDROP_ERROR__UNAUTHORIZED: () => DROPSY_AIRDROP_ERROR__UNAUTHORIZED,
+  DROPSY_AIRDROP_ERROR__UN_AUTHORIZED: () => DROPSY_AIRDROP_ERROR__UN_AUTHORIZED,
+  DROPSY_AIRDROP_ERROR__UPDATE_CUTOFF_TIME_PASSED: () => DROPSY_AIRDROP_ERROR__UPDATE_CUTOFF_TIME_PASSED,
+  DROPSY_AIRDROP_ERROR__VALUE_BELOW_THE_MINIMUM: () => DROPSY_AIRDROP_ERROR__VALUE_BELOW_THE_MINIMUM,
+  DROPSY_AIRDROP_ERROR__VALUE_EXCEEDS_MAXIMUM: () => DROPSY_AIRDROP_ERROR__VALUE_EXCEEDS_MAXIMUM,
+  DROPSY_AIRDROP_ERROR__VALUE_OUT_OF_RANGE: () => DROPSY_AIRDROP_ERROR__VALUE_OUT_OF_RANGE,
+  DROPSY_AIRDROP_ERROR__VAULT_FROZEN: () => DROPSY_AIRDROP_ERROR__VAULT_FROZEN,
+  DROPSY_AIRDROP_ERROR__VAULT_HAS_CLOSE_AUTHORITY: () => DROPSY_AIRDROP_ERROR__VAULT_HAS_CLOSE_AUTHORITY,
+  DROPSY_AIRDROP_ERROR__VAULT_HAS_DELEGATE: () => DROPSY_AIRDROP_ERROR__VAULT_HAS_DELEGATE,
+  DROPSY_AIRDROP_ERROR__VAULT_MINT_MISMATCH: () => DROPSY_AIRDROP_ERROR__VAULT_MINT_MISMATCH,
+  DROPSY_AIRDROP_ERROR__VAULT_NOT_INITIALIZED: () => DROPSY_AIRDROP_ERROR__VAULT_NOT_INITIALIZED,
+  DROPSY_AIRDROP_ERROR__VAULT_NOT_RENT_EXEMPT: () => DROPSY_AIRDROP_ERROR__VAULT_NOT_RENT_EXEMPT,
+  DROPSY_AIRDROP_ERROR__VESTING_ACCOUNT_REQUIRED: () => DROPSY_AIRDROP_ERROR__VESTING_ACCOUNT_REQUIRED,
+  DROPSY_AIRDROP_PROGRAM_ADDRESS: () => DROPSY_AIRDROP_PROGRAM_ADDRESS,
+  DropsyAirdropAccount: () => DropsyAirdropAccount,
+  DropsyAirdropInstruction: () => DropsyAirdropInstruction,
+  INITIALIZE_AIRDROP_CONFIG_DISCRIMINATOR: () => INITIALIZE_AIRDROP_CONFIG_DISCRIMINATOR,
+  INITIALIZE_AIRDROP_MASTER_DISCRIMINATOR: () => INITIALIZE_AIRDROP_MASTER_DISCRIMINATOR,
+  decodeAirdrop: () => decodeAirdrop,
+  decodeAirdropConfig: () => decodeAirdropConfig,
+  decodeAirdropMaster: () => decodeAirdropMaster,
+  decodeBitmapAccount: () => decodeBitmapAccount,
+  fetchAirdrop: () => fetchAirdrop,
+  fetchAirdropConfig: () => fetchAirdropConfig,
+  fetchAirdropMaster: () => fetchAirdropMaster,
+  fetchAllAirdrop: () => fetchAllAirdrop,
+  fetchAllAirdropConfig: () => fetchAllAirdropConfig,
+  fetchAllAirdropMaster: () => fetchAllAirdropMaster,
+  fetchAllBitmapAccount: () => fetchAllBitmapAccount,
+  fetchAllMaybeAirdrop: () => fetchAllMaybeAirdrop,
+  fetchAllMaybeAirdropConfig: () => fetchAllMaybeAirdropConfig,
+  fetchAllMaybeAirdropMaster: () => fetchAllMaybeAirdropMaster,
+  fetchAllMaybeBitmapAccount: () => fetchAllMaybeBitmapAccount,
+  fetchBitmapAccount: () => fetchBitmapAccount,
+  fetchMaybeAirdrop: () => fetchMaybeAirdrop,
+  fetchMaybeAirdropConfig: () => fetchMaybeAirdropConfig,
+  fetchMaybeAirdropMaster: () => fetchMaybeAirdropMaster,
+  fetchMaybeBitmapAccount: () => fetchMaybeBitmapAccount,
+  getAirdropCodec: () => getAirdropCodec,
+  getAirdropConfigCodec: () => getAirdropConfigCodec,
+  getAirdropConfigDecoder: () => getAirdropConfigDecoder,
+  getAirdropConfigDiscriminatorBytes: () => getAirdropConfigDiscriminatorBytes,
+  getAirdropConfigEncoder: () => getAirdropConfigEncoder,
+  getAirdropConfigSize: () => getAirdropConfigSize,
+  getAirdropDecoder: () => getAirdropDecoder,
+  getAirdropDiscriminatorBytes: () => getAirdropDiscriminatorBytes,
+  getAirdropEncoder: () => getAirdropEncoder,
+  getAirdropInitializedCodec: () => getAirdropInitializedCodec,
+  getAirdropInitializedDecoder: () => getAirdropInitializedDecoder,
+  getAirdropInitializedEncoder: () => getAirdropInitializedEncoder,
+  getAirdropMasterCodec: () => getAirdropMasterCodec,
+  getAirdropMasterDecoder: () => getAirdropMasterDecoder,
+  getAirdropMasterDiscriminatorBytes: () => getAirdropMasterDiscriminatorBytes,
+  getAirdropMasterEncoder: () => getAirdropMasterEncoder,
+  getAirdropMasterSize: () => getAirdropMasterSize,
+  getAirdropSize: () => getAirdropSize,
+  getBitmapAccountCodec: () => getBitmapAccountCodec,
+  getBitmapAccountDecoder: () => getBitmapAccountDecoder,
+  getBitmapAccountDiscriminatorBytes: () => getBitmapAccountDiscriminatorBytes,
+  getBitmapAccountEncoder: () => getBitmapAccountEncoder,
+  getBitmapAccountSize: () => getBitmapAccountSize,
+  getBitmapClosedCodec: () => getBitmapClosedCodec,
+  getBitmapClosedDecoder: () => getBitmapClosedDecoder,
+  getBitmapClosedEncoder: () => getBitmapClosedEncoder,
+  getBitmapInitializedCodec: () => getBitmapInitializedCodec,
+  getBitmapInitializedDecoder: () => getBitmapInitializedDecoder,
+  getBitmapInitializedEncoder: () => getBitmapInitializedEncoder,
+  getClaimAirdropDiscriminatorBytes: () => getClaimAirdropDiscriminatorBytes,
+  getClaimAirdropInstruction: () => getClaimAirdropInstruction,
+  getClaimAirdropInstructionAsync: () => getClaimAirdropInstructionAsync,
+  getClaimAirdropInstructionDataCodec: () => getClaimAirdropInstructionDataCodec,
+  getClaimAirdropInstructionDataDecoder: () => getClaimAirdropInstructionDataDecoder,
+  getClaimAirdropInstructionDataEncoder: () => getClaimAirdropInstructionDataEncoder,
+  getCreateAirdropDiscriminatorBytes: () => getCreateAirdropDiscriminatorBytes,
+  getCreateAirdropInstruction: () => getCreateAirdropInstruction,
+  getCreateAirdropInstructionAsync: () => getCreateAirdropInstructionAsync,
+  getCreateAirdropInstructionDataCodec: () => getCreateAirdropInstructionDataCodec,
+  getCreateAirdropInstructionDataDecoder: () => getCreateAirdropInstructionDataDecoder,
+  getCreateAirdropInstructionDataEncoder: () => getCreateAirdropInstructionDataEncoder,
+  getCreateBitmapDiscriminatorBytes: () => getCreateBitmapDiscriminatorBytes,
+  getCreateBitmapInstruction: () => getCreateBitmapInstruction,
+  getCreateBitmapInstructionAsync: () => getCreateBitmapInstructionAsync,
+  getCreateBitmapInstructionDataCodec: () => getCreateBitmapInstructionDataCodec,
+  getCreateBitmapInstructionDataDecoder: () => getCreateBitmapInstructionDataDecoder,
+  getCreateBitmapInstructionDataEncoder: () => getCreateBitmapInstructionDataEncoder,
+  getDepositTokensDiscriminatorBytes: () => getDepositTokensDiscriminatorBytes,
+  getDepositTokensInstruction: () => getDepositTokensInstruction,
+  getDepositTokensInstructionAsync: () => getDepositTokensInstructionAsync,
+  getDepositTokensInstructionDataCodec: () => getDepositTokensInstructionDataCodec,
+  getDepositTokensInstructionDataDecoder: () => getDepositTokensInstructionDataDecoder,
+  getDepositTokensInstructionDataEncoder: () => getDepositTokensInstructionDataEncoder,
+  getDropsyAirdropErrorMessage: () => getDropsyAirdropErrorMessage,
+  getInitializeAirdropConfigDiscriminatorBytes: () => getInitializeAirdropConfigDiscriminatorBytes,
+  getInitializeAirdropConfigInstruction: () => getInitializeAirdropConfigInstruction,
+  getInitializeAirdropConfigInstructionAsync: () => getInitializeAirdropConfigInstructionAsync,
+  getInitializeAirdropConfigInstructionDataCodec: () => getInitializeAirdropConfigInstructionDataCodec,
+  getInitializeAirdropConfigInstructionDataDecoder: () => getInitializeAirdropConfigInstructionDataDecoder,
+  getInitializeAirdropConfigInstructionDataEncoder: () => getInitializeAirdropConfigInstructionDataEncoder,
+  getInitializeAirdropMasterDiscriminatorBytes: () => getInitializeAirdropMasterDiscriminatorBytes,
+  getInitializeAirdropMasterInstruction: () => getInitializeAirdropMasterInstruction,
+  getInitializeAirdropMasterInstructionAsync: () => getInitializeAirdropMasterInstructionAsync,
+  getInitializeAirdropMasterInstructionDataCodec: () => getInitializeAirdropMasterInstructionDataCodec,
+  getInitializeAirdropMasterInstructionDataDecoder: () => getInitializeAirdropMasterInstructionDataDecoder,
+  getInitializeAirdropMasterInstructionDataEncoder: () => getInitializeAirdropMasterInstructionDataEncoder,
+  getTokensDepositedCodec: () => getTokensDepositedCodec,
+  getTokensDepositedDecoder: () => getTokensDepositedDecoder,
+  getTokensDepositedEncoder: () => getTokensDepositedEncoder,
+  getTokensRedeemedCodec: () => getTokensRedeemedCodec,
+  getTokensRedeemedDecoder: () => getTokensRedeemedDecoder,
+  getTokensRedeemedEncoder: () => getTokensRedeemedEncoder,
+  identifyDropsyAirdropAccount: () => identifyDropsyAirdropAccount,
+  identifyDropsyAirdropInstruction: () => identifyDropsyAirdropInstruction,
+  isDropsyAirdropError: () => isDropsyAirdropError,
+  parseClaimAirdropInstruction: () => parseClaimAirdropInstruction,
+  parseCreateAirdropInstruction: () => parseCreateAirdropInstruction,
+  parseCreateBitmapInstruction: () => parseCreateBitmapInstruction,
+  parseDepositTokensInstruction: () => parseDepositTokensInstruction,
+  parseDropsyAirdropInstruction: () => parseDropsyAirdropInstruction,
+  parseInitializeAirdropConfigInstruction: () => parseInitializeAirdropConfigInstruction,
+  parseInitializeAirdropMasterInstruction: () => parseInitializeAirdropMasterInstruction
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/accounts/airdrop.ts
+var import_kit = require("@solana/kit");
+var AIRDROP_DISCRIMINATOR = new Uint8Array([
+  31,
+  112,
+  159,
+  158,
+  124,
+  237,
+  9,
+  241
+]);
+function getAirdropDiscriminatorBytes() {
+  return (0, import_kit.fixEncoderSize)((0, import_kit.getBytesEncoder)(), 8).encode(AIRDROP_DISCRIMINATOR);
+}
+function getAirdropEncoder() {
+  return (0, import_kit.transformEncoder)(
+    (0, import_kit.getStructEncoder)([
+      ["discriminator", (0, import_kit.fixEncoderSize)((0, import_kit.getBytesEncoder)(), 8)],
+      ["master", (0, import_kit.getAddressEncoder)()],
+      ["authority", (0, import_kit.getAddressEncoder)()],
+      ["mint", (0, import_kit.getAddressEncoder)()],
+      ["delegateAuthority", (0, import_kit.getAddressEncoder)()],
+      ["merkleRoot", (0, import_kit.fixEncoderSize)((0, import_kit.getBytesEncoder)(), 32)],
+      ["id", (0, import_kit.getU64Encoder)()],
+      ["supply", (0, import_kit.getU64Encoder)()],
+      ["boost", (0, import_kit.getU64Encoder)()],
+      ["startsAt", (0, import_kit.getI64Encoder)()],
+      ["endsAt", (0, import_kit.getI64Encoder)()],
+      ["bitmapCount", (0, import_kit.getU16Encoder)()],
+      ["state", (0, import_kit.getU8Encoder)()],
+      ["version", (0, import_kit.getU8Encoder)()],
+      ["bump", (0, import_kit.getU8Encoder)()],
+      ["padding", (0, import_kit.fixEncoderSize)((0, import_kit.getBytesEncoder)(), 3)]
+    ]),
+    (value) => ({ ...value, discriminator: AIRDROP_DISCRIMINATOR })
+  );
+}
+function getAirdropDecoder() {
+  return (0, import_kit.getStructDecoder)([
+    ["discriminator", (0, import_kit.fixDecoderSize)((0, import_kit.getBytesDecoder)(), 8)],
+    ["master", (0, import_kit.getAddressDecoder)()],
+    ["authority", (0, import_kit.getAddressDecoder)()],
+    ["mint", (0, import_kit.getAddressDecoder)()],
+    ["delegateAuthority", (0, import_kit.getAddressDecoder)()],
+    ["merkleRoot", (0, import_kit.fixDecoderSize)((0, import_kit.getBytesDecoder)(), 32)],
+    ["id", (0, import_kit.getU64Decoder)()],
+    ["supply", (0, import_kit.getU64Decoder)()],
+    ["boost", (0, import_kit.getU64Decoder)()],
+    ["startsAt", (0, import_kit.getI64Decoder)()],
+    ["endsAt", (0, import_kit.getI64Decoder)()],
+    ["bitmapCount", (0, import_kit.getU16Decoder)()],
+    ["state", (0, import_kit.getU8Decoder)()],
+    ["version", (0, import_kit.getU8Decoder)()],
+    ["bump", (0, import_kit.getU8Decoder)()],
+    ["padding", (0, import_kit.fixDecoderSize)((0, import_kit.getBytesDecoder)(), 3)]
+  ]);
+}
+function getAirdropCodec() {
+  return (0, import_kit.combineCodec)(getAirdropEncoder(), getAirdropDecoder());
+}
+function decodeAirdrop(encodedAccount) {
+  return (0, import_kit.decodeAccount)(
+    encodedAccount,
+    getAirdropDecoder()
+  );
+}
+async function fetchAirdrop(rpc, address, config) {
+  const maybeAccount = await fetchMaybeAirdrop(rpc, address, config);
+  (0, import_kit.assertAccountExists)(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeAirdrop(rpc, address, config) {
+  const maybeAccount = await (0, import_kit.fetchEncodedAccount)(rpc, address, config);
+  return decodeAirdrop(maybeAccount);
+}
+async function fetchAllAirdrop(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeAirdrop(rpc, addresses, config);
+  (0, import_kit.assertAccountsExist)(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeAirdrop(rpc, addresses, config) {
+  const maybeAccounts = await (0, import_kit.fetchEncodedAccounts)(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeAirdrop(maybeAccount));
+}
+function getAirdropSize() {
+  return 216;
+}
+
+// src/accounts/airdropConfig.ts
+var import_kit2 = require("@solana/kit");
+var AIRDROP_CONFIG_DISCRIMINATOR = new Uint8Array([
+  194,
+  149,
+  223,
+  142,
+  42,
+  98,
+  128,
+  16
+]);
+function getAirdropConfigDiscriminatorBytes() {
+  return (0, import_kit2.fixEncoderSize)((0, import_kit2.getBytesEncoder)(), 8).encode(
+    AIRDROP_CONFIG_DISCRIMINATOR
+  );
+}
+function getAirdropConfigEncoder() {
+  return (0, import_kit2.transformEncoder)(
+    (0, import_kit2.getStructEncoder)([
+      ["discriminator", (0, import_kit2.fixEncoderSize)((0, import_kit2.getBytesEncoder)(), 8)],
+      ["authority", (0, import_kit2.getAddressEncoder)()],
+      ["protocolTreasury", (0, import_kit2.getAddressEncoder)()],
+      ["wlRoot", (0, import_kit2.fixEncoderSize)((0, import_kit2.getBytesEncoder)(), 32)],
+      ["protocolFee", (0, import_kit2.getU64Encoder)()],
+      ["airdropMasterCreateFee", (0, import_kit2.getU64Encoder)()],
+      ["maxClaimFee", (0, import_kit2.getU64Encoder)()],
+      ["maxActionFee", (0, import_kit2.getU64Encoder)()],
+      ["minAirdropDuration", (0, import_kit2.getI64Encoder)()],
+      ["defaultAirdropDuration", (0, import_kit2.getI64Encoder)()],
+      ["maxAirdropDuration", (0, import_kit2.getI64Encoder)()],
+      ["updateGracePeriod", (0, import_kit2.getI64Encoder)()],
+      ["masterFeeBps", (0, import_kit2.getU16Encoder)()],
+      ["version", (0, import_kit2.getU8Encoder)()],
+      ["bump", (0, import_kit2.getU8Encoder)()],
+      ["padding", (0, import_kit2.fixEncoderSize)((0, import_kit2.getBytesEncoder)(), 4)],
+      ["reserved", (0, import_kit2.fixEncoderSize)((0, import_kit2.getBytesEncoder)(), 256)]
+    ]),
+    (value) => ({ ...value, discriminator: AIRDROP_CONFIG_DISCRIMINATOR })
+  );
+}
+function getAirdropConfigDecoder() {
+  return (0, import_kit2.getStructDecoder)([
+    ["discriminator", (0, import_kit2.fixDecoderSize)((0, import_kit2.getBytesDecoder)(), 8)],
+    ["authority", (0, import_kit2.getAddressDecoder)()],
+    ["protocolTreasury", (0, import_kit2.getAddressDecoder)()],
+    ["wlRoot", (0, import_kit2.fixDecoderSize)((0, import_kit2.getBytesDecoder)(), 32)],
+    ["protocolFee", (0, import_kit2.getU64Decoder)()],
+    ["airdropMasterCreateFee", (0, import_kit2.getU64Decoder)()],
+    ["maxClaimFee", (0, import_kit2.getU64Decoder)()],
+    ["maxActionFee", (0, import_kit2.getU64Decoder)()],
+    ["minAirdropDuration", (0, import_kit2.getI64Decoder)()],
+    ["defaultAirdropDuration", (0, import_kit2.getI64Decoder)()],
+    ["maxAirdropDuration", (0, import_kit2.getI64Decoder)()],
+    ["updateGracePeriod", (0, import_kit2.getI64Decoder)()],
+    ["masterFeeBps", (0, import_kit2.getU16Decoder)()],
+    ["version", (0, import_kit2.getU8Decoder)()],
+    ["bump", (0, import_kit2.getU8Decoder)()],
+    ["padding", (0, import_kit2.fixDecoderSize)((0, import_kit2.getBytesDecoder)(), 4)],
+    ["reserved", (0, import_kit2.fixDecoderSize)((0, import_kit2.getBytesDecoder)(), 256)]
+  ]);
+}
+function getAirdropConfigCodec() {
+  return (0, import_kit2.combineCodec)(getAirdropConfigEncoder(), getAirdropConfigDecoder());
+}
+function decodeAirdropConfig(encodedAccount) {
+  return (0, import_kit2.decodeAccount)(
+    encodedAccount,
+    getAirdropConfigDecoder()
+  );
+}
+async function fetchAirdropConfig(rpc, address, config) {
+  const maybeAccount = await fetchMaybeAirdropConfig(rpc, address, config);
+  (0, import_kit2.assertAccountExists)(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeAirdropConfig(rpc, address, config) {
+  const maybeAccount = await (0, import_kit2.fetchEncodedAccount)(rpc, address, config);
+  return decodeAirdropConfig(maybeAccount);
+}
+async function fetchAllAirdropConfig(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeAirdropConfig(
+    rpc,
+    addresses,
+    config
+  );
+  (0, import_kit2.assertAccountsExist)(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeAirdropConfig(rpc, addresses, config) {
+  const maybeAccounts = await (0, import_kit2.fetchEncodedAccounts)(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeAirdropConfig(maybeAccount));
+}
+function getAirdropConfigSize() {
+  return 432;
+}
+
+// src/accounts/airdropMaster.ts
+var import_kit3 = require("@solana/kit");
+var AIRDROP_MASTER_DISCRIMINATOR = new Uint8Array([
+  31,
+  109,
+  100,
+  62,
+  106,
+  173,
+  5,
+  4
+]);
+function getAirdropMasterDiscriminatorBytes() {
+  return (0, import_kit3.fixEncoderSize)((0, import_kit3.getBytesEncoder)(), 8).encode(
+    AIRDROP_MASTER_DISCRIMINATOR
+  );
+}
+function getAirdropMasterEncoder() {
+  return (0, import_kit3.transformEncoder)(
+    (0, import_kit3.getStructEncoder)([
+      ["discriminator", (0, import_kit3.fixEncoderSize)((0, import_kit3.getBytesEncoder)(), 8)],
+      ["creator", (0, import_kit3.getAddressEncoder)()],
+      ["authority", (0, import_kit3.getAddressEncoder)()],
+      ["treasury", (0, import_kit3.getAddressEncoder)()],
+      ["createdAirdrops", (0, import_kit3.getU64Encoder)()],
+      ["points", (0, import_kit3.getU64Encoder)()],
+      ["totalClaimCount", (0, import_kit3.getU64Encoder)()],
+      ["monetizedClaimQuota", (0, import_kit3.getU64Encoder)()],
+      ["monetizedClaimCount", (0, import_kit3.getU64Encoder)()],
+      ["airdropUpdateFee", (0, import_kit3.getU64Encoder)()],
+      ["airdropCreationFee", (0, import_kit3.getU64Encoder)()],
+      ["airdropClaimFee", (0, import_kit3.getU64Encoder)()],
+      ["airdropDelegateFee", (0, import_kit3.getU64Encoder)()],
+      ["bitmapCreationFee", (0, import_kit3.getU64Encoder)()],
+      ["bump", (0, import_kit3.getU8Encoder)()],
+      ["padding", (0, import_kit3.fixEncoderSize)((0, import_kit3.getBytesEncoder)(), 7)]
+    ]),
+    (value) => ({ ...value, discriminator: AIRDROP_MASTER_DISCRIMINATOR })
+  );
+}
+function getAirdropMasterDecoder() {
+  return (0, import_kit3.getStructDecoder)([
+    ["discriminator", (0, import_kit3.fixDecoderSize)((0, import_kit3.getBytesDecoder)(), 8)],
+    ["creator", (0, import_kit3.getAddressDecoder)()],
+    ["authority", (0, import_kit3.getAddressDecoder)()],
+    ["treasury", (0, import_kit3.getAddressDecoder)()],
+    ["createdAirdrops", (0, import_kit3.getU64Decoder)()],
+    ["points", (0, import_kit3.getU64Decoder)()],
+    ["totalClaimCount", (0, import_kit3.getU64Decoder)()],
+    ["monetizedClaimQuota", (0, import_kit3.getU64Decoder)()],
+    ["monetizedClaimCount", (0, import_kit3.getU64Decoder)()],
+    ["airdropUpdateFee", (0, import_kit3.getU64Decoder)()],
+    ["airdropCreationFee", (0, import_kit3.getU64Decoder)()],
+    ["airdropClaimFee", (0, import_kit3.getU64Decoder)()],
+    ["airdropDelegateFee", (0, import_kit3.getU64Decoder)()],
+    ["bitmapCreationFee", (0, import_kit3.getU64Decoder)()],
+    ["bump", (0, import_kit3.getU8Decoder)()],
+    ["padding", (0, import_kit3.fixDecoderSize)((0, import_kit3.getBytesDecoder)(), 7)]
+  ]);
+}
+function getAirdropMasterCodec() {
+  return (0, import_kit3.combineCodec)(getAirdropMasterEncoder(), getAirdropMasterDecoder());
+}
+function decodeAirdropMaster(encodedAccount) {
+  return (0, import_kit3.decodeAccount)(
+    encodedAccount,
+    getAirdropMasterDecoder()
+  );
+}
+async function fetchAirdropMaster(rpc, address, config) {
+  const maybeAccount = await fetchMaybeAirdropMaster(rpc, address, config);
+  (0, import_kit3.assertAccountExists)(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeAirdropMaster(rpc, address, config) {
+  const maybeAccount = await (0, import_kit3.fetchEncodedAccount)(rpc, address, config);
+  return decodeAirdropMaster(maybeAccount);
+}
+async function fetchAllAirdropMaster(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeAirdropMaster(
+    rpc,
+    addresses,
+    config
+  );
+  (0, import_kit3.assertAccountsExist)(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeAirdropMaster(rpc, addresses, config) {
+  const maybeAccounts = await (0, import_kit3.fetchEncodedAccounts)(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeAirdropMaster(maybeAccount));
+}
+function getAirdropMasterSize() {
+  return 192;
+}
+
+// src/accounts/bitmapAccount.ts
+var import_kit4 = require("@solana/kit");
+var BITMAP_ACCOUNT_DISCRIMINATOR = new Uint8Array([
+  152,
+  161,
+  147,
+  85,
+  213,
+  38,
+  59,
+  48
+]);
+function getBitmapAccountDiscriminatorBytes() {
+  return (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8).encode(
+    BITMAP_ACCOUNT_DISCRIMINATOR
+  );
+}
+function getBitmapAccountEncoder() {
+  return (0, import_kit4.transformEncoder)(
+    (0, import_kit4.getStructEncoder)([
+      ["discriminator", (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8)],
+      ["authority", (0, import_kit4.getAddressEncoder)()],
+      ["airdrop", (0, import_kit4.getAddressEncoder)()],
+      ["total", (0, import_kit4.getU32Encoder)()],
+      ["claimedBitmap", (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 1e3)],
+      ["id", (0, import_kit4.getU16Encoder)()],
+      ["version", (0, import_kit4.getU8Encoder)()],
+      ["bump", (0, import_kit4.getU8Encoder)()]
+    ]),
+    (value) => ({ ...value, discriminator: BITMAP_ACCOUNT_DISCRIMINATOR })
+  );
+}
+function getBitmapAccountDecoder() {
+  return (0, import_kit4.getStructDecoder)([
+    ["discriminator", (0, import_kit4.fixDecoderSize)((0, import_kit4.getBytesDecoder)(), 8)],
+    ["authority", (0, import_kit4.getAddressDecoder)()],
+    ["airdrop", (0, import_kit4.getAddressDecoder)()],
+    ["total", (0, import_kit4.getU32Decoder)()],
+    ["claimedBitmap", (0, import_kit4.fixDecoderSize)((0, import_kit4.getBytesDecoder)(), 1e3)],
+    ["id", (0, import_kit4.getU16Decoder)()],
+    ["version", (0, import_kit4.getU8Decoder)()],
+    ["bump", (0, import_kit4.getU8Decoder)()]
+  ]);
+}
+function getBitmapAccountCodec() {
+  return (0, import_kit4.combineCodec)(getBitmapAccountEncoder(), getBitmapAccountDecoder());
+}
+function decodeBitmapAccount(encodedAccount) {
+  return (0, import_kit4.decodeAccount)(
+    encodedAccount,
+    getBitmapAccountDecoder()
+  );
+}
+async function fetchBitmapAccount(rpc, address, config) {
+  const maybeAccount = await fetchMaybeBitmapAccount(rpc, address, config);
+  (0, import_kit4.assertAccountExists)(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeBitmapAccount(rpc, address, config) {
+  const maybeAccount = await (0, import_kit4.fetchEncodedAccount)(rpc, address, config);
+  return decodeBitmapAccount(maybeAccount);
+}
+async function fetchAllBitmapAccount(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeBitmapAccount(
+    rpc,
+    addresses,
+    config
+  );
+  (0, import_kit4.assertAccountsExist)(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeBitmapAccount(rpc, addresses, config) {
+  const maybeAccounts = await (0, import_kit4.fetchEncodedAccounts)(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeBitmapAccount(maybeAccount));
+}
+function getBitmapAccountSize() {
+  return 1080;
+}
+
+// src/errors/dropsyAirdrop.ts
+var import_kit13 = require("@solana/kit");
+
+// src/programs/dropsyAirdrop.ts
+var import_kit12 = require("@solana/kit");
+
+// src/instructions/claimAirdrop.ts
+var import_kit6 = require("@solana/kit");
+
+// src/shared/index.ts
+var import_kit5 = require("@solana/kit");
+function expectSome(value) {
+  if (value === null || value === void 0) {
+    throw new Error("Expected a value but received null or undefined.");
+  }
+  return value;
+}
+function expectAddress(value) {
+  if (!value) {
+    throw new Error("Expected a Address.");
+  }
+  if (typeof value === "object" && "address" in value) {
+    return value.address;
+  }
+  if (Array.isArray(value)) {
+    return value[0];
+  }
+  return value;
+}
+function getAccountMetaFactory(programAddress, optionalAccountStrategy) {
+  return (account) => {
+    if (!account.value) {
+      if (optionalAccountStrategy === "omitted") return;
+      return Object.freeze({
+        address: programAddress,
+        role: import_kit5.AccountRole.READONLY
+      });
+    }
+    const writableRole = account.isWritable ? import_kit5.AccountRole.WRITABLE : import_kit5.AccountRole.READONLY;
+    return Object.freeze({
+      address: expectAddress(account.value),
+      role: isTransactionSigner(account.value) ? (0, import_kit5.upgradeRoleToSigner)(writableRole) : writableRole,
+      ...isTransactionSigner(account.value) ? { signer: account.value } : {}
+    });
+  };
+}
+function isTransactionSigner(value) {
+  return !!value && typeof value === "object" && "address" in value && (0, import_kit5.isTransactionSigner)(value);
+}
+
+// src/instructions/claimAirdrop.ts
+var CLAIM_AIRDROP_DISCRIMINATOR = new Uint8Array([
+  137,
+  50,
+  122,
+  111,
+  89,
+  254,
+  8,
+  20
+]);
+function getClaimAirdropDiscriminatorBytes() {
+  return (0, import_kit6.fixEncoderSize)((0, import_kit6.getBytesEncoder)(), 8).encode(
+    CLAIM_AIRDROP_DISCRIMINATOR
+  );
+}
+function getClaimAirdropInstructionDataEncoder() {
+  return (0, import_kit6.transformEncoder)(
+    (0, import_kit6.getStructEncoder)([
+      ["discriminator", (0, import_kit6.fixEncoderSize)((0, import_kit6.getBytesEncoder)(), 8)],
+      ["index", (0, import_kit6.getU64Encoder)()],
+      ["proof", (0, import_kit6.getArrayEncoder)((0, import_kit6.fixEncoderSize)((0, import_kit6.getBytesEncoder)(), 32))],
+      ["amount", (0, import_kit6.getU64Encoder)()],
+      ["claimMapIndex", (0, import_kit6.getU16Encoder)()]
+    ]),
+    (value) => ({ ...value, discriminator: CLAIM_AIRDROP_DISCRIMINATOR })
+  );
+}
+function getClaimAirdropInstructionDataDecoder() {
+  return (0, import_kit6.getStructDecoder)([
+    ["discriminator", (0, import_kit6.fixDecoderSize)((0, import_kit6.getBytesDecoder)(), 8)],
+    ["index", (0, import_kit6.getU64Decoder)()],
+    ["proof", (0, import_kit6.getArrayDecoder)((0, import_kit6.fixDecoderSize)((0, import_kit6.getBytesDecoder)(), 32))],
+    ["amount", (0, import_kit6.getU64Decoder)()],
+    ["claimMapIndex", (0, import_kit6.getU16Decoder)()]
+  ]);
+}
+function getClaimAirdropInstructionDataCodec() {
+  return (0, import_kit6.combineCodec)(
+    getClaimAirdropInstructionDataEncoder(),
+    getClaimAirdropInstructionDataDecoder()
+  );
+}
+async function getClaimAirdropInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? DROPSY_AIRDROP_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    sourceTokenAccount: {
+      value: input.sourceTokenAccount ?? null,
+      isWritable: true
+    },
+    destinationTokenAccount: {
+      value: input.destinationTokenAccount ?? null,
+      isWritable: true
+    },
+    claimer: { value: input.claimer ?? null, isWritable: true },
+    mint: { value: input.mint ?? null, isWritable: false },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+    associatedTokenProgram: {
+      value: input.associatedTokenProgram ?? null,
+      isWritable: false
+    },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false },
+    airdropConfig: { value: input.airdropConfig ?? null, isWritable: false },
+    protocolTreasury: {
+      value: input.protocolTreasury ?? null,
+      isWritable: true
+    },
+    airdropMaster: { value: input.airdropMaster ?? null, isWritable: false },
+    treasury: { value: input.treasury ?? null, isWritable: true },
+    masterCreator: { value: input.masterCreator ?? null, isWritable: false },
+    airdrop: { value: input.airdrop ?? null, isWritable: true },
+    authority: { value: input.authority ?? null, isWritable: false },
+    bitmap: { value: input.bitmap ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.tokenProgram.value) {
+    accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+  }
+  if (!accounts.destinationTokenAccount.value) {
+    accounts.destinationTokenAccount.value = await (0, import_kit6.getProgramDerivedAddress)({
+      programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
+      seeds: [
+        (0, import_kit6.getAddressEncoder)().encode(expectAddress(accounts.claimer.value)),
+        (0, import_kit6.getAddressEncoder)().encode(expectAddress(accounts.tokenProgram.value)),
+        (0, import_kit6.getAddressEncoder)().encode(expectAddress(accounts.mint.value))
+      ]
+    });
+  }
+  if (!accounts.associatedTokenProgram.value) {
+    accounts.associatedTokenProgram.value = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  if (!accounts.airdropConfig.value) {
+    accounts.airdropConfig.value = await (0, import_kit6.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit6.getBytesEncoder)().encode(
+          new Uint8Array([
+            97,
+            105,
+            114,
+            100,
+            114,
+            111,
+            112,
+            95,
+            99,
+            111,
+            110,
+            102,
+            105,
+            103
+          ])
+        )
+      ]
+    });
+  }
+  if (!accounts.airdropMaster.value) {
+    accounts.airdropMaster.value = await (0, import_kit6.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit6.getBytesEncoder)().encode(
+          new Uint8Array([
+            97,
+            105,
+            114,
+            100,
+            114,
+            111,
+            112,
+            95,
+            109,
+            97,
+            115,
+            116,
+            101,
+            114
+          ])
+        ),
+        (0, import_kit6.getAddressEncoder)().encode(expectAddress(accounts.masterCreator.value))
+      ]
+    });
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.sourceTokenAccount),
+      getAccountMeta(accounts.destinationTokenAccount),
+      getAccountMeta(accounts.claimer),
+      getAccountMeta(accounts.mint),
+      getAccountMeta(accounts.tokenProgram),
+      getAccountMeta(accounts.associatedTokenProgram),
+      getAccountMeta(accounts.systemProgram),
+      getAccountMeta(accounts.airdropConfig),
+      getAccountMeta(accounts.protocolTreasury),
+      getAccountMeta(accounts.airdropMaster),
+      getAccountMeta(accounts.treasury),
+      getAccountMeta(accounts.masterCreator),
+      getAccountMeta(accounts.airdrop),
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.bitmap)
+    ],
+    data: getClaimAirdropInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getClaimAirdropInstruction(input, config) {
+  const programAddress = config?.programAddress ?? DROPSY_AIRDROP_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    sourceTokenAccount: {
+      value: input.sourceTokenAccount ?? null,
+      isWritable: true
+    },
+    destinationTokenAccount: {
+      value: input.destinationTokenAccount ?? null,
+      isWritable: true
+    },
+    claimer: { value: input.claimer ?? null, isWritable: true },
+    mint: { value: input.mint ?? null, isWritable: false },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+    associatedTokenProgram: {
+      value: input.associatedTokenProgram ?? null,
+      isWritable: false
+    },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false },
+    airdropConfig: { value: input.airdropConfig ?? null, isWritable: false },
+    protocolTreasury: {
+      value: input.protocolTreasury ?? null,
+      isWritable: true
+    },
+    airdropMaster: { value: input.airdropMaster ?? null, isWritable: false },
+    treasury: { value: input.treasury ?? null, isWritable: true },
+    masterCreator: { value: input.masterCreator ?? null, isWritable: false },
+    airdrop: { value: input.airdrop ?? null, isWritable: true },
+    authority: { value: input.authority ?? null, isWritable: false },
+    bitmap: { value: input.bitmap ?? null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.tokenProgram.value) {
+    accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+  }
+  if (!accounts.associatedTokenProgram.value) {
+    accounts.associatedTokenProgram.value = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.sourceTokenAccount),
+      getAccountMeta(accounts.destinationTokenAccount),
+      getAccountMeta(accounts.claimer),
+      getAccountMeta(accounts.mint),
+      getAccountMeta(accounts.tokenProgram),
+      getAccountMeta(accounts.associatedTokenProgram),
+      getAccountMeta(accounts.systemProgram),
+      getAccountMeta(accounts.airdropConfig),
+      getAccountMeta(accounts.protocolTreasury),
+      getAccountMeta(accounts.airdropMaster),
+      getAccountMeta(accounts.treasury),
+      getAccountMeta(accounts.masterCreator),
+      getAccountMeta(accounts.airdrop),
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.bitmap)
+    ],
+    data: getClaimAirdropInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseClaimAirdropInstruction(instruction) {
+  if (instruction.accounts.length < 15) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      sourceTokenAccount: getNextAccount(),
+      destinationTokenAccount: getNextAccount(),
+      claimer: getNextAccount(),
+      mint: getNextAccount(),
+      tokenProgram: getNextAccount(),
+      associatedTokenProgram: getNextAccount(),
+      systemProgram: getNextAccount(),
+      airdropConfig: getNextAccount(),
+      protocolTreasury: getNextAccount(),
+      airdropMaster: getNextAccount(),
+      treasury: getNextAccount(),
+      masterCreator: getNextAccount(),
+      airdrop: getNextAccount(),
+      authority: getNextAccount(),
+      bitmap: getNextAccount()
+    },
+    data: getClaimAirdropInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/instructions/createAirdrop.ts
+var import_kit7 = require("@solana/kit");
+var CREATE_AIRDROP_DISCRIMINATOR = new Uint8Array([
+  227,
+  135,
+  208,
+  66,
+  137,
+  177,
+  80,
+  94
+]);
+function getCreateAirdropDiscriminatorBytes() {
+  return (0, import_kit7.fixEncoderSize)((0, import_kit7.getBytesEncoder)(), 8).encode(
+    CREATE_AIRDROP_DISCRIMINATOR
+  );
+}
+function getCreateAirdropInstructionDataEncoder() {
+  return (0, import_kit7.transformEncoder)(
+    (0, import_kit7.getStructEncoder)([
+      ["discriminator", (0, import_kit7.fixEncoderSize)((0, import_kit7.getBytesEncoder)(), 8)],
+      ["id", (0, import_kit7.getU64Encoder)()],
+      ["merkleRoot", (0, import_kit7.getOptionEncoder)((0, import_kit7.fixEncoderSize)((0, import_kit7.getBytesEncoder)(), 32))],
+      ["startsAt", (0, import_kit7.getOptionEncoder)((0, import_kit7.getI64Encoder)())],
+      ["endsAt", (0, import_kit7.getOptionEncoder)((0, import_kit7.getI64Encoder)())],
+      ["version", (0, import_kit7.getOptionEncoder)((0, import_kit7.getU8Encoder)())],
+      ["delegateAuthority", (0, import_kit7.getOptionEncoder)((0, import_kit7.getAddressEncoder)())]
+    ]),
+    (value) => ({ ...value, discriminator: CREATE_AIRDROP_DISCRIMINATOR })
+  );
+}
+function getCreateAirdropInstructionDataDecoder() {
+  return (0, import_kit7.getStructDecoder)([
+    ["discriminator", (0, import_kit7.fixDecoderSize)((0, import_kit7.getBytesDecoder)(), 8)],
+    ["id", (0, import_kit7.getU64Decoder)()],
+    ["merkleRoot", (0, import_kit7.getOptionDecoder)((0, import_kit7.fixDecoderSize)((0, import_kit7.getBytesDecoder)(), 32))],
+    ["startsAt", (0, import_kit7.getOptionDecoder)((0, import_kit7.getI64Decoder)())],
+    ["endsAt", (0, import_kit7.getOptionDecoder)((0, import_kit7.getI64Decoder)())],
+    ["version", (0, import_kit7.getOptionDecoder)((0, import_kit7.getU8Decoder)())],
+    ["delegateAuthority", (0, import_kit7.getOptionDecoder)((0, import_kit7.getAddressDecoder)())]
+  ]);
+}
+function getCreateAirdropInstructionDataCodec() {
+  return (0, import_kit7.combineCodec)(
+    getCreateAirdropInstructionDataEncoder(),
+    getCreateAirdropInstructionDataDecoder()
+  );
+}
+async function getCreateAirdropInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? DROPSY_AIRDROP_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    airdropConfig: { value: input.airdropConfig ?? null, isWritable: false },
+    protocolTreasury: {
+      value: input.protocolTreasury ?? null,
+      isWritable: true
+    },
+    airdropMaster: { value: input.airdropMaster ?? null, isWritable: false },
+    treasury: { value: input.treasury ?? null, isWritable: true },
+    masterCreator: { value: input.masterCreator ?? null, isWritable: false },
+    airdrop: { value: input.airdrop ?? null, isWritable: true },
+    mint: { value: input.mint ?? null, isWritable: false },
+    authority: { value: input.authority ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.airdropConfig.value) {
+    accounts.airdropConfig.value = await (0, import_kit7.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit7.getBytesEncoder)().encode(
+          new Uint8Array([
+            97,
+            105,
+            114,
+            100,
+            114,
+            111,
+            112,
+            95,
+            99,
+            111,
+            110,
+            102,
+            105,
+            103
+          ])
+        )
+      ]
+    });
+  }
+  if (!accounts.airdropMaster.value) {
+    accounts.airdropMaster.value = await (0, import_kit7.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit7.getBytesEncoder)().encode(
+          new Uint8Array([
+            97,
+            105,
+            114,
+            100,
+            114,
+            111,
+            112,
+            95,
+            109,
+            97,
+            115,
+            116,
+            101,
+            114
+          ])
+        ),
+        (0, import_kit7.getAddressEncoder)().encode(expectAddress(accounts.masterCreator.value))
+      ]
+    });
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.airdropConfig),
+      getAccountMeta(accounts.protocolTreasury),
+      getAccountMeta(accounts.airdropMaster),
+      getAccountMeta(accounts.treasury),
+      getAccountMeta(accounts.masterCreator),
+      getAccountMeta(accounts.airdrop),
+      getAccountMeta(accounts.mint),
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    data: getCreateAirdropInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getCreateAirdropInstruction(input, config) {
+  const programAddress = config?.programAddress ?? DROPSY_AIRDROP_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    airdropConfig: { value: input.airdropConfig ?? null, isWritable: false },
+    protocolTreasury: {
+      value: input.protocolTreasury ?? null,
+      isWritable: true
+    },
+    airdropMaster: { value: input.airdropMaster ?? null, isWritable: false },
+    treasury: { value: input.treasury ?? null, isWritable: true },
+    masterCreator: { value: input.masterCreator ?? null, isWritable: false },
+    airdrop: { value: input.airdrop ?? null, isWritable: true },
+    mint: { value: input.mint ?? null, isWritable: false },
+    authority: { value: input.authority ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.airdropConfig),
+      getAccountMeta(accounts.protocolTreasury),
+      getAccountMeta(accounts.airdropMaster),
+      getAccountMeta(accounts.treasury),
+      getAccountMeta(accounts.masterCreator),
+      getAccountMeta(accounts.airdrop),
+      getAccountMeta(accounts.mint),
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    data: getCreateAirdropInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseCreateAirdropInstruction(instruction) {
+  if (instruction.accounts.length < 9) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      airdropConfig: getNextAccount(),
+      protocolTreasury: getNextAccount(),
+      airdropMaster: getNextAccount(),
+      treasury: getNextAccount(),
+      masterCreator: getNextAccount(),
+      airdrop: getNextAccount(),
+      mint: getNextAccount(),
+      authority: getNextAccount(),
+      systemProgram: getNextAccount()
+    },
+    data: getCreateAirdropInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/instructions/createBitmap.ts
+var import_kit8 = require("@solana/kit");
+var CREATE_BITMAP_DISCRIMINATOR = new Uint8Array([
+  69,
+  92,
+  61,
+  190,
+  154,
+  237,
+  116,
+  247
+]);
+function getCreateBitmapDiscriminatorBytes() {
+  return (0, import_kit8.fixEncoderSize)((0, import_kit8.getBytesEncoder)(), 8).encode(
+    CREATE_BITMAP_DISCRIMINATOR
+  );
+}
+function getCreateBitmapInstructionDataEncoder() {
+  return (0, import_kit8.transformEncoder)(
+    (0, import_kit8.getStructEncoder)([
+      ["discriminator", (0, import_kit8.fixEncoderSize)((0, import_kit8.getBytesEncoder)(), 8)],
+      ["id", (0, import_kit8.getU16Encoder)()],
+      ["total", (0, import_kit8.getU32Encoder)()]
+    ]),
+    (value) => ({ ...value, discriminator: CREATE_BITMAP_DISCRIMINATOR })
+  );
+}
+function getCreateBitmapInstructionDataDecoder() {
+  return (0, import_kit8.getStructDecoder)([
+    ["discriminator", (0, import_kit8.fixDecoderSize)((0, import_kit8.getBytesDecoder)(), 8)],
+    ["id", (0, import_kit8.getU16Decoder)()],
+    ["total", (0, import_kit8.getU32Decoder)()]
+  ]);
+}
+function getCreateBitmapInstructionDataCodec() {
+  return (0, import_kit8.combineCodec)(
+    getCreateBitmapInstructionDataEncoder(),
+    getCreateBitmapInstructionDataDecoder()
+  );
+}
+async function getCreateBitmapInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? DROPSY_AIRDROP_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    airdropConfig: { value: input.airdropConfig ?? null, isWritable: false },
+    protocolTreasury: {
+      value: input.protocolTreasury ?? null,
+      isWritable: true
+    },
+    airdropMaster: { value: input.airdropMaster ?? null, isWritable: false },
+    treasury: { value: input.treasury ?? null, isWritable: true },
+    masterCreator: { value: input.masterCreator ?? null, isWritable: false },
+    bitmap: { value: input.bitmap ?? null, isWritable: true },
+    airdrop: { value: input.airdrop ?? null, isWritable: true },
+    mint: { value: input.mint ?? null, isWritable: false },
+    authority: { value: input.authority ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.airdropConfig.value) {
+    accounts.airdropConfig.value = await (0, import_kit8.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit8.getBytesEncoder)().encode(
+          new Uint8Array([
+            97,
+            105,
+            114,
+            100,
+            114,
+            111,
+            112,
+            95,
+            99,
+            111,
+            110,
+            102,
+            105,
+            103
+          ])
+        )
+      ]
+    });
+  }
+  if (!accounts.airdropMaster.value) {
+    accounts.airdropMaster.value = await (0, import_kit8.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit8.getBytesEncoder)().encode(
+          new Uint8Array([
+            97,
+            105,
+            114,
+            100,
+            114,
+            111,
+            112,
+            95,
+            109,
+            97,
+            115,
+            116,
+            101,
+            114
+          ])
+        ),
+        (0, import_kit8.getAddressEncoder)().encode(expectAddress(accounts.masterCreator.value))
+      ]
+    });
+  }
+  if (!accounts.airdrop.value) {
+    accounts.airdrop.value = await (0, import_kit8.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit8.getBytesEncoder)().encode(
+          new Uint8Array([97, 105, 114, 100, 114, 111, 112])
+        ),
+        (0, import_kit8.getAddressEncoder)().encode(expectAddress(accounts.authority.value)),
+        (0, import_kit8.getAddressEncoder)().encode(expectAddress(accounts.mint.value))
+      ]
+    });
+  }
+  if (!accounts.bitmap.value) {
+    accounts.bitmap.value = await (0, import_kit8.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit8.getBytesEncoder)().encode(new Uint8Array([98, 105, 116, 109, 97, 112])),
+        (0, import_kit8.getAddressEncoder)().encode(expectAddress(accounts.airdrop.value)),
+        (0, import_kit8.getU16Encoder)().encode(expectSome(args.id))
+      ]
+    });
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.airdropConfig),
+      getAccountMeta(accounts.protocolTreasury),
+      getAccountMeta(accounts.airdropMaster),
+      getAccountMeta(accounts.treasury),
+      getAccountMeta(accounts.masterCreator),
+      getAccountMeta(accounts.bitmap),
+      getAccountMeta(accounts.airdrop),
+      getAccountMeta(accounts.mint),
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    data: getCreateBitmapInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getCreateBitmapInstruction(input, config) {
+  const programAddress = config?.programAddress ?? DROPSY_AIRDROP_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    airdropConfig: { value: input.airdropConfig ?? null, isWritable: false },
+    protocolTreasury: {
+      value: input.protocolTreasury ?? null,
+      isWritable: true
+    },
+    airdropMaster: { value: input.airdropMaster ?? null, isWritable: false },
+    treasury: { value: input.treasury ?? null, isWritable: true },
+    masterCreator: { value: input.masterCreator ?? null, isWritable: false },
+    bitmap: { value: input.bitmap ?? null, isWritable: true },
+    airdrop: { value: input.airdrop ?? null, isWritable: true },
+    mint: { value: input.mint ?? null, isWritable: false },
+    authority: { value: input.authority ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.airdropConfig),
+      getAccountMeta(accounts.protocolTreasury),
+      getAccountMeta(accounts.airdropMaster),
+      getAccountMeta(accounts.treasury),
+      getAccountMeta(accounts.masterCreator),
+      getAccountMeta(accounts.bitmap),
+      getAccountMeta(accounts.airdrop),
+      getAccountMeta(accounts.mint),
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    data: getCreateBitmapInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseCreateBitmapInstruction(instruction) {
+  if (instruction.accounts.length < 10) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      airdropConfig: getNextAccount(),
+      protocolTreasury: getNextAccount(),
+      airdropMaster: getNextAccount(),
+      treasury: getNextAccount(),
+      masterCreator: getNextAccount(),
+      bitmap: getNextAccount(),
+      airdrop: getNextAccount(),
+      mint: getNextAccount(),
+      authority: getNextAccount(),
+      systemProgram: getNextAccount()
+    },
+    data: getCreateBitmapInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/instructions/depositTokens.ts
+var import_kit9 = require("@solana/kit");
+var DEPOSIT_TOKENS_DISCRIMINATOR = new Uint8Array([
+  176,
+  83,
+  229,
+  18,
+  191,
+  143,
+  176,
+  150
+]);
+function getDepositTokensDiscriminatorBytes() {
+  return (0, import_kit9.fixEncoderSize)((0, import_kit9.getBytesEncoder)(), 8).encode(
+    DEPOSIT_TOKENS_DISCRIMINATOR
+  );
+}
+function getDepositTokensInstructionDataEncoder() {
+  return (0, import_kit9.transformEncoder)(
+    (0, import_kit9.getStructEncoder)([
+      ["discriminator", (0, import_kit9.fixEncoderSize)((0, import_kit9.getBytesEncoder)(), 8)],
+      ["amount", (0, import_kit9.getU64Encoder)()]
+    ]),
+    (value) => ({ ...value, discriminator: DEPOSIT_TOKENS_DISCRIMINATOR })
+  );
+}
+function getDepositTokensInstructionDataDecoder() {
+  return (0, import_kit9.getStructDecoder)([
+    ["discriminator", (0, import_kit9.fixDecoderSize)((0, import_kit9.getBytesDecoder)(), 8)],
+    ["amount", (0, import_kit9.getU64Decoder)()]
+  ]);
+}
+function getDepositTokensInstructionDataCodec() {
+  return (0, import_kit9.combineCodec)(
+    getDepositTokensInstructionDataEncoder(),
+    getDepositTokensInstructionDataDecoder()
+  );
+}
+async function getDepositTokensInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? DROPSY_AIRDROP_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    sourceTokenAccount: {
+      value: input.sourceTokenAccount ?? null,
+      isWritable: true
+    },
+    vault: { value: input.vault ?? null, isWritable: true },
+    airdrop: { value: input.airdrop ?? null, isWritable: true },
+    mint: { value: input.mint ?? null, isWritable: false },
+    authority: { value: input.authority ?? null, isWritable: true },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+    associatedTokenProgram: {
+      value: input.associatedTokenProgram ?? null,
+      isWritable: false
+    },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.airdrop.value) {
+    accounts.airdrop.value = await (0, import_kit9.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit9.getBytesEncoder)().encode(
+          new Uint8Array([97, 105, 114, 100, 114, 111, 112])
+        ),
+        (0, import_kit9.getAddressEncoder)().encode(expectAddress(accounts.authority.value)),
+        (0, import_kit9.getAddressEncoder)().encode(expectAddress(accounts.mint.value))
+      ]
+    });
+  }
+  if (!accounts.tokenProgram.value) {
+    accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+  }
+  if (!accounts.vault.value) {
+    accounts.vault.value = await (0, import_kit9.getProgramDerivedAddress)({
+      programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
+      seeds: [
+        (0, import_kit9.getAddressEncoder)().encode(expectAddress(accounts.airdrop.value)),
+        (0, import_kit9.getAddressEncoder)().encode(expectAddress(accounts.tokenProgram.value)),
+        (0, import_kit9.getAddressEncoder)().encode(expectAddress(accounts.mint.value))
+      ]
+    });
+  }
+  if (!accounts.associatedTokenProgram.value) {
+    accounts.associatedTokenProgram.value = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.sourceTokenAccount),
+      getAccountMeta(accounts.vault),
+      getAccountMeta(accounts.airdrop),
+      getAccountMeta(accounts.mint),
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.tokenProgram),
+      getAccountMeta(accounts.associatedTokenProgram),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    data: getDepositTokensInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getDepositTokensInstruction(input, config) {
+  const programAddress = config?.programAddress ?? DROPSY_AIRDROP_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    sourceTokenAccount: {
+      value: input.sourceTokenAccount ?? null,
+      isWritable: true
+    },
+    vault: { value: input.vault ?? null, isWritable: true },
+    airdrop: { value: input.airdrop ?? null, isWritable: true },
+    mint: { value: input.mint ?? null, isWritable: false },
+    authority: { value: input.authority ?? null, isWritable: true },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+    associatedTokenProgram: {
+      value: input.associatedTokenProgram ?? null,
+      isWritable: false
+    },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.tokenProgram.value) {
+    accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+  }
+  if (!accounts.associatedTokenProgram.value) {
+    accounts.associatedTokenProgram.value = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.sourceTokenAccount),
+      getAccountMeta(accounts.vault),
+      getAccountMeta(accounts.airdrop),
+      getAccountMeta(accounts.mint),
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.tokenProgram),
+      getAccountMeta(accounts.associatedTokenProgram),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    data: getDepositTokensInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseDepositTokensInstruction(instruction) {
+  if (instruction.accounts.length < 8) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      sourceTokenAccount: getNextAccount(),
+      vault: getNextAccount(),
+      airdrop: getNextAccount(),
+      mint: getNextAccount(),
+      authority: getNextAccount(),
+      tokenProgram: getNextAccount(),
+      associatedTokenProgram: getNextAccount(),
+      systemProgram: getNextAccount()
+    },
+    data: getDepositTokensInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/instructions/initializeAirdropConfig.ts
+var import_kit10 = require("@solana/kit");
+var INITIALIZE_AIRDROP_CONFIG_DISCRIMINATOR = new Uint8Array([
+  160,
+  68,
+  127,
+  205,
+  130,
+  205,
+  156,
+  94
+]);
+function getInitializeAirdropConfigDiscriminatorBytes() {
+  return (0, import_kit10.fixEncoderSize)((0, import_kit10.getBytesEncoder)(), 8).encode(
+    INITIALIZE_AIRDROP_CONFIG_DISCRIMINATOR
+  );
+}
+function getInitializeAirdropConfigInstructionDataEncoder() {
+  return (0, import_kit10.transformEncoder)(
+    (0, import_kit10.getStructEncoder)([
+      ["discriminator", (0, import_kit10.fixEncoderSize)((0, import_kit10.getBytesEncoder)(), 8)],
+      ["wlRoot", (0, import_kit10.getOptionEncoder)((0, import_kit10.fixEncoderSize)((0, import_kit10.getBytesEncoder)(), 32))],
+      ["airdropMasterCreateFee", (0, import_kit10.getOptionEncoder)((0, import_kit10.getU64Encoder)())],
+      ["maxClaimFee", (0, import_kit10.getOptionEncoder)((0, import_kit10.getU64Encoder)())],
+      ["maxActionFee", (0, import_kit10.getOptionEncoder)((0, import_kit10.getU64Encoder)())],
+      ["minAirdropDuration", (0, import_kit10.getOptionEncoder)((0, import_kit10.getI64Encoder)())],
+      ["defaultAirdropDuration", (0, import_kit10.getOptionEncoder)((0, import_kit10.getI64Encoder)())],
+      ["maxAirdropDuration", (0, import_kit10.getOptionEncoder)((0, import_kit10.getI64Encoder)())],
+      ["updateGracePeriod", (0, import_kit10.getOptionEncoder)((0, import_kit10.getI64Encoder)())],
+      ["protocolFee", (0, import_kit10.getOptionEncoder)((0, import_kit10.getU64Encoder)())],
+      ["masterFeeBps", (0, import_kit10.getOptionEncoder)((0, import_kit10.getU16Encoder)())]
+    ]),
+    (value) => ({
+      ...value,
+      discriminator: INITIALIZE_AIRDROP_CONFIG_DISCRIMINATOR
+    })
+  );
+}
+function getInitializeAirdropConfigInstructionDataDecoder() {
+  return (0, import_kit10.getStructDecoder)([
+    ["discriminator", (0, import_kit10.fixDecoderSize)((0, import_kit10.getBytesDecoder)(), 8)],
+    ["wlRoot", (0, import_kit10.getOptionDecoder)((0, import_kit10.fixDecoderSize)((0, import_kit10.getBytesDecoder)(), 32))],
+    ["airdropMasterCreateFee", (0, import_kit10.getOptionDecoder)((0, import_kit10.getU64Decoder)())],
+    ["maxClaimFee", (0, import_kit10.getOptionDecoder)((0, import_kit10.getU64Decoder)())],
+    ["maxActionFee", (0, import_kit10.getOptionDecoder)((0, import_kit10.getU64Decoder)())],
+    ["minAirdropDuration", (0, import_kit10.getOptionDecoder)((0, import_kit10.getI64Decoder)())],
+    ["defaultAirdropDuration", (0, import_kit10.getOptionDecoder)((0, import_kit10.getI64Decoder)())],
+    ["maxAirdropDuration", (0, import_kit10.getOptionDecoder)((0, import_kit10.getI64Decoder)())],
+    ["updateGracePeriod", (0, import_kit10.getOptionDecoder)((0, import_kit10.getI64Decoder)())],
+    ["protocolFee", (0, import_kit10.getOptionDecoder)((0, import_kit10.getU64Decoder)())],
+    ["masterFeeBps", (0, import_kit10.getOptionDecoder)((0, import_kit10.getU16Decoder)())]
+  ]);
+}
+function getInitializeAirdropConfigInstructionDataCodec() {
+  return (0, import_kit10.combineCodec)(
+    getInitializeAirdropConfigInstructionDataEncoder(),
+    getInitializeAirdropConfigInstructionDataDecoder()
+  );
+}
+async function getInitializeAirdropConfigInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? DROPSY_AIRDROP_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: true },
+    protocolTreasury: {
+      value: input.protocolTreasury ?? null,
+      isWritable: false
+    },
+    authority: { value: input.authority ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.config.value) {
+    accounts.config.value = await (0, import_kit10.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit10.getBytesEncoder)().encode(
+          new Uint8Array([
+            97,
+            105,
+            114,
+            100,
+            114,
+            111,
+            112,
+            95,
+            99,
+            111,
+            110,
+            102,
+            105,
+            103
+          ])
+        )
+      ]
+    });
+  }
+  if (!accounts.authority.value) {
+    accounts.authority.value = "79xcTj8QDPhqg7Bwvoz9CrckmGyo2JJXU9duVqJbCLxc";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.config),
+      getAccountMeta(accounts.protocolTreasury),
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    data: getInitializeAirdropConfigInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getInitializeAirdropConfigInstruction(input, config) {
+  const programAddress = config?.programAddress ?? DROPSY_AIRDROP_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: true },
+    protocolTreasury: {
+      value: input.protocolTreasury ?? null,
+      isWritable: false
+    },
+    authority: { value: input.authority ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.authority.value) {
+    accounts.authority.value = "79xcTj8QDPhqg7Bwvoz9CrckmGyo2JJXU9duVqJbCLxc";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.config),
+      getAccountMeta(accounts.protocolTreasury),
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    data: getInitializeAirdropConfigInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseInitializeAirdropConfigInstruction(instruction) {
+  if (instruction.accounts.length < 4) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      config: getNextAccount(),
+      protocolTreasury: getNextAccount(),
+      authority: getNextAccount(),
+      systemProgram: getNextAccount()
+    },
+    data: getInitializeAirdropConfigInstructionDataDecoder().decode(
+      instruction.data
+    )
+  };
+}
+
+// src/instructions/initializeAirdropMaster.ts
+var import_kit11 = require("@solana/kit");
+var INITIALIZE_AIRDROP_MASTER_DISCRIMINATOR = new Uint8Array([
+  163,
+  197,
+  170,
+  44,
+  57,
+  57,
+  90,
+  65
+]);
+function getInitializeAirdropMasterDiscriminatorBytes() {
+  return (0, import_kit11.fixEncoderSize)((0, import_kit11.getBytesEncoder)(), 8).encode(
+    INITIALIZE_AIRDROP_MASTER_DISCRIMINATOR
+  );
+}
+function getInitializeAirdropMasterInstructionDataEncoder() {
+  return (0, import_kit11.transformEncoder)(
+    (0, import_kit11.getStructEncoder)([
+      ["discriminator", (0, import_kit11.fixEncoderSize)((0, import_kit11.getBytesEncoder)(), 8)],
+      ["airdropUpdateFee", (0, import_kit11.getOptionEncoder)((0, import_kit11.getU64Encoder)())],
+      ["airdropCreationFee", (0, import_kit11.getOptionEncoder)((0, import_kit11.getU64Encoder)())],
+      ["airdropClaimFee", (0, import_kit11.getOptionEncoder)((0, import_kit11.getU64Encoder)())],
+      ["airdropDelegateFee", (0, import_kit11.getOptionEncoder)((0, import_kit11.getU64Encoder)())],
+      ["bitmapCreationFee", (0, import_kit11.getOptionEncoder)((0, import_kit11.getU64Encoder)())],
+      [
+        "discountProof",
+        (0, import_kit11.getOptionEncoder)(
+          (0, import_kit11.getArrayEncoder)((0, import_kit11.fixEncoderSize)((0, import_kit11.getBytesEncoder)(), 32))
+        )
+      ]
+    ]),
+    (value) => ({
+      ...value,
+      discriminator: INITIALIZE_AIRDROP_MASTER_DISCRIMINATOR
+    })
+  );
+}
+function getInitializeAirdropMasterInstructionDataDecoder() {
+  return (0, import_kit11.getStructDecoder)([
+    ["discriminator", (0, import_kit11.fixDecoderSize)((0, import_kit11.getBytesDecoder)(), 8)],
+    ["airdropUpdateFee", (0, import_kit11.getOptionDecoder)((0, import_kit11.getU64Decoder)())],
+    ["airdropCreationFee", (0, import_kit11.getOptionDecoder)((0, import_kit11.getU64Decoder)())],
+    ["airdropClaimFee", (0, import_kit11.getOptionDecoder)((0, import_kit11.getU64Decoder)())],
+    ["airdropDelegateFee", (0, import_kit11.getOptionDecoder)((0, import_kit11.getU64Decoder)())],
+    ["bitmapCreationFee", (0, import_kit11.getOptionDecoder)((0, import_kit11.getU64Decoder)())],
+    [
+      "discountProof",
+      (0, import_kit11.getOptionDecoder)((0, import_kit11.getArrayDecoder)((0, import_kit11.fixDecoderSize)((0, import_kit11.getBytesDecoder)(), 32)))
+    ]
+  ]);
+}
+function getInitializeAirdropMasterInstructionDataCodec() {
+  return (0, import_kit11.combineCodec)(
+    getInitializeAirdropMasterInstructionDataEncoder(),
+    getInitializeAirdropMasterInstructionDataDecoder()
+  );
+}
+async function getInitializeAirdropMasterInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? DROPSY_AIRDROP_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: false },
+    airdropMaster: { value: input.airdropMaster ?? null, isWritable: true },
+    protocolTreasury: {
+      value: input.protocolTreasury ?? null,
+      isWritable: true
+    },
+    treasury: { value: input.treasury ?? null, isWritable: false },
+    affiliate: { value: input.affiliate ?? null, isWritable: true },
+    creator: { value: input.creator ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.config.value) {
+    accounts.config.value = await (0, import_kit11.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit11.getBytesEncoder)().encode(
+          new Uint8Array([
+            97,
+            105,
+            114,
+            100,
+            114,
+            111,
+            112,
+            95,
+            99,
+            111,
+            110,
+            102,
+            105,
+            103
+          ])
+        )
+      ]
+    });
+  }
+  if (!accounts.airdropMaster.value) {
+    accounts.airdropMaster.value = await (0, import_kit11.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit11.getBytesEncoder)().encode(
+          new Uint8Array([
+            97,
+            105,
+            114,
+            100,
+            114,
+            111,
+            112,
+            95,
+            109,
+            97,
+            115,
+            116,
+            101,
+            114
+          ])
+        ),
+        (0, import_kit11.getAddressEncoder)().encode(expectAddress(accounts.creator.value))
+      ]
+    });
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.config),
+      getAccountMeta(accounts.airdropMaster),
+      getAccountMeta(accounts.protocolTreasury),
+      getAccountMeta(accounts.treasury),
+      getAccountMeta(accounts.affiliate),
+      getAccountMeta(accounts.creator),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    data: getInitializeAirdropMasterInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function getInitializeAirdropMasterInstruction(input, config) {
+  const programAddress = config?.programAddress ?? DROPSY_AIRDROP_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    config: { value: input.config ?? null, isWritable: false },
+    airdropMaster: { value: input.airdropMaster ?? null, isWritable: true },
+    protocolTreasury: {
+      value: input.protocolTreasury ?? null,
+      isWritable: true
+    },
+    treasury: { value: input.treasury ?? null, isWritable: false },
+    affiliate: { value: input.affiliate ?? null, isWritable: true },
+    creator: { value: input.creator ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  return Object.freeze({
+    accounts: [
+      getAccountMeta(accounts.config),
+      getAccountMeta(accounts.airdropMaster),
+      getAccountMeta(accounts.protocolTreasury),
+      getAccountMeta(accounts.treasury),
+      getAccountMeta(accounts.affiliate),
+      getAccountMeta(accounts.creator),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    data: getInitializeAirdropMasterInstructionDataEncoder().encode(
+      args
+    ),
+    programAddress
+  });
+}
+function parseInitializeAirdropMasterInstruction(instruction) {
+  if (instruction.accounts.length < 7) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  const getNextOptionalAccount = () => {
+    const accountMeta = getNextAccount();
+    return accountMeta.address === DROPSY_AIRDROP_PROGRAM_ADDRESS ? void 0 : accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      config: getNextAccount(),
+      airdropMaster: getNextAccount(),
+      protocolTreasury: getNextAccount(),
+      treasury: getNextAccount(),
+      affiliate: getNextOptionalAccount(),
+      creator: getNextAccount(),
+      systemProgram: getNextAccount()
+    },
+    data: getInitializeAirdropMasterInstructionDataDecoder().decode(
+      instruction.data
+    )
+  };
+}
+
+// src/programs/dropsyAirdrop.ts
+var DROPSY_AIRDROP_PROGRAM_ADDRESS = "3b97gLF94DDpa7sJQ8orbE3Ab6JQWBsDQTdQ5azoZqcz";
+var DropsyAirdropAccount = /* @__PURE__ */ ((DropsyAirdropAccount2) => {
+  DropsyAirdropAccount2[DropsyAirdropAccount2["Airdrop"] = 0] = "Airdrop";
+  DropsyAirdropAccount2[DropsyAirdropAccount2["AirdropConfig"] = 1] = "AirdropConfig";
+  DropsyAirdropAccount2[DropsyAirdropAccount2["AirdropMaster"] = 2] = "AirdropMaster";
+  DropsyAirdropAccount2[DropsyAirdropAccount2["BitmapAccount"] = 3] = "BitmapAccount";
+  return DropsyAirdropAccount2;
+})(DropsyAirdropAccount || {});
+function identifyDropsyAirdropAccount(account) {
+  const data = "data" in account ? account.data : account;
+  if ((0, import_kit12.containsBytes)(
+    data,
+    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
+      new Uint8Array([31, 112, 159, 158, 124, 237, 9, 241])
+    ),
+    0
+  )) {
+    return 0 /* Airdrop */;
+  }
+  if ((0, import_kit12.containsBytes)(
+    data,
+    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
+      new Uint8Array([194, 149, 223, 142, 42, 98, 128, 16])
+    ),
+    0
+  )) {
+    return 1 /* AirdropConfig */;
+  }
+  if ((0, import_kit12.containsBytes)(
+    data,
+    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
+      new Uint8Array([31, 109, 100, 62, 106, 173, 5, 4])
+    ),
+    0
+  )) {
+    return 2 /* AirdropMaster */;
+  }
+  if ((0, import_kit12.containsBytes)(
+    data,
+    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
+      new Uint8Array([152, 161, 147, 85, 213, 38, 59, 48])
+    ),
+    0
+  )) {
+    return 3 /* BitmapAccount */;
+  }
+  throw new Error(
+    "The provided account could not be identified as a dropsyAirdrop account."
+  );
+}
+var DropsyAirdropInstruction = /* @__PURE__ */ ((DropsyAirdropInstruction2) => {
+  DropsyAirdropInstruction2[DropsyAirdropInstruction2["ClaimAirdrop"] = 0] = "ClaimAirdrop";
+  DropsyAirdropInstruction2[DropsyAirdropInstruction2["CreateAirdrop"] = 1] = "CreateAirdrop";
+  DropsyAirdropInstruction2[DropsyAirdropInstruction2["CreateBitmap"] = 2] = "CreateBitmap";
+  DropsyAirdropInstruction2[DropsyAirdropInstruction2["DepositTokens"] = 3] = "DepositTokens";
+  DropsyAirdropInstruction2[DropsyAirdropInstruction2["InitializeAirdropConfig"] = 4] = "InitializeAirdropConfig";
+  DropsyAirdropInstruction2[DropsyAirdropInstruction2["InitializeAirdropMaster"] = 5] = "InitializeAirdropMaster";
+  return DropsyAirdropInstruction2;
+})(DropsyAirdropInstruction || {});
+function identifyDropsyAirdropInstruction(instruction) {
+  const data = "data" in instruction ? instruction.data : instruction;
+  if ((0, import_kit12.containsBytes)(
+    data,
+    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
+      new Uint8Array([137, 50, 122, 111, 89, 254, 8, 20])
+    ),
+    0
+  )) {
+    return 0 /* ClaimAirdrop */;
+  }
+  if ((0, import_kit12.containsBytes)(
+    data,
+    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
+      new Uint8Array([227, 135, 208, 66, 137, 177, 80, 94])
+    ),
+    0
+  )) {
+    return 1 /* CreateAirdrop */;
+  }
+  if ((0, import_kit12.containsBytes)(
+    data,
+    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
+      new Uint8Array([69, 92, 61, 190, 154, 237, 116, 247])
+    ),
+    0
+  )) {
+    return 2 /* CreateBitmap */;
+  }
+  if ((0, import_kit12.containsBytes)(
+    data,
+    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
+      new Uint8Array([176, 83, 229, 18, 191, 143, 176, 150])
+    ),
+    0
+  )) {
+    return 3 /* DepositTokens */;
+  }
+  if ((0, import_kit12.containsBytes)(
+    data,
+    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
+      new Uint8Array([160, 68, 127, 205, 130, 205, 156, 94])
+    ),
+    0
+  )) {
+    return 4 /* InitializeAirdropConfig */;
+  }
+  if ((0, import_kit12.containsBytes)(
+    data,
+    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
+      new Uint8Array([163, 197, 170, 44, 57, 57, 90, 65])
+    ),
+    0
+  )) {
+    return 5 /* InitializeAirdropMaster */;
+  }
+  throw new Error(
+    "The provided instruction could not be identified as a dropsyAirdrop instruction."
+  );
+}
+function parseDropsyAirdropInstruction(instruction) {
+  const instructionType = identifyDropsyAirdropInstruction(instruction);
+  switch (instructionType) {
+    case 0 /* ClaimAirdrop */: {
+      (0, import_kit12.assertIsInstructionWithAccounts)(instruction);
+      return {
+        instructionType: 0 /* ClaimAirdrop */,
+        ...parseClaimAirdropInstruction(instruction)
+      };
+    }
+    case 1 /* CreateAirdrop */: {
+      (0, import_kit12.assertIsInstructionWithAccounts)(instruction);
+      return {
+        instructionType: 1 /* CreateAirdrop */,
+        ...parseCreateAirdropInstruction(instruction)
+      };
+    }
+    case 2 /* CreateBitmap */: {
+      (0, import_kit12.assertIsInstructionWithAccounts)(instruction);
+      return {
+        instructionType: 2 /* CreateBitmap */,
+        ...parseCreateBitmapInstruction(instruction)
+      };
+    }
+    case 3 /* DepositTokens */: {
+      (0, import_kit12.assertIsInstructionWithAccounts)(instruction);
+      return {
+        instructionType: 3 /* DepositTokens */,
+        ...parseDepositTokensInstruction(instruction)
+      };
+    }
+    case 4 /* InitializeAirdropConfig */: {
+      (0, import_kit12.assertIsInstructionWithAccounts)(instruction);
+      return {
+        instructionType: 4 /* InitializeAirdropConfig */,
+        ...parseInitializeAirdropConfigInstruction(instruction)
+      };
+    }
+    case 5 /* InitializeAirdropMaster */: {
+      (0, import_kit12.assertIsInstructionWithAccounts)(instruction);
+      return {
+        instructionType: 5 /* InitializeAirdropMaster */,
+        ...parseInitializeAirdropMasterInstruction(instruction)
+      };
+    }
+    default:
+      throw new Error(
+        `Unrecognized instruction type: ${instructionType}`
+      );
+  }
+}
+
+// src/errors/dropsyAirdrop.ts
+var DROPSY_AIRDROP_ERROR__VALUE_OUT_OF_RANGE = 6001;
+var DROPSY_AIRDROP_ERROR__VALUE_BELOW_THE_MINIMUM = 6002;
+var DROPSY_AIRDROP_ERROR__VALUE_EXCEEDS_MAXIMUM = 6003;
+var DROPSY_AIRDROP_ERROR__INVALID_PERCENTAGE = 6004;
+var DROPSY_AIRDROP_ERROR__INVALID_TIMESTAMP = 6006;
+var DROPSY_AIRDROP_ERROR__NON_ZERO_VALUE_REQUIRED = 6007;
+var DROPSY_AIRDROP_ERROR__INVALID_PUB_KEY = 6008;
+var DROPSY_AIRDROP_ERROR__UN_AUTHORIZED = 6009;
+var DROPSY_AIRDROP_ERROR__INVALID_MUTABILITY = 6010;
+var DROPSY_AIRDROP_ERROR__INVALID_DELEGATE_PERMISSION = 6011;
+var DROPSY_AIRDROP_ERROR__CLAIM_FEE_TOO_HIGH = 6012;
+var DROPSY_AIRDROP_ERROR__ACTION_FEE_TOO_HIGH = 6013;
+var DROPSY_AIRDROP_ERROR__AIRDROP_NOT_STARTED = 6100;
+var DROPSY_AIRDROP_ERROR__AIRDROP_ENDED = 6101;
+var DROPSY_AIRDROP_ERROR__AIRDROP_NOT_ENDED = 6102;
+var DROPSY_AIRDROP_ERROR__DURATION_TOO_SHORT = 6103;
+var DROPSY_AIRDROP_ERROR__INVALID_END_TIME = 6104;
+var DROPSY_AIRDROP_ERROR__INVALID_VESTING_SCHEDULE = 6105;
+var DROPSY_AIRDROP_ERROR__IMMUTABLE_AIRDROP = 6106;
+var DROPSY_AIRDROP_ERROR__IMMUTABLE_FIELD = 6107;
+var DROPSY_AIRDROP_ERROR__UPDATE_CUTOFF_TIME_PASSED = 6108;
+var DROPSY_AIRDROP_ERROR__INVALID_ADMIN = 6200;
+var DROPSY_AIRDROP_ERROR__OWNER_MISMATCH = 6201;
+var DROPSY_AIRDROP_ERROR__INVALID_VAULT_AUTHORITY = 6202;
+var DROPSY_AIRDROP_ERROR__INVALID_DESTINATION_OWNER = 6203;
+var DROPSY_AIRDROP_ERROR__INVALID_AFFILIATE_PDA = 6204;
+var DROPSY_AIRDROP_ERROR__UNAUTHORIZED = 6205;
+var DROPSY_AIRDROP_ERROR__INVALID_OWNER = 6206;
+var DROPSY_AIRDROP_ERROR__INVALID_MINT = 6300;
+var DROPSY_AIRDROP_ERROR__MINT_MISMATCH = 6301;
+var DROPSY_AIRDROP_ERROR__VAULT_MINT_MISMATCH = 6302;
+var DROPSY_AIRDROP_ERROR__DESTINATION_MINT_MISMATCH = 6303;
+var DROPSY_AIRDROP_ERROR__MINT_IS_FROZEN = 6304;
+var DROPSY_AIRDROP_ERROR__INVALID_MINT_OWNER = 6305;
+var DROPSY_AIRDROP_ERROR__MINT_IS_NOT_INITIALIZED = 6306;
+var DROPSY_AIRDROP_ERROR__MINT_HAS_FREEZE_AUTHORITY = 6307;
+var DROPSY_AIRDROP_ERROR__NFT_NOT_ALLOWED = 6308;
+var DROPSY_AIRDROP_ERROR__VAULT_HAS_DELEGATE = 6401;
+var DROPSY_AIRDROP_ERROR__VAULT_FROZEN = 6402;
+var DROPSY_AIRDROP_ERROR__VAULT_HAS_CLOSE_AUTHORITY = 6403;
+var DROPSY_AIRDROP_ERROR__INVALID_AIRDROP_PDA = 6404;
+var DROPSY_AIRDROP_ERROR__VAULT_NOT_INITIALIZED = 6405;
+var DROPSY_AIRDROP_ERROR__INSUFFICIENT_VAULT_FUNDS = 6406;
+var DROPSY_AIRDROP_ERROR__SOURCE_HAS_DELEGATE = 6450;
+var DROPSY_AIRDROP_ERROR__SOURCE_ACCOUNT_FROZEN = 6451;
+var DROPSY_AIRDROP_ERROR__SOURCE_HAS_CLOSE_AUTHORITY = 6452;
+var DROPSY_AIRDROP_ERROR__INVALID_PROOF = 6500;
+var DROPSY_AIRDROP_ERROR__ALREADY_CLAIMED = 6501;
+var DROPSY_AIRDROP_ERROR__MISSING_BITMAP_PDA = 6502;
+var DROPSY_AIRDROP_ERROR__INVALID_BITMAP_ACCOUNT = 6503;
+var DROPSY_AIRDROP_ERROR__INVALID_BITMAP_INDEX = 6504;
+var DROPSY_AIRDROP_ERROR__TOO_MANY_BITMAPS = 6505;
+var DROPSY_AIRDROP_ERROR__BITMAP_TOO_LARGE = 6506;
+var DROPSY_AIRDROP_ERROR__INVALID_TOTAL = 6507;
+var DROPSY_AIRDROP_ERROR__BITMAP_AIRDROP_MISMATCH = 6508;
+var DROPSY_AIRDROP_ERROR__ACTIVE_BITMAPS_EXIST = 6509;
+var DROPSY_AIRDROP_ERROR__BITMAP_COUNT_UNDERFLOW = 6510;
+var DROPSY_AIRDROP_ERROR__INSUFFICIENT_DEPOSIT = 6600;
+var DROPSY_AIRDROP_ERROR__CREATE_FEE_TOO_HIGH = 6601;
+var DROPSY_AIRDROP_ERROR__INSUFFICIENT_FUNDS_FOR_FEE = 6603;
+var DROPSY_AIRDROP_ERROR__INVALID_FEE_VAULT = 6604;
+var DROPSY_AIRDROP_ERROR__INVALID_FEE_VAULT_OWNER = 6605;
+var DROPSY_AIRDROP_ERROR__INVALID_FEE_VAULT_CURVE = 6606;
+var DROPSY_AIRDROP_ERROR__INVALID_PDA = 6700;
+var DROPSY_AIRDROP_ERROR__INVALID_AMOUNT = 6701;
+var DROPSY_AIRDROP_ERROR__OVERFLOW = 6702;
+var DROPSY_AIRDROP_ERROR__VAULT_NOT_RENT_EXEMPT = 6703;
+var DROPSY_AIRDROP_ERROR__INVALID_TREASURY_ACCOUNT = 6704;
+var DROPSY_AIRDROP_ERROR__INVALID_AIRDROP_VERSION = 6705;
+var DROPSY_AIRDROP_ERROR__INVALID_VESTING_TYPE = 6707;
+var DROPSY_AIRDROP_ERROR__VESTING_ACCOUNT_REQUIRED = 6708;
+var DROPSY_AIRDROP_ERROR__INVALID_PARENT_ACCOUNT = 6709;
+var DROPSY_AIRDROP_ERROR__INVALID_AIRDROP_VESTING_VERSION = 6710;
+var dropsyAirdropErrorMessages;
+if (process.env.NODE_ENV !== "production") {
+  dropsyAirdropErrorMessages = {
+    [DROPSY_AIRDROP_ERROR__ACTION_FEE_TOO_HIGH]: `Action fee exceeds maximum allowed`,
+    [DROPSY_AIRDROP_ERROR__ACTIVE_BITMAPS_EXIST]: `Active bitmaps exist`,
+    [DROPSY_AIRDROP_ERROR__AIRDROP_ENDED]: `Airdrop has already ended`,
+    [DROPSY_AIRDROP_ERROR__AIRDROP_NOT_ENDED]: `Airdrop not yet ended`,
+    [DROPSY_AIRDROP_ERROR__AIRDROP_NOT_STARTED]: `Airdrop has not started yet`,
+    [DROPSY_AIRDROP_ERROR__ALREADY_CLAIMED]: `Tokens already claimed`,
+    [DROPSY_AIRDROP_ERROR__BITMAP_AIRDROP_MISMATCH]: `Bitmap/airdrop mismatch`,
+    [DROPSY_AIRDROP_ERROR__BITMAP_COUNT_UNDERFLOW]: `Bitmaps already closed`,
+    [DROPSY_AIRDROP_ERROR__BITMAP_TOO_LARGE]: `Bitmap size exceeds limit`,
+    [DROPSY_AIRDROP_ERROR__CLAIM_FEE_TOO_HIGH]: `Claim fee exceeds maximum allowed`,
+    [DROPSY_AIRDROP_ERROR__CREATE_FEE_TOO_HIGH]: `Create fee too high (>0.05 SOL)`,
+    [DROPSY_AIRDROP_ERROR__DESTINATION_MINT_MISMATCH]: `Destination mint doesn't match`,
+    [DROPSY_AIRDROP_ERROR__DURATION_TOO_SHORT]: `Airdrop duration must be at least 24 hours`,
+    [DROPSY_AIRDROP_ERROR__IMMUTABLE_AIRDROP]: `Airdrop is immutable`,
+    [DROPSY_AIRDROP_ERROR__IMMUTABLE_FIELD]: `The target field is immutable`,
+    [DROPSY_AIRDROP_ERROR__INSUFFICIENT_DEPOSIT]: `Insufficient SOL deposit`,
+    [DROPSY_AIRDROP_ERROR__INSUFFICIENT_FUNDS_FOR_FEE]: `Insufficient funds for fee`,
+    [DROPSY_AIRDROP_ERROR__INSUFFICIENT_VAULT_FUNDS]: `Insufficient vault funds`,
+    [DROPSY_AIRDROP_ERROR__INVALID_ADMIN]: `This Request Requires Admin Privileges`,
+    [DROPSY_AIRDROP_ERROR__INVALID_AFFILIATE_PDA]: `Mismatched affiliate PDA`,
+    [DROPSY_AIRDROP_ERROR__INVALID_AIRDROP_PDA]: `Invalid vault account`,
+    [DROPSY_AIRDROP_ERROR__INVALID_AIRDROP_VERSION]: `invalid airdrop version`,
+    [DROPSY_AIRDROP_ERROR__INVALID_AIRDROP_VESTING_VERSION]: `Airdrop version don't support vesting`,
+    [DROPSY_AIRDROP_ERROR__INVALID_AMOUNT]: `Invalid amount`,
+    [DROPSY_AIRDROP_ERROR__INVALID_BITMAP_ACCOUNT]: `Invalid bitmap account`,
+    [DROPSY_AIRDROP_ERROR__INVALID_BITMAP_INDEX]: `Invalid bitmap index`,
+    [DROPSY_AIRDROP_ERROR__INVALID_DELEGATE_PERMISSION]: `Invalid delegate permission Value`,
+    [DROPSY_AIRDROP_ERROR__INVALID_DESTINATION_OWNER]: `Destination account owner is not the signer`,
+    [DROPSY_AIRDROP_ERROR__INVALID_END_TIME]: `Airdrop must end at least 24 hours in the future`,
+    [DROPSY_AIRDROP_ERROR__INVALID_FEE_VAULT]: `Invalid fee vault`,
+    [DROPSY_AIRDROP_ERROR__INVALID_FEE_VAULT_CURVE]: `Fee vault not in curve`,
+    [DROPSY_AIRDROP_ERROR__INVALID_FEE_VAULT_OWNER]: `Invalid fee vault owner`,
+    [DROPSY_AIRDROP_ERROR__INVALID_MINT]: `Mint does not match stored state`,
+    [DROPSY_AIRDROP_ERROR__INVALID_MINT_OWNER]: `Invalid token program owner`,
+    [DROPSY_AIRDROP_ERROR__INVALID_MUTABILITY]: `Invalid mutability Value`,
+    [DROPSY_AIRDROP_ERROR__INVALID_OWNER]: `Transaction sender is not the owner`,
+    [DROPSY_AIRDROP_ERROR__INVALID_PARENT_ACCOUNT]: `Invalid Parent account provided`,
+    [DROPSY_AIRDROP_ERROR__INVALID_PDA]: `Invalid PDA account`,
+    [DROPSY_AIRDROP_ERROR__INVALID_PERCENTAGE]: `Invalid percentage (must be 0-100)`,
+    [DROPSY_AIRDROP_ERROR__INVALID_PROOF]: `Invalid merkle proof`,
+    [DROPSY_AIRDROP_ERROR__INVALID_PUB_KEY]: `Invalid Pubkey provided`,
+    [DROPSY_AIRDROP_ERROR__INVALID_TIMESTAMP]: `Invalid timestamp or duration`,
+    [DROPSY_AIRDROP_ERROR__INVALID_TOTAL]: `Invalid total claimers`,
+    [DROPSY_AIRDROP_ERROR__INVALID_TREASURY_ACCOUNT]: `invalid treasury account`,
+    [DROPSY_AIRDROP_ERROR__INVALID_VAULT_AUTHORITY]: `Invalid vault authority`,
+    [DROPSY_AIRDROP_ERROR__INVALID_VESTING_SCHEDULE]: `Vesting schedule is invalid`,
+    [DROPSY_AIRDROP_ERROR__INVALID_VESTING_TYPE]: `Invalid vesting type`,
+    [DROPSY_AIRDROP_ERROR__MINT_HAS_FREEZE_AUTHORITY]: `Mint has freeze authority`,
+    [DROPSY_AIRDROP_ERROR__MINT_IS_FROZEN]: `Mint is frozen`,
+    [DROPSY_AIRDROP_ERROR__MINT_IS_NOT_INITIALIZED]: `Mint must be initialized`,
+    [DROPSY_AIRDROP_ERROR__MINT_MISMATCH]: `Provided mint doesn't match expected mint`,
+    [DROPSY_AIRDROP_ERROR__MISSING_BITMAP_PDA]: `Missing bitmap PDA`,
+    [DROPSY_AIRDROP_ERROR__NFT_NOT_ALLOWED]: `Fungible tokens only (no NFTs)`,
+    [DROPSY_AIRDROP_ERROR__NON_ZERO_VALUE_REQUIRED]: `Number must be non-zero`,
+    [DROPSY_AIRDROP_ERROR__OVERFLOW]: `Arithmetic overflow`,
+    [DROPSY_AIRDROP_ERROR__OWNER_MISMATCH]: `Airdrop owner mismatch`,
+    [DROPSY_AIRDROP_ERROR__SOURCE_ACCOUNT_FROZEN]: `Source account is frozen`,
+    [DROPSY_AIRDROP_ERROR__SOURCE_HAS_CLOSE_AUTHORITY]: `Source has close authority`,
+    [DROPSY_AIRDROP_ERROR__SOURCE_HAS_DELEGATE]: `Source has delegate set`,
+    [DROPSY_AIRDROP_ERROR__TOO_MANY_BITMAPS]: `Too many bitmap accounts`,
+    [DROPSY_AIRDROP_ERROR__UNAUTHORIZED]: `Not Authorized`,
+    [DROPSY_AIRDROP_ERROR__UN_AUTHORIZED]: `Invalid Authority Pubkey`,
+    [DROPSY_AIRDROP_ERROR__UPDATE_CUTOFF_TIME_PASSED]: `Airdrop updates are only allowed until cutoff time before start`,
+    [DROPSY_AIRDROP_ERROR__VALUE_BELOW_THE_MINIMUM]: `Value below the minimum`,
+    [DROPSY_AIRDROP_ERROR__VALUE_EXCEEDS_MAXIMUM]: `Value exceeds the maximum`,
+    [DROPSY_AIRDROP_ERROR__VALUE_OUT_OF_RANGE]: `Value out of range`,
+    [DROPSY_AIRDROP_ERROR__VAULT_FROZEN]: `Vault is frozen`,
+    [DROPSY_AIRDROP_ERROR__VAULT_HAS_CLOSE_AUTHORITY]: `Vault has close authority`,
+    [DROPSY_AIRDROP_ERROR__VAULT_HAS_DELEGATE]: `Vault has delegate set`,
+    [DROPSY_AIRDROP_ERROR__VAULT_MINT_MISMATCH]: `Vault mint doesn't match airdrop mint`,
+    [DROPSY_AIRDROP_ERROR__VAULT_NOT_INITIALIZED]: `Vault not initialized`,
+    [DROPSY_AIRDROP_ERROR__VAULT_NOT_RENT_EXEMPT]: `Vault not rent exempt`,
+    [DROPSY_AIRDROP_ERROR__VESTING_ACCOUNT_REQUIRED]: `vesting account required for vested airdrop`
+  };
+}
+function getDropsyAirdropErrorMessage(code) {
+  if (process.env.NODE_ENV !== "production") {
+    return dropsyAirdropErrorMessages[code];
+  }
+  return "Error message not available in production bundles.";
+}
+function isDropsyAirdropError(error, transactionMessage, code) {
+  return (0, import_kit13.isProgramError)(
+    error,
+    transactionMessage,
+    DROPSY_AIRDROP_PROGRAM_ADDRESS,
+    code
+  );
+}
+
+// src/types/airdropInitialized.ts
+var import_kit14 = require("@solana/kit");
+function getAirdropInitializedEncoder() {
+  return (0, import_kit14.getStructEncoder)([
+    ["airdrop", (0, import_kit14.getAddressEncoder)()],
+    ["mint", (0, import_kit14.getAddressEncoder)()],
+    ["authority", (0, import_kit14.getAddressEncoder)()],
+    ["master", (0, import_kit14.getAddressEncoder)()],
+    ["merkleRoot", (0, import_kit14.fixEncoderSize)((0, import_kit14.getBytesEncoder)(), 32)],
+    ["startTime", (0, import_kit14.getI64Encoder)()],
+    ["endTime", (0, import_kit14.getI64Encoder)()],
+    ["timestamp", (0, import_kit14.getI64Encoder)()]
+  ]);
+}
+function getAirdropInitializedDecoder() {
+  return (0, import_kit14.getStructDecoder)([
+    ["airdrop", (0, import_kit14.getAddressDecoder)()],
+    ["mint", (0, import_kit14.getAddressDecoder)()],
+    ["authority", (0, import_kit14.getAddressDecoder)()],
+    ["master", (0, import_kit14.getAddressDecoder)()],
+    ["merkleRoot", (0, import_kit14.fixDecoderSize)((0, import_kit14.getBytesDecoder)(), 32)],
+    ["startTime", (0, import_kit14.getI64Decoder)()],
+    ["endTime", (0, import_kit14.getI64Decoder)()],
+    ["timestamp", (0, import_kit14.getI64Decoder)()]
+  ]);
+}
+function getAirdropInitializedCodec() {
+  return (0, import_kit14.combineCodec)(
+    getAirdropInitializedEncoder(),
+    getAirdropInitializedDecoder()
+  );
+}
+
+// src/types/bitmapClosed.ts
+var import_kit15 = require("@solana/kit");
+function getBitmapClosedEncoder() {
+  return (0, import_kit15.getStructEncoder)([
+    ["airdrop", (0, import_kit15.getAddressEncoder)()],
+    ["bitmap", (0, import_kit15.getAddressEncoder)()],
+    ["authority", (0, import_kit15.getAddressEncoder)()]
+  ]);
+}
+function getBitmapClosedDecoder() {
+  return (0, import_kit15.getStructDecoder)([
+    ["airdrop", (0, import_kit15.getAddressDecoder)()],
+    ["bitmap", (0, import_kit15.getAddressDecoder)()],
+    ["authority", (0, import_kit15.getAddressDecoder)()]
+  ]);
+}
+function getBitmapClosedCodec() {
+  return (0, import_kit15.combineCodec)(getBitmapClosedEncoder(), getBitmapClosedDecoder());
+}
+
+// src/types/bitmapInitialized.ts
+var import_kit16 = require("@solana/kit");
+function getBitmapInitializedEncoder() {
+  return (0, import_kit16.getStructEncoder)([
+    ["airdrop", (0, import_kit16.getAddressEncoder)()],
+    ["bitmap", (0, import_kit16.getAddressEncoder)()],
+    ["bitmapId", (0, import_kit16.getU16Encoder)()],
+    ["timestamp", (0, import_kit16.getI64Encoder)()]
+  ]);
+}
+function getBitmapInitializedDecoder() {
+  return (0, import_kit16.getStructDecoder)([
+    ["airdrop", (0, import_kit16.getAddressDecoder)()],
+    ["bitmap", (0, import_kit16.getAddressDecoder)()],
+    ["bitmapId", (0, import_kit16.getU16Decoder)()],
+    ["timestamp", (0, import_kit16.getI64Decoder)()]
+  ]);
+}
+function getBitmapInitializedCodec() {
+  return (0, import_kit16.combineCodec)(
+    getBitmapInitializedEncoder(),
+    getBitmapInitializedDecoder()
+  );
+}
+
+// src/types/tokensDeposited.ts
+var import_kit17 = require("@solana/kit");
+function getTokensDepositedEncoder() {
+  return (0, import_kit17.getStructEncoder)([
+    ["airdrop", (0, import_kit17.getAddressEncoder)()],
+    ["amount", (0, import_kit17.getU64Encoder)()],
+    ["newSupply", (0, import_kit17.getU64Encoder)()],
+    ["depositor", (0, import_kit17.getAddressEncoder)()],
+    ["timestamp", (0, import_kit17.getI64Encoder)()]
+  ]);
+}
+function getTokensDepositedDecoder() {
+  return (0, import_kit17.getStructDecoder)([
+    ["airdrop", (0, import_kit17.getAddressDecoder)()],
+    ["amount", (0, import_kit17.getU64Decoder)()],
+    ["newSupply", (0, import_kit17.getU64Decoder)()],
+    ["depositor", (0, import_kit17.getAddressDecoder)()],
+    ["timestamp", (0, import_kit17.getI64Decoder)()]
+  ]);
+}
+function getTokensDepositedCodec() {
+  return (0, import_kit17.combineCodec)(getTokensDepositedEncoder(), getTokensDepositedDecoder());
+}
+
+// src/types/tokensRedeemed.ts
+var import_kit18 = require("@solana/kit");
+function getTokensRedeemedEncoder() {
+  return (0, import_kit18.getStructEncoder)([
+    ["airdrop", (0, import_kit18.getAddressEncoder)()],
+    ["authority", (0, import_kit18.getAddressEncoder)()],
+    ["timestamp", (0, import_kit18.getI64Encoder)()]
+  ]);
+}
+function getTokensRedeemedDecoder() {
+  return (0, import_kit18.getStructDecoder)([
+    ["airdrop", (0, import_kit18.getAddressDecoder)()],
+    ["authority", (0, import_kit18.getAddressDecoder)()],
+    ["timestamp", (0, import_kit18.getI64Decoder)()]
+  ]);
+}
+function getTokensRedeemedCodec() {
+  return (0, import_kit18.combineCodec)(getTokensRedeemedEncoder(), getTokensRedeemedDecoder());
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AIRDROP_CONFIG_DISCRIMINATOR,
+  AIRDROP_DISCRIMINATOR,
+  AIRDROP_MASTER_DISCRIMINATOR,
+  BITMAP_ACCOUNT_DISCRIMINATOR,
+  CLAIM_AIRDROP_DISCRIMINATOR,
+  CREATE_AIRDROP_DISCRIMINATOR,
+  CREATE_BITMAP_DISCRIMINATOR,
+  DEPOSIT_TOKENS_DISCRIMINATOR,
+  DROPSY_AIRDROP_ERROR__ACTION_FEE_TOO_HIGH,
+  DROPSY_AIRDROP_ERROR__ACTIVE_BITMAPS_EXIST,
+  DROPSY_AIRDROP_ERROR__AIRDROP_ENDED,
+  DROPSY_AIRDROP_ERROR__AIRDROP_NOT_ENDED,
+  DROPSY_AIRDROP_ERROR__AIRDROP_NOT_STARTED,
+  DROPSY_AIRDROP_ERROR__ALREADY_CLAIMED,
+  DROPSY_AIRDROP_ERROR__BITMAP_AIRDROP_MISMATCH,
+  DROPSY_AIRDROP_ERROR__BITMAP_COUNT_UNDERFLOW,
+  DROPSY_AIRDROP_ERROR__BITMAP_TOO_LARGE,
+  DROPSY_AIRDROP_ERROR__CLAIM_FEE_TOO_HIGH,
+  DROPSY_AIRDROP_ERROR__CREATE_FEE_TOO_HIGH,
+  DROPSY_AIRDROP_ERROR__DESTINATION_MINT_MISMATCH,
+  DROPSY_AIRDROP_ERROR__DURATION_TOO_SHORT,
+  DROPSY_AIRDROP_ERROR__IMMUTABLE_AIRDROP,
+  DROPSY_AIRDROP_ERROR__IMMUTABLE_FIELD,
+  DROPSY_AIRDROP_ERROR__INSUFFICIENT_DEPOSIT,
+  DROPSY_AIRDROP_ERROR__INSUFFICIENT_FUNDS_FOR_FEE,
+  DROPSY_AIRDROP_ERROR__INSUFFICIENT_VAULT_FUNDS,
+  DROPSY_AIRDROP_ERROR__INVALID_ADMIN,
+  DROPSY_AIRDROP_ERROR__INVALID_AFFILIATE_PDA,
+  DROPSY_AIRDROP_ERROR__INVALID_AIRDROP_PDA,
+  DROPSY_AIRDROP_ERROR__INVALID_AIRDROP_VERSION,
+  DROPSY_AIRDROP_ERROR__INVALID_AIRDROP_VESTING_VERSION,
+  DROPSY_AIRDROP_ERROR__INVALID_AMOUNT,
+  DROPSY_AIRDROP_ERROR__INVALID_BITMAP_ACCOUNT,
+  DROPSY_AIRDROP_ERROR__INVALID_BITMAP_INDEX,
+  DROPSY_AIRDROP_ERROR__INVALID_DELEGATE_PERMISSION,
+  DROPSY_AIRDROP_ERROR__INVALID_DESTINATION_OWNER,
+  DROPSY_AIRDROP_ERROR__INVALID_END_TIME,
+  DROPSY_AIRDROP_ERROR__INVALID_FEE_VAULT,
+  DROPSY_AIRDROP_ERROR__INVALID_FEE_VAULT_CURVE,
+  DROPSY_AIRDROP_ERROR__INVALID_FEE_VAULT_OWNER,
+  DROPSY_AIRDROP_ERROR__INVALID_MINT,
+  DROPSY_AIRDROP_ERROR__INVALID_MINT_OWNER,
+  DROPSY_AIRDROP_ERROR__INVALID_MUTABILITY,
+  DROPSY_AIRDROP_ERROR__INVALID_OWNER,
+  DROPSY_AIRDROP_ERROR__INVALID_PARENT_ACCOUNT,
+  DROPSY_AIRDROP_ERROR__INVALID_PDA,
+  DROPSY_AIRDROP_ERROR__INVALID_PERCENTAGE,
+  DROPSY_AIRDROP_ERROR__INVALID_PROOF,
+  DROPSY_AIRDROP_ERROR__INVALID_PUB_KEY,
+  DROPSY_AIRDROP_ERROR__INVALID_TIMESTAMP,
+  DROPSY_AIRDROP_ERROR__INVALID_TOTAL,
+  DROPSY_AIRDROP_ERROR__INVALID_TREASURY_ACCOUNT,
+  DROPSY_AIRDROP_ERROR__INVALID_VAULT_AUTHORITY,
+  DROPSY_AIRDROP_ERROR__INVALID_VESTING_SCHEDULE,
+  DROPSY_AIRDROP_ERROR__INVALID_VESTING_TYPE,
+  DROPSY_AIRDROP_ERROR__MINT_HAS_FREEZE_AUTHORITY,
+  DROPSY_AIRDROP_ERROR__MINT_IS_FROZEN,
+  DROPSY_AIRDROP_ERROR__MINT_IS_NOT_INITIALIZED,
+  DROPSY_AIRDROP_ERROR__MINT_MISMATCH,
+  DROPSY_AIRDROP_ERROR__MISSING_BITMAP_PDA,
+  DROPSY_AIRDROP_ERROR__NFT_NOT_ALLOWED,
+  DROPSY_AIRDROP_ERROR__NON_ZERO_VALUE_REQUIRED,
+  DROPSY_AIRDROP_ERROR__OVERFLOW,
+  DROPSY_AIRDROP_ERROR__OWNER_MISMATCH,
+  DROPSY_AIRDROP_ERROR__SOURCE_ACCOUNT_FROZEN,
+  DROPSY_AIRDROP_ERROR__SOURCE_HAS_CLOSE_AUTHORITY,
+  DROPSY_AIRDROP_ERROR__SOURCE_HAS_DELEGATE,
+  DROPSY_AIRDROP_ERROR__TOO_MANY_BITMAPS,
+  DROPSY_AIRDROP_ERROR__UNAUTHORIZED,
+  DROPSY_AIRDROP_ERROR__UN_AUTHORIZED,
+  DROPSY_AIRDROP_ERROR__UPDATE_CUTOFF_TIME_PASSED,
+  DROPSY_AIRDROP_ERROR__VALUE_BELOW_THE_MINIMUM,
+  DROPSY_AIRDROP_ERROR__VALUE_EXCEEDS_MAXIMUM,
+  DROPSY_AIRDROP_ERROR__VALUE_OUT_OF_RANGE,
+  DROPSY_AIRDROP_ERROR__VAULT_FROZEN,
+  DROPSY_AIRDROP_ERROR__VAULT_HAS_CLOSE_AUTHORITY,
+  DROPSY_AIRDROP_ERROR__VAULT_HAS_DELEGATE,
+  DROPSY_AIRDROP_ERROR__VAULT_MINT_MISMATCH,
+  DROPSY_AIRDROP_ERROR__VAULT_NOT_INITIALIZED,
+  DROPSY_AIRDROP_ERROR__VAULT_NOT_RENT_EXEMPT,
+  DROPSY_AIRDROP_ERROR__VESTING_ACCOUNT_REQUIRED,
+  DROPSY_AIRDROP_PROGRAM_ADDRESS,
+  DropsyAirdropAccount,
+  DropsyAirdropInstruction,
+  INITIALIZE_AIRDROP_CONFIG_DISCRIMINATOR,
+  INITIALIZE_AIRDROP_MASTER_DISCRIMINATOR,
+  decodeAirdrop,
+  decodeAirdropConfig,
+  decodeAirdropMaster,
+  decodeBitmapAccount,
+  fetchAirdrop,
+  fetchAirdropConfig,
+  fetchAirdropMaster,
+  fetchAllAirdrop,
+  fetchAllAirdropConfig,
+  fetchAllAirdropMaster,
+  fetchAllBitmapAccount,
+  fetchAllMaybeAirdrop,
+  fetchAllMaybeAirdropConfig,
+  fetchAllMaybeAirdropMaster,
+  fetchAllMaybeBitmapAccount,
+  fetchBitmapAccount,
+  fetchMaybeAirdrop,
+  fetchMaybeAirdropConfig,
+  fetchMaybeAirdropMaster,
+  fetchMaybeBitmapAccount,
+  getAirdropCodec,
+  getAirdropConfigCodec,
+  getAirdropConfigDecoder,
+  getAirdropConfigDiscriminatorBytes,
+  getAirdropConfigEncoder,
+  getAirdropConfigSize,
+  getAirdropDecoder,
+  getAirdropDiscriminatorBytes,
+  getAirdropEncoder,
+  getAirdropInitializedCodec,
+  getAirdropInitializedDecoder,
+  getAirdropInitializedEncoder,
+  getAirdropMasterCodec,
+  getAirdropMasterDecoder,
+  getAirdropMasterDiscriminatorBytes,
+  getAirdropMasterEncoder,
+  getAirdropMasterSize,
+  getAirdropSize,
+  getBitmapAccountCodec,
+  getBitmapAccountDecoder,
+  getBitmapAccountDiscriminatorBytes,
+  getBitmapAccountEncoder,
+  getBitmapAccountSize,
+  getBitmapClosedCodec,
+  getBitmapClosedDecoder,
+  getBitmapClosedEncoder,
+  getBitmapInitializedCodec,
+  getBitmapInitializedDecoder,
+  getBitmapInitializedEncoder,
+  getClaimAirdropDiscriminatorBytes,
+  getClaimAirdropInstruction,
+  getClaimAirdropInstructionAsync,
+  getClaimAirdropInstructionDataCodec,
+  getClaimAirdropInstructionDataDecoder,
+  getClaimAirdropInstructionDataEncoder,
+  getCreateAirdropDiscriminatorBytes,
+  getCreateAirdropInstruction,
+  getCreateAirdropInstructionAsync,
+  getCreateAirdropInstructionDataCodec,
+  getCreateAirdropInstructionDataDecoder,
+  getCreateAirdropInstructionDataEncoder,
+  getCreateBitmapDiscriminatorBytes,
+  getCreateBitmapInstruction,
+  getCreateBitmapInstructionAsync,
+  getCreateBitmapInstructionDataCodec,
+  getCreateBitmapInstructionDataDecoder,
+  getCreateBitmapInstructionDataEncoder,
+  getDepositTokensDiscriminatorBytes,
+  getDepositTokensInstruction,
+  getDepositTokensInstructionAsync,
+  getDepositTokensInstructionDataCodec,
+  getDepositTokensInstructionDataDecoder,
+  getDepositTokensInstructionDataEncoder,
+  getDropsyAirdropErrorMessage,
+  getInitializeAirdropConfigDiscriminatorBytes,
+  getInitializeAirdropConfigInstruction,
+  getInitializeAirdropConfigInstructionAsync,
+  getInitializeAirdropConfigInstructionDataCodec,
+  getInitializeAirdropConfigInstructionDataDecoder,
+  getInitializeAirdropConfigInstructionDataEncoder,
+  getInitializeAirdropMasterDiscriminatorBytes,
+  getInitializeAirdropMasterInstruction,
+  getInitializeAirdropMasterInstructionAsync,
+  getInitializeAirdropMasterInstructionDataCodec,
+  getInitializeAirdropMasterInstructionDataDecoder,
+  getInitializeAirdropMasterInstructionDataEncoder,
+  getTokensDepositedCodec,
+  getTokensDepositedDecoder,
+  getTokensDepositedEncoder,
+  getTokensRedeemedCodec,
+  getTokensRedeemedDecoder,
+  getTokensRedeemedEncoder,
+  identifyDropsyAirdropAccount,
+  identifyDropsyAirdropInstruction,
+  isDropsyAirdropError,
+  parseClaimAirdropInstruction,
+  parseCreateAirdropInstruction,
+  parseCreateBitmapInstruction,
+  parseDepositTokensInstruction,
+  parseDropsyAirdropInstruction,
+  parseInitializeAirdropConfigInstruction,
+  parseInitializeAirdropMasterInstruction
+});
+//# sourceMappingURL=index.cjs.map