@dropsy/airdrop 0.3.0 → 0.4.0

package/dist/index.js

@@ -1,218 +1,29 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  AIRDROP_CONFIG_DISCRIMINATOR: () => AIRDROP_CONFIG_DISCRIMINATOR,
-  AIRDROP_DISCRIMINATOR: () => AIRDROP_DISCRIMINATOR,
-  AIRDROP_MASTER_DISCRIMINATOR: () => AIRDROP_MASTER_DISCRIMINATOR,
-  BITMAP_ACCOUNT_DISCRIMINATOR: () => BITMAP_ACCOUNT_DISCRIMINATOR,
-  CLAIM_AIRDROP_DISCRIMINATOR: () => CLAIM_AIRDROP_DISCRIMINATOR,
-  CREATE_AIRDROP_DISCRIMINATOR: () => CREATE_AIRDROP_DISCRIMINATOR,
-  CREATE_BITMAP_DISCRIMINATOR: () => CREATE_BITMAP_DISCRIMINATOR,
-  DEPOSIT_TOKENS_DISCRIMINATOR: () => DEPOSIT_TOKENS_DISCRIMINATOR,
-  DROPSY_AIRDROP_ERROR__ACTION_FEE_TOO_HIGH: () => DROPSY_AIRDROP_ERROR__ACTION_FEE_TOO_HIGH,
-  DROPSY_AIRDROP_ERROR__ACTIVE_BITMAPS_EXIST: () => DROPSY_AIRDROP_ERROR__ACTIVE_BITMAPS_EXIST,
-  DROPSY_AIRDROP_ERROR__AIRDROP_ENDED: () => DROPSY_AIRDROP_ERROR__AIRDROP_ENDED,
-  DROPSY_AIRDROP_ERROR__AIRDROP_NOT_ENDED: () => DROPSY_AIRDROP_ERROR__AIRDROP_NOT_ENDED,
-  DROPSY_AIRDROP_ERROR__AIRDROP_NOT_STARTED: () => DROPSY_AIRDROP_ERROR__AIRDROP_NOT_STARTED,
-  DROPSY_AIRDROP_ERROR__ALREADY_CLAIMED: () => DROPSY_AIRDROP_ERROR__ALREADY_CLAIMED,
-  DROPSY_AIRDROP_ERROR__BITMAP_AIRDROP_MISMATCH: () => DROPSY_AIRDROP_ERROR__BITMAP_AIRDROP_MISMATCH,
-  DROPSY_AIRDROP_ERROR__BITMAP_COUNT_UNDERFLOW: () => DROPSY_AIRDROP_ERROR__BITMAP_COUNT_UNDERFLOW,
-  DROPSY_AIRDROP_ERROR__BITMAP_TOO_LARGE: () => DROPSY_AIRDROP_ERROR__BITMAP_TOO_LARGE,
-  DROPSY_AIRDROP_ERROR__CLAIM_FEE_TOO_HIGH: () => DROPSY_AIRDROP_ERROR__CLAIM_FEE_TOO_HIGH,
-  DROPSY_AIRDROP_ERROR__CREATE_FEE_TOO_HIGH: () => DROPSY_AIRDROP_ERROR__CREATE_FEE_TOO_HIGH,
-  DROPSY_AIRDROP_ERROR__DESTINATION_MINT_MISMATCH: () => DROPSY_AIRDROP_ERROR__DESTINATION_MINT_MISMATCH,
-  DROPSY_AIRDROP_ERROR__DURATION_TOO_SHORT: () => DROPSY_AIRDROP_ERROR__DURATION_TOO_SHORT,
-  DROPSY_AIRDROP_ERROR__IMMUTABLE_AIRDROP: () => DROPSY_AIRDROP_ERROR__IMMUTABLE_AIRDROP,
-  DROPSY_AIRDROP_ERROR__IMMUTABLE_FIELD: () => DROPSY_AIRDROP_ERROR__IMMUTABLE_FIELD,
-  DROPSY_AIRDROP_ERROR__INSUFFICIENT_DEPOSIT: () => DROPSY_AIRDROP_ERROR__INSUFFICIENT_DEPOSIT,
-  DROPSY_AIRDROP_ERROR__INSUFFICIENT_FUNDS_FOR_FEE: () => DROPSY_AIRDROP_ERROR__INSUFFICIENT_FUNDS_FOR_FEE,
-  DROPSY_AIRDROP_ERROR__INSUFFICIENT_VAULT_FUNDS: () => DROPSY_AIRDROP_ERROR__INSUFFICIENT_VAULT_FUNDS,
-  DROPSY_AIRDROP_ERROR__INVALID_ADMIN: () => DROPSY_AIRDROP_ERROR__INVALID_ADMIN,
-  DROPSY_AIRDROP_ERROR__INVALID_AFFILIATE_PDA: () => DROPSY_AIRDROP_ERROR__INVALID_AFFILIATE_PDA,
-  DROPSY_AIRDROP_ERROR__INVALID_AIRDROP_PDA: () => DROPSY_AIRDROP_ERROR__INVALID_AIRDROP_PDA,
-  DROPSY_AIRDROP_ERROR__INVALID_AIRDROP_VERSION: () => DROPSY_AIRDROP_ERROR__INVALID_AIRDROP_VERSION,
-  DROPSY_AIRDROP_ERROR__INVALID_AIRDROP_VESTING_VERSION: () => DROPSY_AIRDROP_ERROR__INVALID_AIRDROP_VESTING_VERSION,
-  DROPSY_AIRDROP_ERROR__INVALID_AMOUNT: () => DROPSY_AIRDROP_ERROR__INVALID_AMOUNT,
-  DROPSY_AIRDROP_ERROR__INVALID_BITMAP_ACCOUNT: () => DROPSY_AIRDROP_ERROR__INVALID_BITMAP_ACCOUNT,
-  DROPSY_AIRDROP_ERROR__INVALID_BITMAP_INDEX: () => DROPSY_AIRDROP_ERROR__INVALID_BITMAP_INDEX,
-  DROPSY_AIRDROP_ERROR__INVALID_DELEGATE_PERMISSION: () => DROPSY_AIRDROP_ERROR__INVALID_DELEGATE_PERMISSION,
-  DROPSY_AIRDROP_ERROR__INVALID_DESTINATION_OWNER: () => DROPSY_AIRDROP_ERROR__INVALID_DESTINATION_OWNER,
-  DROPSY_AIRDROP_ERROR__INVALID_END_TIME: () => DROPSY_AIRDROP_ERROR__INVALID_END_TIME,
-  DROPSY_AIRDROP_ERROR__INVALID_FEE_VAULT: () => DROPSY_AIRDROP_ERROR__INVALID_FEE_VAULT,
-  DROPSY_AIRDROP_ERROR__INVALID_FEE_VAULT_CURVE: () => DROPSY_AIRDROP_ERROR__INVALID_FEE_VAULT_CURVE,
-  DROPSY_AIRDROP_ERROR__INVALID_FEE_VAULT_OWNER: () => DROPSY_AIRDROP_ERROR__INVALID_FEE_VAULT_OWNER,
-  DROPSY_AIRDROP_ERROR__INVALID_MINT: () => DROPSY_AIRDROP_ERROR__INVALID_MINT,
-  DROPSY_AIRDROP_ERROR__INVALID_MINT_OWNER: () => DROPSY_AIRDROP_ERROR__INVALID_MINT_OWNER,
-  DROPSY_AIRDROP_ERROR__INVALID_MUTABILITY: () => DROPSY_AIRDROP_ERROR__INVALID_MUTABILITY,
-  DROPSY_AIRDROP_ERROR__INVALID_OWNER: () => DROPSY_AIRDROP_ERROR__INVALID_OWNER,
-  DROPSY_AIRDROP_ERROR__INVALID_PARENT_ACCOUNT: () => DROPSY_AIRDROP_ERROR__INVALID_PARENT_ACCOUNT,
-  DROPSY_AIRDROP_ERROR__INVALID_PDA: () => DROPSY_AIRDROP_ERROR__INVALID_PDA,
-  DROPSY_AIRDROP_ERROR__INVALID_PERCENTAGE: () => DROPSY_AIRDROP_ERROR__INVALID_PERCENTAGE,
-  DROPSY_AIRDROP_ERROR__INVALID_PROOF: () => DROPSY_AIRDROP_ERROR__INVALID_PROOF,
-  DROPSY_AIRDROP_ERROR__INVALID_PUB_KEY: () => DROPSY_AIRDROP_ERROR__INVALID_PUB_KEY,
-  DROPSY_AIRDROP_ERROR__INVALID_TIMESTAMP: () => DROPSY_AIRDROP_ERROR__INVALID_TIMESTAMP,
-  DROPSY_AIRDROP_ERROR__INVALID_TOTAL: () => DROPSY_AIRDROP_ERROR__INVALID_TOTAL,
-  DROPSY_AIRDROP_ERROR__INVALID_TREASURY_ACCOUNT: () => DROPSY_AIRDROP_ERROR__INVALID_TREASURY_ACCOUNT,
-  DROPSY_AIRDROP_ERROR__INVALID_VAULT_AUTHORITY: () => DROPSY_AIRDROP_ERROR__INVALID_VAULT_AUTHORITY,
-  DROPSY_AIRDROP_ERROR__INVALID_VESTING_SCHEDULE: () => DROPSY_AIRDROP_ERROR__INVALID_VESTING_SCHEDULE,
-  DROPSY_AIRDROP_ERROR__INVALID_VESTING_TYPE: () => DROPSY_AIRDROP_ERROR__INVALID_VESTING_TYPE,
-  DROPSY_AIRDROP_ERROR__MINT_HAS_FREEZE_AUTHORITY: () => DROPSY_AIRDROP_ERROR__MINT_HAS_FREEZE_AUTHORITY,
-  DROPSY_AIRDROP_ERROR__MINT_IS_FROZEN: () => DROPSY_AIRDROP_ERROR__MINT_IS_FROZEN,
-  DROPSY_AIRDROP_ERROR__MINT_IS_NOT_INITIALIZED: () => DROPSY_AIRDROP_ERROR__MINT_IS_NOT_INITIALIZED,
-  DROPSY_AIRDROP_ERROR__MINT_MISMATCH: () => DROPSY_AIRDROP_ERROR__MINT_MISMATCH,
-  DROPSY_AIRDROP_ERROR__MISSING_BITMAP_PDA: () => DROPSY_AIRDROP_ERROR__MISSING_BITMAP_PDA,
-  DROPSY_AIRDROP_ERROR__NFT_NOT_ALLOWED: () => DROPSY_AIRDROP_ERROR__NFT_NOT_ALLOWED,
-  DROPSY_AIRDROP_ERROR__NON_ZERO_VALUE_REQUIRED: () => DROPSY_AIRDROP_ERROR__NON_ZERO_VALUE_REQUIRED,
-  DROPSY_AIRDROP_ERROR__OVERFLOW: () => DROPSY_AIRDROP_ERROR__OVERFLOW,
-  DROPSY_AIRDROP_ERROR__OWNER_MISMATCH: () => DROPSY_AIRDROP_ERROR__OWNER_MISMATCH,
-  DROPSY_AIRDROP_ERROR__SOURCE_ACCOUNT_FROZEN: () => DROPSY_AIRDROP_ERROR__SOURCE_ACCOUNT_FROZEN,
-  DROPSY_AIRDROP_ERROR__SOURCE_HAS_CLOSE_AUTHORITY: () => DROPSY_AIRDROP_ERROR__SOURCE_HAS_CLOSE_AUTHORITY,
-  DROPSY_AIRDROP_ERROR__SOURCE_HAS_DELEGATE: () => DROPSY_AIRDROP_ERROR__SOURCE_HAS_DELEGATE,
-  DROPSY_AIRDROP_ERROR__TOO_MANY_BITMAPS: () => DROPSY_AIRDROP_ERROR__TOO_MANY_BITMAPS,
-  DROPSY_AIRDROP_ERROR__UNAUTHORIZED: () => DROPSY_AIRDROP_ERROR__UNAUTHORIZED,
-  DROPSY_AIRDROP_ERROR__UN_AUTHORIZED: () => DROPSY_AIRDROP_ERROR__UN_AUTHORIZED,
-  DROPSY_AIRDROP_ERROR__UPDATE_CUTOFF_TIME_PASSED: () => DROPSY_AIRDROP_ERROR__UPDATE_CUTOFF_TIME_PASSED,
-  DROPSY_AIRDROP_ERROR__VALUE_BELOW_THE_MINIMUM: () => DROPSY_AIRDROP_ERROR__VALUE_BELOW_THE_MINIMUM,
-  DROPSY_AIRDROP_ERROR__VALUE_EXCEEDS_MAXIMUM: () => DROPSY_AIRDROP_ERROR__VALUE_EXCEEDS_MAXIMUM,
-  DROPSY_AIRDROP_ERROR__VALUE_OUT_OF_RANGE: () => DROPSY_AIRDROP_ERROR__VALUE_OUT_OF_RANGE,
-  DROPSY_AIRDROP_ERROR__VAULT_FROZEN: () => DROPSY_AIRDROP_ERROR__VAULT_FROZEN,
-  DROPSY_AIRDROP_ERROR__VAULT_HAS_CLOSE_AUTHORITY: () => DROPSY_AIRDROP_ERROR__VAULT_HAS_CLOSE_AUTHORITY,
-  DROPSY_AIRDROP_ERROR__VAULT_HAS_DELEGATE: () => DROPSY_AIRDROP_ERROR__VAULT_HAS_DELEGATE,
-  DROPSY_AIRDROP_ERROR__VAULT_MINT_MISMATCH: () => DROPSY_AIRDROP_ERROR__VAULT_MINT_MISMATCH,
-  DROPSY_AIRDROP_ERROR__VAULT_NOT_INITIALIZED: () => DROPSY_AIRDROP_ERROR__VAULT_NOT_INITIALIZED,
-  DROPSY_AIRDROP_ERROR__VAULT_NOT_RENT_EXEMPT: () => DROPSY_AIRDROP_ERROR__VAULT_NOT_RENT_EXEMPT,
-  DROPSY_AIRDROP_ERROR__VESTING_ACCOUNT_REQUIRED: () => DROPSY_AIRDROP_ERROR__VESTING_ACCOUNT_REQUIRED,
-  DROPSY_AIRDROP_PROGRAM_ADDRESS: () => DROPSY_AIRDROP_PROGRAM_ADDRESS,
-  DropsyAirdropAccount: () => DropsyAirdropAccount,
-  DropsyAirdropInstruction: () => DropsyAirdropInstruction,
-  INITIALIZE_AIRDROP_CONFIG_DISCRIMINATOR: () => INITIALIZE_AIRDROP_CONFIG_DISCRIMINATOR,
-  INITIALIZE_AIRDROP_MASTER_DISCRIMINATOR: () => INITIALIZE_AIRDROP_MASTER_DISCRIMINATOR,
-  decodeAirdrop: () => decodeAirdrop,
-  decodeAirdropConfig: () => decodeAirdropConfig,
-  decodeAirdropMaster: () => decodeAirdropMaster,
-  decodeBitmapAccount: () => decodeBitmapAccount,
-  fetchAirdrop: () => fetchAirdrop,
-  fetchAirdropConfig: () => fetchAirdropConfig,
-  fetchAirdropMaster: () => fetchAirdropMaster,
-  fetchAllAirdrop: () => fetchAllAirdrop,
-  fetchAllAirdropConfig: () => fetchAllAirdropConfig,
-  fetchAllAirdropMaster: () => fetchAllAirdropMaster,
-  fetchAllBitmapAccount: () => fetchAllBitmapAccount,
-  fetchAllMaybeAirdrop: () => fetchAllMaybeAirdrop,
-  fetchAllMaybeAirdropConfig: () => fetchAllMaybeAirdropConfig,
-  fetchAllMaybeAirdropMaster: () => fetchAllMaybeAirdropMaster,
-  fetchAllMaybeBitmapAccount: () => fetchAllMaybeBitmapAccount,
-  fetchBitmapAccount: () => fetchBitmapAccount,
-  fetchMaybeAirdrop: () => fetchMaybeAirdrop,
-  fetchMaybeAirdropConfig: () => fetchMaybeAirdropConfig,
-  fetchMaybeAirdropMaster: () => fetchMaybeAirdropMaster,
-  fetchMaybeBitmapAccount: () => fetchMaybeBitmapAccount,
-  getAirdropCodec: () => getAirdropCodec,
-  getAirdropConfigCodec: () => getAirdropConfigCodec,
-  getAirdropConfigDecoder: () => getAirdropConfigDecoder,
-  getAirdropConfigDiscriminatorBytes: () => getAirdropConfigDiscriminatorBytes,
-  getAirdropConfigEncoder: () => getAirdropConfigEncoder,
-  getAirdropConfigSize: () => getAirdropConfigSize,
-  getAirdropDecoder: () => getAirdropDecoder,
-  getAirdropDiscriminatorBytes: () => getAirdropDiscriminatorBytes,
-  getAirdropEncoder: () => getAirdropEncoder,
-  getAirdropInitializedCodec: () => getAirdropInitializedCodec,
-  getAirdropInitializedDecoder: () => getAirdropInitializedDecoder,
-  getAirdropInitializedEncoder: () => getAirdropInitializedEncoder,
-  getAirdropMasterCodec: () => getAirdropMasterCodec,
-  getAirdropMasterDecoder: () => getAirdropMasterDecoder,
-  getAirdropMasterDiscriminatorBytes: () => getAirdropMasterDiscriminatorBytes,
-  getAirdropMasterEncoder: () => getAirdropMasterEncoder,
-  getAirdropMasterSize: () => getAirdropMasterSize,
-  getAirdropSize: () => getAirdropSize,
-  getBitmapAccountCodec: () => getBitmapAccountCodec,
-  getBitmapAccountDecoder: () => getBitmapAccountDecoder,
-  getBitmapAccountDiscriminatorBytes: () => getBitmapAccountDiscriminatorBytes,
-  getBitmapAccountEncoder: () => getBitmapAccountEncoder,
-  getBitmapAccountSize: () => getBitmapAccountSize,
-  getBitmapClosedCodec: () => getBitmapClosedCodec,
-  getBitmapClosedDecoder: () => getBitmapClosedDecoder,
-  getBitmapClosedEncoder: () => getBitmapClosedEncoder,
-  getBitmapInitializedCodec: () => getBitmapInitializedCodec,
-  getBitmapInitializedDecoder: () => getBitmapInitializedDecoder,
-  getBitmapInitializedEncoder: () => getBitmapInitializedEncoder,
-  getClaimAirdropDiscriminatorBytes: () => getClaimAirdropDiscriminatorBytes,
-  getClaimAirdropInstruction: () => getClaimAirdropInstruction,
-  getClaimAirdropInstructionAsync: () => getClaimAirdropInstructionAsync,
-  getClaimAirdropInstructionDataCodec: () => getClaimAirdropInstructionDataCodec,
-  getClaimAirdropInstructionDataDecoder: () => getClaimAirdropInstructionDataDecoder,
-  getClaimAirdropInstructionDataEncoder: () => getClaimAirdropInstructionDataEncoder,
-  getCreateAirdropDiscriminatorBytes: () => getCreateAirdropDiscriminatorBytes,
-  getCreateAirdropInstruction: () => getCreateAirdropInstruction,
-  getCreateAirdropInstructionAsync: () => getCreateAirdropInstructionAsync,
-  getCreateAirdropInstructionDataCodec: () => getCreateAirdropInstructionDataCodec,
-  getCreateAirdropInstructionDataDecoder: () => getCreateAirdropInstructionDataDecoder,
-  getCreateAirdropInstructionDataEncoder: () => getCreateAirdropInstructionDataEncoder,
-  getCreateBitmapDiscriminatorBytes: () => getCreateBitmapDiscriminatorBytes,
-  getCreateBitmapInstruction: () => getCreateBitmapInstruction,
-  getCreateBitmapInstructionAsync: () => getCreateBitmapInstructionAsync,
-  getCreateBitmapInstructionDataCodec: () => getCreateBitmapInstructionDataCodec,
-  getCreateBitmapInstructionDataDecoder: () => getCreateBitmapInstructionDataDecoder,
-  getCreateBitmapInstructionDataEncoder: () => getCreateBitmapInstructionDataEncoder,
-  getDepositTokensDiscriminatorBytes: () => getDepositTokensDiscriminatorBytes,
-  getDepositTokensInstruction: () => getDepositTokensInstruction,
-  getDepositTokensInstructionAsync: () => getDepositTokensInstructionAsync,
-  getDepositTokensInstructionDataCodec: () => getDepositTokensInstructionDataCodec,
-  getDepositTokensInstructionDataDecoder: () => getDepositTokensInstructionDataDecoder,
-  getDepositTokensInstructionDataEncoder: () => getDepositTokensInstructionDataEncoder,
-  getDropsyAirdropErrorMessage: () => getDropsyAirdropErrorMessage,
-  getInitializeAirdropConfigDiscriminatorBytes: () => getInitializeAirdropConfigDiscriminatorBytes,
-  getInitializeAirdropConfigInstruction: () => getInitializeAirdropConfigInstruction,
-  getInitializeAirdropConfigInstructionAsync: () => getInitializeAirdropConfigInstructionAsync,
-  getInitializeAirdropConfigInstructionDataCodec: () => getInitializeAirdropConfigInstructionDataCodec,
-  getInitializeAirdropConfigInstructionDataDecoder: () => getInitializeAirdropConfigInstructionDataDecoder,
-  getInitializeAirdropConfigInstructionDataEncoder: () => getInitializeAirdropConfigInstructionDataEncoder,
-  getInitializeAirdropMasterDiscriminatorBytes: () => getInitializeAirdropMasterDiscriminatorBytes,
-  getInitializeAirdropMasterInstruction: () => getInitializeAirdropMasterInstruction,
-  getInitializeAirdropMasterInstructionAsync: () => getInitializeAirdropMasterInstructionAsync,
-  getInitializeAirdropMasterInstructionDataCodec: () => getInitializeAirdropMasterInstructionDataCodec,
-  getInitializeAirdropMasterInstructionDataDecoder: () => getInitializeAirdropMasterInstructionDataDecoder,
-  getInitializeAirdropMasterInstructionDataEncoder: () => getInitializeAirdropMasterInstructionDataEncoder,
-  getTokensDepositedCodec: () => getTokensDepositedCodec,
-  getTokensDepositedDecoder: () => getTokensDepositedDecoder,
-  getTokensDepositedEncoder: () => getTokensDepositedEncoder,
-  getTokensRedeemedCodec: () => getTokensRedeemedCodec,
-  getTokensRedeemedDecoder: () => getTokensRedeemedDecoder,
-  getTokensRedeemedEncoder: () => getTokensRedeemedEncoder,
-  identifyDropsyAirdropAccount: () => identifyDropsyAirdropAccount,
-  identifyDropsyAirdropInstruction: () => identifyDropsyAirdropInstruction,
-  isDropsyAirdropError: () => isDropsyAirdropError,
-  parseClaimAirdropInstruction: () => parseClaimAirdropInstruction,
-  parseCreateAirdropInstruction: () => parseCreateAirdropInstruction,
-  parseCreateBitmapInstruction: () => parseCreateBitmapInstruction,
-  parseDepositTokensInstruction: () => parseDepositTokensInstruction,
-  parseDropsyAirdropInstruction: () => parseDropsyAirdropInstruction,
-  parseInitializeAirdropConfigInstruction: () => parseInitializeAirdropConfigInstruction,
-  parseInitializeAirdropMasterInstruction: () => parseInitializeAirdropMasterInstruction
-});
-module.exports = __toCommonJS(index_exports);
-
 // src/accounts/airdrop.ts
