@dropsy/airdrop 0.0.1

package/dist/index.js

@@ -0,0 +1,1916 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+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);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AIRDROP_DISCRIMINATOR: () => AIRDROP_DISCRIMINATOR,
+  BITMAP_ACCOUNT_DISCRIMINATOR: () => BITMAP_ACCOUNT_DISCRIMINATOR,
+  CLAIM_TOKENS_DISCRIMINATOR: () => CLAIM_TOKENS_DISCRIMINATOR,
+  CLOSE_AIRDROP_DISCRIMINATOR: () => CLOSE_AIRDROP_DISCRIMINATOR,
+  CLOSE_BITMAP_DISCRIMINATOR: () => CLOSE_BITMAP_DISCRIMINATOR,
+  CONTROLLER_DISCRIMINATOR: () => CONTROLLER_DISCRIMINATOR,
+  DEPOSIT_TOKENS_DISCRIMINATOR: () => DEPOSIT_TOKENS_DISCRIMINATOR,
+  DROPSY_ERROR__ACTIVE_BITMAPS_EXIST: () => DROPSY_ERROR__ACTIVE_BITMAPS_EXIST,
+  DROPSY_ERROR__AIRDROP_ENDED: () => DROPSY_ERROR__AIRDROP_ENDED,
+  DROPSY_ERROR__AIRDROP_NOT_ENDED: () => DROPSY_ERROR__AIRDROP_NOT_ENDED,
+  DROPSY_ERROR__AIRDROP_NOT_STARTED: () => DROPSY_ERROR__AIRDROP_NOT_STARTED,
+  DROPSY_ERROR__ALREADY_CLAIMED: () => DROPSY_ERROR__ALREADY_CLAIMED,
+  DROPSY_ERROR__BITMAP_AIRDROP_MISMATCH: () => DROPSY_ERROR__BITMAP_AIRDROP_MISMATCH,
+  DROPSY_ERROR__BITMAP_COUNT_UNDERFLOW: () => DROPSY_ERROR__BITMAP_COUNT_UNDERFLOW,
+  DROPSY_ERROR__BITMAP_TOO_LARGE: () => DROPSY_ERROR__BITMAP_TOO_LARGE,
+  DROPSY_ERROR__CLAIM_FEE_TOO_HIGH: () => DROPSY_ERROR__CLAIM_FEE_TOO_HIGH,
+  DROPSY_ERROR__CONTROLLER_MISMATCH: () => DROPSY_ERROR__CONTROLLER_MISMATCH,
+  DROPSY_ERROR__CREATE_FEE_TOO_HIGH: () => DROPSY_ERROR__CREATE_FEE_TOO_HIGH,
+  DROPSY_ERROR__DESTINATION_MINT_MISMATCH: () => DROPSY_ERROR__DESTINATION_MINT_MISMATCH,
+  DROPSY_ERROR__DURATION_TOO_SHORT: () => DROPSY_ERROR__DURATION_TOO_SHORT,
+  DROPSY_ERROR__INSUFFICIENT_DEPOSIT: () => DROPSY_ERROR__INSUFFICIENT_DEPOSIT,
+  DROPSY_ERROR__INSUFFICIENT_FUNDS_FOR_FEE: () => DROPSY_ERROR__INSUFFICIENT_FUNDS_FOR_FEE,
+  DROPSY_ERROR__INSUFFICIENT_VAULT_FUNDS: () => DROPSY_ERROR__INSUFFICIENT_VAULT_FUNDS,
+  DROPSY_ERROR__INVALID_AIRDROP_PDA: () => DROPSY_ERROR__INVALID_AIRDROP_PDA,
+  DROPSY_ERROR__INVALID_AMOUNT: () => DROPSY_ERROR__INVALID_AMOUNT,
+  DROPSY_ERROR__INVALID_BITMAP_ACCOUNT: () => DROPSY_ERROR__INVALID_BITMAP_ACCOUNT,
+  DROPSY_ERROR__INVALID_BITMAP_INDEX: () => DROPSY_ERROR__INVALID_BITMAP_INDEX,
+  DROPSY_ERROR__INVALID_DESTINATION_OWNER: () => DROPSY_ERROR__INVALID_DESTINATION_OWNER,
+  DROPSY_ERROR__INVALID_END_TIME: () => DROPSY_ERROR__INVALID_END_TIME,
+  DROPSY_ERROR__INVALID_FEE_VAULT: () => DROPSY_ERROR__INVALID_FEE_VAULT,
+  DROPSY_ERROR__INVALID_FEE_VAULT_CURVE: () => DROPSY_ERROR__INVALID_FEE_VAULT_CURVE,
+  DROPSY_ERROR__INVALID_FEE_VAULT_OWNER: () => DROPSY_ERROR__INVALID_FEE_VAULT_OWNER,
+  DROPSY_ERROR__INVALID_MINT: () => DROPSY_ERROR__INVALID_MINT,
+  DROPSY_ERROR__INVALID_MINT_OWNER: () => DROPSY_ERROR__INVALID_MINT_OWNER,
+  DROPSY_ERROR__INVALID_OWNER: () => DROPSY_ERROR__INVALID_OWNER,
+  DROPSY_ERROR__INVALID_PDA: () => DROPSY_ERROR__INVALID_PDA,
+  DROPSY_ERROR__INVALID_PROOF: () => DROPSY_ERROR__INVALID_PROOF,
+  DROPSY_ERROR__INVALID_TOTAL: () => DROPSY_ERROR__INVALID_TOTAL,
+  DROPSY_ERROR__INVALID_TREASURY_ACCOUNT: () => DROPSY_ERROR__INVALID_TREASURY_ACCOUNT,
+  DROPSY_ERROR__INVALID_VAULT_AUTHORITY: () => DROPSY_ERROR__INVALID_VAULT_AUTHORITY,
+  DROPSY_ERROR__MINT_HAS_FREEZE_AUTHORITY: () => DROPSY_ERROR__MINT_HAS_FREEZE_AUTHORITY,
+  DROPSY_ERROR__MINT_IS_FROZEN: () => DROPSY_ERROR__MINT_IS_FROZEN,
+  DROPSY_ERROR__MINT_IS_NOT_INITIALIZED: () => DROPSY_ERROR__MINT_IS_NOT_INITIALIZED,
+  DROPSY_ERROR__MINT_MISMATCH: () => DROPSY_ERROR__MINT_MISMATCH,
+  DROPSY_ERROR__MISSING_BITMAP_PDA: () => DROPSY_ERROR__MISSING_BITMAP_PDA,
+  DROPSY_ERROR__NFT_NOT_ALLOWED: () => DROPSY_ERROR__NFT_NOT_ALLOWED,
+  DROPSY_ERROR__OVERFLOW: () => DROPSY_ERROR__OVERFLOW,
+  DROPSY_ERROR__OWNER_MISMATCH: () => DROPSY_ERROR__OWNER_MISMATCH,
+  DROPSY_ERROR__SOURCE_ACCOUNT_FROZEN: () => DROPSY_ERROR__SOURCE_ACCOUNT_FROZEN,
+  DROPSY_ERROR__SOURCE_HAS_CLOSE_AUTHORITY: () => DROPSY_ERROR__SOURCE_HAS_CLOSE_AUTHORITY,
+  DROPSY_ERROR__SOURCE_HAS_DELEGATE: () => DROPSY_ERROR__SOURCE_HAS_DELEGATE,
+  DROPSY_ERROR__TOO_MANY_BITMAPS: () => DROPSY_ERROR__TOO_MANY_BITMAPS,
+  DROPSY_ERROR__VAULT_FROZEN: () => DROPSY_ERROR__VAULT_FROZEN,
+  DROPSY_ERROR__VAULT_HAS_CLOSE_AUTHORITY: () => DROPSY_ERROR__VAULT_HAS_CLOSE_AUTHORITY,
+  DROPSY_ERROR__VAULT_HAS_DELEGATE: () => DROPSY_ERROR__VAULT_HAS_DELEGATE,
+  DROPSY_ERROR__VAULT_MINT_MISMATCH: () => DROPSY_ERROR__VAULT_MINT_MISMATCH,
+  DROPSY_ERROR__VAULT_NOT_INITIALIZED: () => DROPSY_ERROR__VAULT_NOT_INITIALIZED,
+  DROPSY_ERROR__VAULT_NOT_RENT_EXEMPT: () => DROPSY_ERROR__VAULT_NOT_RENT_EXEMPT,
+  DROPSY_PROGRAM_ADDRESS: () => DROPSY_PROGRAM_ADDRESS,
+  DropsyAccount: () => DropsyAccount,
+  DropsyInstruction: () => DropsyInstruction,
+  INITIALIZE_AIRDROP_DISCRIMINATOR: () => INITIALIZE_AIRDROP_DISCRIMINATOR,
+  INITIALIZE_BITMAP_DISCRIMINATOR: () => INITIALIZE_BITMAP_DISCRIMINATOR,
+  INITIALIZE_CONTROLLER_DISCRIMINATOR: () => INITIALIZE_CONTROLLER_DISCRIMINATOR,
+  decodeAirdrop: () => decodeAirdrop,
+  decodeBitmapAccount: () => decodeBitmapAccount,
+  decodeController: () => decodeController,
+  fetchAirdrop: () => fetchAirdrop,
+  fetchAllAirdrop: () => fetchAllAirdrop,
+  fetchAllBitmapAccount: () => fetchAllBitmapAccount,
+  fetchAllController: () => fetchAllController,
+  fetchAllMaybeAirdrop: () => fetchAllMaybeAirdrop,
+  fetchAllMaybeBitmapAccount: () => fetchAllMaybeBitmapAccount,
+  fetchAllMaybeController: () => fetchAllMaybeController,
+  fetchBitmapAccount: () => fetchBitmapAccount,
+  fetchController: () => fetchController,
+  fetchMaybeAirdrop: () => fetchMaybeAirdrop,
+  fetchMaybeBitmapAccount: () => fetchMaybeBitmapAccount,
+  fetchMaybeController: () => fetchMaybeController,
+  getAirdropClosedCodec: () => getAirdropClosedCodec,
+  getAirdropClosedDecoder: () => getAirdropClosedDecoder,
+  getAirdropClosedEncoder: () => getAirdropClosedEncoder,
+  getAirdropCodec: () => getAirdropCodec,
+  getAirdropDecoder: () => getAirdropDecoder,
+  getAirdropDiscriminatorBytes: () => getAirdropDiscriminatorBytes,
+  getAirdropEncoder: () => getAirdropEncoder,
+  getAirdropInitializedCodec: () => getAirdropInitializedCodec,
+  getAirdropInitializedDecoder: () => getAirdropInitializedDecoder,
+  getAirdropInitializedEncoder: () => getAirdropInitializedEncoder,
+  getBitmapAccountCodec: () => getBitmapAccountCodec,
+  getBitmapAccountDecoder: () => getBitmapAccountDecoder,
+  getBitmapAccountDiscriminatorBytes: () => getBitmapAccountDiscriminatorBytes,
+  getBitmapAccountEncoder: () => getBitmapAccountEncoder,
+  getBitmapClosedCodec: () => getBitmapClosedCodec,
+  getBitmapClosedDecoder: () => getBitmapClosedDecoder,
+  getBitmapClosedEncoder: () => getBitmapClosedEncoder,
+  getBitmapInitializedCodec: () => getBitmapInitializedCodec,
+  getBitmapInitializedDecoder: () => getBitmapInitializedDecoder,
+  getBitmapInitializedEncoder: () => getBitmapInitializedEncoder,
+  getClaimTokensDiscriminatorBytes: () => getClaimTokensDiscriminatorBytes,
+  getClaimTokensInstruction: () => getClaimTokensInstruction,
+  getClaimTokensInstructionDataCodec: () => getClaimTokensInstructionDataCodec,
+  getClaimTokensInstructionDataDecoder: () => getClaimTokensInstructionDataDecoder,
+  getClaimTokensInstructionDataEncoder: () => getClaimTokensInstructionDataEncoder,
+  getCloseAirdropDiscriminatorBytes: () => getCloseAirdropDiscriminatorBytes,
+  getCloseAirdropInstruction: () => getCloseAirdropInstruction,
+  getCloseAirdropInstructionDataCodec: () => getCloseAirdropInstructionDataCodec,
+  getCloseAirdropInstructionDataDecoder: () => getCloseAirdropInstructionDataDecoder,
+  getCloseAirdropInstructionDataEncoder: () => getCloseAirdropInstructionDataEncoder,
+  getCloseBitmapDiscriminatorBytes: () => getCloseBitmapDiscriminatorBytes,
+  getCloseBitmapInstruction: () => getCloseBitmapInstruction,
+  getCloseBitmapInstructionDataCodec: () => getCloseBitmapInstructionDataCodec,
+  getCloseBitmapInstructionDataDecoder: () => getCloseBitmapInstructionDataDecoder,
+  getCloseBitmapInstructionDataEncoder: () => getCloseBitmapInstructionDataEncoder,
+  getControllerCodec: () => getControllerCodec,
+  getControllerDecoder: () => getControllerDecoder,
+  getControllerDiscriminatorBytes: () => getControllerDiscriminatorBytes,
+  getControllerEncoder: () => getControllerEncoder,
+  getControllerInitializedCodec: () => getControllerInitializedCodec,
+  getControllerInitializedDecoder: () => getControllerInitializedDecoder,
+  getControllerInitializedEncoder: () => getControllerInitializedEncoder,
+  getDepositTokensDiscriminatorBytes: () => getDepositTokensDiscriminatorBytes,
+  getDepositTokensInstruction: () => getDepositTokensInstruction,
+  getDepositTokensInstructionDataCodec: () => getDepositTokensInstructionDataCodec,
+  getDepositTokensInstructionDataDecoder: () => getDepositTokensInstructionDataDecoder,
+  getDepositTokensInstructionDataEncoder: () => getDepositTokensInstructionDataEncoder,
+  getDropsyErrorMessage: () => getDropsyErrorMessage,
+  getInitializeAirdropDiscriminatorBytes: () => getInitializeAirdropDiscriminatorBytes,
+  getInitializeAirdropInstruction: () => getInitializeAirdropInstruction,
+  getInitializeAirdropInstructionAsync: () => getInitializeAirdropInstructionAsync,
+  getInitializeAirdropInstructionDataCodec: () => getInitializeAirdropInstructionDataCodec,
+  getInitializeAirdropInstructionDataDecoder: () => getInitializeAirdropInstructionDataDecoder,
+  getInitializeAirdropInstructionDataEncoder: () => getInitializeAirdropInstructionDataEncoder,
+  getInitializeBitmapDiscriminatorBytes: () => getInitializeBitmapDiscriminatorBytes,
+  getInitializeBitmapInstruction: () => getInitializeBitmapInstruction,
+  getInitializeBitmapInstructionAsync: () => getInitializeBitmapInstructionAsync,
+  getInitializeBitmapInstructionDataCodec: () => getInitializeBitmapInstructionDataCodec,
+  getInitializeBitmapInstructionDataDecoder: () => getInitializeBitmapInstructionDataDecoder,
+  getInitializeBitmapInstructionDataEncoder: () => getInitializeBitmapInstructionDataEncoder,
+  getInitializeControllerDiscriminatorBytes: () => getInitializeControllerDiscriminatorBytes,
+  getInitializeControllerInstruction: () => getInitializeControllerInstruction,
+  getInitializeControllerInstructionAsync: () => getInitializeControllerInstructionAsync,
+  getInitializeControllerInstructionDataCodec: () => getInitializeControllerInstructionDataCodec,
+  getInitializeControllerInstructionDataDecoder: () => getInitializeControllerInstructionDataDecoder,
+  getInitializeControllerInstructionDataEncoder: () => getInitializeControllerInstructionDataEncoder,
+  getTokensDepositedCodec: () => getTokensDepositedCodec,
+  getTokensDepositedDecoder: () => getTokensDepositedDecoder,
+  getTokensDepositedEncoder: () => getTokensDepositedEncoder,
+  identifyDropsyAccount: () => identifyDropsyAccount,
+  identifyDropsyInstruction: () => identifyDropsyInstruction,
+  isDropsyError: () => isDropsyError,
+  parseClaimTokensInstruction: () => parseClaimTokensInstruction,
+  parseCloseAirdropInstruction: () => parseCloseAirdropInstruction,
+  parseCloseBitmapInstruction: () => parseCloseBitmapInstruction,
+  parseDepositTokensInstruction: () => parseDepositTokensInstruction,
+  parseInitializeAirdropInstruction: () => parseInitializeAirdropInstruction,
+  parseInitializeBitmapInstruction: () => parseInitializeBitmapInstruction,
+  parseInitializeControllerInstruction: () => parseInitializeControllerInstruction
+});
+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)],
+      ["id", (0, import_kit.getU64Encoder)()],
+      ["mint", (0, import_kit.getAddressEncoder)()],
+      ["owner", (0, import_kit.getAddressEncoder)()],
+      ["controller", (0, import_kit.getAddressEncoder)()],
+      ["supply", (0, import_kit.getU64Encoder)()],
+      ["merkleRoot", (0, import_kit.getArrayEncoder)((0, import_kit.getU8Encoder)(), { size: 32 })],
+      ["startsAt", (0, import_kit.getI64Encoder)()],
+      ["endsAt", (0, import_kit.getI64Encoder)()],
+      ["bitmapCount", (0, import_kit.getU8Encoder)()],
+      ["version", (0, import_kit.getU8Encoder)()],
+      ["bump", (0, import_kit.getU8Encoder)()]
+    ]),
+    (value) => __spreadProps(__spreadValues({}, value), { discriminator: AIRDROP_DISCRIMINATOR })
+  );
+}
+function getAirdropDecoder() {
+  return (0, import_kit.getStructDecoder)([
+    ["discriminator", (0, import_kit.fixDecoderSize)((0, import_kit.getBytesDecoder)(), 8)],
+    ["id", (0, import_kit.getU64Decoder)()],
+    ["mint", (0, import_kit.getAddressDecoder)()],
+    ["owner", (0, import_kit.getAddressDecoder)()],
+    ["controller", (0, import_kit.getAddressDecoder)()],
+    ["supply", (0, import_kit.getU64Decoder)()],
+    ["merkleRoot", (0, import_kit.getArrayDecoder)((0, import_kit.getU8Decoder)(), { size: 32 })],
+    ["startsAt", (0, import_kit.getI64Decoder)()],
+    ["endsAt", (0, import_kit.getI64Decoder)()],
+    ["bitmapCount", (0, import_kit.getU8Decoder)()],
+    ["version", (0, import_kit.getU8Decoder)()],
+    ["bump", (0, import_kit.getU8Decoder)()]
+  ]);
+}
+function getAirdropCodec() {
+  return (0, import_kit.combineCodec)(getAirdropEncoder(), getAirdropDecoder());
+}
+function decodeAirdrop(encodedAccount) {
+  return (0, import_kit.decodeAccount)(
+    encodedAccount,
+    getAirdropDecoder()
+  );
+}
+function fetchAirdrop(rpc, address, config) {
+  return __async(this, null, function* () {
+    const maybeAccount = yield fetchMaybeAirdrop(rpc, address, config);
+    (0, import_kit.assertAccountExists)(maybeAccount);
+    return maybeAccount;
+  });
+}
+function fetchMaybeAirdrop(rpc, address, config) {
+  return __async(this, null, function* () {
+    const maybeAccount = yield (0, import_kit.fetchEncodedAccount)(rpc, address, config);
+    return decodeAirdrop(maybeAccount);
+  });
+}
+function fetchAllAirdrop(rpc, addresses, config) {
+  return __async(this, null, function* () {
+    const maybeAccounts = yield fetchAllMaybeAirdrop(rpc, addresses, config);
+    (0, import_kit.assertAccountsExist)(maybeAccounts);
+    return maybeAccounts;
+  });
+}
+function fetchAllMaybeAirdrop(rpc, addresses, config) {
+  return __async(this, null, function* () {
+    const maybeAccounts = yield (0, import_kit.fetchEncodedAccounts)(rpc, addresses, config);
+    return maybeAccounts.map((maybeAccount) => decodeAirdrop(maybeAccount));
+  });
+}
+
+// src/accounts/bitmapAccount.ts
+var import_kit2 = require("@solana/kit");
+var BITMAP_ACCOUNT_DISCRIMINATOR = new Uint8Array([
+  152,
+  161,
+  147,
+  85,
+  213,
+  38,
+  59,
+  48
+]);
+function getBitmapAccountDiscriminatorBytes() {
+  return (0, import_kit2.fixEncoderSize)((0, import_kit2.getBytesEncoder)(), 8).encode(
+    BITMAP_ACCOUNT_DISCRIMINATOR
+  );
+}
+function getBitmapAccountEncoder() {
+  return (0, import_kit2.transformEncoder)(
+    (0, import_kit2.getStructEncoder)([
+      ["discriminator", (0, import_kit2.fixEncoderSize)((0, import_kit2.getBytesEncoder)(), 8)],
+      ["owner", (0, import_kit2.getAddressEncoder)()],
+      ["airdrop", (0, import_kit2.getAddressEncoder)()],
+      [
+        "claimedBitmap",
+        (0, import_kit2.addEncoderSizePrefix)((0, import_kit2.getBytesEncoder)(), (0, import_kit2.getU32Encoder)())
+      ],
+      ["id", (0, import_kit2.getU8Encoder)()],
+      ["version", (0, import_kit2.getU8Encoder)()],
+      ["bump", (0, import_kit2.getU8Encoder)()]
+    ]),
+    (value) => __spreadProps(__spreadValues({}, value), { discriminator: BITMAP_ACCOUNT_DISCRIMINATOR })
+  );
+}
+function getBitmapAccountDecoder() {
+  return (0, import_kit2.getStructDecoder)([
+    ["discriminator", (0, import_kit2.fixDecoderSize)((0, import_kit2.getBytesDecoder)(), 8)],
+    ["owner", (0, import_kit2.getAddressDecoder)()],
+    ["airdrop", (0, import_kit2.getAddressDecoder)()],
+    ["claimedBitmap", (0, import_kit2.addDecoderSizePrefix)((0, import_kit2.getBytesDecoder)(), (0, import_kit2.getU32Decoder)())],
+    ["id", (0, import_kit2.getU8Decoder)()],
+    ["version", (0, import_kit2.getU8Decoder)()],
+    ["bump", (0, import_kit2.getU8Decoder)()]
+  ]);
+}
+function getBitmapAccountCodec() {
+  return (0, import_kit2.combineCodec)(getBitmapAccountEncoder(), getBitmapAccountDecoder());
+}
+function decodeBitmapAccount(encodedAccount) {
+  return (0, import_kit2.decodeAccount)(
+    encodedAccount,
+    getBitmapAccountDecoder()
+  );
+}
+function fetchBitmapAccount(rpc, address, config) {
+  return __async(this, null, function* () {
+    const maybeAccount = yield fetchMaybeBitmapAccount(rpc, address, config);
+    (0, import_kit2.assertAccountExists)(maybeAccount);
+    return maybeAccount;
+  });
+}
+function fetchMaybeBitmapAccount(rpc, address, config) {
+  return __async(this, null, function* () {
+    const maybeAccount = yield (0, import_kit2.fetchEncodedAccount)(rpc, address, config);
+    return decodeBitmapAccount(maybeAccount);
+  });
+}
+function fetchAllBitmapAccount(rpc, addresses, config) {
+  return __async(this, null, function* () {
+    const maybeAccounts = yield fetchAllMaybeBitmapAccount(
+      rpc,
+      addresses,
+      config
+    );
+    (0, import_kit2.assertAccountsExist)(maybeAccounts);
+    return maybeAccounts;
+  });
+}
+function fetchAllMaybeBitmapAccount(rpc, addresses, config) {
+  return __async(this, null, function* () {
+    const maybeAccounts = yield (0, import_kit2.fetchEncodedAccounts)(rpc, addresses, config);
+    return maybeAccounts.map((maybeAccount) => decodeBitmapAccount(maybeAccount));
+  });
+}
+
+// src/accounts/controller.ts
+var import_kit3 = require("@solana/kit");
+var CONTROLLER_DISCRIMINATOR = new Uint8Array([
+  184,
+  79,
+  171,
+  0,
+  183,
+  43,
+  113,
+  110
+]);
+function getControllerDiscriminatorBytes() {
+  return (0, import_kit3.fixEncoderSize)((0, import_kit3.getBytesEncoder)(), 8).encode(CONTROLLER_DISCRIMINATOR);
+}
+function getControllerEncoder() {
+  return (0, import_kit3.transformEncoder)(
+    (0, import_kit3.getStructEncoder)([
+      ["discriminator", (0, import_kit3.fixEncoderSize)((0, import_kit3.getBytesEncoder)(), 8)],
+      ["authority", (0, import_kit3.getAddressEncoder)()],
+      ["feeVault", (0, import_kit3.getAddressEncoder)()],
+      ["createFee", (0, import_kit3.getU64Encoder)()],
+      ["claimFee", (0, import_kit3.getU64Encoder)()],
+      ["version", (0, import_kit3.getU8Encoder)()],
+      ["bump", (0, import_kit3.getU8Encoder)()]
+    ]),
+    (value) => __spreadProps(__spreadValues({}, value), { discriminator: CONTROLLER_DISCRIMINATOR })
+  );
+}
+function getControllerDecoder() {
+  return (0, import_kit3.getStructDecoder)([
+    ["discriminator", (0, import_kit3.fixDecoderSize)((0, import_kit3.getBytesDecoder)(), 8)],
+    ["authority", (0, import_kit3.getAddressDecoder)()],
+    ["feeVault", (0, import_kit3.getAddressDecoder)()],
+    ["createFee", (0, import_kit3.getU64Decoder)()],
+    ["claimFee", (0, import_kit3.getU64Decoder)()],
+    ["version", (0, import_kit3.getU8Decoder)()],
+    ["bump", (0, import_kit3.getU8Decoder)()]
+  ]);
+}
+function getControllerCodec() {
+  return (0, import_kit3.combineCodec)(getControllerEncoder(), getControllerDecoder());
+}
+function decodeController(encodedAccount) {
+  return (0, import_kit3.decodeAccount)(
+    encodedAccount,
+    getControllerDecoder()
+  );
+}
+function fetchController(rpc, address, config) {
+  return __async(this, null, function* () {
+    const maybeAccount = yield fetchMaybeController(rpc, address, config);
+    (0, import_kit3.assertAccountExists)(maybeAccount);
+    return maybeAccount;
+  });
+}
+function fetchMaybeController(rpc, address, config) {
+  return __async(this, null, function* () {
+    const maybeAccount = yield (0, import_kit3.fetchEncodedAccount)(rpc, address, config);
+    return decodeController(maybeAccount);
+  });
+}
+function fetchAllController(rpc, addresses, config) {
+  return __async(this, null, function* () {
+    const maybeAccounts = yield fetchAllMaybeController(rpc, addresses, config);
+    (0, import_kit3.assertAccountsExist)(maybeAccounts);
+    return maybeAccounts;
+  });
+}
+function fetchAllMaybeController(rpc, addresses, config) {
+  return __async(this, null, function* () {
+    const maybeAccounts = yield (0, import_kit3.fetchEncodedAccounts)(rpc, addresses, config);
+    return maybeAccounts.map((maybeAccount) => decodeController(maybeAccount));
+  });
+}
+
+// src/errors/dropsy.ts
+var import_kit5 = require("@solana/kit");
+
+// src/programs/dropsy.ts
+var import_kit4 = require("@solana/kit");
+var DROPSY_PROGRAM_ADDRESS = "DropyEMekkCgKmsWiJVcTCAEeFgvHpDAW19ipWebFaPv";
+var DropsyAccount = /* @__PURE__ */ ((DropsyAccount2) => {
+  DropsyAccount2[DropsyAccount2["Airdrop"] = 0] = "Airdrop";
+  DropsyAccount2[DropsyAccount2["BitmapAccount"] = 1] = "BitmapAccount";
+  DropsyAccount2[DropsyAccount2["Controller"] = 2] = "Controller";
+  return DropsyAccount2;
+})(DropsyAccount || {});
+function identifyDropsyAccount(account) {
+  const data = "data" in account ? account.data : account;
+  if ((0, import_kit4.containsBytes)(
+    data,
+    (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8).encode(
+      new Uint8Array([31, 112, 159, 158, 124, 237, 9, 241])
+    ),
+    0
+  )) {
+    return 0 /* Airdrop */;
+  }
+  if ((0, import_kit4.containsBytes)(
+    data,
+    (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8).encode(
+      new Uint8Array([152, 161, 147, 85, 213, 38, 59, 48])
+    ),
+    0
+  )) {
+    return 1 /* BitmapAccount */;
+  }
+  if ((0, import_kit4.containsBytes)(
+    data,
+    (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8).encode(
+      new Uint8Array([184, 79, 171, 0, 183, 43, 113, 110])
+    ),
+    0
+  )) {
+    return 2 /* Controller */;
+  }
+  throw new Error(
+    "The provided account could not be identified as a dropsy account."
+  );
+}
+var DropsyInstruction = /* @__PURE__ */ ((DropsyInstruction2) => {
+  DropsyInstruction2[DropsyInstruction2["ClaimTokens"] = 0] = "ClaimTokens";
+  DropsyInstruction2[DropsyInstruction2["CloseAirdrop"] = 1] = "CloseAirdrop";
+  DropsyInstruction2[DropsyInstruction2["CloseBitmap"] = 2] = "CloseBitmap";
+  DropsyInstruction2[DropsyInstruction2["DepositTokens"] = 3] = "DepositTokens";
+  DropsyInstruction2[DropsyInstruction2["InitializeAirdrop"] = 4] = "InitializeAirdrop";
+  DropsyInstruction2[DropsyInstruction2["InitializeBitmap"] = 5] = "InitializeBitmap";
+  DropsyInstruction2[DropsyInstruction2["InitializeController"] = 6] = "InitializeController";
+  return DropsyInstruction2;
+})(DropsyInstruction || {});
+function identifyDropsyInstruction(instruction) {
+  const data = "data" in instruction ? instruction.data : instruction;
+  if ((0, import_kit4.containsBytes)(
+    data,
+    (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8).encode(
+      new Uint8Array([108, 216, 210, 231, 0, 212, 42, 64])
+    ),
+    0
+  )) {
+    return 0 /* ClaimTokens */;
+  }
+  if ((0, import_kit4.containsBytes)(
+    data,
+    (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8).encode(
+      new Uint8Array([85, 138, 99, 129, 104, 203, 94, 4])
+    ),
+    0
+  )) {
+    return 1 /* CloseAirdrop */;
+  }
+  if ((0, import_kit4.containsBytes)(
+    data,
+    (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8).encode(
+      new Uint8Array([59, 123, 115, 204, 163, 227, 37, 118])
+    ),
+    0
+  )) {
+    return 2 /* CloseBitmap */;
+  }
+  if ((0, import_kit4.containsBytes)(
+    data,
+    (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8).encode(
+      new Uint8Array([176, 83, 229, 18, 191, 143, 176, 150])
+    ),
+    0
+  )) {
+    return 3 /* DepositTokens */;
+  }
+  if ((0, import_kit4.containsBytes)(
+    data,
+    (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8).encode(
+      new Uint8Array([96, 196, 74, 102, 61, 195, 48, 184])
+    ),
+    0
+  )) {
+    return 4 /* InitializeAirdrop */;
+  }
+  if ((0, import_kit4.containsBytes)(
+    data,
+    (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8).encode(
+      new Uint8Array([25, 109, 200, 45, 209, 118, 74, 69])
+    ),
+    0
+  )) {
+    return 5 /* InitializeBitmap */;
+  }
+  if ((0, import_kit4.containsBytes)(
+    data,
+    (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8).encode(
+      new Uint8Array([137, 255, 100, 190, 201, 247, 241, 81])
+    ),
+    0
+  )) {
+    return 6 /* InitializeController */;
+  }
+  throw new Error(
+    "The provided instruction could not be identified as a dropsy instruction."
+  );
+}
+
+// src/errors/dropsy.ts
+var DROPSY_ERROR__AIRDROP_NOT_STARTED = 6100;
+var DROPSY_ERROR__AIRDROP_ENDED = 6101;
+var DROPSY_ERROR__AIRDROP_NOT_ENDED = 6102;
+var DROPSY_ERROR__DURATION_TOO_SHORT = 6103;
+var DROPSY_ERROR__INVALID_END_TIME = 6104;
+var DROPSY_ERROR__INVALID_OWNER = 6200;
+var DROPSY_ERROR__OWNER_MISMATCH = 6201;
+var DROPSY_ERROR__INVALID_VAULT_AUTHORITY = 6202;
+var DROPSY_ERROR__INVALID_DESTINATION_OWNER = 6203;
+var DROPSY_ERROR__CONTROLLER_MISMATCH = 6204;
+var DROPSY_ERROR__INVALID_MINT = 6300;
+var DROPSY_ERROR__MINT_MISMATCH = 6301;
+var DROPSY_ERROR__VAULT_MINT_MISMATCH = 6302;
+var DROPSY_ERROR__DESTINATION_MINT_MISMATCH = 6303;
+var DROPSY_ERROR__MINT_IS_FROZEN = 6304;
+var DROPSY_ERROR__INVALID_MINT_OWNER = 6305;
+var DROPSY_ERROR__MINT_IS_NOT_INITIALIZED = 6306;
+var DROPSY_ERROR__MINT_HAS_FREEZE_AUTHORITY = 6307;
+var DROPSY_ERROR__NFT_NOT_ALLOWED = 6308;
+var DROPSY_ERROR__VAULT_HAS_DELEGATE = 6401;
+var DROPSY_ERROR__VAULT_FROZEN = 6402;
+var DROPSY_ERROR__VAULT_HAS_CLOSE_AUTHORITY = 6403;
+var DROPSY_ERROR__INVALID_AIRDROP_PDA = 6404;
+var DROPSY_ERROR__VAULT_NOT_INITIALIZED = 6405;
+var DROPSY_ERROR__INSUFFICIENT_VAULT_FUNDS = 6406;
+var DROPSY_ERROR__SOURCE_HAS_DELEGATE = 6450;
+var DROPSY_ERROR__SOURCE_ACCOUNT_FROZEN = 6451;
+var DROPSY_ERROR__SOURCE_HAS_CLOSE_AUTHORITY = 6452;
+var DROPSY_ERROR__INVALID_PROOF = 6500;
+var DROPSY_ERROR__ALREADY_CLAIMED = 6501;
+var DROPSY_ERROR__MISSING_BITMAP_PDA = 6502;
+var DROPSY_ERROR__INVALID_BITMAP_ACCOUNT = 6503;
+var DROPSY_ERROR__INVALID_BITMAP_INDEX = 6504;
+var DROPSY_ERROR__TOO_MANY_BITMAPS = 6505;
+var DROPSY_ERROR__BITMAP_TOO_LARGE = 6506;
+var DROPSY_ERROR__INVALID_TOTAL = 6507;
+var DROPSY_ERROR__BITMAP_AIRDROP_MISMATCH = 6508;
+var DROPSY_ERROR__ACTIVE_BITMAPS_EXIST = 6509;
+var DROPSY_ERROR__BITMAP_COUNT_UNDERFLOW = 6510;
+var DROPSY_ERROR__INSUFFICIENT_DEPOSIT = 6600;
+var DROPSY_ERROR__CREATE_FEE_TOO_HIGH = 6601;
+var DROPSY_ERROR__CLAIM_FEE_TOO_HIGH = 6602;
+var DROPSY_ERROR__INSUFFICIENT_FUNDS_FOR_FEE = 6603;
+var DROPSY_ERROR__INVALID_FEE_VAULT = 6604;
+var DROPSY_ERROR__INVALID_FEE_VAULT_OWNER = 6605;
+var DROPSY_ERROR__INVALID_FEE_VAULT_CURVE = 6606;
+var DROPSY_ERROR__INVALID_PDA = 6700;
+var DROPSY_ERROR__INVALID_AMOUNT = 6701;
+var DROPSY_ERROR__OVERFLOW = 6702;
+var DROPSY_ERROR__VAULT_NOT_RENT_EXEMPT = 6703;
+var DROPSY_ERROR__INVALID_TREASURY_ACCOUNT = 6704;
+var dropsyErrorMessages;
+if (process.env.NODE_ENV !== "production") {
+  dropsyErrorMessages = {
+    [DROPSY_ERROR__ACTIVE_BITMAPS_EXIST]: `Active bitmaps exist`,
+    [DROPSY_ERROR__AIRDROP_ENDED]: `Airdrop has already ended`,
+    [DROPSY_ERROR__AIRDROP_NOT_ENDED]: `Airdrop not yet ended`,
+    [DROPSY_ERROR__AIRDROP_NOT_STARTED]: `Airdrop has not started yet`,
+    [DROPSY_ERROR__ALREADY_CLAIMED]: `Tokens already claimed`,
+    [DROPSY_ERROR__BITMAP_AIRDROP_MISMATCH]: `Bitmap/airdrop mismatch`,
+    [DROPSY_ERROR__BITMAP_COUNT_UNDERFLOW]: `Bitmaps already closed`,
+    [DROPSY_ERROR__BITMAP_TOO_LARGE]: `Bitmap size exceeds limit`,
+    [DROPSY_ERROR__CLAIM_FEE_TOO_HIGH]: `Claim fee too high (>0.005 SOL)`,
+    [DROPSY_ERROR__CONTROLLER_MISMATCH]: `Mismatched controller`,
+    [DROPSY_ERROR__CREATE_FEE_TOO_HIGH]: `Create fee too high (>0.05 SOL)`,
+    [DROPSY_ERROR__DESTINATION_MINT_MISMATCH]: `Destination mint doesn't match`,
+    [DROPSY_ERROR__DURATION_TOO_SHORT]: `Airdrop duration must be at least 24 hours`,
+    [DROPSY_ERROR__INSUFFICIENT_DEPOSIT]: `Insufficient SOL deposit`,
+    [DROPSY_ERROR__INSUFFICIENT_FUNDS_FOR_FEE]: `Insufficient funds for fee`,
+    [DROPSY_ERROR__INSUFFICIENT_VAULT_FUNDS]: `Insufficient vault funds`,
+    [DROPSY_ERROR__INVALID_AIRDROP_PDA]: `Invalid vault account`,
+    [DROPSY_ERROR__INVALID_AMOUNT]: `Invalid amount`,
+    [DROPSY_ERROR__INVALID_BITMAP_ACCOUNT]: `Invalid bitmap account`,
+    [DROPSY_ERROR__INVALID_BITMAP_INDEX]: `Invalid bitmap index`,
+    [DROPSY_ERROR__INVALID_DESTINATION_OWNER]: `Destination account owner is not the signer`,
+    [DROPSY_ERROR__INVALID_END_TIME]: `Airdrop must end at least 24 hours in the future`,
+    [DROPSY_ERROR__INVALID_FEE_VAULT]: `Invalid fee vault`,
+    [DROPSY_ERROR__INVALID_FEE_VAULT_CURVE]: `Fee vault not in curve`,
+    [DROPSY_ERROR__INVALID_FEE_VAULT_OWNER]: `Invalid fee vault owner`,
+    [DROPSY_ERROR__INVALID_MINT]: `Mint does not match stored state`,
+    [DROPSY_ERROR__INVALID_MINT_OWNER]: `Invalid token program owner`,
+    [DROPSY_ERROR__INVALID_OWNER]: `Transaction sender is not the owner`,
+    [DROPSY_ERROR__INVALID_PDA]: `Invalid PDA account`,
+    [DROPSY_ERROR__INVALID_PROOF]: `Invalid merkle proof`,
+    [DROPSY_ERROR__INVALID_TOTAL]: `Invalid total claimers`,
+    [DROPSY_ERROR__INVALID_TREASURY_ACCOUNT]: `invalid treasury account`,
+    [DROPSY_ERROR__INVALID_VAULT_AUTHORITY]: `Invalid vault authority`,
+    [DROPSY_ERROR__MINT_HAS_FREEZE_AUTHORITY]: `Mint has freeze authority`,
+    [DROPSY_ERROR__MINT_IS_FROZEN]: `Mint is frozen`,
+    [DROPSY_ERROR__MINT_IS_NOT_INITIALIZED]: `Mint must be initialized`,
+    [DROPSY_ERROR__MINT_MISMATCH]: `Provided mint doesn't match airdrop's mint`,
+    [DROPSY_ERROR__MISSING_BITMAP_PDA]: `Missing bitmap PDA`,
+    [DROPSY_ERROR__NFT_NOT_ALLOWED]: `Fungible tokens only (no NFTs)`,
+    [DROPSY_ERROR__OVERFLOW]: `Arithmetic overflow`,
+    [DROPSY_ERROR__OWNER_MISMATCH]: `Airdrop owner mismatch`,
+    [DROPSY_ERROR__SOURCE_ACCOUNT_FROZEN]: `Source account is frozen`,
+    [DROPSY_ERROR__SOURCE_HAS_CLOSE_AUTHORITY]: `Source has close authority`,
+    [DROPSY_ERROR__SOURCE_HAS_DELEGATE]: `Source has delegate set`,
+    [DROPSY_ERROR__TOO_MANY_BITMAPS]: `Too many bitmap accounts`,
+    [DROPSY_ERROR__VAULT_FROZEN]: `Vault is frozen`,
+    [DROPSY_ERROR__VAULT_HAS_CLOSE_AUTHORITY]: `Vault has close authority`,
+    [DROPSY_ERROR__VAULT_HAS_DELEGATE]: `Vault has delegate set`,
+    [DROPSY_ERROR__VAULT_MINT_MISMATCH]: `Vault mint doesn't match airdrop mint`,
+    [DROPSY_ERROR__VAULT_NOT_INITIALIZED]: `Vault not initialized`,
+    [DROPSY_ERROR__VAULT_NOT_RENT_EXEMPT]: `Vault not rent exempt`
+  };
+}
+function getDropsyErrorMessage(code) {
+  if (process.env.NODE_ENV !== "production") {
+    return dropsyErrorMessages[code];
+  }
+  return "Error message not available in production bundles.";
+}
+function isDropsyError(error, transactionMessage, code) {
+  return (0, import_kit5.isProgramError)(
+    error,
+    transactionMessage,
+    DROPSY_PROGRAM_ADDRESS,
+    code
+  );
+}
+
+// src/instructions/claimTokens.ts
+var import_kit7 = require("@solana/kit");
+
+// src/shared/index.ts
+var import_kit6 = require("@solana/kit");
+function expectSome(value) {
+  if (value == null) {
+    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_kit6.AccountRole.READONLY
+      });
+    }
+    const writableRole = account.isWritable ? import_kit6.AccountRole.WRITABLE : import_kit6.AccountRole.READONLY;
+    return Object.freeze(__spreadValues({
+      address: expectAddress(account.value),
+      role: isTransactionSigner(account.value) ? (0, import_kit6.upgradeRoleToSigner)(writableRole) : writableRole
+    }, isTransactionSigner(account.value) ? { signer: account.value } : {}));
+  };
+}
+function isTransactionSigner(value) {
+  return !!value && typeof value === "object" && "address" in value && (0, import_kit6.isTransactionSigner)(value);
+}
+
+// src/instructions/claimTokens.ts
+var CLAIM_TOKENS_DISCRIMINATOR = new Uint8Array([
+  108,
+  216,
+  210,
+  231,
+  0,
+  212,
+  42,
+  64
+]);
+function getClaimTokensDiscriminatorBytes() {
+  return (0, import_kit7.fixEncoderSize)((0, import_kit7.getBytesEncoder)(), 8).encode(
+    CLAIM_TOKENS_DISCRIMINATOR
+  );
+}
+function getClaimTokensInstructionDataEncoder() {
+  return (0, import_kit7.transformEncoder)(
+    (0, import_kit7.getStructEncoder)([
+      ["discriminator", (0, import_kit7.fixEncoderSize)((0, import_kit7.getBytesEncoder)(), 8)],
+      ["index", (0, import_kit7.getU64Encoder)()],
+      ["proof", (0, import_kit7.getArrayEncoder)((0, import_kit7.getArrayEncoder)((0, import_kit7.getU8Encoder)(), { size: 32 }))],
+      ["amount", (0, import_kit7.getU64Encoder)()]
+    ]),
+    (value) => __spreadProps(__spreadValues({}, value), { discriminator: CLAIM_TOKENS_DISCRIMINATOR })
+  );
+}
+function getClaimTokensInstructionDataDecoder() {
+  return (0, import_kit7.getStructDecoder)([
+    ["discriminator", (0, import_kit7.fixDecoderSize)((0, import_kit7.getBytesDecoder)(), 8)],
+    ["index", (0, import_kit7.getU64Decoder)()],
+    ["proof", (0, import_kit7.getArrayDecoder)((0, import_kit7.getArrayDecoder)((0, import_kit7.getU8Decoder)(), { size: 32 }))],
+    ["amount", (0, import_kit7.getU64Decoder)()]
+  ]);
+}
+function getClaimTokensInstructionDataCodec() {
+  return (0, import_kit7.combineCodec)(
+    getClaimTokensInstructionDataEncoder(),
+    getClaimTokensInstructionDataDecoder()
+  );
+}
+function getClaimTokensInstruction(input, config) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+  const programAddress = (_a = config == null ? void 0 : config.programAddress) != null ? _a : DROPSY_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    vault: { value: (_b = input.vault) != null ? _b : null, isWritable: true },
+    destinationTokenAccount: {
+      value: (_c = input.destinationTokenAccount) != null ? _c : null,
+      isWritable: true
+    },
+    airdrop: { value: (_d = input.airdrop) != null ? _d : null, isWritable: false },
+    bitmap: { value: (_e = input.bitmap) != null ? _e : null, isWritable: true },
+    mint: { value: (_f = input.mint) != null ? _f : null, isWritable: false },
+    feeVault: { value: (_g = input.feeVault) != null ? _g : null, isWritable: true },
+    controller: { value: (_h = input.controller) != null ? _h : null, isWritable: false },
+    claimer: { value: (_i = input.claimer) != null ? _i : null, isWritable: true },
+    treasury: { value: (_j = input.treasury) != null ? _j : null, isWritable: true },
+    tokenProgram: { value: (_k = input.tokenProgram) != null ? _k : null, isWritable: false },
+    systemProgram: { value: (_l = input.systemProgram) != null ? _l : null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = __spreadValues({}, input);
+  if (!accounts.treasury.value) {
+    accounts.treasury.value = "DHffy4rNMtuL8VKgyBEay4jcq8AYHyoAzxLKU6aEijUV";
+  }
+  if (!accounts.tokenProgram.value) {
+    accounts.tokenProgram.value = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  const instruction = {
+    accounts: [
+      getAccountMeta(accounts.vault),
+      getAccountMeta(accounts.destinationTokenAccount),
+      getAccountMeta(accounts.airdrop),
+      getAccountMeta(accounts.bitmap),
+      getAccountMeta(accounts.mint),
+      getAccountMeta(accounts.feeVault),
+      getAccountMeta(accounts.controller),
+      getAccountMeta(accounts.claimer),
+      getAccountMeta(accounts.treasury),
+      getAccountMeta(accounts.tokenProgram),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    programAddress,
+    data: getClaimTokensInstructionDataEncoder().encode(
+      args
+    )
+  };
+  return instruction;
+}
+function parseClaimTokensInstruction(instruction) {
+  if (instruction.accounts.length < 11) {
+    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: {
+      vault: getNextAccount(),
+      destinationTokenAccount: getNextAccount(),
+      airdrop: getNextAccount(),
+      bitmap: getNextAccount(),
+      mint: getNextAccount(),
+      feeVault: getNextAccount(),
+      controller: getNextAccount(),
+      claimer: getNextAccount(),
+      treasury: getNextAccount(),
+      tokenProgram: getNextAccount(),
+      systemProgram: getNextAccount()
+    },
+    data: getClaimTokensInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/instructions/closeAirdrop.ts
+var import_kit8 = require("@solana/kit");
+var CLOSE_AIRDROP_DISCRIMINATOR = new Uint8Array([
+  85,
+  138,
+  99,
+  129,
+  104,
+  203,
+  94,
+  4
+]);
+function getCloseAirdropDiscriminatorBytes() {
+  return (0, import_kit8.fixEncoderSize)((0, import_kit8.getBytesEncoder)(), 8).encode(
+    CLOSE_AIRDROP_DISCRIMINATOR
+  );
+}
+function getCloseAirdropInstructionDataEncoder() {
+  return (0, import_kit8.transformEncoder)(
+    (0, import_kit8.getStructEncoder)([["discriminator", (0, import_kit8.fixEncoderSize)((0, import_kit8.getBytesEncoder)(), 8)]]),
+    (value) => __spreadProps(__spreadValues({}, value), { discriminator: CLOSE_AIRDROP_DISCRIMINATOR })
+  );
+}
+function getCloseAirdropInstructionDataDecoder() {
+  return (0, import_kit8.getStructDecoder)([
+    ["discriminator", (0, import_kit8.fixDecoderSize)((0, import_kit8.getBytesDecoder)(), 8)]
+  ]);
+}
+function getCloseAirdropInstructionDataCodec() {
+  return (0, import_kit8.combineCodec)(
+    getCloseAirdropInstructionDataEncoder(),
+    getCloseAirdropInstructionDataDecoder()
+  );
+}
+function getCloseAirdropInstruction(input, config) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const programAddress = (_a = config == null ? void 0 : config.programAddress) != null ? _a : DROPSY_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    airdrop: { value: (_b = input.airdrop) != null ? _b : null, isWritable: true },
+    vault: { value: (_c = input.vault) != null ? _c : null, isWritable: true },
+    destinationTokenAccount: {
+      value: (_d = input.destinationTokenAccount) != null ? _d : null,
+      isWritable: true
+    },
+    owner: { value: (_e = input.owner) != null ? _e : null, isWritable: true },
+    mint: { value: (_f = input.mint) != null ? _f : null, isWritable: false },
+    tokenProgram: { value: (_g = input.tokenProgram) != null ? _g : null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  if (!accounts.tokenProgram.value) {
+    accounts.tokenProgram.value = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  const instruction = {
+    accounts: [
+      getAccountMeta(accounts.airdrop),
+      getAccountMeta(accounts.vault),
+      getAccountMeta(accounts.destinationTokenAccount),
+      getAccountMeta(accounts.owner),
+      getAccountMeta(accounts.mint),
+      getAccountMeta(accounts.tokenProgram)
+    ],
+    programAddress,
+    data: getCloseAirdropInstructionDataEncoder().encode({})
+  };
+  return instruction;
+}
+function parseCloseAirdropInstruction(instruction) {
+  if (instruction.accounts.length < 6) {
+    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: {
+      airdrop: getNextAccount(),
+      vault: getNextAccount(),
+      destinationTokenAccount: getNextAccount(),
+      owner: getNextAccount(),
+      mint: getNextAccount(),
+      tokenProgram: getNextAccount()
+    },
+    data: getCloseAirdropInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/instructions/closeBitmap.ts
+var import_kit9 = require("@solana/kit");
+var CLOSE_BITMAP_DISCRIMINATOR = new Uint8Array([
+  59,
+  123,
+  115,
+  204,
+  163,
+  227,
+  37,
+  118
+]);
+function getCloseBitmapDiscriminatorBytes() {
+  return (0, import_kit9.fixEncoderSize)((0, import_kit9.getBytesEncoder)(), 8).encode(
+    CLOSE_BITMAP_DISCRIMINATOR
+  );
+}
+function getCloseBitmapInstructionDataEncoder() {
+  return (0, import_kit9.transformEncoder)(
+    (0, import_kit9.getStructEncoder)([["discriminator", (0, import_kit9.fixEncoderSize)((0, import_kit9.getBytesEncoder)(), 8)]]),
+    (value) => __spreadProps(__spreadValues({}, value), { discriminator: CLOSE_BITMAP_DISCRIMINATOR })
+  );
+}
+function getCloseBitmapInstructionDataDecoder() {
+  return (0, import_kit9.getStructDecoder)([
+    ["discriminator", (0, import_kit9.fixDecoderSize)((0, import_kit9.getBytesDecoder)(), 8)]
+  ]);
+}
+function getCloseBitmapInstructionDataCodec() {
+  return (0, import_kit9.combineCodec)(
+    getCloseBitmapInstructionDataEncoder(),
+    getCloseBitmapInstructionDataDecoder()
+  );
+}
+function getCloseBitmapInstruction(input, config) {
+  var _a, _b, _c, _d;
+  const programAddress = (_a = config == null ? void 0 : config.programAddress) != null ? _a : DROPSY_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    airdrop: { value: (_b = input.airdrop) != null ? _b : null, isWritable: true },
+    bitmap: { value: (_c = input.bitmap) != null ? _c : null, isWritable: true },
+    owner: { value: (_d = input.owner) != null ? _d : null, isWritable: true }
+  };
+  const accounts = originalAccounts;
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  const instruction = {
+    accounts: [
+      getAccountMeta(accounts.airdrop),
+      getAccountMeta(accounts.bitmap),
+      getAccountMeta(accounts.owner)
+    ],
+    programAddress,
+    data: getCloseBitmapInstructionDataEncoder().encode({})
+  };
+  return instruction;
+}
+function parseCloseBitmapInstruction(instruction) {
+  if (instruction.accounts.length < 3) {
+    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: {
+      airdrop: getNextAccount(),
+      bitmap: getNextAccount(),
+      owner: getNextAccount()
+    },
+    data: getCloseBitmapInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/instructions/depositTokens.ts
+var import_kit10 = require("@solana/kit");
+var DEPOSIT_TOKENS_DISCRIMINATOR = new Uint8Array([
+  176,
+  83,
+  229,
+  18,
+  191,
+  143,
+  176,
+  150
+]);
+function getDepositTokensDiscriminatorBytes() {
+  return (0, import_kit10.fixEncoderSize)((0, import_kit10.getBytesEncoder)(), 8).encode(
+    DEPOSIT_TOKENS_DISCRIMINATOR
+  );
+}
+function getDepositTokensInstructionDataEncoder() {
+  return (0, import_kit10.transformEncoder)(
+    (0, import_kit10.getStructEncoder)([
+      ["discriminator", (0, import_kit10.fixEncoderSize)((0, import_kit10.getBytesEncoder)(), 8)],
+      ["amount", (0, import_kit10.getU64Encoder)()]
+    ]),
+    (value) => __spreadProps(__spreadValues({}, value), { discriminator: DEPOSIT_TOKENS_DISCRIMINATOR })
+  );
+}
+function getDepositTokensInstructionDataDecoder() {
+  return (0, import_kit10.getStructDecoder)([
+    ["discriminator", (0, import_kit10.fixDecoderSize)((0, import_kit10.getBytesDecoder)(), 8)],
+    ["amount", (0, import_kit10.getU64Decoder)()]
+  ]);
+}
+function getDepositTokensInstructionDataCodec() {
+  return (0, import_kit10.combineCodec)(
+    getDepositTokensInstructionDataEncoder(),
+    getDepositTokensInstructionDataDecoder()
+  );
+}
+function getDepositTokensInstruction(input, config) {
+  var _a, _b, _c, _d, _e, _f, _g;
+  const programAddress = (_a = config == null ? void 0 : config.programAddress) != null ? _a : DROPSY_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    sourceTokenAccount: {
+      value: (_b = input.sourceTokenAccount) != null ? _b : null,
+      isWritable: true
+    },
+    vault: { value: (_c = input.vault) != null ? _c : null, isWritable: true },
+    airdrop: { value: (_d = input.airdrop) != null ? _d : null, isWritable: true },
+    mint: { value: (_e = input.mint) != null ? _e : null, isWritable: false },
+    owner: { value: (_f = input.owner) != null ? _f : null, isWritable: false },
+    tokenProgram: { value: (_g = input.tokenProgram) != null ? _g : null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = __spreadValues({}, input);
+  if (!accounts.tokenProgram.value) {
+    accounts.tokenProgram.value = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  const instruction = {
+    accounts: [
+      getAccountMeta(accounts.sourceTokenAccount),
+      getAccountMeta(accounts.vault),
+      getAccountMeta(accounts.airdrop),
+      getAccountMeta(accounts.mint),
+      getAccountMeta(accounts.owner),
+      getAccountMeta(accounts.tokenProgram)
+    ],
+    programAddress,
+    data: getDepositTokensInstructionDataEncoder().encode(
+      args
+    )
+  };
+  return instruction;
+}
+function parseDepositTokensInstruction(instruction) {
+  if (instruction.accounts.length < 6) {
+    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(),
+      owner: getNextAccount(),
+      tokenProgram: getNextAccount()
+    },
+    data: getDepositTokensInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/instructions/initializeAirdrop.ts
+var import_kit11 = require("@solana/kit");
+var INITIALIZE_AIRDROP_DISCRIMINATOR = new Uint8Array([
+  96,
+  196,
+  74,
+  102,
+  61,
+  195,
+  48,
+  184
+]);
+function getInitializeAirdropDiscriminatorBytes() {
+  return (0, import_kit11.fixEncoderSize)((0, import_kit11.getBytesEncoder)(), 8).encode(
+    INITIALIZE_AIRDROP_DISCRIMINATOR
+  );
+}
+function getInitializeAirdropInstructionDataEncoder() {
+  return (0, import_kit11.transformEncoder)(
+    (0, import_kit11.getStructEncoder)([
+      ["discriminator", (0, import_kit11.fixEncoderSize)((0, import_kit11.getBytesEncoder)(), 8)],
+      ["id", (0, import_kit11.getU64Encoder)()],
+      ["merkleRoot", (0, import_kit11.getArrayEncoder)((0, import_kit11.getU8Encoder)(), { size: 32 })],
+      ["startsTime", (0, import_kit11.getI64Encoder)()],
+      ["endTime", (0, import_kit11.getI64Encoder)()]
+    ]),
+    (value) => __spreadProps(__spreadValues({}, value), { discriminator: INITIALIZE_AIRDROP_DISCRIMINATOR })
+  );
+}
+function getInitializeAirdropInstructionDataDecoder() {
+  return (0, import_kit11.getStructDecoder)([
+    ["discriminator", (0, import_kit11.fixDecoderSize)((0, import_kit11.getBytesDecoder)(), 8)],
+    ["id", (0, import_kit11.getU64Decoder)()],
+    ["merkleRoot", (0, import_kit11.getArrayDecoder)((0, import_kit11.getU8Decoder)(), { size: 32 })],
+    ["startsTime", (0, import_kit11.getI64Decoder)()],
+    ["endTime", (0, import_kit11.getI64Decoder)()]
+  ]);
+}
+function getInitializeAirdropInstructionDataCodec() {
+  return (0, import_kit11.combineCodec)(
+    getInitializeAirdropInstructionDataEncoder(),
+    getInitializeAirdropInstructionDataDecoder()
+  );
+}
+function getInitializeAirdropInstructionAsync(input, config) {
+  return __async(this, null, function* () {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const programAddress = (_a = config == null ? void 0 : config.programAddress) != null ? _a : DROPSY_PROGRAM_ADDRESS;
+    const originalAccounts = {
+      mint: { value: (_b = input.mint) != null ? _b : null, isWritable: false },
+      airdrop: { value: (_c = input.airdrop) != null ? _c : null, isWritable: true },
+      controller: { value: (_d = input.controller) != null ? _d : null, isWritable: true },
+      feeVault: { value: (_e = input.feeVault) != null ? _e : null, isWritable: true },
+      owner: { value: (_f = input.owner) != null ? _f : null, isWritable: true },
+      treasury: { value: (_g = input.treasury) != null ? _g : null, isWritable: true },
+      systemProgram: { value: (_h = input.systemProgram) != null ? _h : null, isWritable: false }
+    };
+    const accounts = originalAccounts;
+    const args = __spreadValues({}, input);
+    if (!accounts.airdrop.value) {
+      accounts.airdrop.value = yield (0, import_kit11.getProgramDerivedAddress)({
+        programAddress,
+        seeds: [
+          (0, import_kit11.getBytesEncoder)().encode(
+            new Uint8Array([97, 105, 114, 100, 114, 111, 112])
+          ),
+          (0, import_kit11.getAddressEncoder)().encode(expectAddress(accounts.mint.value)),
+          (0, import_kit11.getAddressEncoder)().encode(expectAddress(accounts.owner.value)),
+          (0, import_kit11.getU64Encoder)().encode(expectSome(args.id))
+        ]
+      });
+    }
+    if (!accounts.treasury.value) {
+      accounts.treasury.value = "DHffy4rNMtuL8VKgyBEay4jcq8AYHyoAzxLKU6aEijUV";
+    }
+    if (!accounts.systemProgram.value) {
+      accounts.systemProgram.value = "11111111111111111111111111111111";
+    }
+    const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+    const instruction = {
+      accounts: [
+        getAccountMeta(accounts.mint),
+        getAccountMeta(accounts.airdrop),
+        getAccountMeta(accounts.controller),
+        getAccountMeta(accounts.feeVault),
+        getAccountMeta(accounts.owner),
+        getAccountMeta(accounts.treasury),
+        getAccountMeta(accounts.systemProgram)
+      ],
+      programAddress,
+      data: getInitializeAirdropInstructionDataEncoder().encode(
+        args
+      )
+    };
+    return instruction;
+  });
+}
+function getInitializeAirdropInstruction(input, config) {
+  var _a, _b, _c, _d, _e, _f, _g, _h;
+  const programAddress = (_a = config == null ? void 0 : config.programAddress) != null ? _a : DROPSY_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    mint: { value: (_b = input.mint) != null ? _b : null, isWritable: false },
+    airdrop: { value: (_c = input.airdrop) != null ? _c : null, isWritable: true },
+    controller: { value: (_d = input.controller) != null ? _d : null, isWritable: true },
+    feeVault: { value: (_e = input.feeVault) != null ? _e : null, isWritable: true },
+    owner: { value: (_f = input.owner) != null ? _f : null, isWritable: true },
+    treasury: { value: (_g = input.treasury) != null ? _g : null, isWritable: true },
+    systemProgram: { value: (_h = input.systemProgram) != null ? _h : null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = __spreadValues({}, input);
+  if (!accounts.treasury.value) {
+    accounts.treasury.value = "DHffy4rNMtuL8VKgyBEay4jcq8AYHyoAzxLKU6aEijUV";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  const instruction = {
+    accounts: [
+      getAccountMeta(accounts.mint),
+      getAccountMeta(accounts.airdrop),
+      getAccountMeta(accounts.controller),
+      getAccountMeta(accounts.feeVault),
+      getAccountMeta(accounts.owner),
+      getAccountMeta(accounts.treasury),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    programAddress,
+    data: getInitializeAirdropInstructionDataEncoder().encode(
+      args
+    )
+  };
+  return instruction;
+}
+function parseInitializeAirdropInstruction(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;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      mint: getNextAccount(),
+      airdrop: getNextAccount(),
+      controller: getNextAccount(),
+      feeVault: getNextAccount(),
+      owner: getNextAccount(),
+      treasury: getNextAccount(),
+      systemProgram: getNextAccount()
+    },
+    data: getInitializeAirdropInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/instructions/initializeBitmap.ts
+var import_kit12 = require("@solana/kit");
+var INITIALIZE_BITMAP_DISCRIMINATOR = new Uint8Array([
+  25,
+  109,
+  200,
+  45,
+  209,
+  118,
+  74,
+  69
+]);
+function getInitializeBitmapDiscriminatorBytes() {
+  return (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
+    INITIALIZE_BITMAP_DISCRIMINATOR
+  );
+}
+function getInitializeBitmapInstructionDataEncoder() {
+  return (0, import_kit12.transformEncoder)(
+    (0, import_kit12.getStructEncoder)([
+      ["discriminator", (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8)],
+      ["id", (0, import_kit12.getU8Encoder)()],
+      ["total", (0, import_kit12.getU64Encoder)()]
+    ]),
+    (value) => __spreadProps(__spreadValues({}, value), { discriminator: INITIALIZE_BITMAP_DISCRIMINATOR })
+  );
+}
+function getInitializeBitmapInstructionDataDecoder() {
+  return (0, import_kit12.getStructDecoder)([
+    ["discriminator", (0, import_kit12.fixDecoderSize)((0, import_kit12.getBytesDecoder)(), 8)],
+    ["id", (0, import_kit12.getU8Decoder)()],
+    ["total", (0, import_kit12.getU64Decoder)()]
+  ]);
+}
+function getInitializeBitmapInstructionDataCodec() {
+  return (0, import_kit12.combineCodec)(
+    getInitializeBitmapInstructionDataEncoder(),
+    getInitializeBitmapInstructionDataDecoder()
+  );
+}
+function getInitializeBitmapInstructionAsync(input, config) {
+  return __async(this, null, function* () {
+    var _a, _b, _c, _d, _e;
+    const programAddress = (_a = config == null ? void 0 : config.programAddress) != null ? _a : DROPSY_PROGRAM_ADDRESS;
+    const originalAccounts = {
+      bitmap: { value: (_b = input.bitmap) != null ? _b : null, isWritable: true },
+      airdrop: { value: (_c = input.airdrop) != null ? _c : null, isWritable: true },
+      owner: { value: (_d = input.owner) != null ? _d : null, isWritable: true },
+      systemProgram: { value: (_e = input.systemProgram) != null ? _e : null, isWritable: false }
+    };
+    const accounts = originalAccounts;
+    const args = __spreadValues({}, input);
+    if (!accounts.bitmap.value) {
+      accounts.bitmap.value = yield (0, import_kit12.getProgramDerivedAddress)({
+        programAddress,
+        seeds: [
+          (0, import_kit12.getBytesEncoder)().encode(new Uint8Array([98, 105, 116, 109, 97, 112])),
+          (0, import_kit12.getAddressEncoder)().encode(expectAddress(accounts.airdrop.value)),
+          (0, import_kit12.getU8Encoder)().encode(expectSome(args.id))
+        ]
+      });
+    }
+    if (!accounts.systemProgram.value) {
+      accounts.systemProgram.value = "11111111111111111111111111111111";
+    }
+    const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+    const instruction = {
+      accounts: [
+        getAccountMeta(accounts.bitmap),
+        getAccountMeta(accounts.airdrop),
+        getAccountMeta(accounts.owner),
+        getAccountMeta(accounts.systemProgram)
+      ],
+      programAddress,
+      data: getInitializeBitmapInstructionDataEncoder().encode(
+        args
+      )
+    };
+    return instruction;
+  });
+}
+function getInitializeBitmapInstruction(input, config) {
+  var _a, _b, _c, _d, _e;
+  const programAddress = (_a = config == null ? void 0 : config.programAddress) != null ? _a : DROPSY_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    bitmap: { value: (_b = input.bitmap) != null ? _b : null, isWritable: true },
+    airdrop: { value: (_c = input.airdrop) != null ? _c : null, isWritable: true },
+    owner: { value: (_d = input.owner) != null ? _d : null, isWritable: true },
+    systemProgram: { value: (_e = input.systemProgram) != null ? _e : null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = __spreadValues({}, input);
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  const instruction = {
+    accounts: [
+      getAccountMeta(accounts.bitmap),
+      getAccountMeta(accounts.airdrop),
+      getAccountMeta(accounts.owner),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    programAddress,
+    data: getInitializeBitmapInstructionDataEncoder().encode(
+      args
+    )
+  };
+  return instruction;
+}
+function parseInitializeBitmapInstruction(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: {
+      bitmap: getNextAccount(),
+      airdrop: getNextAccount(),
+      owner: getNextAccount(),
+      systemProgram: getNextAccount()
+    },
+    data: getInitializeBitmapInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/instructions/initializeController.ts
+var import_kit13 = require("@solana/kit");
+var INITIALIZE_CONTROLLER_DISCRIMINATOR = new Uint8Array([
+  137,
+  255,
+  100,
+  190,
+  201,
+  247,
+  241,
+  81
+]);
+function getInitializeControllerDiscriminatorBytes() {
+  return (0, import_kit13.fixEncoderSize)((0, import_kit13.getBytesEncoder)(), 8).encode(
+    INITIALIZE_CONTROLLER_DISCRIMINATOR
+  );
+}
+function getInitializeControllerInstructionDataEncoder() {
+  return (0, import_kit13.transformEncoder)(
+    (0, import_kit13.getStructEncoder)([
+      ["discriminator", (0, import_kit13.fixEncoderSize)((0, import_kit13.getBytesEncoder)(), 8)],
+      ["createFee", (0, import_kit13.getU64Encoder)()],
+      ["claimFee", (0, import_kit13.getU64Encoder)()]
+    ]),
+    (value) => __spreadProps(__spreadValues({}, value), {
+      discriminator: INITIALIZE_CONTROLLER_DISCRIMINATOR
+    })
+  );
+}
+function getInitializeControllerInstructionDataDecoder() {
+  return (0, import_kit13.getStructDecoder)([
+    ["discriminator", (0, import_kit13.fixDecoderSize)((0, import_kit13.getBytesDecoder)(), 8)],
+    ["createFee", (0, import_kit13.getU64Decoder)()],
+    ["claimFee", (0, import_kit13.getU64Decoder)()]
+  ]);
+}
+function getInitializeControllerInstructionDataCodec() {
+  return (0, import_kit13.combineCodec)(
+    getInitializeControllerInstructionDataEncoder(),
+    getInitializeControllerInstructionDataDecoder()
+  );
+}
+function getInitializeControllerInstructionAsync(input, config) {
+  return __async(this, null, function* () {
+    var _a, _b, _c, _d, _e, _f;
+    const programAddress = (_a = config == null ? void 0 : config.programAddress) != null ? _a : DROPSY_PROGRAM_ADDRESS;
+    const originalAccounts = {
+      controller: { value: (_b = input.controller) != null ? _b : null, isWritable: true },
+      feeVault: { value: (_c = input.feeVault) != null ? _c : null, isWritable: false },
+      treasury: { value: (_d = input.treasury) != null ? _d : null, isWritable: true },
+      payer: { value: (_e = input.payer) != null ? _e : null, isWritable: true },
+      systemProgram: { value: (_f = input.systemProgram) != null ? _f : null, isWritable: false }
+    };
+    const accounts = originalAccounts;
+    const args = __spreadValues({}, input);
+    if (!accounts.controller.value) {
+      accounts.controller.value = yield (0, import_kit13.getProgramDerivedAddress)({
+        programAddress,
+        seeds: [
+          (0, import_kit13.getBytesEncoder)().encode(
+            new Uint8Array([
+              99,
+              111,
+              110,
+              116,
+              114,
+              111,
+              108,
+              108,
+              101,
+              114,
+              45,
+              100,
+              114,
+              111,
+              112,
+              115,
+              121
+            ])
+          ),
+          (0, import_kit13.getAddressEncoder)().encode(expectAddress(accounts.payer.value))
+        ]
+      });
+    }
+    if (!accounts.treasury.value) {
+      accounts.treasury.value = "DHffy4rNMtuL8VKgyBEay4jcq8AYHyoAzxLKU6aEijUV";
+    }
+    if (!accounts.systemProgram.value) {
+      accounts.systemProgram.value = "11111111111111111111111111111111";
+    }
+    const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+    const instruction = {
+      accounts: [
+        getAccountMeta(accounts.controller),
+        getAccountMeta(accounts.feeVault),
+        getAccountMeta(accounts.treasury),
+        getAccountMeta(accounts.payer),
+        getAccountMeta(accounts.systemProgram)
+      ],
+      programAddress,
+      data: getInitializeControllerInstructionDataEncoder().encode(
+        args
+      )
+    };
+    return instruction;
+  });
+}
+function getInitializeControllerInstruction(input, config) {
+  var _a, _b, _c, _d, _e, _f;
+  const programAddress = (_a = config == null ? void 0 : config.programAddress) != null ? _a : DROPSY_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    controller: { value: (_b = input.controller) != null ? _b : null, isWritable: true },
+    feeVault: { value: (_c = input.feeVault) != null ? _c : null, isWritable: false },
+    treasury: { value: (_d = input.treasury) != null ? _d : null, isWritable: true },
+    payer: { value: (_e = input.payer) != null ? _e : null, isWritable: true },
+    systemProgram: { value: (_f = input.systemProgram) != null ? _f : null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = __spreadValues({}, input);
+  if (!accounts.treasury.value) {
+    accounts.treasury.value = "DHffy4rNMtuL8VKgyBEay4jcq8AYHyoAzxLKU6aEijUV";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  const instruction = {
+    accounts: [
+      getAccountMeta(accounts.controller),
+      getAccountMeta(accounts.feeVault),
+      getAccountMeta(accounts.treasury),
+      getAccountMeta(accounts.payer),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    programAddress,
+    data: getInitializeControllerInstructionDataEncoder().encode(
+      args
+    )
+  };
+  return instruction;
+}
+function parseInitializeControllerInstruction(instruction) {
+  if (instruction.accounts.length < 5) {
+    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: {
+      controller: getNextAccount(),
+      feeVault: getNextAccount(),
+      treasury: getNextAccount(),
+      payer: getNextAccount(),
+      systemProgram: getNextAccount()
+    },
+    data: getInitializeControllerInstructionDataDecoder().decode(
+      instruction.data
+    )
+  };
+}
+
+// src/types/airdropClosed.ts
+var import_kit14 = require("@solana/kit");
+function getAirdropClosedEncoder() {
+  return (0, import_kit14.getStructEncoder)([
+    ["airdrop", (0, import_kit14.getAddressEncoder)()],
+    ["owner", (0, import_kit14.getAddressEncoder)()],
+    ["timestamp", (0, import_kit14.getI64Encoder)()]
+  ]);
+}
+function getAirdropClosedDecoder() {
+  return (0, import_kit14.getStructDecoder)([
+    ["airdrop", (0, import_kit14.getAddressDecoder)()],
+    ["owner", (0, import_kit14.getAddressDecoder)()],
+    ["timestamp", (0, import_kit14.getI64Decoder)()]
+  ]);
+}
+function getAirdropClosedCodec() {
+  return (0, import_kit14.combineCodec)(getAirdropClosedEncoder(), getAirdropClosedDecoder());
+}
+
+// src/types/airdropInitialized.ts
+var import_kit15 = require("@solana/kit");
+function getAirdropInitializedEncoder() {
+  return (0, import_kit15.getStructEncoder)([
+    ["airdrop", (0, import_kit15.getAddressEncoder)()],
+    ["mint", (0, import_kit15.getAddressEncoder)()],
+    ["owner", (0, import_kit15.getAddressEncoder)()],
+    ["controller", (0, import_kit15.getAddressEncoder)()],
+    ["controllerAuthority", (0, import_kit15.getAddressEncoder)()],
+    ["merkleRoot", (0, import_kit15.getArrayEncoder)((0, import_kit15.getU8Encoder)(), { size: 32 })],
+    ["startTime", (0, import_kit15.getI64Encoder)()],
+    ["endTime", (0, import_kit15.getI64Encoder)()],
+    ["timestamp", (0, import_kit15.getI64Encoder)()]
+  ]);
+}
+function getAirdropInitializedDecoder() {
+  return (0, import_kit15.getStructDecoder)([
+    ["airdrop", (0, import_kit15.getAddressDecoder)()],
+    ["mint", (0, import_kit15.getAddressDecoder)()],
+    ["owner", (0, import_kit15.getAddressDecoder)()],
+    ["controller", (0, import_kit15.getAddressDecoder)()],
+    ["controllerAuthority", (0, import_kit15.getAddressDecoder)()],
+    ["merkleRoot", (0, import_kit15.getArrayDecoder)((0, import_kit15.getU8Decoder)(), { size: 32 })],
+    ["startTime", (0, import_kit15.getI64Decoder)()],
+    ["endTime", (0, import_kit15.getI64Decoder)()],
+    ["timestamp", (0, import_kit15.getI64Decoder)()]
+  ]);
+}
+function getAirdropInitializedCodec() {
+  return (0, import_kit15.combineCodec)(
+    getAirdropInitializedEncoder(),
+    getAirdropInitializedDecoder()
+  );
+}
+
+// src/types/bitmapClosed.ts
+var import_kit16 = require("@solana/kit");
+function getBitmapClosedEncoder() {
+  return (0, import_kit16.getStructEncoder)([
+    ["airdrop", (0, import_kit16.getAddressEncoder)()],
+    ["bitmap", (0, import_kit16.getAddressEncoder)()],
+    ["owner", (0, import_kit16.getAddressEncoder)()]
+  ]);
+}
+function getBitmapClosedDecoder() {
+  return (0, import_kit16.getStructDecoder)([
+    ["airdrop", (0, import_kit16.getAddressDecoder)()],
+    ["bitmap", (0, import_kit16.getAddressDecoder)()],
+    ["owner", (0, import_kit16.getAddressDecoder)()]
+  ]);
+}
+function getBitmapClosedCodec() {
+  return (0, import_kit16.combineCodec)(getBitmapClosedEncoder(), getBitmapClosedDecoder());
+}
+
+// src/types/bitmapInitialized.ts
+var import_kit17 = require("@solana/kit");
+function getBitmapInitializedEncoder() {
+  return (0, import_kit17.getStructEncoder)([
+    ["airdrop", (0, import_kit17.getAddressEncoder)()],
+    ["bitmap", (0, import_kit17.getAddressEncoder)()],
+    ["bitmapId", (0, import_kit17.getU8Encoder)()],
+    ["totalClaims", (0, import_kit17.getU64Encoder)()]
+  ]);
+}
+function getBitmapInitializedDecoder() {
+  return (0, import_kit17.getStructDecoder)([
+    ["airdrop", (0, import_kit17.getAddressDecoder)()],
+    ["bitmap", (0, import_kit17.getAddressDecoder)()],
+    ["bitmapId", (0, import_kit17.getU8Decoder)()],
+    ["totalClaims", (0, import_kit17.getU64Decoder)()]
+  ]);
+}
+function getBitmapInitializedCodec() {
+  return (0, import_kit17.combineCodec)(
+    getBitmapInitializedEncoder(),
+    getBitmapInitializedDecoder()
+  );
+}
+
+// src/types/controllerInitialized.ts
+var import_kit18 = require("@solana/kit");
+function getControllerInitializedEncoder() {
+  return (0, import_kit18.getStructEncoder)([
+    ["authority", (0, import_kit18.getAddressEncoder)()],
+    ["feeVault", (0, import_kit18.getAddressEncoder)()],
+    ["createFee", (0, import_kit18.getU64Encoder)()],
+    ["claimFee", (0, import_kit18.getU64Encoder)()],
+    ["bump", (0, import_kit18.getU8Encoder)()],
+    ["timestamp", (0, import_kit18.getI64Encoder)()]
+  ]);
+}
+function getControllerInitializedDecoder() {
+  return (0, import_kit18.getStructDecoder)([
+    ["authority", (0, import_kit18.getAddressDecoder)()],
+    ["feeVault", (0, import_kit18.getAddressDecoder)()],
+    ["createFee", (0, import_kit18.getU64Decoder)()],
+    ["claimFee", (0, import_kit18.getU64Decoder)()],
+    ["bump", (0, import_kit18.getU8Decoder)()],
+    ["timestamp", (0, import_kit18.getI64Decoder)()]
+  ]);
+}
+function getControllerInitializedCodec() {
+  return (0, import_kit18.combineCodec)(
+    getControllerInitializedEncoder(),
+    getControllerInitializedDecoder()
+  );
+}
+
+// src/types/tokensDeposited.ts
+var import_kit19 = require("@solana/kit");
+function getTokensDepositedEncoder() {
+  return (0, import_kit19.getStructEncoder)([
+    ["airdrop", (0, import_kit19.getAddressEncoder)()],
+    ["amount", (0, import_kit19.getU64Encoder)()],
+    ["newSupply", (0, import_kit19.getU64Encoder)()],
+    ["depositor", (0, import_kit19.getAddressEncoder)()],
+    ["timestamp", (0, import_kit19.getI64Encoder)()]
+  ]);
+}
+function getTokensDepositedDecoder() {
+  return (0, import_kit19.getStructDecoder)([
+    ["airdrop", (0, import_kit19.getAddressDecoder)()],
+    ["amount", (0, import_kit19.getU64Decoder)()],
+    ["newSupply", (0, import_kit19.getU64Decoder)()],
+    ["depositor", (0, import_kit19.getAddressDecoder)()],
+    ["timestamp", (0, import_kit19.getI64Decoder)()]
+  ]);
+}
+function getTokensDepositedCodec() {
+  return (0, import_kit19.combineCodec)(getTokensDepositedEncoder(), getTokensDepositedDecoder());
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AIRDROP_DISCRIMINATOR,
+  BITMAP_ACCOUNT_DISCRIMINATOR,
+  CLAIM_TOKENS_DISCRIMINATOR,
+  CLOSE_AIRDROP_DISCRIMINATOR,
+  CLOSE_BITMAP_DISCRIMINATOR,
+  CONTROLLER_DISCRIMINATOR,
+  DEPOSIT_TOKENS_DISCRIMINATOR,
+  DROPSY_ERROR__ACTIVE_BITMAPS_EXIST,
+  DROPSY_ERROR__AIRDROP_ENDED,
+  DROPSY_ERROR__AIRDROP_NOT_ENDED,
+  DROPSY_ERROR__AIRDROP_NOT_STARTED,
+  DROPSY_ERROR__ALREADY_CLAIMED,
+  DROPSY_ERROR__BITMAP_AIRDROP_MISMATCH,
+  DROPSY_ERROR__BITMAP_COUNT_UNDERFLOW,
+  DROPSY_ERROR__BITMAP_TOO_LARGE,
+  DROPSY_ERROR__CLAIM_FEE_TOO_HIGH,
+  DROPSY_ERROR__CONTROLLER_MISMATCH,
+  DROPSY_ERROR__CREATE_FEE_TOO_HIGH,
+  DROPSY_ERROR__DESTINATION_MINT_MISMATCH,
+  DROPSY_ERROR__DURATION_TOO_SHORT,
+  DROPSY_ERROR__INSUFFICIENT_DEPOSIT,
+  DROPSY_ERROR__INSUFFICIENT_FUNDS_FOR_FEE,
+  DROPSY_ERROR__INSUFFICIENT_VAULT_FUNDS,
+  DROPSY_ERROR__INVALID_AIRDROP_PDA,
+  DROPSY_ERROR__INVALID_AMOUNT,
+  DROPSY_ERROR__INVALID_BITMAP_ACCOUNT,
+  DROPSY_ERROR__INVALID_BITMAP_INDEX,
+  DROPSY_ERROR__INVALID_DESTINATION_OWNER,
+  DROPSY_ERROR__INVALID_END_TIME,
+  DROPSY_ERROR__INVALID_FEE_VAULT,
+  DROPSY_ERROR__INVALID_FEE_VAULT_CURVE,
+  DROPSY_ERROR__INVALID_FEE_VAULT_OWNER,
+  DROPSY_ERROR__INVALID_MINT,
+  DROPSY_ERROR__INVALID_MINT_OWNER,
+  DROPSY_ERROR__INVALID_OWNER,
+  DROPSY_ERROR__INVALID_PDA,
+  DROPSY_ERROR__INVALID_PROOF,
+  DROPSY_ERROR__INVALID_TOTAL,
+  DROPSY_ERROR__INVALID_TREASURY_ACCOUNT,
+  DROPSY_ERROR__INVALID_VAULT_AUTHORITY,
+  DROPSY_ERROR__MINT_HAS_FREEZE_AUTHORITY,
+  DROPSY_ERROR__MINT_IS_FROZEN,
+  DROPSY_ERROR__MINT_IS_NOT_INITIALIZED,
+  DROPSY_ERROR__MINT_MISMATCH,
+  DROPSY_ERROR__MISSING_BITMAP_PDA,
+  DROPSY_ERROR__NFT_NOT_ALLOWED,
+  DROPSY_ERROR__OVERFLOW,
+  DROPSY_ERROR__OWNER_MISMATCH,
+  DROPSY_ERROR__SOURCE_ACCOUNT_FROZEN,
+  DROPSY_ERROR__SOURCE_HAS_CLOSE_AUTHORITY,
+  DROPSY_ERROR__SOURCE_HAS_DELEGATE,
+  DROPSY_ERROR__TOO_MANY_BITMAPS,
+  DROPSY_ERROR__VAULT_FROZEN,
+  DROPSY_ERROR__VAULT_HAS_CLOSE_AUTHORITY,
+  DROPSY_ERROR__VAULT_HAS_DELEGATE,
+  DROPSY_ERROR__VAULT_MINT_MISMATCH,
+  DROPSY_ERROR__VAULT_NOT_INITIALIZED,
+  DROPSY_ERROR__VAULT_NOT_RENT_EXEMPT,
+  DROPSY_PROGRAM_ADDRESS,
+  DropsyAccount,
+  DropsyInstruction,
+  INITIALIZE_AIRDROP_DISCRIMINATOR,
+  INITIALIZE_BITMAP_DISCRIMINATOR,
+  INITIALIZE_CONTROLLER_DISCRIMINATOR,
+  decodeAirdrop,
+  decodeBitmapAccount,
+  decodeController,
+  fetchAirdrop,
+  fetchAllAirdrop,
+  fetchAllBitmapAccount,
+  fetchAllController,
+  fetchAllMaybeAirdrop,
+  fetchAllMaybeBitmapAccount,
+  fetchAllMaybeController,
+  fetchBitmapAccount,
+  fetchController,
+  fetchMaybeAirdrop,
+  fetchMaybeBitmapAccount,
+  fetchMaybeController,
+  getAirdropClosedCodec,
+  getAirdropClosedDecoder,
+  getAirdropClosedEncoder,
+  getAirdropCodec,
+  getAirdropDecoder,
+  getAirdropDiscriminatorBytes,
+  getAirdropEncoder,
+  getAirdropInitializedCodec,
+  getAirdropInitializedDecoder,
+  getAirdropInitializedEncoder,
+  getBitmapAccountCodec,
+  getBitmapAccountDecoder,
+  getBitmapAccountDiscriminatorBytes,
+  getBitmapAccountEncoder,
+  getBitmapClosedCodec,
+  getBitmapClosedDecoder,
+  getBitmapClosedEncoder,
+  getBitmapInitializedCodec,
+  getBitmapInitializedDecoder,
+  getBitmapInitializedEncoder,
+  getClaimTokensDiscriminatorBytes,
+  getClaimTokensInstruction,
+  getClaimTokensInstructionDataCodec,
+  getClaimTokensInstructionDataDecoder,
+  getClaimTokensInstructionDataEncoder,
+  getCloseAirdropDiscriminatorBytes,
+  getCloseAirdropInstruction,
+  getCloseAirdropInstructionDataCodec,
+  getCloseAirdropInstructionDataDecoder,
+  getCloseAirdropInstructionDataEncoder,
+  getCloseBitmapDiscriminatorBytes,
+  getCloseBitmapInstruction,
+  getCloseBitmapInstructionDataCodec,
+  getCloseBitmapInstructionDataDecoder,
+  getCloseBitmapInstructionDataEncoder,
+  getControllerCodec,
+  getControllerDecoder,
+  getControllerDiscriminatorBytes,
+  getControllerEncoder,
+  getControllerInitializedCodec,
+  getControllerInitializedDecoder,
+  getControllerInitializedEncoder,
+  getDepositTokensDiscriminatorBytes,
+  getDepositTokensInstruction,
+  getDepositTokensInstructionDataCodec,
+  getDepositTokensInstructionDataDecoder,
+  getDepositTokensInstructionDataEncoder,
+  getDropsyErrorMessage,
+  getInitializeAirdropDiscriminatorBytes,
+  getInitializeAirdropInstruction,
+  getInitializeAirdropInstructionAsync,
+  getInitializeAirdropInstructionDataCodec,
+  getInitializeAirdropInstructionDataDecoder,
+  getInitializeAirdropInstructionDataEncoder,
+  getInitializeBitmapDiscriminatorBytes,
+  getInitializeBitmapInstruction,
+  getInitializeBitmapInstructionAsync,
+  getInitializeBitmapInstructionDataCodec,
+  getInitializeBitmapInstructionDataDecoder,
+  getInitializeBitmapInstructionDataEncoder,
+  getInitializeControllerDiscriminatorBytes,
+  getInitializeControllerInstruction,
+  getInitializeControllerInstructionAsync,
+  getInitializeControllerInstructionDataCodec,
+  getInitializeControllerInstructionDataDecoder,
+  getInitializeControllerInstructionDataEncoder,
+  getTokensDepositedCodec,
+  getTokensDepositedDecoder,
+  getTokensDepositedEncoder,
+  identifyDropsyAccount,
+  identifyDropsyInstruction,
+  isDropsyError,
+  parseClaimTokensInstruction,
+  parseCloseAirdropInstruction,
+  parseCloseBitmapInstruction,
+  parseDepositTokensInstruction,
+  parseInitializeAirdropInstruction,
+  parseInitializeBitmapInstruction,
+  parseInitializeControllerInstruction
+});