@dropsy/airdrop 0.0.1

package/dist/index.mjs

@@ -0,0 +1,1961 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+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 __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/accounts/airdrop.ts
+import {
+  assertAccountExists,
+  assertAccountsExist,
+  combineCodec,
+  decodeAccount,
+  fetchEncodedAccount,
+  fetchEncodedAccounts,
+  fixDecoderSize,
+  fixEncoderSize,
+  getAddressDecoder,
+  getAddressEncoder,
+  getArrayDecoder,
+  getArrayEncoder,
+  getBytesDecoder,
+  getBytesEncoder,
+  getI64Decoder,
+  getI64Encoder,
+  getStructDecoder,
+  getStructEncoder,
+  getU64Decoder,
+  getU64Encoder,
+  getU8Decoder,
+  getU8Encoder,
+  transformEncoder
+} from "@solana/kit";
+var AIRDROP_DISCRIMINATOR = new Uint8Array([
+  31,
+  112,
+  159,
+  158,
+  124,
+  237,
+  9,
+  241
+]);
+function getAirdropDiscriminatorBytes() {
+  return fixEncoderSize(getBytesEncoder(), 8).encode(AIRDROP_DISCRIMINATOR);
+}
+function getAirdropEncoder() {
+  return transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["id", getU64Encoder()],
+      ["mint", getAddressEncoder()],
+      ["owner", getAddressEncoder()],
+      ["controller", getAddressEncoder()],
+      ["supply", getU64Encoder()],
+      ["merkleRoot", getArrayEncoder(getU8Encoder(), { size: 32 })],
+      ["startsAt", getI64Encoder()],
+      ["endsAt", getI64Encoder()],
+      ["bitmapCount", getU8Encoder()],
+      ["version", getU8Encoder()],
+      ["bump", getU8Encoder()]
+    ]),
+    (value) => __spreadProps(__spreadValues({}, value), { discriminator: AIRDROP_DISCRIMINATOR })
+  );
+}
+function getAirdropDecoder() {
+  return getStructDecoder([
+    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+    ["id", getU64Decoder()],
+    ["mint", getAddressDecoder()],
+    ["owner", getAddressDecoder()],
+    ["controller", getAddressDecoder()],
+    ["supply", getU64Decoder()],
+    ["merkleRoot", getArrayDecoder(getU8Decoder(), { size: 32 })],
+    ["startsAt", getI64Decoder()],
+    ["endsAt", getI64Decoder()],
+    ["bitmapCount", getU8Decoder()],
+    ["version", getU8Decoder()],
+    ["bump", getU8Decoder()]
+  ]);
+}
+function getAirdropCodec() {
+  return combineCodec(getAirdropEncoder(), getAirdropDecoder());
+}
+function decodeAirdrop(encodedAccount) {
+  return decodeAccount(
+    encodedAccount,
+    getAirdropDecoder()
+  );
+}
+function fetchAirdrop(rpc, address, config) {
+  return __async(this, null, function* () {
+    const maybeAccount = yield fetchMaybeAirdrop(rpc, address, config);
+    assertAccountExists(maybeAccount);
+    return maybeAccount;
+  });
+}
+function fetchMaybeAirdrop(rpc, address, config) {
+  return __async(this, null, function* () {
+    const maybeAccount = yield fetchEncodedAccount(rpc, address, config);
+    return decodeAirdrop(maybeAccount);
+  });
+}
+function fetchAllAirdrop(rpc, addresses, config) {
+  return __async(this, null, function* () {
+    const maybeAccounts = yield fetchAllMaybeAirdrop(rpc, addresses, config);
+    assertAccountsExist(maybeAccounts);
+    return maybeAccounts;
+  });
+}
+function fetchAllMaybeAirdrop(rpc, addresses, config) {
+  return __async(this, null, function* () {
+    const maybeAccounts = yield fetchEncodedAccounts(rpc, addresses, config);
+    return maybeAccounts.map((maybeAccount) => decodeAirdrop(maybeAccount));
+  });
+}
+
+// src/accounts/bitmapAccount.ts
+import {
+  addDecoderSizePrefix,
+  addEncoderSizePrefix,
+  assertAccountExists as assertAccountExists2,
+  assertAccountsExist as assertAccountsExist2,
+  combineCodec as combineCodec2,
+  decodeAccount as decodeAccount2,
+  fetchEncodedAccount as fetchEncodedAccount2,
+  fetchEncodedAccounts as fetchEncodedAccounts2,
+  fixDecoderSize as fixDecoderSize2,
+  fixEncoderSize as fixEncoderSize2,
+  getAddressDecoder as getAddressDecoder2,
+  getAddressEncoder as getAddressEncoder2,
+  getBytesDecoder as getBytesDecoder2,
+  getBytesEncoder as getBytesEncoder2,
+  getStructDecoder as getStructDecoder2,
+  getStructEncoder as getStructEncoder2,
+  getU32Decoder,
+  getU32Encoder,
+  getU8Decoder as getU8Decoder2,
+  getU8Encoder as getU8Encoder2,
+  transformEncoder as transformEncoder2
+} from "@solana/kit";
+var BITMAP_ACCOUNT_DISCRIMINATOR = new Uint8Array([
+  152,
+  161,
+  147,
+  85,
+  213,
+  38,
+  59,
+  48
+]);
+function getBitmapAccountDiscriminatorBytes() {
+  return fixEncoderSize2(getBytesEncoder2(), 8).encode(
+    BITMAP_ACCOUNT_DISCRIMINATOR
+  );
+}
+function getBitmapAccountEncoder() {
+  return transformEncoder2(
+    getStructEncoder2([
+      ["discriminator", fixEncoderSize2(getBytesEncoder2(), 8)],
+      ["owner", getAddressEncoder2()],
+      ["airdrop", getAddressEncoder2()],
+      [
+        "claimedBitmap",
+        addEncoderSizePrefix(getBytesEncoder2(), getU32Encoder())
+      ],
+      ["id", getU8Encoder2()],
+      ["version", getU8Encoder2()],
+      ["bump", getU8Encoder2()]
+    ]),
+    (value) => __spreadProps(__spreadValues({}, value), { discriminator: BITMAP_ACCOUNT_DISCRIMINATOR })
+  );
+}
+function getBitmapAccountDecoder() {
+  return getStructDecoder2([
+    ["discriminator", fixDecoderSize2(getBytesDecoder2(), 8)],
+    ["owner", getAddressDecoder2()],
+    ["airdrop", getAddressDecoder2()],
+    ["claimedBitmap", addDecoderSizePrefix(getBytesDecoder2(), getU32Decoder())],
+    ["id", getU8Decoder2()],
+    ["version", getU8Decoder2()],
+    ["bump", getU8Decoder2()]
+  ]);
+}
+function getBitmapAccountCodec() {
+  return combineCodec2(getBitmapAccountEncoder(), getBitmapAccountDecoder());
+}
+function decodeBitmapAccount(encodedAccount) {
+  return decodeAccount2(
+    encodedAccount,
+    getBitmapAccountDecoder()
+  );
+}
+function fetchBitmapAccount(rpc, address, config) {
+  return __async(this, null, function* () {
+    const maybeAccount = yield fetchMaybeBitmapAccount(rpc, address, config);
+    assertAccountExists2(maybeAccount);
+    return maybeAccount;
+  });
+}
+function fetchMaybeBitmapAccount(rpc, address, config) {
+  return __async(this, null, function* () {
+    const maybeAccount = yield fetchEncodedAccount2(rpc, address, config);
+    return decodeBitmapAccount(maybeAccount);
+  });
+}
+function fetchAllBitmapAccount(rpc, addresses, config) {
+  return __async(this, null, function* () {
+    const maybeAccounts = yield fetchAllMaybeBitmapAccount(
+      rpc,
+      addresses,
+      config
+    );
+    assertAccountsExist2(maybeAccounts);
+    return maybeAccounts;
+  });
+}
+function fetchAllMaybeBitmapAccount(rpc, addresses, config) {
+  return __async(this, null, function* () {
+    const maybeAccounts = yield fetchEncodedAccounts2(rpc, addresses, config);
+    return maybeAccounts.map((maybeAccount) => decodeBitmapAccount(maybeAccount));
+  });
+}
+
+// src/accounts/controller.ts
+import {
+  assertAccountExists as assertAccountExists3,
+  assertAccountsExist as assertAccountsExist3,
+  combineCodec as combineCodec3,
+  decodeAccount as decodeAccount3,
+  fetchEncodedAccount as fetchEncodedAccount3,
+  fetchEncodedAccounts as fetchEncodedAccounts3,
+  fixDecoderSize as fixDecoderSize3,
+  fixEncoderSize as fixEncoderSize3,
+  getAddressDecoder as getAddressDecoder3,
+  getAddressEncoder as getAddressEncoder3,
+  getBytesDecoder as getBytesDecoder3,
+  getBytesEncoder as getBytesEncoder3,
+  getStructDecoder as getStructDecoder3,
+  getStructEncoder as getStructEncoder3,
+  getU64Decoder as getU64Decoder2,
+  getU64Encoder as getU64Encoder2,
+  getU8Decoder as getU8Decoder3,
+  getU8Encoder as getU8Encoder3,
+  transformEncoder as transformEncoder3
+} from "@solana/kit";
+var CONTROLLER_DISCRIMINATOR = new Uint8Array([
+  184,
+  79,
+  171,
+  0,
+  183,
+  43,
+  113,
+  110
+]);
+function getControllerDiscriminatorBytes() {
+  return fixEncoderSize3(getBytesEncoder3(), 8).encode(CONTROLLER_DISCRIMINATOR);
+}
+function getControllerEncoder() {
+  return transformEncoder3(
+    getStructEncoder3([
+      ["discriminator", fixEncoderSize3(getBytesEncoder3(), 8)],
+      ["authority", getAddressEncoder3()],
+      ["feeVault", getAddressEncoder3()],
+      ["createFee", getU64Encoder2()],
+      ["claimFee", getU64Encoder2()],
+      ["version", getU8Encoder3()],
+      ["bump", getU8Encoder3()]
+    ]),
+    (value) => __spreadProps(__spreadValues({}, value), { discriminator: CONTROLLER_DISCRIMINATOR })
+  );
+}
+function getControllerDecoder() {
+  return getStructDecoder3([
+    ["discriminator", fixDecoderSize3(getBytesDecoder3(), 8)],
+    ["authority", getAddressDecoder3()],
+    ["feeVault", getAddressDecoder3()],
+    ["createFee", getU64Decoder2()],
+    ["claimFee", getU64Decoder2()],
+    ["version", getU8Decoder3()],
+    ["bump", getU8Decoder3()]
+  ]);
+}
+function getControllerCodec() {
+  return combineCodec3(getControllerEncoder(), getControllerDecoder());
+}
+function decodeController(encodedAccount) {
+  return decodeAccount3(
+    encodedAccount,
+    getControllerDecoder()
+  );
+}
+function fetchController(rpc, address, config) {
+  return __async(this, null, function* () {
+    const maybeAccount = yield fetchMaybeController(rpc, address, config);
+    assertAccountExists3(maybeAccount);
+    return maybeAccount;
+  });
+}
+function fetchMaybeController(rpc, address, config) {
+  return __async(this, null, function* () {
+    const maybeAccount = yield fetchEncodedAccount3(rpc, address, config);
+    return decodeController(maybeAccount);
+  });
+}
+function fetchAllController(rpc, addresses, config) {
+  return __async(this, null, function* () {
+    const maybeAccounts = yield fetchAllMaybeController(rpc, addresses, config);
+    assertAccountsExist3(maybeAccounts);
+    return maybeAccounts;
+  });
+}
+function fetchAllMaybeController(rpc, addresses, config) {
+  return __async(this, null, function* () {
+    const maybeAccounts = yield fetchEncodedAccounts3(rpc, addresses, config);
+    return maybeAccounts.map((maybeAccount) => decodeController(maybeAccount));
+  });
+}
+
+// src/errors/dropsy.ts
+import {
+  isProgramError
+} from "@solana/kit";
+
+// src/programs/dropsy.ts
+import {
+  containsBytes,
+  fixEncoderSize as fixEncoderSize4,
+  getBytesEncoder as getBytesEncoder4
+} from "@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 (containsBytes(
+    data,
+    fixEncoderSize4(getBytesEncoder4(), 8).encode(
+      new Uint8Array([31, 112, 159, 158, 124, 237, 9, 241])
+    ),
+    0
+  )) {
+    return 0 /* Airdrop */;
+  }
+  if (containsBytes(
+    data,
+    fixEncoderSize4(getBytesEncoder4(), 8).encode(
+      new Uint8Array([152, 161, 147, 85, 213, 38, 59, 48])
+    ),
+    0
+  )) {
+    return 1 /* BitmapAccount */;
+  }
+  if (containsBytes(
+    data,
+    fixEncoderSize4(getBytesEncoder4(), 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 (containsBytes(
+    data,
+    fixEncoderSize4(getBytesEncoder4(), 8).encode(
+      new Uint8Array([108, 216, 210, 231, 0, 212, 42, 64])
+    ),
+    0
+  )) {
+    return 0 /* ClaimTokens */;
+  }
+  if (containsBytes(
+    data,
+    fixEncoderSize4(getBytesEncoder4(), 8).encode(
+      new Uint8Array([85, 138, 99, 129, 104, 203, 94, 4])
+    ),
+    0
+  )) {
+    return 1 /* CloseAirdrop */;
+  }
+  if (containsBytes(
+    data,
+    fixEncoderSize4(getBytesEncoder4(), 8).encode(
+      new Uint8Array([59, 123, 115, 204, 163, 227, 37, 118])
+    ),
+    0
+  )) {
+    return 2 /* CloseBitmap */;
+  }
+  if (containsBytes(
+    data,
+    fixEncoderSize4(getBytesEncoder4(), 8).encode(
+      new Uint8Array([176, 83, 229, 18, 191, 143, 176, 150])
+    ),
+    0
+  )) {
+    return 3 /* DepositTokens */;
+  }
+  if (containsBytes(
+    data,
+    fixEncoderSize4(getBytesEncoder4(), 8).encode(
+      new Uint8Array([96, 196, 74, 102, 61, 195, 48, 184])
+    ),
+    0
+  )) {
+    return 4 /* InitializeAirdrop */;
+  }
+  if (containsBytes(
+    data,
+    fixEncoderSize4(getBytesEncoder4(), 8).encode(
+      new Uint8Array([25, 109, 200, 45, 209, 118, 74, 69])
+    ),
+    0
+  )) {
+    return 5 /* InitializeBitmap */;
+  }
+  if (containsBytes(
+    data,
+    fixEncoderSize4(getBytesEncoder4(), 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 isProgramError(
+    error,
+    transactionMessage,
+    DROPSY_PROGRAM_ADDRESS,
+    code
+  );
+}
+
+// src/instructions/claimTokens.ts
+import {
+  combineCodec as combineCodec4,
+  fixDecoderSize as fixDecoderSize4,
+  fixEncoderSize as fixEncoderSize5,
+  getArrayDecoder as getArrayDecoder2,
+  getArrayEncoder as getArrayEncoder2,
+  getBytesDecoder as getBytesDecoder4,
+  getBytesEncoder as getBytesEncoder5,
+  getStructDecoder as getStructDecoder4,
+  getStructEncoder as getStructEncoder4,
+  getU64Decoder as getU64Decoder3,
+  getU64Encoder as getU64Encoder3,
+  getU8Decoder as getU8Decoder4,
+  getU8Encoder as getU8Encoder4,
+  transformEncoder as transformEncoder4
+} from "@solana/kit";
+
+// src/shared/index.ts
+import {
+  AccountRole,
+  isProgramDerivedAddress,
+  isTransactionSigner as kitIsTransactionSigner,
+  upgradeRoleToSigner
+} from "@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: AccountRole.READONLY
+      });
+    }
+    const writableRole = account.isWritable ? AccountRole.WRITABLE : AccountRole.READONLY;
+    return Object.freeze(__spreadValues({
+      address: expectAddress(account.value),
+      role: isTransactionSigner(account.value) ? upgradeRoleToSigner(writableRole) : writableRole
+    }, isTransactionSigner(account.value) ? { signer: account.value } : {}));
+  };
+}
+function isTransactionSigner(value) {
+  return !!value && typeof value === "object" && "address" in value && kitIsTransactionSigner(value);
+}
+
+// src/instructions/claimTokens.ts
+var CLAIM_TOKENS_DISCRIMINATOR = new Uint8Array([
+  108,
+  216,
+  210,
+  231,
+  0,
+  212,
+  42,
+  64
+]);
+function getClaimTokensDiscriminatorBytes() {
+  return fixEncoderSize5(getBytesEncoder5(), 8).encode(
+    CLAIM_TOKENS_DISCRIMINATOR
+  );
+}
+function getClaimTokensInstructionDataEncoder() {
+  return transformEncoder4(
+    getStructEncoder4([
+      ["discriminator", fixEncoderSize5(getBytesEncoder5(), 8)],
+      ["index", getU64Encoder3()],
+      ["proof", getArrayEncoder2(getArrayEncoder2(getU8Encoder4(), { size: 32 }))],
+      ["amount", getU64Encoder3()]
+    ]),
+    (value) => __spreadProps(__spreadValues({}, value), { discriminator: CLAIM_TOKENS_DISCRIMINATOR })
+  );
+}
+function getClaimTokensInstructionDataDecoder() {
+  return getStructDecoder4([
+    ["discriminator", fixDecoderSize4(getBytesDecoder4(), 8)],
+    ["index", getU64Decoder3()],
+    ["proof", getArrayDecoder2(getArrayDecoder2(getU8Decoder4(), { size: 32 }))],
+    ["amount", getU64Decoder3()]
+  ]);
+}
+function getClaimTokensInstructionDataCodec() {
+  return combineCodec4(
+    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
+import {
+  combineCodec as combineCodec5,
+  fixDecoderSize as fixDecoderSize5,
+  fixEncoderSize as fixEncoderSize6,
+  getBytesDecoder as getBytesDecoder5,
+  getBytesEncoder as getBytesEncoder6,
+  getStructDecoder as getStructDecoder5,
+  getStructEncoder as getStructEncoder5,
+  transformEncoder as transformEncoder5
+} from "@solana/kit";
+var CLOSE_AIRDROP_DISCRIMINATOR = new Uint8Array([
+  85,
+  138,
+  99,
+  129,
+  104,
+  203,
+  94,
+  4
+]);
+function getCloseAirdropDiscriminatorBytes() {
+  return fixEncoderSize6(getBytesEncoder6(), 8).encode(
+    CLOSE_AIRDROP_DISCRIMINATOR
+  );
+}
+function getCloseAirdropInstructionDataEncoder() {
+  return transformEncoder5(
+    getStructEncoder5([["discriminator", fixEncoderSize6(getBytesEncoder6(), 8)]]),
+    (value) => __spreadProps(__spreadValues({}, value), { discriminator: CLOSE_AIRDROP_DISCRIMINATOR })
+  );
+}
+function getCloseAirdropInstructionDataDecoder() {
+  return getStructDecoder5([
+    ["discriminator", fixDecoderSize5(getBytesDecoder5(), 8)]
+  ]);
+}
+function getCloseAirdropInstructionDataCodec() {
+  return combineCodec5(
+    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
+import {
+  combineCodec as combineCodec6,
+  fixDecoderSize as fixDecoderSize6,
+  fixEncoderSize as fixEncoderSize7,
+  getBytesDecoder as getBytesDecoder6,
+  getBytesEncoder as getBytesEncoder7,
+  getStructDecoder as getStructDecoder6,
+  getStructEncoder as getStructEncoder6,
+  transformEncoder as transformEncoder6
+} from "@solana/kit";
+var CLOSE_BITMAP_DISCRIMINATOR = new Uint8Array([
+  59,
+  123,
+  115,
+  204,
+  163,
+  227,
+  37,
+  118
+]);
+function getCloseBitmapDiscriminatorBytes() {
+  return fixEncoderSize7(getBytesEncoder7(), 8).encode(
+    CLOSE_BITMAP_DISCRIMINATOR
+  );
+}
+function getCloseBitmapInstructionDataEncoder() {
+  return transformEncoder6(
+    getStructEncoder6([["discriminator", fixEncoderSize7(getBytesEncoder7(), 8)]]),
+    (value) => __spreadProps(__spreadValues({}, value), { discriminator: CLOSE_BITMAP_DISCRIMINATOR })
+  );
+}
+function getCloseBitmapInstructionDataDecoder() {
+  return getStructDecoder6([
+    ["discriminator", fixDecoderSize6(getBytesDecoder6(), 8)]
+  ]);
+}
+function getCloseBitmapInstructionDataCodec() {
+  return combineCodec6(
+    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
+import {
+  combineCodec as combineCodec7,
+  fixDecoderSize as fixDecoderSize7,
+  fixEncoderSize as fixEncoderSize8,
+  getBytesDecoder as getBytesDecoder7,
+  getBytesEncoder as getBytesEncoder8,
+  getStructDecoder as getStructDecoder7,
+  getStructEncoder as getStructEncoder7,
+  getU64Decoder as getU64Decoder4,
+  getU64Encoder as getU64Encoder4,
+  transformEncoder as transformEncoder7
+} from "@solana/kit";
+var DEPOSIT_TOKENS_DISCRIMINATOR = new Uint8Array([
+  176,
+  83,
+  229,
+  18,
+  191,
+  143,
+  176,
+  150
+]);
+function getDepositTokensDiscriminatorBytes() {
+  return fixEncoderSize8(getBytesEncoder8(), 8).encode(
+    DEPOSIT_TOKENS_DISCRIMINATOR
+  );
+}
+function getDepositTokensInstructionDataEncoder() {
+  return transformEncoder7(
+    getStructEncoder7([
+      ["discriminator", fixEncoderSize8(getBytesEncoder8(), 8)],
+      ["amount", getU64Encoder4()]
+    ]),
+    (value) => __spreadProps(__spreadValues({}, value), { discriminator: DEPOSIT_TOKENS_DISCRIMINATOR })
+  );
+}
+function getDepositTokensInstructionDataDecoder() {
+  return getStructDecoder7([
+    ["discriminator", fixDecoderSize7(getBytesDecoder7(), 8)],
+    ["amount", getU64Decoder4()]
+  ]);
+}
+function getDepositTokensInstructionDataCodec() {
+  return combineCodec7(
+    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
+import {
+  combineCodec as combineCodec8,
+  fixDecoderSize as fixDecoderSize8,
+  fixEncoderSize as fixEncoderSize9,
+  getAddressEncoder as getAddressEncoder4,
+  getArrayDecoder as getArrayDecoder3,
+  getArrayEncoder as getArrayEncoder3,
+  getBytesDecoder as getBytesDecoder8,
+  getBytesEncoder as getBytesEncoder9,
+  getI64Decoder as getI64Decoder2,
+  getI64Encoder as getI64Encoder2,
+  getProgramDerivedAddress,
+  getStructDecoder as getStructDecoder8,
+  getStructEncoder as getStructEncoder8,
+  getU64Decoder as getU64Decoder5,
+  getU64Encoder as getU64Encoder5,
+  getU8Decoder as getU8Decoder5,
+  getU8Encoder as getU8Encoder5,
+  transformEncoder as transformEncoder8
+} from "@solana/kit";
+var INITIALIZE_AIRDROP_DISCRIMINATOR = new Uint8Array([
+  96,
+  196,
+  74,
+  102,
+  61,
+  195,
+  48,
+  184
+]);
+function getInitializeAirdropDiscriminatorBytes() {
+  return fixEncoderSize9(getBytesEncoder9(), 8).encode(
+    INITIALIZE_AIRDROP_DISCRIMINATOR
+  );
+}
+function getInitializeAirdropInstructionDataEncoder() {
+  return transformEncoder8(
+    getStructEncoder8([
+      ["discriminator", fixEncoderSize9(getBytesEncoder9(), 8)],
+      ["id", getU64Encoder5()],
+      ["merkleRoot", getArrayEncoder3(getU8Encoder5(), { size: 32 })],
+      ["startsTime", getI64Encoder2()],
+      ["endTime", getI64Encoder2()]
+    ]),
+    (value) => __spreadProps(__spreadValues({}, value), { discriminator: INITIALIZE_AIRDROP_DISCRIMINATOR })
+  );
+}
+function getInitializeAirdropInstructionDataDecoder() {
+  return getStructDecoder8([
+    ["discriminator", fixDecoderSize8(getBytesDecoder8(), 8)],
+    ["id", getU64Decoder5()],
+    ["merkleRoot", getArrayDecoder3(getU8Decoder5(), { size: 32 })],
+    ["startsTime", getI64Decoder2()],
+    ["endTime", getI64Decoder2()]
+  ]);
+}
+function getInitializeAirdropInstructionDataCodec() {
+  return combineCodec8(
+    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 getProgramDerivedAddress({
+        programAddress,
+        seeds: [
+          getBytesEncoder9().encode(
+            new Uint8Array([97, 105, 114, 100, 114, 111, 112])
+          ),
+          getAddressEncoder4().encode(expectAddress(accounts.mint.value)),
+          getAddressEncoder4().encode(expectAddress(accounts.owner.value)),
+          getU64Encoder5().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
+import {
+  combineCodec as combineCodec9,
+  fixDecoderSize as fixDecoderSize9,
+  fixEncoderSize as fixEncoderSize10,
+  getAddressEncoder as getAddressEncoder5,
+  getBytesDecoder as getBytesDecoder9,
+  getBytesEncoder as getBytesEncoder10,
+  getProgramDerivedAddress as getProgramDerivedAddress2,
+  getStructDecoder as getStructDecoder9,
+  getStructEncoder as getStructEncoder9,
+  getU64Decoder as getU64Decoder6,
+  getU64Encoder as getU64Encoder6,
+  getU8Decoder as getU8Decoder6,
+  getU8Encoder as getU8Encoder6,
+  transformEncoder as transformEncoder9
+} from "@solana/kit";
+var INITIALIZE_BITMAP_DISCRIMINATOR = new Uint8Array([
+  25,
+  109,
+  200,
+  45,
+  209,
+  118,
+  74,
+  69
+]);
+function getInitializeBitmapDiscriminatorBytes() {
+  return fixEncoderSize10(getBytesEncoder10(), 8).encode(
+    INITIALIZE_BITMAP_DISCRIMINATOR
+  );
+}
+function getInitializeBitmapInstructionDataEncoder() {
+  return transformEncoder9(
+    getStructEncoder9([
+      ["discriminator", fixEncoderSize10(getBytesEncoder10(), 8)],
+      ["id", getU8Encoder6()],
+      ["total", getU64Encoder6()]
+    ]),
+    (value) => __spreadProps(__spreadValues({}, value), { discriminator: INITIALIZE_BITMAP_DISCRIMINATOR })
+  );
+}
+function getInitializeBitmapInstructionDataDecoder() {
+  return getStructDecoder9([
+    ["discriminator", fixDecoderSize9(getBytesDecoder9(), 8)],
+    ["id", getU8Decoder6()],
+    ["total", getU64Decoder6()]
+  ]);
+}
+function getInitializeBitmapInstructionDataCodec() {
+  return combineCodec9(
+    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 getProgramDerivedAddress2({
+        programAddress,
+        seeds: [
+          getBytesEncoder10().encode(new Uint8Array([98, 105, 116, 109, 97, 112])),
+          getAddressEncoder5().encode(expectAddress(accounts.airdrop.value)),
+          getU8Encoder6().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
+import {
+  combineCodec as combineCodec10,
+  fixDecoderSize as fixDecoderSize10,
+  fixEncoderSize as fixEncoderSize11,
+  getAddressEncoder as getAddressEncoder6,
+  getBytesDecoder as getBytesDecoder10,
+  getBytesEncoder as getBytesEncoder11,
+  getProgramDerivedAddress as getProgramDerivedAddress3,
+  getStructDecoder as getStructDecoder10,
+  getStructEncoder as getStructEncoder10,
+  getU64Decoder as getU64Decoder7,
+  getU64Encoder as getU64Encoder7,
+  transformEncoder as transformEncoder10
+} from "@solana/kit";
+var INITIALIZE_CONTROLLER_DISCRIMINATOR = new Uint8Array([
+  137,
+  255,
+  100,
+  190,
+  201,
+  247,
+  241,
+  81
+]);
+function getInitializeControllerDiscriminatorBytes() {
+  return fixEncoderSize11(getBytesEncoder11(), 8).encode(
+    INITIALIZE_CONTROLLER_DISCRIMINATOR
+  );
+}
+function getInitializeControllerInstructionDataEncoder() {
+  return transformEncoder10(
+    getStructEncoder10([
+      ["discriminator", fixEncoderSize11(getBytesEncoder11(), 8)],
+      ["createFee", getU64Encoder7()],
+      ["claimFee", getU64Encoder7()]
+    ]),
+    (value) => __spreadProps(__spreadValues({}, value), {
+      discriminator: INITIALIZE_CONTROLLER_DISCRIMINATOR
+    })
+  );
+}
+function getInitializeControllerInstructionDataDecoder() {
+  return getStructDecoder10([
+    ["discriminator", fixDecoderSize10(getBytesDecoder10(), 8)],
+    ["createFee", getU64Decoder7()],
+    ["claimFee", getU64Decoder7()]
+  ]);
+}
+function getInitializeControllerInstructionDataCodec() {
+  return combineCodec10(
+    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 getProgramDerivedAddress3({
+        programAddress,
+        seeds: [
+          getBytesEncoder11().encode(
+            new Uint8Array([
+              99,
+              111,
+              110,
+              116,
+              114,
+              111,
+              108,
+              108,
+              101,
+              114,
+              45,
+              100,
+              114,
+              111,
+              112,
+              115,
+              121
+            ])
+          ),
+          getAddressEncoder6().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
+import {
+  combineCodec as combineCodec11,
+  getAddressDecoder as getAddressDecoder4,
+  getAddressEncoder as getAddressEncoder7,
+  getI64Decoder as getI64Decoder3,
+  getI64Encoder as getI64Encoder3,
+  getStructDecoder as getStructDecoder11,
+  getStructEncoder as getStructEncoder11
+} from "@solana/kit";
+function getAirdropClosedEncoder() {
+  return getStructEncoder11([
+    ["airdrop", getAddressEncoder7()],
+    ["owner", getAddressEncoder7()],
+    ["timestamp", getI64Encoder3()]
+  ]);
+}
+function getAirdropClosedDecoder() {
+  return getStructDecoder11([
+    ["airdrop", getAddressDecoder4()],
+    ["owner", getAddressDecoder4()],
+    ["timestamp", getI64Decoder3()]
+  ]);
+}
+function getAirdropClosedCodec() {
+  return combineCodec11(getAirdropClosedEncoder(), getAirdropClosedDecoder());
+}
+
+// src/types/airdropInitialized.ts
+import {
+  combineCodec as combineCodec12,
+  getAddressDecoder as getAddressDecoder5,
+  getAddressEncoder as getAddressEncoder8,
+  getArrayDecoder as getArrayDecoder4,
+  getArrayEncoder as getArrayEncoder4,
+  getI64Decoder as getI64Decoder4,
+  getI64Encoder as getI64Encoder4,
+  getStructDecoder as getStructDecoder12,
+  getStructEncoder as getStructEncoder12,
+  getU8Decoder as getU8Decoder7,
+  getU8Encoder as getU8Encoder7
+} from "@solana/kit";
+function getAirdropInitializedEncoder() {
+  return getStructEncoder12([
+    ["airdrop", getAddressEncoder8()],
+    ["mint", getAddressEncoder8()],
+    ["owner", getAddressEncoder8()],
+    ["controller", getAddressEncoder8()],
+    ["controllerAuthority", getAddressEncoder8()],
+    ["merkleRoot", getArrayEncoder4(getU8Encoder7(), { size: 32 })],
+    ["startTime", getI64Encoder4()],
+    ["endTime", getI64Encoder4()],
+    ["timestamp", getI64Encoder4()]
+  ]);
+}
+function getAirdropInitializedDecoder() {
+  return getStructDecoder12([
+    ["airdrop", getAddressDecoder5()],
+    ["mint", getAddressDecoder5()],
+    ["owner", getAddressDecoder5()],
+    ["controller", getAddressDecoder5()],
+    ["controllerAuthority", getAddressDecoder5()],
+    ["merkleRoot", getArrayDecoder4(getU8Decoder7(), { size: 32 })],
+    ["startTime", getI64Decoder4()],
+    ["endTime", getI64Decoder4()],
+    ["timestamp", getI64Decoder4()]
+  ]);
+}
+function getAirdropInitializedCodec() {
+  return combineCodec12(
+    getAirdropInitializedEncoder(),
+    getAirdropInitializedDecoder()
+  );
+}
+
+// src/types/bitmapClosed.ts
+import {
+  combineCodec as combineCodec13,
+  getAddressDecoder as getAddressDecoder6,
+  getAddressEncoder as getAddressEncoder9,
+  getStructDecoder as getStructDecoder13,
+  getStructEncoder as getStructEncoder13
+} from "@solana/kit";
+function getBitmapClosedEncoder() {
+  return getStructEncoder13([
+    ["airdrop", getAddressEncoder9()],
+    ["bitmap", getAddressEncoder9()],
+    ["owner", getAddressEncoder9()]
+  ]);
+}
+function getBitmapClosedDecoder() {
+  return getStructDecoder13([
+    ["airdrop", getAddressDecoder6()],
+    ["bitmap", getAddressDecoder6()],
+    ["owner", getAddressDecoder6()]
+  ]);
+}
+function getBitmapClosedCodec() {
+  return combineCodec13(getBitmapClosedEncoder(), getBitmapClosedDecoder());
+}
+
+// src/types/bitmapInitialized.ts
+import {
+  combineCodec as combineCodec14,
+  getAddressDecoder as getAddressDecoder7,
+  getAddressEncoder as getAddressEncoder10,
+  getStructDecoder as getStructDecoder14,
+  getStructEncoder as getStructEncoder14,
+  getU64Decoder as getU64Decoder8,
+  getU64Encoder as getU64Encoder8,
+  getU8Decoder as getU8Decoder8,
+  getU8Encoder as getU8Encoder8
+} from "@solana/kit";
+function getBitmapInitializedEncoder() {
+  return getStructEncoder14([
+    ["airdrop", getAddressEncoder10()],
+    ["bitmap", getAddressEncoder10()],
+    ["bitmapId", getU8Encoder8()],
+    ["totalClaims", getU64Encoder8()]
+  ]);
+}
+function getBitmapInitializedDecoder() {
+  return getStructDecoder14([
+    ["airdrop", getAddressDecoder7()],
+    ["bitmap", getAddressDecoder7()],
+    ["bitmapId", getU8Decoder8()],
+    ["totalClaims", getU64Decoder8()]
+  ]);
+}
+function getBitmapInitializedCodec() {
+  return combineCodec14(
+    getBitmapInitializedEncoder(),
+    getBitmapInitializedDecoder()
+  );
+}
+
+// src/types/controllerInitialized.ts
+import {
+  combineCodec as combineCodec15,
+  getAddressDecoder as getAddressDecoder8,
+  getAddressEncoder as getAddressEncoder11,
+  getI64Decoder as getI64Decoder5,
+  getI64Encoder as getI64Encoder5,
+  getStructDecoder as getStructDecoder15,
+  getStructEncoder as getStructEncoder15,
+  getU64Decoder as getU64Decoder9,
+  getU64Encoder as getU64Encoder9,
+  getU8Decoder as getU8Decoder9,
+  getU8Encoder as getU8Encoder9
+} from "@solana/kit";
+function getControllerInitializedEncoder() {
+  return getStructEncoder15([
+    ["authority", getAddressEncoder11()],
+    ["feeVault", getAddressEncoder11()],
+    ["createFee", getU64Encoder9()],
+    ["claimFee", getU64Encoder9()],
+    ["bump", getU8Encoder9()],
+    ["timestamp", getI64Encoder5()]
+  ]);
+}
+function getControllerInitializedDecoder() {
+  return getStructDecoder15([
+    ["authority", getAddressDecoder8()],
+    ["feeVault", getAddressDecoder8()],
+    ["createFee", getU64Decoder9()],
+    ["claimFee", getU64Decoder9()],
+    ["bump", getU8Decoder9()],
+    ["timestamp", getI64Decoder5()]
+  ]);
+}
+function getControllerInitializedCodec() {
+  return combineCodec15(
+    getControllerInitializedEncoder(),
+    getControllerInitializedDecoder()
+  );
+}
+
+// src/types/tokensDeposited.ts
+import {
+  combineCodec as combineCodec16,
+  getAddressDecoder as getAddressDecoder9,
+  getAddressEncoder as getAddressEncoder12,
+  getI64Decoder as getI64Decoder6,
+  getI64Encoder as getI64Encoder6,
+  getStructDecoder as getStructDecoder16,
+  getStructEncoder as getStructEncoder16,
+  getU64Decoder as getU64Decoder10,
+  getU64Encoder as getU64Encoder10
+} from "@solana/kit";
+function getTokensDepositedEncoder() {
+  return getStructEncoder16([
+    ["airdrop", getAddressEncoder12()],
+    ["amount", getU64Encoder10()],
+    ["newSupply", getU64Encoder10()],
+    ["depositor", getAddressEncoder12()],
+    ["timestamp", getI64Encoder6()]
+  ]);
+}
+function getTokensDepositedDecoder() {
+  return getStructDecoder16([
+    ["airdrop", getAddressDecoder9()],
+    ["amount", getU64Decoder10()],
+    ["newSupply", getU64Decoder10()],
+    ["depositor", getAddressDecoder9()],
+    ["timestamp", getI64Decoder6()]
+  ]);
+}
+function getTokensDepositedCodec() {
+  return combineCodec16(getTokensDepositedEncoder(), getTokensDepositedDecoder());
+}
+export {
+  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
+};