@dropsy/airdrop 0.4.0 → 0.4.1

package/dist/index.js

@@ -1,29 +1,218 @@
+"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
-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 import_kit = require("@solana/kit");
 var AIRDROP_DISCRIMINATOR = new Uint8Array([
   31,
   112,
@@ -35,76 +224,76 @@ var AIRDROP_DISCRIMINATOR = new Uint8Array([
   241
 ]);
 function getAirdropDiscriminatorBytes() {
-  return fixEncoderSize(getBytesEncoder(), 8).encode(AIRDROP_DISCRIMINATOR);
+  return (0, import_kit.fixEncoderSize)((0, import_kit.getBytesEncoder)(), 8).encode(AIRDROP_DISCRIMINATOR);
 }
 function getAirdropEncoder() {
-  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)]
+  return (0, import_kit.transformEncoder)(
+    (0, import_kit.getStructEncoder)([
+      ["discriminator", (0, import_kit.fixEncoderSize)((0, import_kit.getBytesEncoder)(), 8)],
+      ["master", (0, import_kit.getAddressEncoder)()],
+      ["authority", (0, import_kit.getAddressEncoder)()],
+      ["mint", (0, import_kit.getAddressEncoder)()],
+      ["delegateAuthority", (0, import_kit.getAddressEncoder)()],
+      ["merkleRoot", (0, import_kit.fixEncoderSize)((0, import_kit.getBytesEncoder)(), 32)],
+      ["id", (0, import_kit.getU64Encoder)()],
+      ["supply", (0, import_kit.getU64Encoder)()],
+      ["boost", (0, import_kit.getU64Encoder)()],
+      ["startsAt", (0, import_kit.getI64Encoder)()],
+      ["endsAt", (0, import_kit.getI64Encoder)()],
+      ["bitmapCount", (0, import_kit.getU16Encoder)()],
+      ["state", (0, import_kit.getU8Encoder)()],
+      ["version", (0, import_kit.getU8Encoder)()],
+      ["bump", (0, import_kit.getU8Encoder)()],
+      ["padding", (0, import_kit.fixEncoderSize)((0, import_kit.getBytesEncoder)(), 3)]
     ]),
     (value) => ({ ...value, discriminator: AIRDROP_DISCRIMINATOR })
   );
 }
 function getAirdropDecoder() {
-  return 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)]
+  return (0, import_kit.getStructDecoder)([
+    ["discriminator", (0, import_kit.fixDecoderSize)((0, import_kit.getBytesDecoder)(), 8)],
+    ["master", (0, import_kit.getAddressDecoder)()],
+    ["authority", (0, import_kit.getAddressDecoder)()],
+    ["mint", (0, import_kit.getAddressDecoder)()],
+    ["delegateAuthority", (0, import_kit.getAddressDecoder)()],
+    ["merkleRoot", (0, import_kit.fixDecoderSize)((0, import_kit.getBytesDecoder)(), 32)],
+    ["id", (0, import_kit.getU64Decoder)()],
+    ["supply", (0, import_kit.getU64Decoder)()],
+    ["boost", (0, import_kit.getU64Decoder)()],
+    ["startsAt", (0, import_kit.getI64Decoder)()],
+    ["endsAt", (0, import_kit.getI64Decoder)()],
+    ["bitmapCount", (0, import_kit.getU16Decoder)()],
+    ["state", (0, import_kit.getU8Decoder)()],
+    ["version", (0, import_kit.getU8Decoder)()],
+    ["bump", (0, import_kit.getU8Decoder)()],
+    ["padding", (0, import_kit.fixDecoderSize)((0, import_kit.getBytesDecoder)(), 3)]
   ]);
 }
 function getAirdropCodec() {
-  return combineCodec(getAirdropEncoder(), getAirdropDecoder());
+  return (0, import_kit.combineCodec)(getAirdropEncoder(), getAirdropDecoder());
 }
 function decodeAirdrop(encodedAccount) {
-  return decodeAccount(
+  return (0, import_kit.decodeAccount)(
     encodedAccount,
     getAirdropDecoder()
   );
 }
 async function fetchAirdrop(rpc, address, config) {
   const maybeAccount = await fetchMaybeAirdrop(rpc, address, config);
-  assertAccountExists(maybeAccount);
+  (0, import_kit.assertAccountExists)(maybeAccount);
   return maybeAccount;
 }
 async function fetchMaybeAirdrop(rpc, address, config) {
-  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  const maybeAccount = await (0, import_kit.fetchEncodedAccount)(rpc, address, config);
   return decodeAirdrop(maybeAccount);
 }
 async function fetchAllAirdrop(rpc, addresses, config) {
   const maybeAccounts = await fetchAllMaybeAirdrop(rpc, addresses, config);
-  assertAccountsExist(maybeAccounts);
+  (0, import_kit.assertAccountsExist)(maybeAccounts);
   return maybeAccounts;
 }
 async function fetchAllMaybeAirdrop(rpc, addresses, config) {
-  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  const maybeAccounts = await (0, import_kit.fetchEncodedAccounts)(rpc, addresses, config);
   return maybeAccounts.map((maybeAccount) => decodeAirdrop(maybeAccount));
 }
 function getAirdropSize() {
@@ -112,31 +301,7 @@ function getAirdropSize() {
 }
 
 // src/accounts/airdropConfig.ts
-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 import_kit2 = require("@solana/kit");
 var AIRDROP_CONFIG_DISCRIMINATOR = new Uint8Array([
   194,
   149,
@@ -148,71 +313,71 @@ var AIRDROP_CONFIG_DISCRIMINATOR = new Uint8Array([
   16
 ]);
 function getAirdropConfigDiscriminatorBytes() {
-  return fixEncoderSize2(getBytesEncoder2(), 8).encode(
+  return (0, import_kit2.fixEncoderSize)((0, import_kit2.getBytesEncoder)(), 8).encode(
     AIRDROP_CONFIG_DISCRIMINATOR
   );
 }
 function getAirdropConfigEncoder() {
-  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)]
+  return (0, import_kit2.transformEncoder)(
+    (0, import_kit2.getStructEncoder)([
+      ["discriminator", (0, import_kit2.fixEncoderSize)((0, import_kit2.getBytesEncoder)(), 8)],
+      ["authority", (0, import_kit2.getAddressEncoder)()],
+      ["protocolTreasury", (0, import_kit2.getAddressEncoder)()],
+      ["wlRoot", (0, import_kit2.fixEncoderSize)((0, import_kit2.getBytesEncoder)(), 32)],
+      ["protocolFee", (0, import_kit2.getU64Encoder)()],
+      ["airdropMasterCreateFee", (0, import_kit2.getU64Encoder)()],
+      ["maxClaimFee", (0, import_kit2.getU64Encoder)()],
+      ["maxActionFee", (0, import_kit2.getU64Encoder)()],
+      ["minAirdropDuration", (0, import_kit2.getI64Encoder)()],
+      ["defaultAirdropDuration", (0, import_kit2.getI64Encoder)()],
+      ["maxAirdropDuration", (0, import_kit2.getI64Encoder)()],
+      ["updateGracePeriod", (0, import_kit2.getI64Encoder)()],
+      ["masterFeeBps", (0, import_kit2.getU16Encoder)()],
+      ["version", (0, import_kit2.getU8Encoder)()],
+      ["bump", (0, import_kit2.getU8Encoder)()],
+      ["padding", (0, import_kit2.fixEncoderSize)((0, import_kit2.getBytesEncoder)(), 4)],
+      ["reserved", (0, import_kit2.fixEncoderSize)((0, import_kit2.getBytesEncoder)(), 256)]
     ]),
     (value) => ({ ...value, discriminator: AIRDROP_CONFIG_DISCRIMINATOR })
   );
 }
 function getAirdropConfigDecoder() {
-  return 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)]
+  return (0, import_kit2.getStructDecoder)([
+    ["discriminator", (0, import_kit2.fixDecoderSize)((0, import_kit2.getBytesDecoder)(), 8)],
+    ["authority", (0, import_kit2.getAddressDecoder)()],
+    ["protocolTreasury", (0, import_kit2.getAddressDecoder)()],
+    ["wlRoot", (0, import_kit2.fixDecoderSize)((0, import_kit2.getBytesDecoder)(), 32)],
+    ["protocolFee", (0, import_kit2.getU64Decoder)()],
+    ["airdropMasterCreateFee", (0, import_kit2.getU64Decoder)()],
+    ["maxClaimFee", (0, import_kit2.getU64Decoder)()],
+    ["maxActionFee", (0, import_kit2.getU64Decoder)()],
+    ["minAirdropDuration", (0, import_kit2.getI64Decoder)()],
+    ["defaultAirdropDuration", (0, import_kit2.getI64Decoder)()],
+    ["maxAirdropDuration", (0, import_kit2.getI64Decoder)()],
+    ["updateGracePeriod", (0, import_kit2.getI64Decoder)()],
+    ["masterFeeBps", (0, import_kit2.getU16Decoder)()],
+    ["version", (0, import_kit2.getU8Decoder)()],
+    ["bump", (0, import_kit2.getU8Decoder)()],
+    ["padding", (0, import_kit2.fixDecoderSize)((0, import_kit2.getBytesDecoder)(), 4)],
+    ["reserved", (0, import_kit2.fixDecoderSize)((0, import_kit2.getBytesDecoder)(), 256)]
   ]);
 }
 function getAirdropConfigCodec() {
-  return combineCodec2(getAirdropConfigEncoder(), getAirdropConfigDecoder());
+  return (0, import_kit2.combineCodec)(getAirdropConfigEncoder(), getAirdropConfigDecoder());
 }
 function decodeAirdropConfig(encodedAccount) {
-  return decodeAccount2(
+  return (0, import_kit2.decodeAccount)(
     encodedAccount,
     getAirdropConfigDecoder()
   );
 }
 async function fetchAirdropConfig(rpc, address, config) {
   const maybeAccount = await fetchMaybeAirdropConfig(rpc, address, config);
-  assertAccountExists2(maybeAccount);
+  (0, import_kit2.assertAccountExists)(maybeAccount);
   return maybeAccount;
 }
 async function fetchMaybeAirdropConfig(rpc, address, config) {
-  const maybeAccount = await fetchEncodedAccount2(rpc, address, config);
+  const maybeAccount = await (0, import_kit2.fetchEncodedAccount)(rpc, address, config);
   return decodeAirdropConfig(maybeAccount);
 }
 async function fetchAllAirdropConfig(rpc, addresses, config) {
@@ -221,11 +386,11 @@ async function fetchAllAirdropConfig(rpc, addresses, config) {
     addresses,
     config
   );
-  assertAccountsExist2(maybeAccounts);
+  (0, import_kit2.assertAccountsExist)(maybeAccounts);
   return maybeAccounts;
 }
 async function fetchAllMaybeAirdropConfig(rpc, addresses, config) {
-  const maybeAccounts = await fetchEncodedAccounts2(rpc, addresses, config);
+  const maybeAccounts = await (0, import_kit2.fetchEncodedAccounts)(rpc, addresses, config);
   return maybeAccounts.map((maybeAccount) => decodeAirdropConfig(maybeAccount));
 }
 function getAirdropConfigSize() {
@@ -233,27 +398,7 @@ function getAirdropConfigSize() {
 }
 
 // src/accounts/airdropMaster.ts
-import {
-  assertAccountExists as assertAccountExists3,
-  assertAccountsExist as assertAccountsExist3,
-  combineCodec as combineCodec3,
-  decodeAccount as decodeAccount3,
-  fetchEncodedAccount as fetchEncodedAccount3,
-  fetchEncodedAccounts as fetchEncodedAccounts3,
-  fixDecoderSize as fixDecoderSize3,
-  fixEncoderSize as fixEncoderSize3,
-  getAddressDecoder as getAddressDecoder3,
-  getAddressEncoder as getAddressEncoder3,
-  getBytesDecoder as getBytesDecoder3,
-  getBytesEncoder as getBytesEncoder3,
-  getStructDecoder as getStructDecoder3,
-  getStructEncoder as getStructEncoder3,
-  getU64Decoder as getU64Decoder3,
-  getU64Encoder as getU64Encoder3,
-  getU8Decoder as getU8Decoder3,
-  getU8Encoder as getU8Encoder3,
-  transformEncoder as transformEncoder3
-} from "@solana/kit";
+var import_kit3 = require("@solana/kit");
 var AIRDROP_MASTER_DISCRIMINATOR = new Uint8Array([
   31,
   109,
@@ -265,69 +410,69 @@ var AIRDROP_MASTER_DISCRIMINATOR = new Uint8Array([
   4
 ]);
 function getAirdropMasterDiscriminatorBytes() {
-  return fixEncoderSize3(getBytesEncoder3(), 8).encode(
+  return (0, import_kit3.fixEncoderSize)((0, import_kit3.getBytesEncoder)(), 8).encode(
     AIRDROP_MASTER_DISCRIMINATOR
   );
 }
 function getAirdropMasterEncoder() {
-  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)]
+  return (0, import_kit3.transformEncoder)(
+    (0, import_kit3.getStructEncoder)([
+      ["discriminator", (0, import_kit3.fixEncoderSize)((0, import_kit3.getBytesEncoder)(), 8)],
+      ["creator", (0, import_kit3.getAddressEncoder)()],
+      ["authority", (0, import_kit3.getAddressEncoder)()],
+      ["treasury", (0, import_kit3.getAddressEncoder)()],
+      ["createdAirdrops", (0, import_kit3.getU64Encoder)()],
+      ["points", (0, import_kit3.getU64Encoder)()],
+      ["totalClaimCount", (0, import_kit3.getU64Encoder)()],
+      ["monetizedClaimQuota", (0, import_kit3.getU64Encoder)()],
+      ["monetizedClaimCount", (0, import_kit3.getU64Encoder)()],
+      ["airdropUpdateFee", (0, import_kit3.getU64Encoder)()],
+      ["airdropCreationFee", (0, import_kit3.getU64Encoder)()],
+      ["airdropClaimFee", (0, import_kit3.getU64Encoder)()],
+      ["airdropDelegateFee", (0, import_kit3.getU64Encoder)()],
+      ["bitmapCreationFee", (0, import_kit3.getU64Encoder)()],
+      ["bump", (0, import_kit3.getU8Encoder)()],
+      ["padding", (0, import_kit3.fixEncoderSize)((0, import_kit3.getBytesEncoder)(), 7)]
     ]),
     (value) => ({ ...value, discriminator: AIRDROP_MASTER_DISCRIMINATOR })
   );
 }
 function getAirdropMasterDecoder() {
-  return 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)]
+  return (0, import_kit3.getStructDecoder)([
+    ["discriminator", (0, import_kit3.fixDecoderSize)((0, import_kit3.getBytesDecoder)(), 8)],
+    ["creator", (0, import_kit3.getAddressDecoder)()],
+    ["authority", (0, import_kit3.getAddressDecoder)()],
+    ["treasury", (0, import_kit3.getAddressDecoder)()],
+    ["createdAirdrops", (0, import_kit3.getU64Decoder)()],
+    ["points", (0, import_kit3.getU64Decoder)()],
+    ["totalClaimCount", (0, import_kit3.getU64Decoder)()],
+    ["monetizedClaimQuota", (0, import_kit3.getU64Decoder)()],
+    ["monetizedClaimCount", (0, import_kit3.getU64Decoder)()],
+    ["airdropUpdateFee", (0, import_kit3.getU64Decoder)()],
+    ["airdropCreationFee", (0, import_kit3.getU64Decoder)()],
+    ["airdropClaimFee", (0, import_kit3.getU64Decoder)()],
+    ["airdropDelegateFee", (0, import_kit3.getU64Decoder)()],
+    ["bitmapCreationFee", (0, import_kit3.getU64Decoder)()],
+    ["bump", (0, import_kit3.getU8Decoder)()],
+    ["padding", (0, import_kit3.fixDecoderSize)((0, import_kit3.getBytesDecoder)(), 7)]
   ]);
 }
 function getAirdropMasterCodec() {
-  return combineCodec3(getAirdropMasterEncoder(), getAirdropMasterDecoder());
+  return (0, import_kit3.combineCodec)(getAirdropMasterEncoder(), getAirdropMasterDecoder());
 }
 function decodeAirdropMaster(encodedAccount) {
-  return decodeAccount3(
+  return (0, import_kit3.decodeAccount)(
     encodedAccount,
     getAirdropMasterDecoder()
   );
 }
 async function fetchAirdropMaster(rpc, address, config) {
   const maybeAccount = await fetchMaybeAirdropMaster(rpc, address, config);
-  assertAccountExists3(maybeAccount);
+  (0, import_kit3.assertAccountExists)(maybeAccount);
   return maybeAccount;
 }
 async function fetchMaybeAirdropMaster(rpc, address, config) {
-  const maybeAccount = await fetchEncodedAccount3(rpc, address, config);
+  const maybeAccount = await (0, import_kit3.fetchEncodedAccount)(rpc, address, config);
   return decodeAirdropMaster(maybeAccount);
 }
 async function fetchAllAirdropMaster(rpc, addresses, config) {
@@ -336,11 +481,11 @@ async function fetchAllAirdropMaster(rpc, addresses, config) {
     addresses,
     config
   );
-  assertAccountsExist3(maybeAccounts);
+  (0, import_kit3.assertAccountsExist)(maybeAccounts);
   return maybeAccounts;
 }
 async function fetchAllMaybeAirdropMaster(rpc, addresses, config) {
-  const maybeAccounts = await fetchEncodedAccounts3(rpc, addresses, config);
+  const maybeAccounts = await (0, import_kit3.fetchEncodedAccounts)(rpc, addresses, config);
   return maybeAccounts.map((maybeAccount) => decodeAirdropMaster(maybeAccount));
 }
 function getAirdropMasterSize() {
@@ -348,29 +493,7 @@ function getAirdropMasterSize() {
 }
 
 // src/accounts/bitmapAccount.ts
-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 import_kit4 = require("@solana/kit");
 var BITMAP_ACCOUNT_DISCRIMINATOR = new Uint8Array([
   152,
   161,
@@ -382,53 +505,53 @@ var BITMAP_ACCOUNT_DISCRIMINATOR = new Uint8Array([
   48
 ]);
 function getBitmapAccountDiscriminatorBytes() {
-  return fixEncoderSize4(getBytesEncoder4(), 8).encode(
+  return (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8).encode(
     BITMAP_ACCOUNT_DISCRIMINATOR
   );
 }
 function getBitmapAccountEncoder() {
-  return transformEncoder4(
-    getStructEncoder4([
-      ["discriminator", fixEncoderSize4(getBytesEncoder4(), 8)],
-      ["authority", getAddressEncoder4()],
-      ["airdrop", getAddressEncoder4()],
-      ["total", getU32Encoder()],
-      ["claimedBitmap", fixEncoderSize4(getBytesEncoder4(), 1e3)],
-      ["id", getU16Encoder3()],
-      ["version", getU8Encoder4()],
-      ["bump", getU8Encoder4()]
+  return (0, import_kit4.transformEncoder)(
+    (0, import_kit4.getStructEncoder)([
+      ["discriminator", (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8)],
+      ["authority", (0, import_kit4.getAddressEncoder)()],
+      ["airdrop", (0, import_kit4.getAddressEncoder)()],
+      ["total", (0, import_kit4.getU32Encoder)()],
+      ["claimedBitmap", (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 1e3)],
+      ["id", (0, import_kit4.getU16Encoder)()],
+      ["version", (0, import_kit4.getU8Encoder)()],
+      ["bump", (0, import_kit4.getU8Encoder)()]
     ]),
     (value) => ({ ...value, discriminator: BITMAP_ACCOUNT_DISCRIMINATOR })
   );
 }
 function getBitmapAccountDecoder() {
-  return getStructDecoder4([
-    ["discriminator", fixDecoderSize4(getBytesDecoder4(), 8)],
-    ["authority", getAddressDecoder4()],
-    ["airdrop", getAddressDecoder4()],
-    ["total", getU32Decoder()],
-    ["claimedBitmap", fixDecoderSize4(getBytesDecoder4(), 1e3)],
-    ["id", getU16Decoder3()],
-    ["version", getU8Decoder4()],
-    ["bump", getU8Decoder4()]
+  return (0, import_kit4.getStructDecoder)([
+    ["discriminator", (0, import_kit4.fixDecoderSize)((0, import_kit4.getBytesDecoder)(), 8)],
+    ["authority", (0, import_kit4.getAddressDecoder)()],
+    ["airdrop", (0, import_kit4.getAddressDecoder)()],
+    ["total", (0, import_kit4.getU32Decoder)()],
+    ["claimedBitmap", (0, import_kit4.fixDecoderSize)((0, import_kit4.getBytesDecoder)(), 1e3)],
+    ["id", (0, import_kit4.getU16Decoder)()],
+    ["version", (0, import_kit4.getU8Decoder)()],
+    ["bump", (0, import_kit4.getU8Decoder)()]
   ]);
 }
 function getBitmapAccountCodec() {
-  return combineCodec4(getBitmapAccountEncoder(), getBitmapAccountDecoder());
+  return (0, import_kit4.combineCodec)(getBitmapAccountEncoder(), getBitmapAccountDecoder());
 }
 function decodeBitmapAccount(encodedAccount) {
-  return decodeAccount4(
+  return (0, import_kit4.decodeAccount)(
     encodedAccount,
     getBitmapAccountDecoder()
   );
 }
 async function fetchBitmapAccount(rpc, address, config) {
   const maybeAccount = await fetchMaybeBitmapAccount(rpc, address, config);
-  assertAccountExists4(maybeAccount);
+  (0, import_kit4.assertAccountExists)(maybeAccount);
   return maybeAccount;
 }
 async function fetchMaybeBitmapAccount(rpc, address, config) {
-  const maybeAccount = await fetchEncodedAccount4(rpc, address, config);
+  const maybeAccount = await (0, import_kit4.fetchEncodedAccount)(rpc, address, config);
   return decodeBitmapAccount(maybeAccount);
 }
 async function fetchAllBitmapAccount(rpc, addresses, config) {
@@ -437,11 +560,11 @@ async function fetchAllBitmapAccount(rpc, addresses, config) {
     addresses,
     config
   );
-  assertAccountsExist4(maybeAccounts);
+  (0, import_kit4.assertAccountsExist)(maybeAccounts);
   return maybeAccounts;
 }
 async function fetchAllMaybeBitmapAccount(rpc, addresses, config) {
-  const maybeAccounts = await fetchEncodedAccounts4(rpc, addresses, config);
+  const maybeAccounts = await (0, import_kit4.fetchEncodedAccounts)(rpc, addresses, config);
   return maybeAccounts.map((maybeAccount) => decodeBitmapAccount(maybeAccount));
 }
 function getBitmapAccountSize() {
@@ -449,45 +572,16 @@ function getBitmapAccountSize() {
 }
 
 // src/errors/dropsyAirdrop.ts
-import {
-  isProgramError
-} from "@solana/kit";
+var import_kit13 = require("@solana/kit");
 
 // src/programs/dropsyAirdrop.ts
-import {
-  assertIsInstructionWithAccounts,
-  containsBytes,
-  fixEncoderSize as fixEncoderSize11,
-  getBytesEncoder as getBytesEncoder11
-} from "@solana/kit";
+var import_kit12 = require("@solana/kit");
 
 // src/instructions/claimAirdrop.ts
-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";
+var import_kit6 = require("@solana/kit");
 
 // src/shared/index.ts
-import {
-  AccountRole,
-  isProgramDerivedAddress,
-  isTransactionSigner as kitIsTransactionSigner,
-  upgradeRoleToSigner
-} from "@solana/kit";
+var import_kit5 = require("@solana/kit");
 function expectSome(value) {
   if (value === null || value === void 0) {
     throw new Error("Expected a value but received null or undefined.");
@@ -512,19 +606,19 @@ function getAccountMetaFactory(programAddress, optionalAccountStrategy) {
       if (optionalAccountStrategy === "omitted") return;
       return Object.freeze({
         address: programAddress,
-        role: AccountRole.READONLY
+        role: import_kit5.AccountRole.READONLY
       });
     }
-    const writableRole = account.isWritable ? AccountRole.WRITABLE : AccountRole.READONLY;
+    const writableRole = account.isWritable ? import_kit5.AccountRole.WRITABLE : import_kit5.AccountRole.READONLY;
     return Object.freeze({
       address: expectAddress(account.value),
-      role: isTransactionSigner(account.value) ? upgradeRoleToSigner(writableRole) : writableRole,
+      role: isTransactionSigner(account.value) ? (0, import_kit5.upgradeRoleToSigner)(writableRole) : writableRole,
       ...isTransactionSigner(account.value) ? { signer: account.value } : {}
     });
   };
 }
 function isTransactionSigner(value) {
-  return !!value && typeof value === "object" && "address" in value && kitIsTransactionSigner(value);
+  return !!value && typeof value === "object" && "address" in value && (0, import_kit5.isTransactionSigner)(value);
 }
 
 // src/instructions/claimAirdrop.ts
@@ -539,33 +633,33 @@ var CLAIM_AIRDROP_DISCRIMINATOR = new Uint8Array([
   20
 ]);
 function getClaimAirdropDiscriminatorBytes() {
-  return fixEncoderSize5(getBytesEncoder5(), 8).encode(
+  return (0, import_kit6.fixEncoderSize)((0, import_kit6.getBytesEncoder)(), 8).encode(
     CLAIM_AIRDROP_DISCRIMINATOR
   );
 }
 function getClaimAirdropInstructionDataEncoder() {
-  return transformEncoder5(
-    getStructEncoder5([
-      ["discriminator", fixEncoderSize5(getBytesEncoder5(), 8)],
-      ["index", getU64Encoder4()],
-      ["proof", getArrayEncoder(fixEncoderSize5(getBytesEncoder5(), 32))],
-      ["amount", getU64Encoder4()],
-      ["claimMapIndex", getU16Encoder4()]
+  return (0, import_kit6.transformEncoder)(
+    (0, import_kit6.getStructEncoder)([
+      ["discriminator", (0, import_kit6.fixEncoderSize)((0, import_kit6.getBytesEncoder)(), 8)],
+      ["index", (0, import_kit6.getU64Encoder)()],
+      ["proof", (0, import_kit6.getArrayEncoder)((0, import_kit6.fixEncoderSize)((0, import_kit6.getBytesEncoder)(), 32))],
+      ["amount", (0, import_kit6.getU64Encoder)()],
+      ["claimMapIndex", (0, import_kit6.getU16Encoder)()]
     ]),
     (value) => ({ ...value, discriminator: CLAIM_AIRDROP_DISCRIMINATOR })
   );
 }
 function getClaimAirdropInstructionDataDecoder() {
-  return getStructDecoder5([
-    ["discriminator", fixDecoderSize5(getBytesDecoder5(), 8)],
-    ["index", getU64Decoder4()],
-    ["proof", getArrayDecoder(fixDecoderSize5(getBytesDecoder5(), 32))],
-    ["amount", getU64Decoder4()],
-    ["claimMapIndex", getU16Decoder4()]
+  return (0, import_kit6.getStructDecoder)([
+    ["discriminator", (0, import_kit6.fixDecoderSize)((0, import_kit6.getBytesDecoder)(), 8)],
+    ["index", (0, import_kit6.getU64Decoder)()],
+    ["proof", (0, import_kit6.getArrayDecoder)((0, import_kit6.fixDecoderSize)((0, import_kit6.getBytesDecoder)(), 32))],
+    ["amount", (0, import_kit6.getU64Decoder)()],
+    ["claimMapIndex", (0, import_kit6.getU16Decoder)()]
   ]);
 }
 function getClaimAirdropInstructionDataCodec() {
-  return combineCodec5(
+  return (0, import_kit6.combineCodec)(
     getClaimAirdropInstructionDataEncoder(),
     getClaimAirdropInstructionDataDecoder()
   );
@@ -607,12 +701,12 @@ async function getClaimAirdropInstructionAsync(input, config) {
     accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
   }
   if (!accounts.destinationTokenAccount.value) {
-    accounts.destinationTokenAccount.value = await getProgramDerivedAddress({
+    accounts.destinationTokenAccount.value = await (0, import_kit6.getProgramDerivedAddress)({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder5().encode(expectAddress(accounts.claimer.value)),
-        getAddressEncoder5().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder5().encode(expectAddress(accounts.mint.value))
+        (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))
       ]
     });
   }
@@ -623,10 +717,10 @@ async function getClaimAirdropInstructionAsync(input, config) {
     accounts.systemProgram.value = "11111111111111111111111111111111";
   }
   if (!accounts.airdropConfig.value) {
-    accounts.airdropConfig.value = await getProgramDerivedAddress({
+    accounts.airdropConfig.value = await (0, import_kit6.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        getBytesEncoder5().encode(
+        (0, import_kit6.getBytesEncoder)().encode(
           new Uint8Array([
             97,
             105,
@@ -648,10 +742,10 @@ async function getClaimAirdropInstructionAsync(input, config) {
     });
   }
   if (!accounts.airdropMaster.value) {
-    accounts.airdropMaster.value = await getProgramDerivedAddress({
+    accounts.airdropMaster.value = await (0, import_kit6.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        getBytesEncoder5().encode(
+        (0, import_kit6.getBytesEncoder)().encode(
           new Uint8Array([
             97,
             105,
@@ -669,7 +763,7 @@ async function getClaimAirdropInstructionAsync(input, config) {
             114
           ])
         ),
-        getAddressEncoder5().encode(expectAddress(accounts.masterCreator.value))
+        (0, import_kit6.getAddressEncoder)().encode(expectAddress(accounts.masterCreator.value))
       ]
     });
   }
@@ -799,27 +893,7 @@ function parseClaimAirdropInstruction(instruction) {
 }
 
 // src/instructions/createAirdrop.ts
-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 import_kit7 = require("@solana/kit");
 var CREATE_AIRDROP_DISCRIMINATOR = new Uint8Array([
   227,
   135,
@@ -831,37 +905,37 @@ var CREATE_AIRDROP_DISCRIMINATOR = new Uint8Array([
   94
 ]);
 function getCreateAirdropDiscriminatorBytes() {
-  return fixEncoderSize6(getBytesEncoder6(), 8).encode(
+  return (0, import_kit7.fixEncoderSize)((0, import_kit7.getBytesEncoder)(), 8).encode(
     CREATE_AIRDROP_DISCRIMINATOR
   );
 }
 function getCreateAirdropInstructionDataEncoder() {
-  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())]
+  return (0, import_kit7.transformEncoder)(
+    (0, import_kit7.getStructEncoder)([
+      ["discriminator", (0, import_kit7.fixEncoderSize)((0, import_kit7.getBytesEncoder)(), 8)],
+      ["id", (0, import_kit7.getU64Encoder)()],
+      ["merkleRoot", (0, import_kit7.getOptionEncoder)((0, import_kit7.fixEncoderSize)((0, import_kit7.getBytesEncoder)(), 32))],
+      ["startsAt", (0, import_kit7.getOptionEncoder)((0, import_kit7.getI64Encoder)())],
+      ["endsAt", (0, import_kit7.getOptionEncoder)((0, import_kit7.getI64Encoder)())],
+      ["version", (0, import_kit7.getOptionEncoder)((0, import_kit7.getU8Encoder)())],
+      ["delegateAuthority", (0, import_kit7.getOptionEncoder)((0, import_kit7.getAddressEncoder)())]
     ]),
     (value) => ({ ...value, discriminator: CREATE_AIRDROP_DISCRIMINATOR })
   );
 }
 function getCreateAirdropInstructionDataDecoder() {
-  return getStructDecoder6([
-    ["discriminator", fixDecoderSize6(getBytesDecoder6(), 8)],
-    ["id", getU64Decoder5()],
-    ["merkleRoot", getOptionDecoder(fixDecoderSize6(getBytesDecoder6(), 32))],
-    ["startsAt", getOptionDecoder(getI64Decoder3())],
-    ["endsAt", getOptionDecoder(getI64Decoder3())],
-    ["version", getOptionDecoder(getU8Decoder5())],
-    ["delegateAuthority", getOptionDecoder(getAddressDecoder5())]
+  return (0, import_kit7.getStructDecoder)([
+    ["discriminator", (0, import_kit7.fixDecoderSize)((0, import_kit7.getBytesDecoder)(), 8)],
+    ["id", (0, import_kit7.getU64Decoder)()],
+    ["merkleRoot", (0, import_kit7.getOptionDecoder)((0, import_kit7.fixDecoderSize)((0, import_kit7.getBytesDecoder)(), 32))],
+    ["startsAt", (0, import_kit7.getOptionDecoder)((0, import_kit7.getI64Decoder)())],
+    ["endsAt", (0, import_kit7.getOptionDecoder)((0, import_kit7.getI64Decoder)())],
+    ["version", (0, import_kit7.getOptionDecoder)((0, import_kit7.getU8Decoder)())],
+    ["delegateAuthority", (0, import_kit7.getOptionDecoder)((0, import_kit7.getAddressDecoder)())]
   ]);
 }
 function getCreateAirdropInstructionDataCodec() {
-  return combineCodec6(
+  return (0, import_kit7.combineCodec)(
     getCreateAirdropInstructionDataEncoder(),
     getCreateAirdropInstructionDataDecoder()
   );
@@ -885,10 +959,10 @@ async function getCreateAirdropInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.airdropConfig.value) {
-    accounts.airdropConfig.value = await getProgramDerivedAddress2({
+    accounts.airdropConfig.value = await (0, import_kit7.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        getBytesEncoder6().encode(
+        (0, import_kit7.getBytesEncoder)().encode(
           new Uint8Array([
             97,
             105,
@@ -910,10 +984,10 @@ async function getCreateAirdropInstructionAsync(input, config) {
     });
   }
   if (!accounts.airdropMaster.value) {
-    accounts.airdropMaster.value = await getProgramDerivedAddress2({
+    accounts.airdropMaster.value = await (0, import_kit7.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        getBytesEncoder6().encode(
+        (0, import_kit7.getBytesEncoder)().encode(
           new Uint8Array([
             97,
             105,
@@ -931,7 +1005,7 @@ async function getCreateAirdropInstructionAsync(input, config) {
             114
           ])
         ),
-        getAddressEncoder6().encode(expectAddress(accounts.masterCreator.value))
+        (0, import_kit7.getAddressEncoder)().encode(expectAddress(accounts.masterCreator.value))
       ]
     });
   }
@@ -1025,22 +1099,7 @@ function parseCreateAirdropInstruction(instruction) {
 }
 
 // src/instructions/createBitmap.ts
-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 import_kit8 = require("@solana/kit");
 var CREATE_BITMAP_DISCRIMINATOR = new Uint8Array([
   69,
   92,
@@ -1052,29 +1111,29 @@ var CREATE_BITMAP_DISCRIMINATOR = new Uint8Array([
   247
 ]);
 function getCreateBitmapDiscriminatorBytes() {
-  return fixEncoderSize7(getBytesEncoder7(), 8).encode(
+  return (0, import_kit8.fixEncoderSize)((0, import_kit8.getBytesEncoder)(), 8).encode(
     CREATE_BITMAP_DISCRIMINATOR
   );
 }
 function getCreateBitmapInstructionDataEncoder() {
-  return transformEncoder7(
-    getStructEncoder7([
-      ["discriminator", fixEncoderSize7(getBytesEncoder7(), 8)],
-      ["id", getU16Encoder5()],
-      ["total", getU32Encoder2()]
+  return (0, import_kit8.transformEncoder)(
+    (0, import_kit8.getStructEncoder)([
+      ["discriminator", (0, import_kit8.fixEncoderSize)((0, import_kit8.getBytesEncoder)(), 8)],
+      ["id", (0, import_kit8.getU16Encoder)()],
+      ["total", (0, import_kit8.getU32Encoder)()]
     ]),
     (value) => ({ ...value, discriminator: CREATE_BITMAP_DISCRIMINATOR })
   );
 }
 function getCreateBitmapInstructionDataDecoder() {
-  return getStructDecoder7([
-    ["discriminator", fixDecoderSize7(getBytesDecoder7(), 8)],
-    ["id", getU16Decoder5()],
-    ["total", getU32Decoder2()]
+  return (0, import_kit8.getStructDecoder)([
+    ["discriminator", (0, import_kit8.fixDecoderSize)((0, import_kit8.getBytesDecoder)(), 8)],
+    ["id", (0, import_kit8.getU16Decoder)()],
+    ["total", (0, import_kit8.getU32Decoder)()]
   ]);
 }
 function getCreateBitmapInstructionDataCodec() {
-  return combineCodec7(
+  return (0, import_kit8.combineCodec)(
     getCreateBitmapInstructionDataEncoder(),
     getCreateBitmapInstructionDataDecoder()
   );
@@ -1099,10 +1158,10 @@ async function getCreateBitmapInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.airdropConfig.value) {
-    accounts.airdropConfig.value = await getProgramDerivedAddress3({
+    accounts.airdropConfig.value = await (0, import_kit8.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        getBytesEncoder7().encode(
+        (0, import_kit8.getBytesEncoder)().encode(
           new Uint8Array([
             97,
             105,
@@ -1124,10 +1183,10 @@ async function getCreateBitmapInstructionAsync(input, config) {
     });
   }
   if (!accounts.airdropMaster.value) {
-    accounts.airdropMaster.value = await getProgramDerivedAddress3({
+    accounts.airdropMaster.value = await (0, import_kit8.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        getBytesEncoder7().encode(
+        (0, import_kit8.getBytesEncoder)().encode(
           new Uint8Array([
             97,
             105,
@@ -1145,29 +1204,29 @@ async function getCreateBitmapInstructionAsync(input, config) {
             114
           ])
         ),
-        getAddressEncoder7().encode(expectAddress(accounts.masterCreator.value))
+        (0, import_kit8.getAddressEncoder)().encode(expectAddress(accounts.masterCreator.value))
       ]
     });
   }
   if (!accounts.airdrop.value) {
-    accounts.airdrop.value = await getProgramDerivedAddress3({
+    accounts.airdrop.value = await (0, import_kit8.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        getBytesEncoder7().encode(
+        (0, import_kit8.getBytesEncoder)().encode(
           new Uint8Array([97, 105, 114, 100, 114, 111, 112])
         ),
-        getAddressEncoder7().encode(expectAddress(accounts.authority.value)),
-        getAddressEncoder7().encode(expectAddress(accounts.mint.value))
+        (0, import_kit8.getAddressEncoder)().encode(expectAddress(accounts.authority.value)),
+        (0, import_kit8.getAddressEncoder)().encode(expectAddress(accounts.mint.value))
       ]
     });
   }
   if (!accounts.bitmap.value) {
-    accounts.bitmap.value = await getProgramDerivedAddress3({
+    accounts.bitmap.value = await (0, import_kit8.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        getBytesEncoder7().encode(new Uint8Array([98, 105, 116, 109, 97, 112])),
-        getAddressEncoder7().encode(expectAddress(accounts.airdrop.value)),
-        getU16Encoder5().encode(expectSome(args.id))
+        (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))
       ]
     });
   }
@@ -1265,20 +1324,7 @@ function parseCreateBitmapInstruction(instruction) {
 }
 
 // src/instructions/depositTokens.ts
-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 import_kit9 = require("@solana/kit");
 var DEPOSIT_TOKENS_DISCRIMINATOR = new Uint8Array([
   176,
   83,
@@ -1290,27 +1336,27 @@ var DEPOSIT_TOKENS_DISCRIMINATOR = new Uint8Array([
   150
 ]);
 function getDepositTokensDiscriminatorBytes() {
-  return fixEncoderSize8(getBytesEncoder8(), 8).encode(
+  return (0, import_kit9.fixEncoderSize)((0, import_kit9.getBytesEncoder)(), 8).encode(
     DEPOSIT_TOKENS_DISCRIMINATOR
   );
 }
 function getDepositTokensInstructionDataEncoder() {
-  return transformEncoder8(
-    getStructEncoder8([
-      ["discriminator", fixEncoderSize8(getBytesEncoder8(), 8)],
-      ["amount", getU64Encoder6()]
+  return (0, import_kit9.transformEncoder)(
+    (0, import_kit9.getStructEncoder)([
+      ["discriminator", (0, import_kit9.fixEncoderSize)((0, import_kit9.getBytesEncoder)(), 8)],
+      ["amount", (0, import_kit9.getU64Encoder)()]
     ]),
     (value) => ({ ...value, discriminator: DEPOSIT_TOKENS_DISCRIMINATOR })
   );
 }
 function getDepositTokensInstructionDataDecoder() {
-  return getStructDecoder8([
-    ["discriminator", fixDecoderSize8(getBytesDecoder8(), 8)],
-    ["amount", getU64Decoder6()]
+  return (0, import_kit9.getStructDecoder)([
+    ["discriminator", (0, import_kit9.fixDecoderSize)((0, import_kit9.getBytesDecoder)(), 8)],
+    ["amount", (0, import_kit9.getU64Decoder)()]
   ]);
 }
 function getDepositTokensInstructionDataCodec() {
-  return combineCodec8(
+  return (0, import_kit9.combineCodec)(
     getDepositTokensInstructionDataEncoder(),
     getDepositTokensInstructionDataDecoder()
   );
@@ -1336,14 +1382,14 @@ async function getDepositTokensInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.airdrop.value) {
-    accounts.airdrop.value = await getProgramDerivedAddress4({
+    accounts.airdrop.value = await (0, import_kit9.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        getBytesEncoder8().encode(
+        (0, import_kit9.getBytesEncoder)().encode(
           new Uint8Array([97, 105, 114, 100, 114, 111, 112])
         ),
-        getAddressEncoder8().encode(expectAddress(accounts.authority.value)),
-        getAddressEncoder8().encode(expectAddress(accounts.mint.value))
+        (0, import_kit9.getAddressEncoder)().encode(expectAddress(accounts.authority.value)),
+        (0, import_kit9.getAddressEncoder)().encode(expectAddress(accounts.mint.value))
       ]
     });
   }
@@ -1351,12 +1397,12 @@ async function getDepositTokensInstructionAsync(input, config) {
     accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
   }
   if (!accounts.vault.value) {
-    accounts.vault.value = await getProgramDerivedAddress4({
+    accounts.vault.value = await (0, import_kit9.getProgramDerivedAddress)({
       programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
       seeds: [
-        getAddressEncoder8().encode(expectAddress(accounts.airdrop.value)),
-        getAddressEncoder8().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder8().encode(expectAddress(accounts.mint.value))
+        (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))
       ]
     });
   }
@@ -1458,25 +1504,7 @@ function parseDepositTokensInstruction(instruction) {
 }
 
 // src/instructions/initializeAirdropConfig.ts
-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 import_kit10 = require("@solana/kit");
 var INITIALIZE_AIRDROP_CONFIG_DISCRIMINATOR = new Uint8Array([
   160,
   68,
@@ -1488,24 +1516,24 @@ var INITIALIZE_AIRDROP_CONFIG_DISCRIMINATOR = new Uint8Array([
   94
 ]);
 function getInitializeAirdropConfigDiscriminatorBytes() {
-  return fixEncoderSize9(getBytesEncoder9(), 8).encode(
+  return (0, import_kit10.fixEncoderSize)((0, import_kit10.getBytesEncoder)(), 8).encode(
     INITIALIZE_AIRDROP_CONFIG_DISCRIMINATOR
   );
 }
 function getInitializeAirdropConfigInstructionDataEncoder() {
-  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())]
+  return (0, import_kit10.transformEncoder)(
+    (0, import_kit10.getStructEncoder)([
+      ["discriminator", (0, import_kit10.fixEncoderSize)((0, import_kit10.getBytesEncoder)(), 8)],
+      ["wlRoot", (0, import_kit10.getOptionEncoder)((0, import_kit10.fixEncoderSize)((0, import_kit10.getBytesEncoder)(), 32))],
+      ["airdropMasterCreateFee", (0, import_kit10.getOptionEncoder)((0, import_kit10.getU64Encoder)())],
+      ["maxClaimFee", (0, import_kit10.getOptionEncoder)((0, import_kit10.getU64Encoder)())],
+      ["maxActionFee", (0, import_kit10.getOptionEncoder)((0, import_kit10.getU64Encoder)())],
+      ["minAirdropDuration", (0, import_kit10.getOptionEncoder)((0, import_kit10.getI64Encoder)())],
+      ["defaultAirdropDuration", (0, import_kit10.getOptionEncoder)((0, import_kit10.getI64Encoder)())],
+      ["maxAirdropDuration", (0, import_kit10.getOptionEncoder)((0, import_kit10.getI64Encoder)())],
+      ["updateGracePeriod", (0, import_kit10.getOptionEncoder)((0, import_kit10.getI64Encoder)())],
+      ["protocolFee", (0, import_kit10.getOptionEncoder)((0, import_kit10.getU64Encoder)())],
+      ["masterFeeBps", (0, import_kit10.getOptionEncoder)((0, import_kit10.getU16Encoder)())]
     ]),
     (value) => ({
       ...value,
@@ -1514,22 +1542,22 @@ function getInitializeAirdropConfigInstructionDataEncoder() {
   );
 }
 function getInitializeAirdropConfigInstructionDataDecoder() {
-  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())]
+  return (0, import_kit10.getStructDecoder)([
+    ["discriminator", (0, import_kit10.fixDecoderSize)((0, import_kit10.getBytesDecoder)(), 8)],
+    ["wlRoot", (0, import_kit10.getOptionDecoder)((0, import_kit10.fixDecoderSize)((0, import_kit10.getBytesDecoder)(), 32))],
+    ["airdropMasterCreateFee", (0, import_kit10.getOptionDecoder)((0, import_kit10.getU64Decoder)())],
+    ["maxClaimFee", (0, import_kit10.getOptionDecoder)((0, import_kit10.getU64Decoder)())],
+    ["maxActionFee", (0, import_kit10.getOptionDecoder)((0, import_kit10.getU64Decoder)())],
+    ["minAirdropDuration", (0, import_kit10.getOptionDecoder)((0, import_kit10.getI64Decoder)())],
+    ["defaultAirdropDuration", (0, import_kit10.getOptionDecoder)((0, import_kit10.getI64Decoder)())],
+    ["maxAirdropDuration", (0, import_kit10.getOptionDecoder)((0, import_kit10.getI64Decoder)())],
+    ["updateGracePeriod", (0, import_kit10.getOptionDecoder)((0, import_kit10.getI64Decoder)())],
+    ["protocolFee", (0, import_kit10.getOptionDecoder)((0, import_kit10.getU64Decoder)())],
+    ["masterFeeBps", (0, import_kit10.getOptionDecoder)((0, import_kit10.getU16Decoder)())]
   ]);
 }
 function getInitializeAirdropConfigInstructionDataCodec() {
-  return combineCodec9(
+  return (0, import_kit10.combineCodec)(
     getInitializeAirdropConfigInstructionDataEncoder(),
     getInitializeAirdropConfigInstructionDataDecoder()
   );
@@ -1548,10 +1576,10 @@ async function getInitializeAirdropConfigInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.config.value) {
-    accounts.config.value = await getProgramDerivedAddress5({
+    accounts.config.value = await (0, import_kit10.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        getBytesEncoder9().encode(
+        (0, import_kit10.getBytesEncoder)().encode(
           new Uint8Array([
             97,
             105,
@@ -1650,24 +1678,7 @@ function parseInitializeAirdropConfigInstruction(instruction) {
 }
 
 // src/instructions/initializeAirdropMaster.ts
-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 import_kit11 = require("@solana/kit");
 var INITIALIZE_AIRDROP_MASTER_DISCRIMINATOR = new Uint8Array([
   163,
   197,
@@ -1679,23 +1690,23 @@ var INITIALIZE_AIRDROP_MASTER_DISCRIMINATOR = new Uint8Array([
   65
 ]);
 function getInitializeAirdropMasterDiscriminatorBytes() {
-  return fixEncoderSize10(getBytesEncoder10(), 8).encode(
+  return (0, import_kit11.fixEncoderSize)((0, import_kit11.getBytesEncoder)(), 8).encode(
     INITIALIZE_AIRDROP_MASTER_DISCRIMINATOR
   );
 }
 function getInitializeAirdropMasterInstructionDataEncoder() {
-  return transformEncoder10(
-    getStructEncoder10([
-      ["discriminator", fixEncoderSize10(getBytesEncoder10(), 8)],
-      ["airdropUpdateFee", getOptionEncoder3(getU64Encoder8())],
-      ["airdropCreationFee", getOptionEncoder3(getU64Encoder8())],
-      ["airdropClaimFee", getOptionEncoder3(getU64Encoder8())],
-      ["airdropDelegateFee", getOptionEncoder3(getU64Encoder8())],
-      ["bitmapCreationFee", getOptionEncoder3(getU64Encoder8())],
+  return (0, import_kit11.transformEncoder)(
+    (0, import_kit11.getStructEncoder)([
+      ["discriminator", (0, import_kit11.fixEncoderSize)((0, import_kit11.getBytesEncoder)(), 8)],
+      ["airdropUpdateFee", (0, import_kit11.getOptionEncoder)((0, import_kit11.getU64Encoder)())],
+      ["airdropCreationFee", (0, import_kit11.getOptionEncoder)((0, import_kit11.getU64Encoder)())],
+      ["airdropClaimFee", (0, import_kit11.getOptionEncoder)((0, import_kit11.getU64Encoder)())],
+      ["airdropDelegateFee", (0, import_kit11.getOptionEncoder)((0, import_kit11.getU64Encoder)())],
+      ["bitmapCreationFee", (0, import_kit11.getOptionEncoder)((0, import_kit11.getU64Encoder)())],
       [
         "discountProof",
-        getOptionEncoder3(
-          getArrayEncoder2(fixEncoderSize10(getBytesEncoder10(), 32))
+        (0, import_kit11.getOptionEncoder)(
+          (0, import_kit11.getArrayEncoder)((0, import_kit11.fixEncoderSize)((0, import_kit11.getBytesEncoder)(), 32))
         )
       ]
     ]),
@@ -1706,21 +1717,21 @@ function getInitializeAirdropMasterInstructionDataEncoder() {
   );
 }
 function getInitializeAirdropMasterInstructionDataDecoder() {
-  return getStructDecoder10([
-    ["discriminator", fixDecoderSize10(getBytesDecoder10(), 8)],
-    ["airdropUpdateFee", getOptionDecoder3(getU64Decoder8())],
-    ["airdropCreationFee", getOptionDecoder3(getU64Decoder8())],
-    ["airdropClaimFee", getOptionDecoder3(getU64Decoder8())],
-    ["airdropDelegateFee", getOptionDecoder3(getU64Decoder8())],
-    ["bitmapCreationFee", getOptionDecoder3(getU64Decoder8())],
+  return (0, import_kit11.getStructDecoder)([
+    ["discriminator", (0, import_kit11.fixDecoderSize)((0, import_kit11.getBytesDecoder)(), 8)],
+    ["airdropUpdateFee", (0, import_kit11.getOptionDecoder)((0, import_kit11.getU64Decoder)())],
+    ["airdropCreationFee", (0, import_kit11.getOptionDecoder)((0, import_kit11.getU64Decoder)())],
+    ["airdropClaimFee", (0, import_kit11.getOptionDecoder)((0, import_kit11.getU64Decoder)())],
+    ["airdropDelegateFee", (0, import_kit11.getOptionDecoder)((0, import_kit11.getU64Decoder)())],
+    ["bitmapCreationFee", (0, import_kit11.getOptionDecoder)((0, import_kit11.getU64Decoder)())],
     [
       "discountProof",
-      getOptionDecoder3(getArrayDecoder2(fixDecoderSize10(getBytesDecoder10(), 32)))
+      (0, import_kit11.getOptionDecoder)((0, import_kit11.getArrayDecoder)((0, import_kit11.fixDecoderSize)((0, import_kit11.getBytesDecoder)(), 32)))
     ]
   ]);
 }
 function getInitializeAirdropMasterInstructionDataCodec() {
-  return combineCodec10(
+  return (0, import_kit11.combineCodec)(
     getInitializeAirdropMasterInstructionDataEncoder(),
     getInitializeAirdropMasterInstructionDataDecoder()
   );
@@ -1742,10 +1753,10 @@ async function getInitializeAirdropMasterInstructionAsync(input, config) {
   const accounts = originalAccounts;
   const args = { ...input };
   if (!accounts.config.value) {
-    accounts.config.value = await getProgramDerivedAddress6({
+    accounts.config.value = await (0, import_kit11.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        getBytesEncoder10().encode(
+        (0, import_kit11.getBytesEncoder)().encode(
           new Uint8Array([
             97,
             105,
@@ -1767,10 +1778,10 @@ async function getInitializeAirdropMasterInstructionAsync(input, config) {
     });
   }
   if (!accounts.airdropMaster.value) {
-    accounts.airdropMaster.value = await getProgramDerivedAddress6({
+    accounts.airdropMaster.value = await (0, import_kit11.getProgramDerivedAddress)({
       programAddress,
       seeds: [
-        getBytesEncoder10().encode(
+        (0, import_kit11.getBytesEncoder)().encode(
           new Uint8Array([
             97,
             105,
@@ -1788,7 +1799,7 @@ async function getInitializeAirdropMasterInstructionAsync(input, config) {
             114
           ])
         ),
-        getAddressEncoder9().encode(expectAddress(accounts.creator.value))
+        (0, import_kit11.getAddressEncoder)().encode(expectAddress(accounts.creator.value))
       ]
     });
   }
@@ -1890,36 +1901,36 @@ var DropsyAirdropAccount = /* @__PURE__ */ ((DropsyAirdropAccount2) => {
 })(DropsyAirdropAccount || {});
 function identifyDropsyAirdropAccount(account) {
   const data = "data" in account ? account.data : account;
-  if (containsBytes(
+  if ((0, import_kit12.containsBytes)(
     data,
-    fixEncoderSize11(getBytesEncoder11(), 8).encode(
+    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
       new Uint8Array([31, 112, 159, 158, 124, 237, 9, 241])
     ),
     0
   )) {
     return 0 /* Airdrop */;
   }
-  if (containsBytes(
+  if ((0, import_kit12.containsBytes)(
     data,
-    fixEncoderSize11(getBytesEncoder11(), 8).encode(
+    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
       new Uint8Array([194, 149, 223, 142, 42, 98, 128, 16])
     ),
     0
   )) {
     return 1 /* AirdropConfig */;
   }
-  if (containsBytes(
+  if ((0, import_kit12.containsBytes)(
     data,
-    fixEncoderSize11(getBytesEncoder11(), 8).encode(
+    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
       new Uint8Array([31, 109, 100, 62, 106, 173, 5, 4])
     ),
     0
   )) {
     return 2 /* AirdropMaster */;
   }
-  if (containsBytes(
+  if ((0, import_kit12.containsBytes)(
     data,
-    fixEncoderSize11(getBytesEncoder11(), 8).encode(
+    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
       new Uint8Array([152, 161, 147, 85, 213, 38, 59, 48])
     ),
     0
@@ -1941,54 +1952,54 @@ var DropsyAirdropInstruction = /* @__PURE__ */ ((DropsyAirdropInstruction2) => {
 })(DropsyAirdropInstruction || {});
 function identifyDropsyAirdropInstruction(instruction) {
   const data = "data" in instruction ? instruction.data : instruction;
-  if (containsBytes(
+  if ((0, import_kit12.containsBytes)(
     data,
-    fixEncoderSize11(getBytesEncoder11(), 8).encode(
+    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
       new Uint8Array([137, 50, 122, 111, 89, 254, 8, 20])
     ),
     0
   )) {
     return 0 /* ClaimAirdrop */;
   }
-  if (containsBytes(
+  if ((0, import_kit12.containsBytes)(
     data,
-    fixEncoderSize11(getBytesEncoder11(), 8).encode(
+    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
       new Uint8Array([227, 135, 208, 66, 137, 177, 80, 94])
     ),
     0
   )) {
     return 1 /* CreateAirdrop */;
   }
-  if (containsBytes(
+  if ((0, import_kit12.containsBytes)(
     data,
-    fixEncoderSize11(getBytesEncoder11(), 8).encode(
+    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
       new Uint8Array([69, 92, 61, 190, 154, 237, 116, 247])
     ),
     0
   )) {
     return 2 /* CreateBitmap */;
   }
-  if (containsBytes(
+  if ((0, import_kit12.containsBytes)(
     data,
-    fixEncoderSize11(getBytesEncoder11(), 8).encode(
+    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
       new Uint8Array([176, 83, 229, 18, 191, 143, 176, 150])
     ),
     0
   )) {
     return 3 /* DepositTokens */;
   }
-  if (containsBytes(
+  if ((0, import_kit12.containsBytes)(
     data,
-    fixEncoderSize11(getBytesEncoder11(), 8).encode(
+    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
       new Uint8Array([160, 68, 127, 205, 130, 205, 156, 94])
     ),
     0
   )) {
     return 4 /* InitializeAirdropConfig */;
   }
-  if (containsBytes(
+  if ((0, import_kit12.containsBytes)(
     data,
-    fixEncoderSize11(getBytesEncoder11(), 8).encode(
+    (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
       new Uint8Array([163, 197, 170, 44, 57, 57, 90, 65])
     ),
     0
@@ -2003,42 +2014,42 @@ function parseDropsyAirdropInstruction(instruction) {
   const instructionType = identifyDropsyAirdropInstruction(instruction);
   switch (instructionType) {
     case 0 /* ClaimAirdrop */: {
-      assertIsInstructionWithAccounts(instruction);
+      (0, import_kit12.assertIsInstructionWithAccounts)(instruction);
       return {
         instructionType: 0 /* ClaimAirdrop */,
         ...parseClaimAirdropInstruction(instruction)
       };
     }
     case 1 /* CreateAirdrop */: {
-      assertIsInstructionWithAccounts(instruction);
+      (0, import_kit12.assertIsInstructionWithAccounts)(instruction);
       return {
         instructionType: 1 /* CreateAirdrop */,
         ...parseCreateAirdropInstruction(instruction)
       };
     }
     case 2 /* CreateBitmap */: {
-      assertIsInstructionWithAccounts(instruction);
+      (0, import_kit12.assertIsInstructionWithAccounts)(instruction);
       return {
         instructionType: 2 /* CreateBitmap */,
         ...parseCreateBitmapInstruction(instruction)
       };
     }
     case 3 /* DepositTokens */: {
-      assertIsInstructionWithAccounts(instruction);
+      (0, import_kit12.assertIsInstructionWithAccounts)(instruction);
       return {
         instructionType: 3 /* DepositTokens */,
         ...parseDepositTokensInstruction(instruction)
       };
     }
     case 4 /* InitializeAirdropConfig */: {
-      assertIsInstructionWithAccounts(instruction);
+      (0, import_kit12.assertIsInstructionWithAccounts)(instruction);
       return {
         instructionType: 4 /* InitializeAirdropConfig */,
         ...parseInitializeAirdropConfigInstruction(instruction)
       };
     }
     case 5 /* InitializeAirdropMaster */: {
-      assertIsInstructionWithAccounts(instruction);
+      (0, import_kit12.assertIsInstructionWithAccounts)(instruction);
       return {
         instructionType: 5 /* InitializeAirdropMaster */,
         ...parseInitializeAirdropMasterInstruction(instruction)
@@ -2210,7 +2221,7 @@ function getDropsyAirdropErrorMessage(code) {
   return "Error message not available in production bundles.";
 }
 function isDropsyAirdropError(error, transactionMessage, code) {
-  return isProgramError(
+  return (0, import_kit13.isProgramError)(
     error,
     transactionMessage,
     DROPSY_AIRDROP_PROGRAM_ADDRESS,
@@ -2219,173 +2230,128 @@ function isDropsyAirdropError(error, transactionMessage, code) {
 }
 
 // src/types/airdropInitialized.ts
-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";
+var import_kit14 = require("@solana/kit");
 function getAirdropInitializedEncoder() {
-  return getStructEncoder11([
-    ["airdrop", getAddressEncoder10()],
-    ["mint", getAddressEncoder10()],
-    ["authority", getAddressEncoder10()],
-    ["master", getAddressEncoder10()],
-    ["merkleRoot", fixEncoderSize12(getBytesEncoder12(), 32)],
-    ["startTime", getI64Encoder5()],
-    ["endTime", getI64Encoder5()],
-    ["timestamp", getI64Encoder5()]
+  return (0, import_kit14.getStructEncoder)([
+    ["airdrop", (0, import_kit14.getAddressEncoder)()],
+    ["mint", (0, import_kit14.getAddressEncoder)()],
+    ["authority", (0, import_kit14.getAddressEncoder)()],
+    ["master", (0, import_kit14.getAddressEncoder)()],
+    ["merkleRoot", (0, import_kit14.fixEncoderSize)((0, import_kit14.getBytesEncoder)(), 32)],
+    ["startTime", (0, import_kit14.getI64Encoder)()],
+    ["endTime", (0, import_kit14.getI64Encoder)()],
+    ["timestamp", (0, import_kit14.getI64Encoder)()]
   ]);
 }
 function getAirdropInitializedDecoder() {
-  return getStructDecoder11([
-    ["airdrop", getAddressDecoder6()],
-    ["mint", getAddressDecoder6()],
-    ["authority", getAddressDecoder6()],
-    ["master", getAddressDecoder6()],
-    ["merkleRoot", fixDecoderSize11(getBytesDecoder11(), 32)],
-    ["startTime", getI64Decoder5()],
-    ["endTime", getI64Decoder5()],
-    ["timestamp", getI64Decoder5()]
+  return (0, import_kit14.getStructDecoder)([
+    ["airdrop", (0, import_kit14.getAddressDecoder)()],
+    ["mint", (0, import_kit14.getAddressDecoder)()],
+    ["authority", (0, import_kit14.getAddressDecoder)()],
+    ["master", (0, import_kit14.getAddressDecoder)()],
+    ["merkleRoot", (0, import_kit14.fixDecoderSize)((0, import_kit14.getBytesDecoder)(), 32)],
+    ["startTime", (0, import_kit14.getI64Decoder)()],
+    ["endTime", (0, import_kit14.getI64Decoder)()],
+    ["timestamp", (0, import_kit14.getI64Decoder)()]
   ]);
 }
 function getAirdropInitializedCodec() {
-  return combineCodec11(
+  return (0, import_kit14.combineCodec)(
     getAirdropInitializedEncoder(),
     getAirdropInitializedDecoder()
   );
 }
 
 // src/types/bitmapClosed.ts
-import {
-  combineCodec as combineCodec12,
-  getAddressDecoder as getAddressDecoder7,
-  getAddressEncoder as getAddressEncoder11,
-  getStructDecoder as getStructDecoder12,
-  getStructEncoder as getStructEncoder12
-} from "@solana/kit";
+var import_kit15 = require("@solana/kit");
 function getBitmapClosedEncoder() {
-  return getStructEncoder12([
-    ["airdrop", getAddressEncoder11()],
-    ["bitmap", getAddressEncoder11()],
-    ["authority", getAddressEncoder11()]
+  return (0, import_kit15.getStructEncoder)([
+    ["airdrop", (0, import_kit15.getAddressEncoder)()],
+    ["bitmap", (0, import_kit15.getAddressEncoder)()],
+    ["authority", (0, import_kit15.getAddressEncoder)()]
   ]);
 }
 function getBitmapClosedDecoder() {
-  return getStructDecoder12([
-    ["airdrop", getAddressDecoder7()],
-    ["bitmap", getAddressDecoder7()],
-    ["authority", getAddressDecoder7()]
+  return (0, import_kit15.getStructDecoder)([
+    ["airdrop", (0, import_kit15.getAddressDecoder)()],
+    ["bitmap", (0, import_kit15.getAddressDecoder)()],
+    ["authority", (0, import_kit15.getAddressDecoder)()]
   ]);
 }
 function getBitmapClosedCodec() {
-  return combineCodec12(getBitmapClosedEncoder(), getBitmapClosedDecoder());
+  return (0, import_kit15.combineCodec)(getBitmapClosedEncoder(), getBitmapClosedDecoder());
 }
 
 // src/types/bitmapInitialized.ts
-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";
+var import_kit16 = require("@solana/kit");
 function getBitmapInitializedEncoder() {
-  return getStructEncoder13([
-    ["airdrop", getAddressEncoder12()],
-    ["bitmap", getAddressEncoder12()],
-    ["bitmapId", getU16Encoder7()],
-    ["timestamp", getI64Encoder6()]
+  return (0, import_kit16.getStructEncoder)([
+    ["airdrop", (0, import_kit16.getAddressEncoder)()],
+    ["bitmap", (0, import_kit16.getAddressEncoder)()],
+    ["bitmapId", (0, import_kit16.getU16Encoder)()],
+    ["timestamp", (0, import_kit16.getI64Encoder)()]
   ]);
 }
 function getBitmapInitializedDecoder() {
-  return getStructDecoder13([
-    ["airdrop", getAddressDecoder8()],
-    ["bitmap", getAddressDecoder8()],
-    ["bitmapId", getU16Decoder7()],
-    ["timestamp", getI64Decoder6()]
+  return (0, import_kit16.getStructDecoder)([
+    ["airdrop", (0, import_kit16.getAddressDecoder)()],
+    ["bitmap", (0, import_kit16.getAddressDecoder)()],
+    ["bitmapId", (0, import_kit16.getU16Decoder)()],
+    ["timestamp", (0, import_kit16.getI64Decoder)()]
   ]);
 }
 function getBitmapInitializedCodec() {
-  return combineCodec13(
+  return (0, import_kit16.combineCodec)(
     getBitmapInitializedEncoder(),
     getBitmapInitializedDecoder()
   );
 }
 
 // src/types/tokensDeposited.ts
-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";
+var import_kit17 = require("@solana/kit");
 function getTokensDepositedEncoder() {
-  return getStructEncoder14([
-    ["airdrop", getAddressEncoder13()],
-    ["amount", getU64Encoder9()],
-    ["newSupply", getU64Encoder9()],
-    ["depositor", getAddressEncoder13()],
-    ["timestamp", getI64Encoder7()]
+  return (0, import_kit17.getStructEncoder)([
+    ["airdrop", (0, import_kit17.getAddressEncoder)()],
+    ["amount", (0, import_kit17.getU64Encoder)()],
+    ["newSupply", (0, import_kit17.getU64Encoder)()],
+    ["depositor", (0, import_kit17.getAddressEncoder)()],
+    ["timestamp", (0, import_kit17.getI64Encoder)()]
   ]);
 }
 function getTokensDepositedDecoder() {
-  return getStructDecoder14([
-    ["airdrop", getAddressDecoder9()],
-    ["amount", getU64Decoder9()],
-    ["newSupply", getU64Decoder9()],
-    ["depositor", getAddressDecoder9()],
-    ["timestamp", getI64Decoder7()]
+  return (0, import_kit17.getStructDecoder)([
+    ["airdrop", (0, import_kit17.getAddressDecoder)()],
+    ["amount", (0, import_kit17.getU64Decoder)()],
+    ["newSupply", (0, import_kit17.getU64Decoder)()],
+    ["depositor", (0, import_kit17.getAddressDecoder)()],
+    ["timestamp", (0, import_kit17.getI64Decoder)()]
   ]);
 }
 function getTokensDepositedCodec() {
-  return combineCodec14(getTokensDepositedEncoder(), getTokensDepositedDecoder());
+  return (0, import_kit17.combineCodec)(getTokensDepositedEncoder(), getTokensDepositedDecoder());
 }
 
 // src/types/tokensRedeemed.ts
-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";
+var import_kit18 = require("@solana/kit");
 function getTokensRedeemedEncoder() {
-  return getStructEncoder15([
-    ["airdrop", getAddressEncoder14()],
-    ["authority", getAddressEncoder14()],
-    ["timestamp", getI64Encoder8()]
+  return (0, import_kit18.getStructEncoder)([
+    ["airdrop", (0, import_kit18.getAddressEncoder)()],
+    ["authority", (0, import_kit18.getAddressEncoder)()],
+    ["timestamp", (0, import_kit18.getI64Encoder)()]
   ]);
 }
 function getTokensRedeemedDecoder() {
-  return getStructDecoder15([
-    ["airdrop", getAddressDecoder10()],
-    ["authority", getAddressDecoder10()],
-    ["timestamp", getI64Decoder8()]
+  return (0, import_kit18.getStructDecoder)([
+    ["airdrop", (0, import_kit18.getAddressDecoder)()],
+    ["authority", (0, import_kit18.getAddressDecoder)()],
+    ["timestamp", (0, import_kit18.getI64Decoder)()]
   ]);
 }
 function getTokensRedeemedCodec() {
-  return combineCodec15(getTokensRedeemedEncoder(), getTokensRedeemedDecoder());
+  return (0, import_kit18.combineCodec)(getTokensRedeemedEncoder(), getTokensRedeemedDecoder());
 }
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   AIRDROP_CONFIG_DISCRIMINATOR,
   AIRDROP_DISCRIMINATOR,
   AIRDROP_MASTER_DISCRIMINATOR,
@@ -2574,5 +2540,5 @@ export {
   parseDropsyAirdropInstruction,
   parseInitializeAirdropConfigInstruction,
   parseInitializeAirdropMasterInstruction
-};
+});
 //# sourceMappingURL=index.js.map