-var import_kit = require("@solana/kit");
+import {
+  assertAccountExists,
+  assertAccountsExist,
+  combineCodec,
+  decodeAccount,
+  fetchEncodedAccount,
+  fetchEncodedAccounts,
+  fixDecoderSize,
+  fixEncoderSize,
+  getAddressDecoder,
+  getAddressEncoder,
+  getBytesDecoder,
+  getBytesEncoder,
+  getI64Decoder,
+  getI64Encoder,
+  getStructDecoder,
+  getStructEncoder,
+  getU16Decoder,
+  getU16Encoder,
+  getU64Decoder,
+  getU64Encoder,
+  getU8Decoder,
+  getU8Encoder,
+  transformEncoder
+} from "@solana/kit";
 var AIRDROP_DISCRIMINATOR = new Uint8Array([
   31,
   112,
@@ -224,86 +35,108 @@ var AIRDROP_DISCRIMINATOR = new Uint8Array([
   241
 ]);
 function getAirdropDiscriminatorBytes() {
-  return (0, import_kit.fixEncoderSize)((0, import_kit.getBytesEncoder)(), 8).encode(AIRDROP_DISCRIMINATOR);
+  return fixEncoderSize(getBytesEncoder(), 8).encode(AIRDROP_DISCRIMINATOR);
 }
 function getAirdropEncoder() {
-  return (0, import_kit.transformEncoder)(
-    (0, import_kit.getStructEncoder)([
-      ["discriminator", (0, import_kit.fixEncoderSize)((0, import_kit.getBytesEncoder)(), 8)],
-      ["master", (0, import_kit.getAddressEncoder)()],
-      ["authority", (0, import_kit.getAddressEncoder)()],
-      ["mint", (0, import_kit.getAddressEncoder)()],
-      ["delegateAuthority", (0, import_kit.getAddressEncoder)()],
-      ["merkleRoot", (0, import_kit.fixEncoderSize)((0, import_kit.getBytesEncoder)(), 32)],
-      ["supply", (0, import_kit.getU64Encoder)()],
-      ["boost", (0, import_kit.getU64Encoder)()],
-      ["startsAt", (0, import_kit.getI64Encoder)()],
-      ["endsAt", (0, import_kit.getI64Encoder)()],
-      ["bitmapCount", (0, import_kit.getU16Encoder)()],
-      ["delegatePermissions", (0, import_kit.getU8Encoder)()],
-      ["mutable", (0, import_kit.getU8Encoder)()],
-      ["state", (0, import_kit.getU8Encoder)()],
-      ["version", (0, import_kit.getU8Encoder)()],
-      ["bump", (0, import_kit.getU8Encoder)()],
-      ["padding", (0, import_kit.fixEncoderSize)((0, import_kit.getBytesEncoder)(), 1)]
+  return transformEncoder(
+    getStructEncoder([
+      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+      ["master", getAddressEncoder()],
+      ["authority", getAddressEncoder()],
+      ["mint", getAddressEncoder()],
+      ["delegateAuthority", getAddressEncoder()],
+      ["merkleRoot", fixEncoderSize(getBytesEncoder(), 32)],
+      ["id", getU64Encoder()],
+      ["supply", getU64Encoder()],
+      ["boost", getU64Encoder()],
+      ["startsAt", getI64Encoder()],
+      ["endsAt", getI64Encoder()],
+      ["bitmapCount", getU16Encoder()],
+      ["state", getU8Encoder()],
+      ["version", getU8Encoder()],
+      ["bump", getU8Encoder()],
+      ["padding", fixEncoderSize(getBytesEncoder(), 3)]
     ]),
     (value) => ({ ...value, discriminator: AIRDROP_DISCRIMINATOR })
   );
 }
 function getAirdropDecoder() {
-  return (0, import_kit.getStructDecoder)([
-    ["discriminator", (0, import_kit.fixDecoderSize)((0, import_kit.getBytesDecoder)(), 8)],
-    ["master", (0, import_kit.getAddressDecoder)()],
-    ["authority", (0, import_kit.getAddressDecoder)()],
-    ["mint", (0, import_kit.getAddressDecoder)()],
-    ["delegateAuthority", (0, import_kit.getAddressDecoder)()],
-    ["merkleRoot", (0, import_kit.fixDecoderSize)((0, import_kit.getBytesDecoder)(), 32)],
-    ["supply", (0, import_kit.getU64Decoder)()],
-    ["boost", (0, import_kit.getU64Decoder)()],
-    ["startsAt", (0, import_kit.getI64Decoder)()],
-    ["endsAt", (0, import_kit.getI64Decoder)()],
-    ["bitmapCount", (0, import_kit.getU16Decoder)()],
-    ["delegatePermissions", (0, import_kit.getU8Decoder)()],
-    ["mutable", (0, import_kit.getU8Decoder)()],
-    ["state", (0, import_kit.getU8Decoder)()],
-    ["version", (0, import_kit.getU8Decoder)()],
-    ["bump", (0, import_kit.getU8Decoder)()],
-    ["padding", (0, import_kit.fixDecoderSize)((0, import_kit.getBytesDecoder)(), 1)]
+  return getStructDecoder([
+    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+    ["master", getAddressDecoder()],
+    ["authority", getAddressDecoder()],
+    ["mint", getAddressDecoder()],
+    ["delegateAuthority", getAddressDecoder()],
+    ["merkleRoot", fixDecoderSize(getBytesDecoder(), 32)],
+    ["id", getU64Decoder()],
+    ["supply", getU64Decoder()],
+    ["boost", getU64Decoder()],
+    ["startsAt", getI64Decoder()],
+    ["endsAt", getI64Decoder()],
+    ["bitmapCount", getU16Decoder()],
+    ["state", getU8Decoder()],
+    ["version", getU8Decoder()],
+    ["bump", getU8Decoder()],
+    ["padding", fixDecoderSize(getBytesDecoder(), 3)]
   ]);
 }
 function getAirdropCodec() {
-  return (0, import_kit.combineCodec)(getAirdropEncoder(), getAirdropDecoder());
+  return combineCodec(getAirdropEncoder(), getAirdropDecoder());
 }
 function decodeAirdrop(encodedAccount) {
-  return (0, import_kit.decodeAccount)(
+  return decodeAccount(
     encodedAccount,
     getAirdropDecoder()
   );
 }
 async function fetchAirdrop(rpc, address, config) {
   const maybeAccount = await fetchMaybeAirdrop(rpc, address, config);
-  (0, import_kit.assertAccountExists)(maybeAccount);
+  assertAccountExists(maybeAccount);
   return maybeAccount;
 }
 async function fetchMaybeAirdrop(rpc, address, config) {
-  const maybeAccount = await (0, import_kit.fetchEncodedAccount)(rpc, address, config);
+  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
   return decodeAirdrop(maybeAccount);
 }
 async function fetchAllAirdrop(rpc, addresses, config) {
   const maybeAccounts = await fetchAllMaybeAirdrop(rpc, addresses, config);
-  (0, import_kit.assertAccountsExist)(maybeAccounts);
+  assertAccountsExist(maybeAccounts);
   return maybeAccounts;
 }
 async function fetchAllMaybeAirdrop(rpc, addresses, config) {
-  const maybeAccounts = await (0, import_kit.fetchEncodedAccounts)(rpc, addresses, config);
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
   return maybeAccounts.map((maybeAccount) => decodeAirdrop(maybeAccount));
 }
 function getAirdropSize() {
-  return 208;
+  return 216;
 }
 
 // src/accounts/airdropConfig.ts
-var import_kit2 = require("@solana/kit");
+import {
+  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,
+  getI64Decoder as getI64Decoder2,
+  getI64Encoder as getI64Encoder2,
+  getStructDecoder as getStructDecoder2,
+  getStructEncoder as getStructEncoder2,
+  getU16Decoder as getU16Decoder2,
+  getU16Encoder as getU16Encoder2,
+  getU64Decoder as getU64Decoder2,
+  getU64Encoder as getU64Encoder2,
+  getU8Decoder as getU8Decoder2,
+  getU8Encoder as getU8Encoder2,
+  transformEncoder as transformEncoder2
+} from "@solana/kit";
 var AIRDROP_CONFIG_DISCRIMINATOR = new Uint8Array([
   194,
   149,
@@ -315,71 +148,71 @@ var AIRDROP_CONFIG_DISCRIMINATOR = new Uint8Array([
   16
 ]);
 function getAirdropConfigDiscriminatorBytes() {
-  return (0, import_kit2.fixEncoderSize)((0, import_kit2.getBytesEncoder)(), 8).encode(
+  return fixEncoderSize2(getBytesEncoder2(), 8).encode(
     AIRDROP_CONFIG_DISCRIMINATOR
   );
 }
 function getAirdropConfigEncoder() {
-  return (0, import_kit2.transformEncoder)(
-    (0, import_kit2.getStructEncoder)([
-      ["discriminator", (0, import_kit2.fixEncoderSize)((0, import_kit2.getBytesEncoder)(), 8)],
-      ["authority", (0, import_kit2.getAddressEncoder)()],
-      ["protocolTreasury", (0, import_kit2.getAddressEncoder)()],
-      ["wlRoot", (0, import_kit2.fixEncoderSize)((0, import_kit2.getBytesEncoder)(), 32)],
-      ["protocolFee", (0, import_kit2.getU64Encoder)()],
-      ["airdropMasterCreateFee", (0, import_kit2.getU64Encoder)()],
-      ["maxClaimFee", (0, import_kit2.getU64Encoder)()],
-      ["maxActionFee", (0, import_kit2.getU64Encoder)()],
-      ["minAirdropDuration", (0, import_kit2.getI64Encoder)()],
-      ["defaultAirdropDuration", (0, import_kit2.getI64Encoder)()],
-      ["maxAirdropDuration", (0, import_kit2.getI64Encoder)()],
-      ["updateGracePeriod", (0, import_kit2.getI64Encoder)()],
-      ["masterFeeBps", (0, import_kit2.getU16Encoder)()],
-      ["version", (0, import_kit2.getU8Encoder)()],
-      ["bump", (0, import_kit2.getU8Encoder)()],
-      ["padding", (0, import_kit2.fixEncoderSize)((0, import_kit2.getBytesEncoder)(), 4)],
-      ["reserved", (0, import_kit2.fixEncoderSize)((0, import_kit2.getBytesEncoder)(), 256)]
+  return transformEncoder2(
+    getStructEncoder2([
+      ["discriminator", fixEncoderSize2(getBytesEncoder2(), 8)],
+      ["authority", getAddressEncoder2()],
+      ["protocolTreasury", getAddressEncoder2()],
+      ["wlRoot", fixEncoderSize2(getBytesEncoder2(), 32)],
+      ["protocolFee", getU64Encoder2()],
+      ["airdropMasterCreateFee", getU64Encoder2()],
+      ["maxClaimFee", getU64Encoder2()],
+      ["maxActionFee", getU64Encoder2()],
+      ["minAirdropDuration", getI64Encoder2()],
+      ["defaultAirdropDuration", getI64Encoder2()],
+      ["maxAirdropDuration", getI64Encoder2()],
+      ["updateGracePeriod", getI64Encoder2()],
+      ["masterFeeBps", getU16Encoder2()],
+      ["version", getU8Encoder2()],
+      ["bump", getU8Encoder2()],
+      ["padding", fixEncoderSize2(getBytesEncoder2(), 4)],
+      ["reserved", fixEncoderSize2(getBytesEncoder2(), 256)]
     ]),
     (value) => ({ ...value, discriminator: AIRDROP_CONFIG_DISCRIMINATOR })
   );
 }
 function getAirdropConfigDecoder() {
-  return (0, import_kit2.getStructDecoder)([
-    ["discriminator", (0, import_kit2.fixDecoderSize)((0, import_kit2.getBytesDecoder)(), 8)],
-    ["authority", (0, import_kit2.getAddressDecoder)()],
-    ["protocolTreasury", (0, import_kit2.getAddressDecoder)()],
-    ["wlRoot", (0, import_kit2.fixDecoderSize)((0, import_kit2.getBytesDecoder)(), 32)],
-    ["protocolFee", (0, import_kit2.getU64Decoder)()],
-    ["airdropMasterCreateFee", (0, import_kit2.getU64Decoder)()],
-    ["maxClaimFee", (0, import_kit2.getU64Decoder)()],
-    ["maxActionFee", (0, import_kit2.getU64Decoder)()],
-    ["minAirdropDuration", (0, import_kit2.getI64Decoder)()],
-    ["defaultAirdropDuration", (0, import_kit2.getI64Decoder)()],
-    ["maxAirdropDuration", (0, import_kit2.getI64Decoder)()],
-    ["updateGracePeriod", (0, import_kit2.getI64Decoder)()],
-    ["masterFeeBps", (0, import_kit2.getU16Decoder)()],
-    ["version", (0, import_kit2.getU8Decoder)()],
-    ["bump", (0, import_kit2.getU8Decoder)()],
-    ["padding", (0, import_kit2.fixDecoderSize)((0, import_kit2.getBytesDecoder)(), 4)],
-    ["reserved", (0, import_kit2.fixDecoderSize)((0, import_kit2.getBytesDecoder)(), 256)]
+  return getStructDecoder2([
+    ["discriminator", fixDecoderSize2(getBytesDecoder2(), 8)],
+    ["authority", getAddressDecoder2()],
+    ["protocolTreasury", getAddressDecoder2()],
+    ["wlRoot", fixDecoderSize2(getBytesDecoder2(), 32)],
+    ["protocolFee", getU64Decoder2()],
+    ["airdropMasterCreateFee", getU64Decoder2()],
+    ["maxClaimFee", getU64Decoder2()],
+    ["maxActionFee", getU64Decoder2()],
+    ["minAirdropDuration", getI64Decoder2()],
+    ["defaultAirdropDuration", getI64Decoder2()],
+    ["maxAirdropDuration", getI64Decoder2()],
+    ["updateGracePeriod", getI64Decoder2()],
+    ["masterFeeBps", getU16Decoder2()],
+    ["version", getU8Decoder2()],
+    ["bump", getU8Decoder2()],
+    ["padding", fixDecoderSize2(getBytesDecoder2(), 4)],
+    ["reserved", fixDecoderSize2(getBytesDecoder2(), 256)]
   ]);
 }
 function getAirdropConfigCodec() {
-  return (0, import_kit2.combineCodec)(getAirdropConfigEncoder(), getAirdropConfigDecoder());
+  return combineCodec2(getAirdropConfigEncoder(), getAirdropConfigDecoder());
 }
 function decodeAirdropConfig(encodedAccount) {
-  return (0, import_kit2.decodeAccount)(
+  return decodeAccount2(
     encodedAccount,
     getAirdropConfigDecoder()
   );
 }
 async function fetchAirdropConfig(rpc, address, config) {
   const maybeAccount = await fetchMaybeAirdropConfig(rpc, address, config);
-  (0, import_kit2.assertAccountExists)(maybeAccount);
+  assertAccountExists2(maybeAccount);
   return maybeAccount;
 }
 async function fetchMaybeAirdropConfig(rpc, address, config) {
-  const maybeAccount = await (0, import_kit2.fetchEncodedAccount)(rpc, address, config);
+  const maybeAccount = await fetchEncodedAccount2(rpc, address, config);
   return decodeAirdropConfig(maybeAccount);
 }
 async function fetchAllAirdropConfig(rpc, addresses, config) {
@@ -388,11 +221,11 @@ async function fetchAllAirdropConfig(rpc, addresses, config) {
     addresses,
     config
   );
-  (0, import_kit2.assertAccountsExist)(maybeAccounts);
+  assertAccountsExist2(maybeAccounts);
   return maybeAccounts;
 }
 async function fetchAllMaybeAirdropConfig(rpc, addresses, config) {
-  const maybeAccounts = await (0, import_kit2.fetchEncodedAccounts)(rpc, addresses, config);
+  const maybeAccounts = await fetchEncodedAccounts2(rpc, addresses, config);
   return maybeAccounts.map((maybeAccount) => decodeAirdropConfig(maybeAccount));
 }
 function getAirdropConfigSize() {
@@ -400,7 +233,27 @@ function getAirdropConfigSize() {
 }
 
 // src/accounts/airdropMaster.ts
-var import_kit3 = require("@solana/kit");
+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 getU64Decoder3,
+  getU64Encoder as getU64Encoder3,
+  getU8Decoder as getU8Decoder3,
+  getU8Encoder as getU8Encoder3,
+  transformEncoder as transformEncoder3
+} from "@solana/kit";
 var AIRDROP_MASTER_DISCRIMINATOR = new Uint8Array([
   31,
   109,
@@ -412,67 +265,69 @@ var AIRDROP_MASTER_DISCRIMINATOR = new Uint8Array([
   4
 ]);
 function getAirdropMasterDiscriminatorBytes() {
-  return (0, import_kit3.fixEncoderSize)((0, import_kit3.getBytesEncoder)(), 8).encode(
+  return fixEncoderSize3(getBytesEncoder3(), 8).encode(
     AIRDROP_MASTER_DISCRIMINATOR
   );
 }
 function getAirdropMasterEncoder() {
-  return (0, import_kit3.transformEncoder)(
-    (0, import_kit3.getStructEncoder)([
-      ["discriminator", (0, import_kit3.fixEncoderSize)((0, import_kit3.getBytesEncoder)(), 8)],
-      ["creator", (0, import_kit3.getAddressEncoder)()],
-      ["authority", (0, import_kit3.getAddressEncoder)()],
-      ["treasury", (0, import_kit3.getAddressEncoder)()],
-      ["points", (0, import_kit3.getU64Encoder)()],
-      ["totalClaimCount", (0, import_kit3.getU64Encoder)()],
-      ["monetizedClaimQuota", (0, import_kit3.getU64Encoder)()],
-      ["monetizedClaimCount", (0, import_kit3.getU64Encoder)()],
-      ["airdropUpdateFee", (0, import_kit3.getU64Encoder)()],
-      ["airdropCreationFee", (0, import_kit3.getU64Encoder)()],
-      ["airdropClaimFee", (0, import_kit3.getU64Encoder)()],
-      ["airdropDelegateFee", (0, import_kit3.getU64Encoder)()],
-      ["bitmapCreationFee", (0, import_kit3.getU64Encoder)()],
-      ["bump", (0, import_kit3.getU8Encoder)()],
-      ["padding", (0, import_kit3.fixEncoderSize)((0, import_kit3.getBytesEncoder)(), 7)]
+  return transformEncoder3(
+    getStructEncoder3([
+      ["discriminator", fixEncoderSize3(getBytesEncoder3(), 8)],
+      ["creator", getAddressEncoder3()],
+      ["authority", getAddressEncoder3()],
+      ["treasury", getAddressEncoder3()],
+      ["createdAirdrops", getU64Encoder3()],
+      ["points", getU64Encoder3()],
+      ["totalClaimCount", getU64Encoder3()],
+      ["monetizedClaimQuota", getU64Encoder3()],
+      ["monetizedClaimCount", getU64Encoder3()],
+      ["airdropUpdateFee", getU64Encoder3()],
+      ["airdropCreationFee", getU64Encoder3()],
+      ["airdropClaimFee", getU64Encoder3()],
+      ["airdropDelegateFee", getU64Encoder3()],
+      ["bitmapCreationFee", getU64Encoder3()],
+      ["bump", getU8Encoder3()],
+      ["padding", fixEncoderSize3(getBytesEncoder3(), 7)]
     ]),
     (value) => ({ ...value, discriminator: AIRDROP_MASTER_DISCRIMINATOR })
   );
 }
 function getAirdropMasterDecoder() {
-  return (0, import_kit3.getStructDecoder)([
-    ["discriminator", (0, import_kit3.fixDecoderSize)((0, import_kit3.getBytesDecoder)(), 8)],
-    ["creator", (0, import_kit3.getAddressDecoder)()],
-    ["authority", (0, import_kit3.getAddressDecoder)()],
-    ["treasury", (0, import_kit3.getAddressDecoder)()],
-    ["points", (0, import_kit3.getU64Decoder)()],
-    ["totalClaimCount", (0, import_kit3.getU64Decoder)()],
-    ["monetizedClaimQuota", (0, import_kit3.getU64Decoder)()],
-    ["monetizedClaimCount", (0, import_kit3.getU64Decoder)()],
-    ["airdropUpdateFee", (0, import_kit3.getU64Decoder)()],
-    ["airdropCreationFee", (0, import_kit3.getU64Decoder)()],
-    ["airdropClaimFee", (0, import_kit3.getU64Decoder)()],
-    ["airdropDelegateFee", (0, import_kit3.getU64Decoder)()],
-    ["bitmapCreationFee", (0, import_kit3.getU64Decoder)()],
-    ["bump", (0, import_kit3.getU8Decoder)()],
-    ["padding", (0, import_kit3.fixDecoderSize)((0, import_kit3.getBytesDecoder)(), 7)]
+  return getStructDecoder3([
+    ["discriminator", fixDecoderSize3(getBytesDecoder3(), 8)],
+    ["creator", getAddressDecoder3()],
+    ["authority", getAddressDecoder3()],
+    ["treasury", getAddressDecoder3()],
+    ["createdAirdrops", getU64Decoder3()],
+    ["points", getU64Decoder3()],
+    ["totalClaimCount", getU64Decoder3()],
+    ["monetizedClaimQuota", getU64Decoder3()],
+    ["monetizedClaimCount", getU64Decoder3()],
+    ["airdropUpdateFee", getU64Decoder3()],
+    ["airdropCreationFee", getU64Decoder3()],
+    ["airdropClaimFee", getU64Decoder3()],
+    ["airdropDelegateFee", getU64Decoder3()],
+    ["bitmapCreationFee", getU64Decoder3()],
+    ["bump", getU8Decoder3()],
+    ["padding", fixDecoderSize3(getBytesDecoder3(), 7)]
   ]);
 }
 function getAirdropMasterCodec() {
-  return (0, import_kit3.combineCodec)(getAirdropMasterEncoder(), getAirdropMasterDecoder());
+  return combineCodec3(getAirdropMasterEncoder(), getAirdropMasterDecoder());
 }
 function decodeAirdropMaster(encodedAccount) {
-  return (0, import_kit3.decodeAccount)(
+  return decodeAccount3(
     encodedAccount,
     getAirdropMasterDecoder()
   );
 }
 async function fetchAirdropMaster(rpc, address, config) {
   const maybeAccount = await fetchMaybeAirdropMaster(rpc, address, config);
-  (0, import_kit3.assertAccountExists)(maybeAccount);
+  assertAccountExists3(maybeAccount);
   return maybeAccount;
 }
 async function fetchMaybeAirdropMaster(rpc, address, config) {
-  const maybeAccount = await (0, import_kit3.fetchEncodedAccount)(rpc, address, config);
+  const maybeAccount = await fetchEncodedAccount3(rpc, address, config);
   return decodeAirdropMaster(maybeAccount);
 }
 async function fetchAllAirdropMaster(rpc, addresses, config) {
@@ -481,19 +336,41 @@ async function fetchAllAirdropMaster(rpc, addresses, config) {
     addresses,
     config
   );
-  (0, import_kit3.assertAccountsExist)(maybeAccounts);
+  assertAccountsExist3(maybeAccounts);
   return maybeAccounts;
 }
 async function fetchAllMaybeAirdropMaster(rpc, addresses, config) {
-  const maybeAccounts = await (0, import_kit3.fetchEncodedAccounts)(rpc, addresses, config);
+  const maybeAccounts = await fetchEncodedAccounts3(rpc, addresses, config);
   return maybeAccounts.map((maybeAccount) => decodeAirdropMaster(maybeAccount));
 }
 function getAirdropMasterSize() {
-  return 184;
+  return 192;
 }
 
 // src/accounts/bitmapAccount.ts
-var import_kit4 = require("@solana/kit");
+import {
+  assertAccountExists as assertAccountExists4,
+  assertAccountsExist as assertAccountsExist4,
+  combineCodec as combineCodec4,
+  decodeAccount as decodeAccount4,
+  fetchEncodedAccount as fetchEncodedAccount4,
+  fetchEncodedAccounts as fetchEncodedAccounts4,
+  fixDecoderSize as fixDecoderSize4,
+  fixEncoderSize as fixEncoderSize4,
+  getAddressDecoder as getAddressDecoder4,
+  getAddressEncoder as getAddressEncoder4,
+  getBytesDecoder as getBytesDecoder4,
+  getBytesEncoder as getBytesEncoder4,
+  getStructDecoder as getStructDecoder4,
+  getStructEncoder as getStructEncoder4,
+  getU16Decoder as getU16Decoder3,
+  getU16Encoder as getU16Encoder3,
+  getU32Decoder,
+  getU32Encoder,
+  getU8Decoder as getU8Decoder4,
+  getU8Encoder as getU8Encoder4,
+  transformEncoder as transformEncoder4
+} from "@solana/kit";
 var BITMAP_ACCOUNT_DISCRIMINATOR = new Uint8Array([
   152,
   161,
@@ -505,53 +382,53 @@ var BITMAP_ACCOUNT_DISCRIMINATOR = new Uint8Array([
   48
 ]);
 function getBitmapAccountDiscriminatorBytes() {
-  return (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8).encode(
+  return fixEncoderSize4(getBytesEncoder4(), 8).encode(
     BITMAP_ACCOUNT_DISCRIMINATOR
   );
 }
 function getBitmapAccountEncoder() {
-  return (0, import_kit4.transformEncoder)(
-    (0, import_kit4.getStructEncoder)([
-      ["discriminator", (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8)],
-      ["authority", (0, import_kit4.getAddressEncoder)()],
-      ["airdrop", (0, import_kit4.getAddressEncoder)()],
-      ["total", (0, import_kit4.getU32Encoder)()],
-      ["claimedBitmap", (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8e3)],
-      ["id", (0, import_kit4.getU16Encoder)()],
-      ["version", (0, import_kit4.getU8Encoder)()],
-      ["bump", (0, import_kit4.getU8Encoder)()]
+  return transformEncoder4(
+    getStructEncoder4([
+      ["discriminator", fixEncoderSize4(getBytesEncoder4(), 8)],
+      ["authority", getAddressEncoder4()],
+      ["airdrop", getAddressEncoder4()],
+      ["total", getU32Encoder()],
+      ["claimedBitmap", fixEncoderSize4(getBytesEncoder4(), 1e3)],
+      ["id", getU16Encoder3()],
+      ["version", getU8Encoder4()],
+      ["bump", getU8Encoder4()]
     ]),
     (value) => ({ ...value, discriminator: BITMAP_ACCOUNT_DISCRIMINATOR })
   );
 }
 function getBitmapAccountDecoder() {
-  return (0, import_kit4.getStructDecoder)([
-    ["discriminator", (0, import_kit4.fixDecoderSize)((0, import_kit4.getBytesDecoder)(), 8)],
-    ["authority", (0, import_kit4.getAddressDecoder)()],
-    ["airdrop", (0, import_kit4.getAddressDecoder)()],
-    ["total", (0, import_kit4.getU32Decoder)()],
-    ["claimedBitmap", (0, import_kit4.fixDecoderSize)((0, import_kit4.getBytesDecoder)(), 8e3)],
-    ["id", (0, import_kit4.getU16Decoder)()],
-    ["version", (0, import_kit4.getU8Decoder)()],
-    ["bump", (0, import_kit4.getU8Decoder)()]
+  return getStructDecoder4([
+    ["discriminator", fixDecoderSize4(getBytesDecoder4(), 8)],
+    ["authority", getAddressDecoder4()],
+    ["airdrop", getAddressDecoder4()],
+    ["total", getU32Decoder()],
+    ["claimedBitmap", fixDecoderSize4(getBytesDecoder4(), 1e3)],
+    ["id", getU16Decoder3()],
+    ["version", getU8Decoder4()],
+    ["bump", getU8Decoder4()]
   ]);
 }
 function getBitmapAccountCodec() {
-  return (0, import_kit4.combineCodec)(getBitmapAccountEncoder(), getBitmapAccountDecoder());
+  return combineCodec4(getBitmapAccountEncoder(), getBitmapAccountDecoder());
 }
 function decodeBitmapAccount(encodedAccount) {
-  return (0, import_kit4.decodeAccount)(
+  return decodeAccount4(
     encodedAccount,
     getBitmapAccountDecoder()
   );
 }
 async function fetchBitmapAccount(rpc, address, config) {
   const maybeAccount = await fetchMaybeBitmapAccount(rpc, address, config);
-  (0, import_kit4.assertAccountExists)(maybeAccount);
+  assertAccountExists4(maybeAccount);
   return maybeAccount;
 }
 async function fetchMaybeBitmapAccount(rpc, address, config) {
-  const maybeAccount = await (0, import_kit4.fetchEncodedAccount)(rpc, address, config);
+  const maybeAccount = await fetchEncodedAccount4(rpc, address, config);
   return decodeBitmapAccount(maybeAccount);
 }
 async function fetchAllBitmapAccount(rpc, addresses, config) {
@@ -560,28 +437,57 @@ async function fetchAllBitmapAccount(rpc, addresses, config) {
     addresses,
     config
   );
-  (0, import_kit4.assertAccountsExist)(maybeAccounts);
+  assertAccountsExist4(maybeAccounts);
   return maybeAccounts;
 }
 async function fetchAllMaybeBitmapAccount(rpc, addresses, config) {
-  const maybeAccounts = await (0, import_kit4.fetchEncodedAccounts)(rpc, addresses, config);
+  const maybeAccounts = await fetchEncodedAccounts4(rpc, addresses, config);
   return maybeAccounts.map((maybeAccount) => decodeBitmapAccount(maybeAccount));
 }
 function getBitmapAccountSize() {
-  return 8080;
+  return 1080;
 }
 
 // src/errors/dropsyAirdrop.ts
-var import_kit13 = require("@solana/kit");
+import {
+  isProgramError
+} from "@solana/kit";
 
 // src/programs/dropsyAirdrop.ts
-var import_kit12 = require("@solana/kit");
+import {
+  assertIsInstructionWithAccounts,
+  containsBytes,
+  fixEncoderSize as fixEncoderSize11,
+  getBytesEncoder as getBytesEncoder11
+} from "@solana/kit";
 
 // src/instructions/claimAirdrop.ts
-var import_kit6 = require("@solana/kit");
+import {
+  combineCodec as combineCodec5,
+  fixDecoderSize as fixDecoderSize5,
+  fixEncoderSize as fixEncoderSize5,
+  getAddressEncoder as getAddressEncoder5,
+  getArrayDecoder,
+  getArrayEncoder,
+  getBytesDecoder as getBytesDecoder5,
+  getBytesEncoder as getBytesEncoder5,
+  getProgramDerivedAddress,
+  getStructDecoder as getStructDecoder5,
+  getStructEncoder as getStructEncoder5,
+  getU16Decoder as getU16Decoder4,
+  getU16Encoder as getU16Encoder4,
+  getU64Decoder as getU64Decoder4,
+  getU64Encoder as getU64Encoder4,
+  transformEncoder as transformEncoder5
+} from "@solana/kit";
 
 // src/shared/index.ts
-var import_kit5 = require("@solana/kit");
+import {
+  AccountRole,
+  isProgramDerivedAddress,
+  isTransactionSigner as kitIsTransactionSigner,
+  upgradeRoleToSigner
+} from "@solana/kit";
 function expectSome(value) {
   if (value === null || value === void 0) {
     throw new Error("Expected a value but received null or undefined.");
@@ -606,19 +512,19 @@ function getAccountMetaFactory(programAddress, optionalAccountStrategy) {
       if (optionalAccountStrategy === "omitted") return;
       return Object.freeze({
         address: programAddress,
-        role: import_kit5.AccountRole.READONLY
+        role: AccountRole.READONLY
       });
     }
-    const writableRole = account.isWritable ? import_kit5.AccountRole.WRITABLE : import_kit5.AccountRole.READONLY;
+    const writableRole = account.isWritable ? AccountRole.WRITABLE : AccountRole.READONLY;
     return Object.freeze({
       address: expectAddress(account.value),
-      role: isTransactionSigner(account.value) ? (0, import_kit5.upgradeRoleToSigner)(writableRole) : writableRole,
+      role: isTransactionSigner(account.value) ? upgradeRoleToSigner(writableRole) : writableRole,
       ...isTransactionSigner(account.value) ? { signer: account.value } : {}
     });
   };
 }
 function isTransactionSigner(value) {
-  return !!value && typeof value === "object" && "address" in value && (0, import_kit5.isTransactionSigner)(value);
+  return !!value && typeof value === "object" && "address" in value && kitIsTransactionSigner(value);
 }
 
 // src/instructions/claimAirdrop.ts
@@ -633,33 +539,33 @@ var CLAIM_AIRDROP_DISCRIMINATOR = new Uint8Array([
   20
 ]);
 function getClaimAirdropDiscriminatorBytes() {
-  return (0, import_kit6.fixEncoderSize)((0, import_kit6.getBytesEncoder)(), 8).encode(
+  return fixEncoderSize5(getBytesEncoder5(), 8).encode(
     CLAIM_AIRDROP_DISCRIMINATOR
   );
 }
 function getClaimAirdropInstructionDataEncoder() {
-  return (0, import_kit6.transformEncoder)(
-    (0, import_kit6.getStructEncoder)([
-      ["discriminator", (0, import_kit6.fixEncoderSize)((0, import_kit6.getBytesEncoder)(), 8)],
-      ["index", (0, import_kit6.getU64Encoder)()],
-      ["proof", (0, import_kit6.getArrayEncoder)((0, import_kit6.fixEncoderSize)((0, import_kit6.getBytesEncoder)(), 32))],
-      ["amount", (0, import_kit6.getU64Encoder)()],
-      ["claimMapIndex", (0, import_kit6.getU16Encoder)()]
+  return transformEncoder5(
+    getStructEncoder5([
+      ["discriminator", fixEncoderSize5(getBytesEncoder5(), 8)],
+      ["index", getU64Encoder4()],
+      ["proof", getArrayEncoder(fixEncoderSize5(getBytesEncoder5(), 32))],
+      ["amount", getU64Encoder4()],
+      ["claimMapIndex", getU16Encoder4()]
     ]),
     (value) => ({ ...value, discriminator: CLAIM_AIRDROP_DISCRIMINATOR })
   );
 }
 function getClaimAirdropInstructionDataDecoder() {
-  return (0, import_kit6.getStructDecoder)([
-    ["discriminator", (0, import_kit6.fixDecoderSize)((0, import_kit6.getBytesDecoder)(), 8)],
-    ["index", (0, import_kit6.getU64Decoder)()],
-    ["proof", (0, import_kit6.getArrayDecoder)((0, import_kit6.fixDecoderSize)((0, import_kit6.getBytesDecoder)(), 32))],
-    ["amount", (0, import_kit6.getU64Decoder)()],
-    ["claimMapIndex", (0, import_kit6.getU16Decoder)()]
+  return getStructDecoder5([
+    ["discriminator", fixDecoderSize5(getBytesDecoder5(), 8)],
+    ["index", getU64Decoder4()],
+    ["proof", getArrayDecoder(fixDecoderSize5(getBytesDecoder5(), 32))],
+    ["amount", getU64Decoder4()],
+    ["claimMapIndex", getU16Decoder4()]
   ]);
 }
 function getClaimAirdropInstructionDataCodec() {
-  return (0, import_kit6.combineCodec)(
+  return combineCodec5(
     getClaimAirdropInstructionDataEncoder(),
     getClaimAirdropInstructionDataDecoder()
   );
@@ -701,12 +607,12 @@ async function getClaimAirdropInstructionAsync(input, config) {
     accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
   }
   if (!accounts.destinationTokenAccount.value) {
-    accounts.destinationTokenAccount.value = await (0, import_kit6.getProgramDerivedAddress)({
+    accounts.destinationTokenAccount.value = await getProgramDerivedAddress({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        (0, import_kit6.getAddressEncoder)().encode(expectAddress(accounts.claimer.value)),
-        (0, import_kit6.getAddressEncoder)().encode(expectAddress(accounts.tokenProgram.value)),
-        (0, import_kit6.getAddressEncoder)().encode(expectAddress(accounts.mint.value))
+        getAddressEncoder5().encode(expectAddress(accounts.claimer.value)),
+        getAddressEncoder5().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder5().encode(expectAddress(accounts.mint.value))
       ]
     });
   }
@@ -717,10 +623,10 @@ async function getClaimAirdropInstructionAsync(input, config) {
     accounts.systemProgram.value = "11111111111111111111111111111111";
   }
   if (!accounts.airdropConfig.value) {
-    accounts.airdropConfig.value = await (0, import_kit6.getProgramDerivedAddress)({
+    accounts.airdropConfig.value = await getProgramDerivedAddress({
       programAddress,
       seeds: [
-        (0, import_kit6.getBytesEncoder)().encode(
+        getBytesEncoder5().encode(
           new Uint8Array([
             97,
             105,
@@ -742,10 +648,10 @@ async function getClaimAirdropInstructionAsync(input, config) {
     });
   }
   if (!accounts.airdropMaster.value) {
-    accounts.airdropMaster.value = await (0, import_kit6.getProgramDerivedAddress)({
+    accounts.airdropMaster.value = await getProgramDerivedAddress({
       programAddress,
       seeds: [
-        (0, import_kit6.getBytesEncoder)().encode(
+        getBytesEncoder5().encode(
           new Uint8Array([
             97,
             105,
@@ -763,7 +669,7 @@ async function getClaimAirdropInstructionAsync(input, config) {
             114
           ])
         ),
-        (0, import_kit6.getAddressEncoder)().encode(expectAddress(accounts.masterCreator.value))
+        getAddressEncoder5().encode(expectAddress(accounts.masterCreator.value))
       ]
     });
   }
@@ -893,7 +799,27 @@ function parseClaimAirdropInstruction(instruction) {
 }
 
 // src/instructions/createAirdrop.ts
-var import_kit7 = require("@solana/kit");
+import {
+  combineCodec as combineCodec6,
+  fixDecoderSize as fixDecoderSize6,
+  fixEncoderSize as fixEncoderSize6,
+  getAddressDecoder as getAddressDecoder5,
+  getAddressEncoder as getAddressEncoder6,
+  getBytesDecoder as getBytesDecoder6,
+  getBytesEncoder as getBytesEncoder6,
+  getI64Decoder as getI64Decoder3,
+  getI64Encoder as getI64Encoder3,
+  getOptionDecoder,
+  getOptionEncoder,
+  getProgramDerivedAddress as getProgramDerivedAddress2,
+  getStructDecoder as getStructDecoder6,
+  getStructEncoder as getStructEncoder6,
+  getU64Decoder as getU64Decoder5,
+  getU64Encoder as getU64Encoder5,
+  getU8Decoder as getU8Decoder5,
+  getU8Encoder as getU8Encoder5,
+  transformEncoder as transformEncoder6
+} from "@solana/kit";
 var CREATE_AIRDROP_DISCRIMINATOR = new Uint8Array([
   227,
   135,
@@ -905,39 +831,37 @@ var CREATE_AIRDROP_DISCRIMINATOR = new Uint8Array([
   94
 ]);
 function getCreateAirdropDiscriminatorBytes() {
-  return (0, import_kit7.fixEncoderSize)((0, import_kit7.getBytesEncoder)(), 8).encode(
+  return fixEncoderSize6(getBytesEncoder6(), 8).encode(
     CREATE_AIRDROP_DISCRIMINATOR
   );
 }
 function getCreateAirdropInstructionDataEncoder() {
-  return (0, import_kit7.transformEncoder)(
-    (0, import_kit7.getStructEncoder)([
-      ["discriminator", (0, import_kit7.fixEncoderSize)((0, import_kit7.getBytesEncoder)(), 8)],
-      ["merkleRoot", (0, import_kit7.getOptionEncoder)((0, import_kit7.fixEncoderSize)((0, import_kit7.getBytesEncoder)(), 32))],
-      ["startsAt", (0, import_kit7.getOptionEncoder)((0, import_kit7.getI64Encoder)())],
-      ["endsAt", (0, import_kit7.getOptionEncoder)((0, import_kit7.getI64Encoder)())],
-      ["version", (0, import_kit7.getOptionEncoder)((0, import_kit7.getU8Encoder)())],
-      ["mutable", (0, import_kit7.getOptionEncoder)((0, import_kit7.getU8Encoder)())],
-      ["delegateAuthority", (0, import_kit7.getOptionEncoder)((0, import_kit7.getAddressEncoder)())],
-      ["delegatePermissions", (0, import_kit7.getOptionEncoder)((0, import_kit7.getU8Encoder)())]
+  return transformEncoder6(
+    getStructEncoder6([
+      ["discriminator", fixEncoderSize6(getBytesEncoder6(), 8)],
+      ["id", getU64Encoder5()],
+      ["merkleRoot", getOptionEncoder(fixEncoderSize6(getBytesEncoder6(), 32))],
+      ["startsAt", getOptionEncoder(getI64Encoder3())],
+      ["endsAt", getOptionEncoder(getI64Encoder3())],
+      ["version", getOptionEncoder(getU8Encoder5())],
+      ["delegateAuthority", getOptionEncoder(getAddressEncoder6())]
     ]),
     (value) => ({ ...value, discriminator: CREATE_AIRDROP_DISCRIMINATOR })
   );
 }
 function getCreateAirdropInstructionDataDecoder() {
-  return (0, import_kit7.getStructDecoder)([
-    ["discriminator", (0, import_kit7.fixDecoderSize)((0, import_kit7.getBytesDecoder)(), 8)],
-    ["merkleRoot", (0, import_kit7.getOptionDecoder)((0, import_kit7.fixDecoderSize)((0, import_kit7.getBytesDecoder)(), 32))],
-    ["startsAt", (0, import_kit7.getOptionDecoder)((0, import_kit7.getI64Decoder)())],
-    ["endsAt", (0, import_kit7.getOptionDecoder)((0, import_kit7.getI64Decoder)())],
-    ["version", (0, import_kit7.getOptionDecoder)((0, import_kit7.getU8Decoder)())],
-    ["mutable", (0, import_kit7.getOptionDecoder)((0, import_kit7.getU8Decoder)())],
-    ["delegateAuthority", (0, import_kit7.getOptionDecoder)((0, import_kit7.getAddressDecoder)())],
-    ["delegatePermissions", (0, import_kit7.getOptionDecoder)((0, import_kit7.getU8Decoder)())]
+  return getStructDecoder6([
+    ["discriminator", fixDecoderSize6(getBytesDecoder6(), 8)],
+    ["id", getU64Decoder5()],
+    ["merkleRoot", getOptionDecoder(fixDecoderSize6(getBytesDecoder6(), 32))],
+    ["startsAt", getOptionDecoder(getI64Decoder3())],
+    ["endsAt", getOptionDecoder(getI64Decoder3())],
+    ["version", getOptionDecoder(getU8Decoder5())],
+    ["delegateAuthority", getOptionDecoder(getAddressDecoder5())]
   ]);
 }
 function getCreateAirdropInstructionDataCodec() {
-  return (0, import_kit7.combineCodec)(
+  return combineCodec6(
     getCreateAirdropInstructionDataEncoder(),
     getCreateAirdropInstructionDataDecoder()
   );
@@ -961,10 +885,10 @@ async function getCreateAirdropInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.airdropConfig.value) {
-    accounts.airdropConfig.value = await (0, import_kit7.getProgramDerivedAddress)({
+    accounts.airdropConfig.value = await getProgramDerivedAddress2({
       programAddress,
       seeds: [
-        (0, import_kit7.getBytesEncoder)().encode(
+        getBytesEncoder6().encode(
           new Uint8Array([
             97,
             105,
@@ -986,10 +910,10 @@ async function getCreateAirdropInstructionAsync(input, config) {
     });
   }
   if (!accounts.airdropMaster.value) {
-    accounts.airdropMaster.value = await (0, import_kit7.getProgramDerivedAddress)({
+    accounts.airdropMaster.value = await getProgramDerivedAddress2({
       programAddress,
       seeds: [
-        (0, import_kit7.getBytesEncoder)().encode(
+        getBytesEncoder6().encode(
           new Uint8Array([
             97,
             105,
@@ -1007,19 +931,7 @@ async function getCreateAirdropInstructionAsync(input, config) {
             114
           ])
         ),
-        (0, import_kit7.getAddressEncoder)().encode(expectAddress(accounts.masterCreator.value))
-      ]
-    });
-  }
-  if (!accounts.airdrop.value) {
-    accounts.airdrop.value = await (0, import_kit7.getProgramDerivedAddress)({
-      programAddress,
-      seeds: [
-        (0, import_kit7.getBytesEncoder)().encode(
-          new Uint8Array([97, 105, 114, 100, 114, 111, 112])
-        ),
-        (0, import_kit7.getAddressEncoder)().encode(expectAddress(accounts.authority.value)),
-        (0, import_kit7.getAddressEncoder)().encode(expectAddress(accounts.mint.value))
+        getAddressEncoder6().encode(expectAddress(accounts.masterCreator.value))
       ]
     });
   }
@@ -1113,7 +1025,22 @@ function parseCreateAirdropInstruction(instruction) {
 }
 
 // src/instructions/createBitmap.ts
-var import_kit8 = require("@solana/kit");
+import {
+  combineCodec as combineCodec7,
+  fixDecoderSize as fixDecoderSize7,
+  fixEncoderSize as fixEncoderSize7,
+  getAddressEncoder as getAddressEncoder7,
+  getBytesDecoder as getBytesDecoder7,
+  getBytesEncoder as getBytesEncoder7,
+  getProgramDerivedAddress as getProgramDerivedAddress3,
+  getStructDecoder as getStructDecoder7,
+  getStructEncoder as getStructEncoder7,
+  getU16Decoder as getU16Decoder5,
+  getU16Encoder as getU16Encoder5,
+  getU32Decoder as getU32Decoder2,
+  getU32Encoder as getU32Encoder2,
+  transformEncoder as transformEncoder7
+} from "@solana/kit";
 var CREATE_BITMAP_DISCRIMINATOR = new Uint8Array([
   69,
   92,
@@ -1125,29 +1052,29 @@ var CREATE_BITMAP_DISCRIMINATOR = new Uint8Array([
   247
 ]);
 function getCreateBitmapDiscriminatorBytes() {
-  return (0, import_kit8.fixEncoderSize)((0, import_kit8.getBytesEncoder)(), 8).encode(
+  return fixEncoderSize7(getBytesEncoder7(), 8).encode(
     CREATE_BITMAP_DISCRIMINATOR
   );
 }
 function getCreateBitmapInstructionDataEncoder() {
-  return (0, import_kit8.transformEncoder)(
-    (0, import_kit8.getStructEncoder)([
-      ["discriminator", (0, import_kit8.fixEncoderSize)((0, import_kit8.getBytesEncoder)(), 8)],
-      ["id", (0, import_kit8.getU16Encoder)()],
-      ["total", (0, import_kit8.getU32Encoder)()]
+  return transformEncoder7(
+    getStructEncoder7([
+      ["discriminator", fixEncoderSize7(getBytesEncoder7(), 8)],
+      ["id", getU16Encoder5()],
+      ["total", getU32Encoder2()]
     ]),
     (value) => ({ ...value, discriminator: CREATE_BITMAP_DISCRIMINATOR })
   );
 }
 function getCreateBitmapInstructionDataDecoder() {
-  return (0, import_kit8.getStructDecoder)([
-    ["discriminator", (0, import_kit8.fixDecoderSize)((0, import_kit8.getBytesDecoder)(), 8)],
-    ["id", (0, import_kit8.getU16Decoder)()],
-    ["total", (0, import_kit8.getU32Decoder)()]
+  return getStructDecoder7([
+    ["discriminator", fixDecoderSize7(getBytesDecoder7(), 8)],
+    ["id", getU16Decoder5()],
+    ["total", getU32Decoder2()]
   ]);
 }
 function getCreateBitmapInstructionDataCodec() {
-  return (0, import_kit8.combineCodec)(
+  return combineCodec7(
     getCreateBitmapInstructionDataEncoder(),
     getCreateBitmapInstructionDataDecoder()
   );
@@ -1172,10 +1099,10 @@ async function getCreateBitmapInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.airdropConfig.value) {
-    accounts.airdropConfig.value = await (0, import_kit8.getProgramDerivedAddress)({
+    accounts.airdropConfig.value = await getProgramDerivedAddress3({
       programAddress,
       seeds: [
-        (0, import_kit8.getBytesEncoder)().encode(
+        getBytesEncoder7().encode(
           new Uint8Array([
             97,
             105,
@@ -1197,10 +1124,10 @@ async function getCreateBitmapInstructionAsync(input, config) {
     });
   }
   if (!accounts.airdropMaster.value) {
-    accounts.airdropMaster.value = await (0, import_kit8.getProgramDerivedAddress)({
+    accounts.airdropMaster.value = await getProgramDerivedAddress3({
       programAddress,
       seeds: [
-        (0, import_kit8.getBytesEncoder)().encode(
+        getBytesEncoder7().encode(
           new Uint8Array([
             97,
             105,
@@ -1218,29 +1145,29 @@ async function getCreateBitmapInstructionAsync(input, config) {
             114
           ])
         ),
-        (0, import_kit8.getAddressEncoder)().encode(expectAddress(accounts.masterCreator.value))
+        getAddressEncoder7().encode(expectAddress(accounts.masterCreator.value))
       ]
     });
   }
   if (!accounts.airdrop.value) {
-    accounts.airdrop.value = await (0, import_kit8.getProgramDerivedAddress)({
+    accounts.airdrop.value = await getProgramDerivedAddress3({
       programAddress,
       seeds: [
-        (0, import_kit8.getBytesEncoder)().encode(
+        getBytesEncoder7().encode(
           new Uint8Array([97, 105, 114, 100, 114, 111, 112])
         ),
-        (0, import_kit8.getAddressEncoder)().encode(expectAddress(accounts.authority.value)),
-        (0, import_kit8.getAddressEncoder)().encode(expectAddress(accounts.mint.value))
+        getAddressEncoder7().encode(expectAddress(accounts.authority.value)),
+        getAddressEncoder7().encode(expectAddress(accounts.mint.value))
       ]
     });
   }
   if (!accounts.bitmap.value) {
-    accounts.bitmap.value = await (0, import_kit8.getProgramDerivedAddress)({
+    accounts.bitmap.value = await getProgramDerivedAddress3({
       programAddress,
       seeds: [
-        (0, import_kit8.getBytesEncoder)().encode(new Uint8Array([98, 105, 116, 109, 97, 112])),
-        (0, import_kit8.getAddressEncoder)().encode(expectAddress(accounts.airdrop.value)),
-        (0, import_kit8.getU16Encoder)().encode(expectSome(args.id))
+        getBytesEncoder7().encode(new Uint8Array([98, 105, 116, 109, 97, 112])),
+        getAddressEncoder7().encode(expectAddress(accounts.airdrop.value)),
+        getU16Encoder5().encode(expectSome(args.id))
       ]
     });
   }
@@ -1338,7 +1265,20 @@ function parseCreateBitmapInstruction(instruction) {
 }
 
 // src/instructions/depositTokens.ts
-var import_kit9 = require("@solana/kit");
+import {
+  combineCodec as combineCodec8,
+  fixDecoderSize as fixDecoderSize8,
+  fixEncoderSize as fixEncoderSize8,
+  getAddressEncoder as getAddressEncoder8,
+  getBytesDecoder as getBytesDecoder8,
+  getBytesEncoder as getBytesEncoder8,
+  getProgramDerivedAddress as getProgramDerivedAddress4,
+  getStructDecoder as getStructDecoder8,
+  getStructEncoder as getStructEncoder8,
+  getU64Decoder as getU64Decoder6,
+  getU64Encoder as getU64Encoder6,
+  transformEncoder as transformEncoder8
+} from "@solana/kit";
 var DEPOSIT_TOKENS_DISCRIMINATOR = new Uint8Array([
   176,
   83,
@@ -1350,27 +1290,27 @@ var DEPOSIT_TOKENS_DISCRIMINATOR = new Uint8Array([
   150
 ]);
 function getDepositTokensDiscriminatorBytes() {
-  return (0, import_kit9.fixEncoderSize)((0, import_kit9.getBytesEncoder)(), 8).encode(
+  return fixEncoderSize8(getBytesEncoder8(), 8).encode(
     DEPOSIT_TOKENS_DISCRIMINATOR
   );
 }
 function getDepositTokensInstructionDataEncoder() {
-  return (0, import_kit9.transformEncoder)(
-    (0, import_kit9.getStructEncoder)([
-      ["discriminator", (0, import_kit9.fixEncoderSize)((0, import_kit9.getBytesEncoder)(), 8)],
-      ["amount", (0, import_kit9.getU64Encoder)()]
+  return transformEncoder8(
+    getStructEncoder8([
+      ["discriminator", fixEncoderSize8(getBytesEncoder8(), 8)],
+      ["amount", getU64Encoder6()]
     ]),
     (value) => ({ ...value, discriminator: DEPOSIT_TOKENS_DISCRIMINATOR })
   );
 }
 function getDepositTokensInstructionDataDecoder() {
-  return (0, import_kit9.getStructDecoder)([
-    ["discriminator", (0, import_kit9.fixDecoderSize)((0, import_kit9.getBytesDecoder)(), 8)],
-    ["amount", (0, import_kit9.getU64Decoder)()]
+  return getStructDecoder8([
+    ["discriminator", fixDecoderSize8(getBytesDecoder8(), 8)],
+    ["amount", getU64Decoder6()]
   ]);
 }
 function getDepositTokensInstructionDataCodec() {
-  return (0, import_kit9.combineCodec)(
+  return combineCodec8(
     getDepositTokensInstructionDataEncoder(),
     getDepositTokensInstructionDataDecoder()
   );
@@ -1396,14 +1336,14 @@ async function getDepositTokensInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.airdrop.value) {
-    accounts.airdrop.value = await (0, import_kit9.getProgramDerivedAddress)({
+    accounts.airdrop.value = await getProgramDerivedAddress4({
       programAddress,
       seeds: [
-        (0, import_kit9.getBytesEncoder)().encode(
+        getBytesEncoder8().encode(
           new Uint8Array([97, 105, 114, 100, 114, 111, 112])
         ),
-        (0, import_kit9.getAddressEncoder)().encode(expectAddress(accounts.authority.value)),
-        (0, import_kit9.getAddressEncoder)().encode(expectAddress(accounts.mint.value))
+        getAddressEncoder8().encode(expectAddress(accounts.authority.value)),
+        getAddressEncoder8().encode(expectAddress(accounts.mint.value))
       ]
     });
   }
@@ -1411,12 +1351,12 @@ async function getDepositTokensInstructionAsync(input, config) {
     accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
   }
   if (!accounts.vault.value) {
-    accounts.vault.value = await (0, import_kit9.getProgramDerivedAddress)({
+    accounts.vault.value = await getProgramDerivedAddress4({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        (0, import_kit9.getAddressEncoder)().encode(expectAddress(accounts.airdrop.value)),
-        (0, import_kit9.getAddressEncoder)().encode(expectAddress(accounts.tokenProgram.value)),
-        (0, import_kit9.getAddressEncoder)().encode(expectAddress(accounts.mint.value))
+        getAddressEncoder8().encode(expectAddress(accounts.airdrop.value)),
+        getAddressEncoder8().encode(expectAddress(accounts.tokenProgram.value)),
+        getAddressEncoder8().encode(expectAddress(accounts.mint.value))
       ]
     });
   }
@@ -1518,7 +1458,25 @@ function parseDepositTokensInstruction(instruction) {
 }
 
 // src/instructions/initializeAirdropConfig.ts
-var import_kit10 = require("@solana/kit");
+import {
+  combineCodec as combineCodec9,
+  fixDecoderSize as fixDecoderSize9,
+  fixEncoderSize as fixEncoderSize9,
+  getBytesDecoder as getBytesDecoder9,
+  getBytesEncoder as getBytesEncoder9,
+  getI64Decoder as getI64Decoder4,
+  getI64Encoder as getI64Encoder4,
+  getOptionDecoder as getOptionDecoder2,
+  getOptionEncoder as getOptionEncoder2,
+  getProgramDerivedAddress as getProgramDerivedAddress5,
+  getStructDecoder as getStructDecoder9,
+  getStructEncoder as getStructEncoder9,
+  getU16Decoder as getU16Decoder6,
+  getU16Encoder as getU16Encoder6,
+  getU64Decoder as getU64Decoder7,
+  getU64Encoder as getU64Encoder7,
+  transformEncoder as transformEncoder9
+} from "@solana/kit";
 var INITIALIZE_AIRDROP_CONFIG_DISCRIMINATOR = new Uint8Array([
   160,
   68,
@@ -1530,24 +1488,24 @@ var INITIALIZE_AIRDROP_CONFIG_DISCRIMINATOR = new Uint8Array([
   94
 ]);
 function getInitializeAirdropConfigDiscriminatorBytes() {
-  return (0, import_kit10.fixEncoderSize)((0, import_kit10.getBytesEncoder)(), 8).encode(
+  return fixEncoderSize9(getBytesEncoder9(), 8).encode(
     INITIALIZE_AIRDROP_CONFIG_DISCRIMINATOR
   );
 }
 function getInitializeAirdropConfigInstructionDataEncoder() {
-  return (0, import_kit10.transformEncoder)(
-    (0, import_kit10.getStructEncoder)([
-      ["discriminator", (0, import_kit10.fixEncoderSize)((0, import_kit10.getBytesEncoder)(), 8)],
-      ["wlRoot", (0, import_kit10.getOptionEncoder)((0, import_kit10.fixEncoderSize)((0, import_kit10.getBytesEncoder)(), 32))],
-      ["airdropMasterCreateFee", (0, import_kit10.getOptionEncoder)((0, import_kit10.getU64Encoder)())],
-      ["maxClaimFee", (0, import_kit10.getOptionEncoder)((0, import_kit10.getU64Encoder)())],
-      ["maxActionFee", (0, import_kit10.getOptionEncoder)((0, import_kit10.getU64Encoder)())],
-      ["minAirdropDuration", (0, import_kit10.getOptionEncoder)((0, import_kit10.getI64Encoder)())],
-      ["defaultAirdropDuration", (0, import_kit10.getOptionEncoder)((0, import_kit10.getI64Encoder)())],
-      ["maxAirdropDuration", (0, import_kit10.getOptionEncoder)((0, import_kit10.getI64Encoder)())],
-      ["updateGracePeriod", (0, import_kit10.getOptionEncoder)((0, import_kit10.getI64Encoder)())],
-      ["protocolFee", (0, import_kit10.getOptionEncoder)((0, import_kit10.getU64Encoder)())],
-      ["masterFeeBps", (0, import_kit10.getOptionEncoder)((0, import_kit10.getU16Encoder)())]
+  return transformEncoder9(
+    getStructEncoder9([
+      ["discriminator", fixEncoderSize9(getBytesEncoder9(), 8)],
+      ["wlRoot", getOptionEncoder2(fixEncoderSize9(getBytesEncoder9(), 32))],
+      ["airdropMasterCreateFee", getOptionEncoder2(getU64Encoder7())],
+      ["maxClaimFee", getOptionEncoder2(getU64Encoder7())],
+      ["maxActionFee", getOptionEncoder2(getU64Encoder7())],
+      ["minAirdropDuration", getOptionEncoder2(getI64Encoder4())],
+      ["defaultAirdropDuration", getOptionEncoder2(getI64Encoder4())],
+      ["maxAirdropDuration", getOptionEncoder2(getI64Encoder4())],
+      ["updateGracePeriod", getOptionEncoder2(getI64Encoder4())],
+      ["protocolFee", getOptionEncoder2(getU64Encoder7())],
+      ["masterFeeBps", getOptionEncoder2(getU16Encoder6())]
     ]),
     (value) => ({
       ...value,
@@ -1556,22 +1514,22 @@ function getInitializeAirdropConfigInstructionDataEncoder() {
   );
 }
 function getInitializeAirdropConfigInstructionDataDecoder() {
-  return (0, import_kit10.getStructDecoder)([
-    ["discriminator", (0, import_kit10.fixDecoderSize)((0, import_kit10.getBytesDecoder)(), 8)],
-    ["wlRoot", (0, import_kit10.getOptionDecoder)((0, import_kit10.fixDecoderSize)((0, import_kit10.getBytesDecoder)(), 32))],
-    ["airdropMasterCreateFee", (0, import_kit10.getOptionDecoder)((0, import_kit10.getU64Decoder)())],
-    ["maxClaimFee", (0, import_kit10.getOptionDecoder)((0, import_kit10.getU64Decoder)())],
-    ["maxActionFee", (0, import_kit10.getOptionDecoder)((0, import_kit10.getU64Decoder)())],
-    ["minAirdropDuration", (0, import_kit10.getOptionDecoder)((0, import_kit10.getI64Decoder)())],
-    ["defaultAirdropDuration", (0, import_kit10.getOptionDecoder)((0, import_kit10.getI64Decoder)())],
-    ["maxAirdropDuration", (0, import_kit10.getOptionDecoder)((0, import_kit10.getI64Decoder)())],
-    ["updateGracePeriod", (0, import_kit10.getOptionDecoder)((0, import_kit10.getI64Decoder)())],
-    ["protocolFee", (0, import_kit10.getOptionDecoder)((0, import_kit10.getU64Decoder)())],
-    ["masterFeeBps", (0, import_kit10.getOptionDecoder)((0, import_kit10.getU16Decoder)())]
+  return getStructDecoder9([
+    ["discriminator", fixDecoderSize9(getBytesDecoder9(), 8)],
+    ["wlRoot", getOptionDecoder2(fixDecoderSize9(getBytesDecoder9(), 32))],
+    ["airdropMasterCreateFee", getOptionDecoder2(getU64Decoder7())],
+    ["maxClaimFee", getOptionDecoder2(getU64Decoder7())],
+    ["maxActionFee", getOptionDecoder2(getU64Decoder7())],
+    ["minAirdropDuration", getOptionDecoder2(getI64Decoder4())],
+    ["defaultAirdropDuration", getOptionDecoder2(getI64Decoder4())],
+    ["maxAirdropDuration", getOptionDecoder2(getI64Decoder4())],
+    ["updateGracePeriod", getOptionDecoder2(getI64Decoder4())],
+    ["protocolFee", getOptionDecoder2(getU64Decoder7())],
+    ["masterFeeBps", getOptionDecoder2(getU16Decoder6())]
   ]);
 }
 function getInitializeAirdropConfigInstructionDataCodec() {
-  return (0, import_kit10.combineCodec)(
+  return combineCodec9(
     getInitializeAirdropConfigInstructionDataEncoder(),
     getInitializeAirdropConfigInstructionDataDecoder()
   );
@@ -1590,10 +1548,10 @@ async function getInitializeAirdropConfigInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.config.value) {
-    accounts.config.value = await (0, import_kit10.getProgramDerivedAddress)({
+    accounts.config.value = await getProgramDerivedAddress5({
       programAddress,
       seeds: [
-        (0, import_kit10.getBytesEncoder)().encode(
+        getBytesEncoder9().encode(
           new Uint8Array([
             97,
             105,
@@ -1692,7 +1650,24 @@ function parseInitializeAirdropConfigInstruction(instruction) {
 }
 
 // src/instructions/initializeAirdropMaster.ts
-var import_kit11 = require("@solana/kit");
+import {
+  combineCodec as combineCodec10,
+  fixDecoderSize as fixDecoderSize10,
+  fixEncoderSize as fixEncoderSize10,
+  getAddressEncoder as getAddressEncoder9,
+  getArrayDecoder as getArrayDecoder2,
+  getArrayEncoder as getArrayEncoder2,
+  getBytesDecoder as getBytesDecoder10,
+  getBytesEncoder as getBytesEncoder10,
+  getOptionDecoder as getOptionDecoder3,
+  getOptionEncoder as getOptionEncoder3,
+  getProgramDerivedAddress as getProgramDerivedAddress6,
+  getStructDecoder as getStructDecoder10,
+  getStructEncoder as getStructEncoder10,
+  getU64Decoder as getU64Decoder8,
+  getU64Encoder as getU64Encoder8,
+  transformEncoder as transformEncoder10
+} from "@solana/kit";
 var INITIALIZE_AIRDROP_MASTER_DISCRIMINATOR = new Uint8Array([
   163,
   197,
@@ -1704,23 +1679,23 @@ var INITIALIZE_AIRDROP_MASTER_DISCRIMINATOR = new Uint8Array([
   65
 ]);
 function getInitializeAirdropMasterDiscriminatorBytes() {
-  return (0, import_kit11.fixEncoderSize)((0, import_kit11.getBytesEncoder)(), 8).encode(
+  return fixEncoderSize10(getBytesEncoder10(), 8).encode(
     INITIALIZE_AIRDROP_MASTER_DISCRIMINATOR
   );
 }
 function getInitializeAirdropMasterInstructionDataEncoder() {
-  return (0, import_kit11.transformEncoder)(
-    (0, import_kit11.getStructEncoder)([
-      ["discriminator", (0, import_kit11.fixEncoderSize)((0, import_kit11.getBytesEncoder)(), 8)],
-      ["airdropUpdateFee", (0, import_kit11.getOptionEncoder)((0, import_kit11.getU64Encoder)())],
-      ["airdropCreationFee", (0, import_kit11.getOptionEncoder)((0, import_kit11.getU64Encoder)())],
-      ["airdropClaimFee", (0, import_kit11.getOptionEncoder)((0, import_kit11.getU64Encoder)())],
-      ["airdropDelegateFee", (0, import_kit11.getOptionEncoder)((0, import_kit11.getU64Encoder)())],
-      ["bitmapCreationFee", (0, import_kit11.getOptionEncoder)((0, import_kit11.getU64Encoder)())],
+  return transformEncoder10(
+    getStructEncoder10([
+      ["discriminator", fixEncoderSize10(getBytesEncoder10(), 8)],
+      ["airdropUpdateFee", getOptionEncoder3(getU64Encoder8())],
+      ["airdropCreationFee", getOptionEncoder3(getU64Encoder8())],
+      ["airdropClaimFee", getOptionEncoder3(getU64Encoder8())],
+      ["airdropDelegateFee", getOptionEncoder3(getU64Encoder8())],
+      ["bitmapCreationFee", getOptionEncoder3(getU64Encoder8())],
       [
         "discountProof",
-        (0, import_kit11.getOptionEncoder)(
-          (0, import_kit11.getArrayEncoder)((0, import_kit11.fixEncoderSize)((0, import_kit11.getBytesEncoder)(), 32))
+        getOptionEncoder3(
+          getArrayEncoder2(fixEncoderSize10(getBytesEncoder10(), 32))
         )
       ]
     ]),
@@ -1731,21 +1706,21 @@ function getInitializeAirdropMasterInstructionDataEncoder() {
   );
 }
 function getInitializeAirdropMasterInstructionDataDecoder() {
-  return (0, import_kit11.getStructDecoder)([
-    ["discriminator", (0, import_kit11.fixDecoderSize)((0, import_kit11.getBytesDecoder)(), 8)],
-    ["airdropUpdateFee", (0, import_kit11.getOptionDecoder)((0, import_kit11.getU64Decoder)())],
-    ["airdropCreationFee", (0, import_kit11.getOptionDecoder)((0, import_kit11.getU64Decoder)())],
-    ["airdropClaimFee", (0, import_kit11.getOptionDecoder)((0, import_kit11.getU64Decoder)())],
-    ["airdropDelegateFee", (0, import_kit11.getOptionDecoder)((0, import_kit11.getU64Decoder)())],
-    ["bitmapCreationFee", (0, import_kit11.getOptionDecoder)((0, import_kit11.getU64Decoder)())],
+  return getStructDecoder10([
+    ["discriminator", fixDecoderSize10(getBytesDecoder10(), 8)],
+    ["airdropUpdateFee", getOptionDecoder3(getU64Decoder8())],
+    ["airdropCreationFee", getOptionDecoder3(getU64Decoder8())],
+    ["airdropClaimFee", getOptionDecoder3(getU64Decoder8())],
+    ["airdropDelegateFee", getOptionDecoder3(getU64Decoder8())],
+    ["bitmapCreationFee", getOptionDecoder3(getU64Decoder8())],
     [
       "discountProof",
-      (0, import_kit11.getOptionDecoder)((0, import_kit11.getArrayDecoder)((0, import_kit11.fixDecoderSize)((0, import_kit11.getBytesDecoder)(), 32)))
+      getOptionDecoder3(getArrayDecoder2(fixDecoderSize10(getBytesDecoder10(), 32)))
     ]
   ]);
 }
 function getInitializeAirdropMasterInstructionDataCodec() {
-  return (0, import_kit11.combineCodec)(
+  return combineCodec10(
     getInitializeAirdropMasterInstructionDataEncoder(),
     getInitializeAirdropMasterInstructionDataDecoder()
   );
@@ -1767,10 +1742,10 @@ async function getInitializeAirdropMasterInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.config.value) {
-    accounts.config.value = await (0, import_kit11.getProgramDerivedAddress)({
+    accounts.config.value = await getProgramDerivedAddress6({
       programAddress,
       seeds: [
-        (0, import_kit11.getBytesEncoder)().encode(
+        getBytesEncoder10().encode(
           new Uint8Array([
             97,
             105,
@@ -1792,10 +1767,10 @@ async function getInitializeAirdropMasterInstructionAsync(input, config) {
     });
   }
   if (!accounts.airdropMaster.value) {
-    accounts.airdropMaster.value = await (0, import_kit11.getProgramDerivedAddress)({
+    accounts.airdropMaster.value = await getProgramDerivedAddress6({
       programAddress,
       seeds: [
-        (0, import_kit11.getBytesEncoder)().encode(
+        getBytesEncoder10().encode(
           new Uint8Array([
             97,
             105,
@@ -1813,7 +1788,7 @@ async function getInitializeAirdropMasterInstructionAsync(input, config) {
             114
           ])
         ),
-        (0, import_kit11.getAddressEncoder)().encode(expectAddress(accounts.creator.value))
+        getAddressEncoder9().encode(expectAddress(accounts.creator.value))
       ]
     });
   }
@@ -1905,7 +1880,7 @@ function parseInitializeAirdropMasterInstruction(instruction) {
 }
 
 // src/programs/dropsyAirdrop.ts
-var DROPSY_AIRDROP_PROGRAM_ADDRESS = "BWd3s27cPuinNkZYqZvRbdfvpGyP9ff5rJZk4WhuNwDw";
+var DROPSY_AIRDROP_PROGRAM_ADDRESS = "3b97gLF94DDpa7sJQ8orbE3Ab6JQWBsDQTdQ5azoZqcz";
 var DropsyAirdropAccount = /* @__PURE__ */ ((DropsyAirdropAccount2) => {
   DropsyAirdropAccount2[DropsyAirdropAccount2["Airdrop"] = 0] = "Airdrop";
   DropsyAirdropAccount2[DropsyAirdropAccount2["AirdropConfig"] = 1] = "AirdropConfig";
@@ -1915,36 +1890,36 @@ var DropsyAirdropAccount = /* @__PURE__ */ ((DropsyAirdropAccount2) => {
 })(DropsyAirdropAccount || {});
 function identifyDropsyAirdropAccount(account) {
   const data = "data" in account ? account.data : account;
-  if ((0, import_kit12.containsBytes)(
+  if (containsBytes(
     data,
-    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
+    fixEncoderSize11(getBytesEncoder11(), 8).encode(
       new Uint8Array([31, 112, 159, 158, 124, 237, 9, 241])
     ),
     0
   )) {
     return 0 /* Airdrop */;
   }
-  if ((0, import_kit12.containsBytes)(
+  if (containsBytes(
     data,
-    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
+    fixEncoderSize11(getBytesEncoder11(), 8).encode(
       new Uint8Array([194, 149, 223, 142, 42, 98, 128, 16])
     ),
     0
   )) {
     return 1 /* AirdropConfig */;
   }
-  if ((0, import_kit12.containsBytes)(
+  if (containsBytes(
     data,
-    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
+    fixEncoderSize11(getBytesEncoder11(), 8).encode(
       new Uint8Array([31, 109, 100, 62, 106, 173, 5, 4])
     ),
     0
   )) {
     return 2 /* AirdropMaster */;
   }
-  if ((0, import_kit12.containsBytes)(
+  if (containsBytes(
     data,
-    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
+    fixEncoderSize11(getBytesEncoder11(), 8).encode(
       new Uint8Array([152, 161, 147, 85, 213, 38, 59, 48])
     ),
     0
@@ -1966,54 +1941,54 @@ var DropsyAirdropInstruction = /* @__PURE__ */ ((DropsyAirdropInstruction2) => {
 })(DropsyAirdropInstruction || {});
 function identifyDropsyAirdropInstruction(instruction) {
   const data = "data" in instruction ? instruction.data : instruction;
-  if ((0, import_kit12.containsBytes)(
+  if (containsBytes(
     data,
-    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
+    fixEncoderSize11(getBytesEncoder11(), 8).encode(
       new Uint8Array([137, 50, 122, 111, 89, 254, 8, 20])
     ),
     0
   )) {
     return 0 /* ClaimAirdrop */;
   }
-  if ((0, import_kit12.containsBytes)(
+  if (containsBytes(
     data,
-    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
+    fixEncoderSize11(getBytesEncoder11(), 8).encode(
       new Uint8Array([227, 135, 208, 66, 137, 177, 80, 94])
     ),
     0
   )) {
     return 1 /* CreateAirdrop */;
   }
-  if ((0, import_kit12.containsBytes)(
+  if (containsBytes(
     data,
-    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
+    fixEncoderSize11(getBytesEncoder11(), 8).encode(
       new Uint8Array([69, 92, 61, 190, 154, 237, 116, 247])
     ),
     0
   )) {
     return 2 /* CreateBitmap */;
   }
-  if ((0, import_kit12.containsBytes)(
+  if (containsBytes(
     data,
-    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
+    fixEncoderSize11(getBytesEncoder11(), 8).encode(
       new Uint8Array([176, 83, 229, 18, 191, 143, 176, 150])
     ),
     0
   )) {
     return 3 /* DepositTokens */;
   }
-  if ((0, import_kit12.containsBytes)(
+  if (containsBytes(
     data,
-    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
+    fixEncoderSize11(getBytesEncoder11(), 8).encode(
       new Uint8Array([160, 68, 127, 205, 130, 205, 156, 94])
     ),
     0
   )) {
     return 4 /* InitializeAirdropConfig */;
   }
-  if ((0, import_kit12.containsBytes)(
+  if (containsBytes(
     data,
-    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
+    fixEncoderSize11(getBytesEncoder11(), 8).encode(
       new Uint8Array([163, 197, 170, 44, 57, 57, 90, 65])
     ),
     0
@@ -2028,42 +2003,42 @@ function parseDropsyAirdropInstruction(instruction) {
   const instructionType = identifyDropsyAirdropInstruction(instruction);
   switch (instructionType) {
     case 0 /* ClaimAirdrop */: {
-      (0, import_kit12.assertIsInstructionWithAccounts)(instruction);
+      assertIsInstructionWithAccounts(instruction);
       return {
         instructionType: 0 /* ClaimAirdrop */,
         ...parseClaimAirdropInstruction(instruction)
       };
     }
     case 1 /* CreateAirdrop */: {
-      (0, import_kit12.assertIsInstructionWithAccounts)(instruction);
+      assertIsInstructionWithAccounts(instruction);
       return {
         instructionType: 1 /* CreateAirdrop */,
         ...parseCreateAirdropInstruction(instruction)
       };
     }
     case 2 /* CreateBitmap */: {
-      (0, import_kit12.assertIsInstructionWithAccounts)(instruction);
+      assertIsInstructionWithAccounts(instruction);
       return {
         instructionType: 2 /* CreateBitmap */,
         ...parseCreateBitmapInstruction(instruction)
       };
     }
     case 3 /* DepositTokens */: {
-      (0, import_kit12.assertIsInstructionWithAccounts)(instruction);
+      assertIsInstructionWithAccounts(instruction);
       return {
         instructionType: 3 /* DepositTokens */,
         ...parseDepositTokensInstruction(instruction)
       };
     }
     case 4 /* InitializeAirdropConfig */: {
-      (0, import_kit12.assertIsInstructionWithAccounts)(instruction);
+      assertIsInstructionWithAccounts(instruction);
       return {
         instructionType: 4 /* InitializeAirdropConfig */,
         ...parseInitializeAirdropConfigInstruction(instruction)
       };
     }
     case 5 /* InitializeAirdropMaster */: {
-      (0, import_kit12.assertIsInstructionWithAccounts)(instruction);
+      assertIsInstructionWithAccounts(instruction);
       return {
         instructionType: 5 /* InitializeAirdropMaster */,
         ...parseInitializeAirdropMasterInstruction(instruction)
@@ -2235,7 +2210,7 @@ function getDropsyAirdropErrorMessage(code) {
   return "Error message not available in production bundles.";
 }
 function isDropsyAirdropError(error, transactionMessage, code) {
-  return (0, import_kit13.isProgramError)(
+  return isProgramError(
     error,
     transactionMessage,
     DROPSY_AIRDROP_PROGRAM_ADDRESS,
@@ -2244,128 +2219,173 @@ function isDropsyAirdropError(error, transactionMessage, code) {
 }
 
 // src/types/airdropInitialized.ts
-var import_kit14 = require("@solana/kit");
+import {
+  combineCodec as combineCodec11,
+  fixDecoderSize as fixDecoderSize11,
+  fixEncoderSize as fixEncoderSize12,
+  getAddressDecoder as getAddressDecoder6,
+  getAddressEncoder as getAddressEncoder10,
+  getBytesDecoder as getBytesDecoder11,
+  getBytesEncoder as getBytesEncoder12,
+  getI64Decoder as getI64Decoder5,
+  getI64Encoder as getI64Encoder5,
+  getStructDecoder as getStructDecoder11,
+  getStructEncoder as getStructEncoder11
+} from "@solana/kit";
 function getAirdropInitializedEncoder() {
-  return (0, import_kit14.getStructEncoder)([
-    ["airdrop", (0, import_kit14.getAddressEncoder)()],
-    ["mint", (0, import_kit14.getAddressEncoder)()],
-    ["authority", (0, import_kit14.getAddressEncoder)()],
-    ["master", (0, import_kit14.getAddressEncoder)()],
-    ["merkleRoot", (0, import_kit14.fixEncoderSize)((0, import_kit14.getBytesEncoder)(), 32)],
-    ["startTime", (0, import_kit14.getI64Encoder)()],
-    ["endTime", (0, import_kit14.getI64Encoder)()],
-    ["timestamp", (0, import_kit14.getI64Encoder)()]
+  return getStructEncoder11([
+    ["airdrop", getAddressEncoder10()],
+    ["mint", getAddressEncoder10()],
+    ["authority", getAddressEncoder10()],
+    ["master", getAddressEncoder10()],
+    ["merkleRoot", fixEncoderSize12(getBytesEncoder12(), 32)],
+    ["startTime", getI64Encoder5()],
+    ["endTime", getI64Encoder5()],
+    ["timestamp", getI64Encoder5()]
   ]);
 }
 function getAirdropInitializedDecoder() {
-  return (0, import_kit14.getStructDecoder)([
-    ["airdrop", (0, import_kit14.getAddressDecoder)()],
-    ["mint", (0, import_kit14.getAddressDecoder)()],
-    ["authority", (0, import_kit14.getAddressDecoder)()],
-    ["master", (0, import_kit14.getAddressDecoder)()],
-    ["merkleRoot", (0, import_kit14.fixDecoderSize)((0, import_kit14.getBytesDecoder)(), 32)],
-    ["startTime", (0, import_kit14.getI64Decoder)()],
-    ["endTime", (0, import_kit14.getI64Decoder)()],
-    ["timestamp", (0, import_kit14.getI64Decoder)()]
+  return getStructDecoder11([
+    ["airdrop", getAddressDecoder6()],
+    ["mint", getAddressDecoder6()],
+    ["authority", getAddressDecoder6()],
+    ["master", getAddressDecoder6()],
+    ["merkleRoot", fixDecoderSize11(getBytesDecoder11(), 32)],
+    ["startTime", getI64Decoder5()],
+    ["endTime", getI64Decoder5()],
+    ["timestamp", getI64Decoder5()]
   ]);
 }
 function getAirdropInitializedCodec() {
-  return (0, import_kit14.combineCodec)(
+  return combineCodec11(
     getAirdropInitializedEncoder(),
     getAirdropInitializedDecoder()
   );
 }
 
 // src/types/bitmapClosed.ts
-var import_kit15 = require("@solana/kit");
+import {
+  combineCodec as combineCodec12,
+  getAddressDecoder as getAddressDecoder7,
+  getAddressEncoder as getAddressEncoder11,
+  getStructDecoder as getStructDecoder12,
+  getStructEncoder as getStructEncoder12
+} from "@solana/kit";
 function getBitmapClosedEncoder() {
-  return (0, import_kit15.getStructEncoder)([
-    ["airdrop", (0, import_kit15.getAddressEncoder)()],
-    ["bitmap", (0, import_kit15.getAddressEncoder)()],
-    ["authority", (0, import_kit15.getAddressEncoder)()]
+  return getStructEncoder12([
+    ["airdrop", getAddressEncoder11()],
+    ["bitmap", getAddressEncoder11()],
+    ["authority", getAddressEncoder11()]
   ]);
 }
 function getBitmapClosedDecoder() {
-  return (0, import_kit15.getStructDecoder)([
-    ["airdrop", (0, import_kit15.getAddressDecoder)()],
-    ["bitmap", (0, import_kit15.getAddressDecoder)()],
-    ["authority", (0, import_kit15.getAddressDecoder)()]
+  return getStructDecoder12([
+    ["airdrop", getAddressDecoder7()],
+    ["bitmap", getAddressDecoder7()],
+    ["authority", getAddressDecoder7()]
   ]);
 }
 function getBitmapClosedCodec() {
-  return (0, import_kit15.combineCodec)(getBitmapClosedEncoder(), getBitmapClosedDecoder());
+  return combineCodec12(getBitmapClosedEncoder(), getBitmapClosedDecoder());
 }
 
 // src/types/bitmapInitialized.ts
-var import_kit16 = require("@solana/kit");
+import {
+  combineCodec as combineCodec13,
+  getAddressDecoder as getAddressDecoder8,
+  getAddressEncoder as getAddressEncoder12,
+  getI64Decoder as getI64Decoder6,
+  getI64Encoder as getI64Encoder6,
+  getStructDecoder as getStructDecoder13,
+  getStructEncoder as getStructEncoder13,
+  getU16Decoder as getU16Decoder7,
+  getU16Encoder as getU16Encoder7
+} from "@solana/kit";
 function getBitmapInitializedEncoder() {
-  return (0, import_kit16.getStructEncoder)([
-    ["airdrop", (0, import_kit16.getAddressEncoder)()],
-    ["bitmap", (0, import_kit16.getAddressEncoder)()],
-    ["bitmapId", (0, import_kit16.getU16Encoder)()],
-    ["timestamp", (0, import_kit16.getI64Encoder)()]
+  return getStructEncoder13([
+    ["airdrop", getAddressEncoder12()],
+    ["bitmap", getAddressEncoder12()],
+    ["bitmapId", getU16Encoder7()],
+    ["timestamp", getI64Encoder6()]
   ]);
 }
 function getBitmapInitializedDecoder() {
-  return (0, import_kit16.getStructDecoder)([
-    ["airdrop", (0, import_kit16.getAddressDecoder)()],
-    ["bitmap", (0, import_kit16.getAddressDecoder)()],
-    ["bitmapId", (0, import_kit16.getU16Decoder)()],
-    ["timestamp", (0, import_kit16.getI64Decoder)()]
+  return getStructDecoder13([
+    ["airdrop", getAddressDecoder8()],
+    ["bitmap", getAddressDecoder8()],
+    ["bitmapId", getU16Decoder7()],
+    ["timestamp", getI64Decoder6()]
   ]);
 }
 function getBitmapInitializedCodec() {
-  return (0, import_kit16.combineCodec)(
+  return combineCodec13(
     getBitmapInitializedEncoder(),
     getBitmapInitializedDecoder()
   );
 }
 
 // src/types/tokensDeposited.ts
-var import_kit17 = require("@solana/kit");
+import {
+  combineCodec as combineCodec14,
+  getAddressDecoder as getAddressDecoder9,
+  getAddressEncoder as getAddressEncoder13,
+  getI64Decoder as getI64Decoder7,
+  getI64Encoder as getI64Encoder7,
+  getStructDecoder as getStructDecoder14,
+  getStructEncoder as getStructEncoder14,
+  getU64Decoder as getU64Decoder9,
+  getU64Encoder as getU64Encoder9
+} from "@solana/kit";
 function getTokensDepositedEncoder() {
-  return (0, import_kit17.getStructEncoder)([
-    ["airdrop", (0, import_kit17.getAddressEncoder)()],
-    ["amount", (0, import_kit17.getU64Encoder)()],
-    ["newSupply", (0, import_kit17.getU64Encoder)()],
-    ["depositor", (0, import_kit17.getAddressEncoder)()],
-    ["timestamp", (0, import_kit17.getI64Encoder)()]
+  return getStructEncoder14([
+    ["airdrop", getAddressEncoder13()],
+    ["amount", getU64Encoder9()],
+    ["newSupply", getU64Encoder9()],
+    ["depositor", getAddressEncoder13()],
+    ["timestamp", getI64Encoder7()]
   ]);
 }
 function getTokensDepositedDecoder() {
-  return (0, import_kit17.getStructDecoder)([
-    ["airdrop", (0, import_kit17.getAddressDecoder)()],
-    ["amount", (0, import_kit17.getU64Decoder)()],
-    ["newSupply", (0, import_kit17.getU64Decoder)()],
-    ["depositor", (0, import_kit17.getAddressDecoder)()],
-    ["timestamp", (0, import_kit17.getI64Decoder)()]
+  return getStructDecoder14([
+    ["airdrop", getAddressDecoder9()],
+    ["amount", getU64Decoder9()],
+    ["newSupply", getU64Decoder9()],
+    ["depositor", getAddressDecoder9()],
+    ["timestamp", getI64Decoder7()]
   ]);
 }
 function getTokensDepositedCodec() {
-  return (0, import_kit17.combineCodec)(getTokensDepositedEncoder(), getTokensDepositedDecoder());
+  return combineCodec14(getTokensDepositedEncoder(), getTokensDepositedDecoder());
 }
 
 // src/types/tokensRedeemed.ts
-var import_kit18 = require("@solana/kit");
+import {
+  combineCodec as combineCodec15,
+  getAddressDecoder as getAddressDecoder10,
+  getAddressEncoder as getAddressEncoder14,
+  getI64Decoder as getI64Decoder8,
+  getI64Encoder as getI64Encoder8,
+  getStructDecoder as getStructDecoder15,
+  getStructEncoder as getStructEncoder15
+} from "@solana/kit";
 function getTokensRedeemedEncoder() {
-  return (0, import_kit18.getStructEncoder)([
-    ["airdrop", (0, import_kit18.getAddressEncoder)()],
-    ["authority", (0, import_kit18.getAddressEncoder)()],
-    ["timestamp", (0, import_kit18.getI64Encoder)()]
+  return getStructEncoder15([
+    ["airdrop", getAddressEncoder14()],
+    ["authority", getAddressEncoder14()],
+    ["timestamp", getI64Encoder8()]
   ]);
 }
 function getTokensRedeemedDecoder() {
-  return (0, import_kit18.getStructDecoder)([
-    ["airdrop", (0, import_kit18.getAddressDecoder)()],
-    ["authority", (0, import_kit18.getAddressDecoder)()],
-    ["timestamp", (0, import_kit18.getI64Decoder)()]
+  return getStructDecoder15([
+    ["airdrop", getAddressDecoder10()],
+    ["authority", getAddressDecoder10()],
+    ["timestamp", getI64Decoder8()]
   ]);
 }
 function getTokensRedeemedCodec() {
-  return (0, import_kit18.combineCodec)(getTokensRedeemedEncoder(), getTokensRedeemedDecoder());
+  return combineCodec15(getTokensRedeemedEncoder(), getTokensRedeemedDecoder());
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   AIRDROP_CONFIG_DISCRIMINATOR,
   AIRDROP_DISCRIMINATOR,
   AIRDROP_MASTER_DISCRIMINATOR,
@@ -2554,5 +2574,5 @@ function getTokensRedeemedCodec() {
   parseDropsyAirdropInstruction,
   parseInitializeAirdropConfigInstruction,
   parseInitializeAirdropMasterInstruction
-});
+};
 //# sourceMappingURL=index.js.map