@dropsy/airdrop 0.0.1 → 0.1.0

package/dist/index.js

@@ -1,25 +1,8 @@
 "use strict";
 var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -33,26 +16,6 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
 
 // src/index.ts
 var index_exports = {};
@@ -121,26 +84,44 @@ __export(index_exports, {
   INITIALIZE_AIRDROP_DISCRIMINATOR: () => INITIALIZE_AIRDROP_DISCRIMINATOR,
   INITIALIZE_BITMAP_DISCRIMINATOR: () => INITIALIZE_BITMAP_DISCRIMINATOR,
   INITIALIZE_CONTROLLER_DISCRIMINATOR: () => INITIALIZE_CONTROLLER_DISCRIMINATOR,
+  INITIALIZE_MASTER_DISCRIMINATOR: () => INITIALIZE_MASTER_DISCRIMINATOR,
+  MASTER_DISCRIMINATOR: () => MASTER_DISCRIMINATOR,
+  STATS_DISCRIMINATOR: () => STATS_DISCRIMINATOR,
+  WITHDRAW_CONTROLLER_FEES_DISCRIMINATOR: () => WITHDRAW_CONTROLLER_FEES_DISCRIMINATOR,
+  createDefaultSolanaClient: () => createDefaultSolanaClient,
+  createTransactionMessageFromInstruction: () => createTransactionMessageFromInstruction,
   decodeAirdrop: () => decodeAirdrop,
   decodeBitmapAccount: () => decodeBitmapAccount,
   decodeController: () => decodeController,
+  decodeMaster: () => decodeMaster,
+  decodeStats: () => decodeStats,
   fetchAirdrop: () => fetchAirdrop,
   fetchAllAirdrop: () => fetchAllAirdrop,
   fetchAllBitmapAccount: () => fetchAllBitmapAccount,
   fetchAllController: () => fetchAllController,
+  fetchAllMaster: () => fetchAllMaster,
   fetchAllMaybeAirdrop: () => fetchAllMaybeAirdrop,
   fetchAllMaybeBitmapAccount: () => fetchAllMaybeBitmapAccount,
   fetchAllMaybeController: () => fetchAllMaybeController,
+  fetchAllMaybeMaster: () => fetchAllMaybeMaster,
+  fetchAllMaybeStats: () => fetchAllMaybeStats,
+  fetchAllStats: () => fetchAllStats,
   fetchBitmapAccount: () => fetchBitmapAccount,
   fetchController: () => fetchController,
+  fetchMaster: () => fetchMaster,
   fetchMaybeAirdrop: () => fetchMaybeAirdrop,
   fetchMaybeBitmapAccount: () => fetchMaybeBitmapAccount,
   fetchMaybeController: () => fetchMaybeController,
+  fetchMaybeMaster: () => fetchMaybeMaster,
+  fetchMaybeStats: () => fetchMaybeStats,
+  fetchStats: () => fetchStats,
+  generateKeyPairSignerWithSol: () => generateKeyPairSignerWithSol,
   getAirdropClosedCodec: () => getAirdropClosedCodec,
   getAirdropClosedDecoder: () => getAirdropClosedDecoder,
   getAirdropClosedEncoder: () => getAirdropClosedEncoder,
   getAirdropCodec: () => getAirdropCodec,
   getAirdropDecoder: () => getAirdropDecoder,
+  getAirdropDerivedAddress: () => getAirdropDerivedAddress,
   getAirdropDiscriminatorBytes: () => getAirdropDiscriminatorBytes,
   getAirdropEncoder: () => getAirdropEncoder,
   getAirdropInitializedCodec: () => getAirdropInitializedCodec,
@@ -156,6 +137,7 @@ __export(index_exports, {
   getBitmapInitializedCodec: () => getBitmapInitializedCodec,
   getBitmapInitializedDecoder: () => getBitmapInitializedDecoder,
   getBitmapInitializedEncoder: () => getBitmapInitializedEncoder,
+  getClaimMapAddress: () => getClaimMapAddress,
   getClaimTokensDiscriminatorBytes: () => getClaimTokensDiscriminatorBytes,
   getClaimTokensInstruction: () => getClaimTokensInstruction,
   getClaimTokensInstructionDataCodec: () => getClaimTokensInstructionDataCodec,
@@ -163,27 +145,35 @@ __export(index_exports, {
   getClaimTokensInstructionDataEncoder: () => getClaimTokensInstructionDataEncoder,
   getCloseAirdropDiscriminatorBytes: () => getCloseAirdropDiscriminatorBytes,
   getCloseAirdropInstruction: () => getCloseAirdropInstruction,
+  getCloseAirdropInstructionAsync: () => getCloseAirdropInstructionAsync,
   getCloseAirdropInstructionDataCodec: () => getCloseAirdropInstructionDataCodec,
   getCloseAirdropInstructionDataDecoder: () => getCloseAirdropInstructionDataDecoder,
   getCloseAirdropInstructionDataEncoder: () => getCloseAirdropInstructionDataEncoder,
   getCloseBitmapDiscriminatorBytes: () => getCloseBitmapDiscriminatorBytes,
   getCloseBitmapInstruction: () => getCloseBitmapInstruction,
+  getCloseBitmapInstructionAsync: () => getCloseBitmapInstructionAsync,
   getCloseBitmapInstructionDataCodec: () => getCloseBitmapInstructionDataCodec,
   getCloseBitmapInstructionDataDecoder: () => getCloseBitmapInstructionDataDecoder,
   getCloseBitmapInstructionDataEncoder: () => getCloseBitmapInstructionDataEncoder,
   getControllerCodec: () => getControllerCodec,
   getControllerDecoder: () => getControllerDecoder,
+  getControllerDerivedAddress: () => getControllerDerivedAddress,
   getControllerDiscriminatorBytes: () => getControllerDiscriminatorBytes,
   getControllerEncoder: () => getControllerEncoder,
   getControllerInitializedCodec: () => getControllerInitializedCodec,
   getControllerInitializedDecoder: () => getControllerInitializedDecoder,
   getControllerInitializedEncoder: () => getControllerInitializedEncoder,
+  getControllerVaultAddress: () => getControllerVaultAddress,
   getDepositTokensDiscriminatorBytes: () => getDepositTokensDiscriminatorBytes,
   getDepositTokensInstruction: () => getDepositTokensInstruction,
   getDepositTokensInstructionDataCodec: () => getDepositTokensInstructionDataCodec,
   getDepositTokensInstructionDataDecoder: () => getDepositTokensInstructionDataDecoder,
   getDepositTokensInstructionDataEncoder: () => getDepositTokensInstructionDataEncoder,
+  getDropsyDerivedAddress: () => getDropsyDerivedAddress,
   getDropsyErrorMessage: () => getDropsyErrorMessage,
+  getFeesCollectedCodec: () => getFeesCollectedCodec,
+  getFeesCollectedDecoder: () => getFeesCollectedDecoder,
+  getFeesCollectedEncoder: () => getFeesCollectedEncoder,
   getInitializeAirdropDiscriminatorBytes: () => getInitializeAirdropDiscriminatorBytes,
   getInitializeAirdropInstruction: () => getInitializeAirdropInstruction,
   getInitializeAirdropInstructionAsync: () => getInitializeAirdropInstructionAsync,
@@ -202,9 +192,34 @@ __export(index_exports, {
   getInitializeControllerInstructionDataCodec: () => getInitializeControllerInstructionDataCodec,
   getInitializeControllerInstructionDataDecoder: () => getInitializeControllerInstructionDataDecoder,
   getInitializeControllerInstructionDataEncoder: () => getInitializeControllerInstructionDataEncoder,
+  getInitializeMasterDiscriminatorBytes: () => getInitializeMasterDiscriminatorBytes,
+  getInitializeMasterInstruction: () => getInitializeMasterInstruction,
+  getInitializeMasterInstructionAsync: () => getInitializeMasterInstructionAsync,
+  getInitializeMasterInstructionDataCodec: () => getInitializeMasterInstructionDataCodec,
+  getInitializeMasterInstructionDataDecoder: () => getInitializeMasterInstructionDataDecoder,
+  getInitializeMasterInstructionDataEncoder: () => getInitializeMasterInstructionDataEncoder,
+  getMasterCodec: () => getMasterCodec,
+  getMasterDecoder: () => getMasterDecoder,
+  getMasterDerivedAddress: () => getMasterDerivedAddress,
+  getMasterDiscriminatorBytes: () => getMasterDiscriminatorBytes,
+  getMasterEncoder: () => getMasterEncoder,
+  getMasterInitializedCodec: () => getMasterInitializedCodec,
+  getMasterInitializedDecoder: () => getMasterInitializedDecoder,
+  getMasterInitializedEncoder: () => getMasterInitializedEncoder,
+  getStatsCodec: () => getStatsCodec,
+  getStatsDecoder: () => getStatsDecoder,
+  getStatsDerivedAddress: () => getStatsDerivedAddress,
+  getStatsDiscriminatorBytes: () => getStatsDiscriminatorBytes,
+  getStatsEncoder: () => getStatsEncoder,
   getTokensDepositedCodec: () => getTokensDepositedCodec,
   getTokensDepositedDecoder: () => getTokensDepositedDecoder,
   getTokensDepositedEncoder: () => getTokensDepositedEncoder,
+  getWithdrawControllerFeesDiscriminatorBytes: () => getWithdrawControllerFeesDiscriminatorBytes,
+  getWithdrawControllerFeesInstruction: () => getWithdrawControllerFeesInstruction,
+  getWithdrawControllerFeesInstructionAsync: () => getWithdrawControllerFeesInstructionAsync,
+  getWithdrawControllerFeesInstructionDataCodec: () => getWithdrawControllerFeesInstructionDataCodec,
+  getWithdrawControllerFeesInstructionDataDecoder: () => getWithdrawControllerFeesInstructionDataDecoder,
+  getWithdrawControllerFeesInstructionDataEncoder: () => getWithdrawControllerFeesInstructionDataEncoder,
   identifyDropsyAccount: () => identifyDropsyAccount,
   identifyDropsyInstruction: () => identifyDropsyInstruction,
   isDropsyError: () => isDropsyError,
@@ -214,7 +229,9 @@ __export(index_exports, {
   parseDepositTokensInstruction: () => parseDepositTokensInstruction,
   parseInitializeAirdropInstruction: () => parseInitializeAirdropInstruction,
   parseInitializeBitmapInstruction: () => parseInitializeBitmapInstruction,
-  parseInitializeControllerInstruction: () => parseInitializeControllerInstruction
+  parseInitializeControllerInstruction: () => parseInitializeControllerInstruction,
+  parseInitializeMasterInstruction: () => parseInitializeMasterInstruction,
+  parseWithdrawControllerFeesInstruction: () => parseWithdrawControllerFeesInstruction
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -237,9 +254,8 @@ function getAirdropEncoder() {
   return (0, import_kit.transformEncoder)(
     (0, import_kit.getStructEncoder)([
       ["discriminator", (0, import_kit.fixEncoderSize)((0, import_kit.getBytesEncoder)(), 8)],
-      ["id", (0, import_kit.getU64Encoder)()],
+      ["authority", (0, import_kit.getAddressEncoder)()],
       ["mint", (0, import_kit.getAddressEncoder)()],
-      ["owner", (0, import_kit.getAddressEncoder)()],
       ["controller", (0, import_kit.getAddressEncoder)()],
       ["supply", (0, import_kit.getU64Encoder)()],
       ["merkleRoot", (0, import_kit.getArrayEncoder)((0, import_kit.getU8Encoder)(), { size: 32 })],
@@ -249,15 +265,14 @@ function getAirdropEncoder() {
       ["version", (0, import_kit.getU8Encoder)()],
       ["bump", (0, import_kit.getU8Encoder)()]
     ]),
-    (value) => __spreadProps(__spreadValues({}, value), { discriminator: AIRDROP_DISCRIMINATOR })
+    (value) => ({ ...value, discriminator: AIRDROP_DISCRIMINATOR })
   );
 }
 function getAirdropDecoder() {
   return (0, import_kit.getStructDecoder)([
     ["discriminator", (0, import_kit.fixDecoderSize)((0, import_kit.getBytesDecoder)(), 8)],
-    ["id", (0, import_kit.getU64Decoder)()],
+    ["authority", (0, import_kit.getAddressDecoder)()],
     ["mint", (0, import_kit.getAddressDecoder)()],
-    ["owner", (0, import_kit.getAddressDecoder)()],
     ["controller", (0, import_kit.getAddressDecoder)()],
     ["supply", (0, import_kit.getU64Decoder)()],
     ["merkleRoot", (0, import_kit.getArrayDecoder)((0, import_kit.getU8Decoder)(), { size: 32 })],
@@ -277,31 +292,23 @@ function decodeAirdrop(encodedAccount) {
     getAirdropDecoder()
   );
 }
-function fetchAirdrop(rpc, address, config) {
-  return __async(this, null, function* () {
-    const maybeAccount = yield fetchMaybeAirdrop(rpc, address, config);
-    (0, import_kit.assertAccountExists)(maybeAccount);
-    return maybeAccount;
-  });
+async function fetchAirdrop(rpc, address, config) {
+  const maybeAccount = await fetchMaybeAirdrop(rpc, address, config);
+  (0, import_kit.assertAccountExists)(maybeAccount);
+  return maybeAccount;
 }
-function fetchMaybeAirdrop(rpc, address, config) {
-  return __async(this, null, function* () {
-    const maybeAccount = yield (0, import_kit.fetchEncodedAccount)(rpc, address, config);
-    return decodeAirdrop(maybeAccount);
-  });
+async function fetchMaybeAirdrop(rpc, address, config) {
+  const maybeAccount = await (0, import_kit.fetchEncodedAccount)(rpc, address, config);
+  return decodeAirdrop(maybeAccount);
 }
-function fetchAllAirdrop(rpc, addresses, config) {
-  return __async(this, null, function* () {
-    const maybeAccounts = yield fetchAllMaybeAirdrop(rpc, addresses, config);
-    (0, import_kit.assertAccountsExist)(maybeAccounts);
-    return maybeAccounts;
-  });
+async function fetchAllAirdrop(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeAirdrop(rpc, addresses, config);
+  (0, import_kit.assertAccountsExist)(maybeAccounts);
+  return maybeAccounts;
 }
-function fetchAllMaybeAirdrop(rpc, addresses, config) {
-  return __async(this, null, function* () {
-    const maybeAccounts = yield (0, import_kit.fetchEncodedAccounts)(rpc, addresses, config);
-    return maybeAccounts.map((maybeAccount) => decodeAirdrop(maybeAccount));
-  });
+async function fetchAllMaybeAirdrop(rpc, addresses, config) {
+  const maybeAccounts = await (0, import_kit.fetchEncodedAccounts)(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeAirdrop(maybeAccount));
 }
 
 // src/accounts/bitmapAccount.ts
@@ -325,7 +332,7 @@ function getBitmapAccountEncoder() {
   return (0, import_kit2.transformEncoder)(
     (0, import_kit2.getStructEncoder)([
       ["discriminator", (0, import_kit2.fixEncoderSize)((0, import_kit2.getBytesEncoder)(), 8)],
-      ["owner", (0, import_kit2.getAddressEncoder)()],
+      ["authority", (0, import_kit2.getAddressEncoder)()],
       ["airdrop", (0, import_kit2.getAddressEncoder)()],
       [
         "claimedBitmap",
@@ -335,13 +342,13 @@ function getBitmapAccountEncoder() {
       ["version", (0, import_kit2.getU8Encoder)()],
       ["bump", (0, import_kit2.getU8Encoder)()]
     ]),
-    (value) => __spreadProps(__spreadValues({}, value), { discriminator: BITMAP_ACCOUNT_DISCRIMINATOR })
+    (value) => ({ ...value, discriminator: BITMAP_ACCOUNT_DISCRIMINATOR })
   );
 }
 function getBitmapAccountDecoder() {
   return (0, import_kit2.getStructDecoder)([
     ["discriminator", (0, import_kit2.fixDecoderSize)((0, import_kit2.getBytesDecoder)(), 8)],
-    ["owner", (0, import_kit2.getAddressDecoder)()],
+    ["authority", (0, import_kit2.getAddressDecoder)()],
     ["airdrop", (0, import_kit2.getAddressDecoder)()],
     ["claimedBitmap", (0, import_kit2.addDecoderSizePrefix)((0, import_kit2.getBytesDecoder)(), (0, import_kit2.getU32Decoder)())],
     ["id", (0, import_kit2.getU8Decoder)()],
@@ -358,35 +365,27 @@ function decodeBitmapAccount(encodedAccount) {
     getBitmapAccountDecoder()
   );
 }
-function fetchBitmapAccount(rpc, address, config) {
-  return __async(this, null, function* () {
-    const maybeAccount = yield fetchMaybeBitmapAccount(rpc, address, config);
-    (0, import_kit2.assertAccountExists)(maybeAccount);
-    return maybeAccount;
-  });
+async function fetchBitmapAccount(rpc, address, config) {
+  const maybeAccount = await fetchMaybeBitmapAccount(rpc, address, config);
+  (0, import_kit2.assertAccountExists)(maybeAccount);
+  return maybeAccount;
 }
-function fetchMaybeBitmapAccount(rpc, address, config) {
-  return __async(this, null, function* () {
-    const maybeAccount = yield (0, import_kit2.fetchEncodedAccount)(rpc, address, config);
-    return decodeBitmapAccount(maybeAccount);
-  });
+async function fetchMaybeBitmapAccount(rpc, address, config) {
+  const maybeAccount = await (0, import_kit2.fetchEncodedAccount)(rpc, address, config);
+  return decodeBitmapAccount(maybeAccount);
 }
-function fetchAllBitmapAccount(rpc, addresses, config) {
-  return __async(this, null, function* () {
-    const maybeAccounts = yield fetchAllMaybeBitmapAccount(
-      rpc,
-      addresses,
-      config
-    );
-    (0, import_kit2.assertAccountsExist)(maybeAccounts);
-    return maybeAccounts;
-  });
+async function fetchAllBitmapAccount(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeBitmapAccount(
+    rpc,
+    addresses,
+    config
+  );
+  (0, import_kit2.assertAccountsExist)(maybeAccounts);
+  return maybeAccounts;
 }
-function fetchAllMaybeBitmapAccount(rpc, addresses, config) {
-  return __async(this, null, function* () {
-    const maybeAccounts = yield (0, import_kit2.fetchEncodedAccounts)(rpc, addresses, config);
-    return maybeAccounts.map((maybeAccount) => decodeBitmapAccount(maybeAccount));
-  });
+async function fetchAllMaybeBitmapAccount(rpc, addresses, config) {
+  const maybeAccounts = await (0, import_kit2.fetchEncodedAccounts)(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeBitmapAccount(maybeAccount));
 }
 
 // src/accounts/controller.ts
@@ -410,12 +409,12 @@ function getControllerEncoder() {
       ["discriminator", (0, import_kit3.fixEncoderSize)((0, import_kit3.getBytesEncoder)(), 8)],
       ["authority", (0, import_kit3.getAddressEncoder)()],
       ["feeVault", (0, import_kit3.getAddressEncoder)()],
-      ["createFee", (0, import_kit3.getU64Encoder)()],
-      ["claimFee", (0, import_kit3.getU64Encoder)()],
+      ["feeLamports", (0, import_kit3.getU64Encoder)()],
       ["version", (0, import_kit3.getU8Encoder)()],
-      ["bump", (0, import_kit3.getU8Encoder)()]
+      ["bump", (0, import_kit3.getU8Encoder)()],
+      ["feeVaultBump", (0, import_kit3.getU8Encoder)()]
     ]),
-    (value) => __spreadProps(__spreadValues({}, value), { discriminator: CONTROLLER_DISCRIMINATOR })
+    (value) => ({ ...value, discriminator: CONTROLLER_DISCRIMINATOR })
   );
 }
 function getControllerDecoder() {
@@ -423,10 +422,10 @@ function getControllerDecoder() {
     ["discriminator", (0, import_kit3.fixDecoderSize)((0, import_kit3.getBytesDecoder)(), 8)],
     ["authority", (0, import_kit3.getAddressDecoder)()],
     ["feeVault", (0, import_kit3.getAddressDecoder)()],
-    ["createFee", (0, import_kit3.getU64Decoder)()],
-    ["claimFee", (0, import_kit3.getU64Decoder)()],
+    ["feeLamports", (0, import_kit3.getU64Decoder)()],
     ["version", (0, import_kit3.getU8Decoder)()],
-    ["bump", (0, import_kit3.getU8Decoder)()]
+    ["bump", (0, import_kit3.getU8Decoder)()],
+    ["feeVaultBump", (0, import_kit3.getU8Decoder)()]
   ]);
 }
 function getControllerCodec() {
@@ -438,74 +437,224 @@ function decodeController(encodedAccount) {
     getControllerDecoder()
   );
 }
-function fetchController(rpc, address, config) {
-  return __async(this, null, function* () {
-    const maybeAccount = yield fetchMaybeController(rpc, address, config);
-    (0, import_kit3.assertAccountExists)(maybeAccount);
-    return maybeAccount;
-  });
+async function fetchController(rpc, address, config) {
+  const maybeAccount = await fetchMaybeController(rpc, address, config);
+  (0, import_kit3.assertAccountExists)(maybeAccount);
+  return maybeAccount;
 }
-function fetchMaybeController(rpc, address, config) {
-  return __async(this, null, function* () {
-    const maybeAccount = yield (0, import_kit3.fetchEncodedAccount)(rpc, address, config);
-    return decodeController(maybeAccount);
-  });
+async function fetchMaybeController(rpc, address, config) {
+  const maybeAccount = await (0, import_kit3.fetchEncodedAccount)(rpc, address, config);
+  return decodeController(maybeAccount);
 }
-function fetchAllController(rpc, addresses, config) {
-  return __async(this, null, function* () {
-    const maybeAccounts = yield fetchAllMaybeController(rpc, addresses, config);
-    (0, import_kit3.assertAccountsExist)(maybeAccounts);
-    return maybeAccounts;
-  });
+async function fetchAllController(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeController(rpc, addresses, config);
+  (0, import_kit3.assertAccountsExist)(maybeAccounts);
+  return maybeAccounts;
 }
-function fetchAllMaybeController(rpc, addresses, config) {
-  return __async(this, null, function* () {
-    const maybeAccounts = yield (0, import_kit3.fetchEncodedAccounts)(rpc, addresses, config);
-    return maybeAccounts.map((maybeAccount) => decodeController(maybeAccount));
-  });
+async function fetchAllMaybeController(rpc, addresses, config) {
+  const maybeAccounts = await (0, import_kit3.fetchEncodedAccounts)(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeController(maybeAccount));
 }
 
-// src/errors/dropsy.ts
+// src/accounts/master.ts
+var import_kit4 = require("@solana/kit");
+var MASTER_DISCRIMINATOR = new Uint8Array([
+  168,
+  213,
+  193,
+  12,
+  77,
+  162,
+  58,
+  235
+]);
+function getMasterDiscriminatorBytes() {
+  return (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8).encode(MASTER_DISCRIMINATOR);
+}
+function getMasterEncoder() {
+  return (0, import_kit4.transformEncoder)(
+    (0, import_kit4.getStructEncoder)([
+      ["discriminator", (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8)],
+      ["authority", (0, import_kit4.getAddressEncoder)()],
+      ["feeVault", (0, import_kit4.getAddressEncoder)()],
+      ["protocolFee", (0, import_kit4.getU64Encoder)()],
+      ["withdrawFee", (0, import_kit4.getU64Encoder)()],
+      ["initControllerFee", (0, import_kit4.getU64Encoder)()],
+      ["version", (0, import_kit4.getU8Encoder)()],
+      ["bump", (0, import_kit4.getU8Encoder)()]
+    ]),
+    (value) => ({ ...value, discriminator: MASTER_DISCRIMINATOR })
+  );
+}
+function getMasterDecoder() {
+  return (0, import_kit4.getStructDecoder)([
+    ["discriminator", (0, import_kit4.fixDecoderSize)((0, import_kit4.getBytesDecoder)(), 8)],
+    ["authority", (0, import_kit4.getAddressDecoder)()],
+    ["feeVault", (0, import_kit4.getAddressDecoder)()],
+    ["protocolFee", (0, import_kit4.getU64Decoder)()],
+    ["withdrawFee", (0, import_kit4.getU64Decoder)()],
+    ["initControllerFee", (0, import_kit4.getU64Decoder)()],
+    ["version", (0, import_kit4.getU8Decoder)()],
+    ["bump", (0, import_kit4.getU8Decoder)()]
+  ]);
+}
+function getMasterCodec() {
+  return (0, import_kit4.combineCodec)(getMasterEncoder(), getMasterDecoder());
+}
+function decodeMaster(encodedAccount) {
+  return (0, import_kit4.decodeAccount)(
+    encodedAccount,
+    getMasterDecoder()
+  );
+}
+async function fetchMaster(rpc, address, config) {
+  const maybeAccount = await fetchMaybeMaster(rpc, address, config);
+  (0, import_kit4.assertAccountExists)(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeMaster(rpc, address, config) {
+  const maybeAccount = await (0, import_kit4.fetchEncodedAccount)(rpc, address, config);
+  return decodeMaster(maybeAccount);
+}
+async function fetchAllMaster(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeMaster(rpc, addresses, config);
+  (0, import_kit4.assertAccountsExist)(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeMaster(rpc, addresses, config) {
+  const maybeAccounts = await (0, import_kit4.fetchEncodedAccounts)(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeMaster(maybeAccount));
+}
+
+// src/accounts/stats.ts
 var import_kit5 = require("@solana/kit");
+var STATS_DISCRIMINATOR = new Uint8Array([
+  190,
+  125,
+  51,
+  63,
+  169,
+  197,
+  36,
+  238
+]);
+function getStatsDiscriminatorBytes() {
+  return (0, import_kit5.fixEncoderSize)((0, import_kit5.getBytesEncoder)(), 8).encode(STATS_DISCRIMINATOR);
+}
+function getStatsEncoder() {
+  return (0, import_kit5.transformEncoder)(
+    (0, import_kit5.getStructEncoder)([
+      ["discriminator", (0, import_kit5.fixEncoderSize)((0, import_kit5.getBytesEncoder)(), 8)],
+      ["initializedControllers", (0, import_kit5.getU64Encoder)()],
+      ["initializedAirdrops", (0, import_kit5.getU64Encoder)()],
+      ["initializedClaimMaps", (0, import_kit5.getU64Encoder)()],
+      ["closedAirdrops", (0, import_kit5.getU64Encoder)()],
+      ["closedClaimMap", (0, import_kit5.getU64Encoder)()],
+      ["bump", (0, import_kit5.getU8Encoder)()]
+    ]),
+    (value) => ({ ...value, discriminator: STATS_DISCRIMINATOR })
+  );
+}
+function getStatsDecoder() {
+  return (0, import_kit5.getStructDecoder)([
+    ["discriminator", (0, import_kit5.fixDecoderSize)((0, import_kit5.getBytesDecoder)(), 8)],
+    ["initializedControllers", (0, import_kit5.getU64Decoder)()],
+    ["initializedAirdrops", (0, import_kit5.getU64Decoder)()],
+    ["initializedClaimMaps", (0, import_kit5.getU64Decoder)()],
+    ["closedAirdrops", (0, import_kit5.getU64Decoder)()],
+    ["closedClaimMap", (0, import_kit5.getU64Decoder)()],
+    ["bump", (0, import_kit5.getU8Decoder)()]
+  ]);
+}
+function getStatsCodec() {
+  return (0, import_kit5.combineCodec)(getStatsEncoder(), getStatsDecoder());
+}
+function decodeStats(encodedAccount) {
+  return (0, import_kit5.decodeAccount)(
+    encodedAccount,
+    getStatsDecoder()
+  );
+}
+async function fetchStats(rpc, address, config) {
+  const maybeAccount = await fetchMaybeStats(rpc, address, config);
+  (0, import_kit5.assertAccountExists)(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeStats(rpc, address, config) {
+  const maybeAccount = await (0, import_kit5.fetchEncodedAccount)(rpc, address, config);
+  return decodeStats(maybeAccount);
+}
+async function fetchAllStats(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeStats(rpc, addresses, config);
+  (0, import_kit5.assertAccountsExist)(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeStats(rpc, addresses, config) {
+  const maybeAccounts = await (0, import_kit5.fetchEncodedAccounts)(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeStats(maybeAccount));
+}
+
+// src/errors/dropsy.ts
+var import_kit7 = require("@solana/kit");
 
 // src/programs/dropsy.ts
-var import_kit4 = require("@solana/kit");
-var DROPSY_PROGRAM_ADDRESS = "DropyEMekkCgKmsWiJVcTCAEeFgvHpDAW19ipWebFaPv";
+var import_kit6 = require("@solana/kit");
+var DROPSY_PROGRAM_ADDRESS = "DropmEfonJRZyPaRQbPgn4nrt3cDi5678bLbzVQRvgLp";
 var DropsyAccount = /* @__PURE__ */ ((DropsyAccount2) => {
   DropsyAccount2[DropsyAccount2["Airdrop"] = 0] = "Airdrop";
   DropsyAccount2[DropsyAccount2["BitmapAccount"] = 1] = "BitmapAccount";
   DropsyAccount2[DropsyAccount2["Controller"] = 2] = "Controller";
+  DropsyAccount2[DropsyAccount2["Master"] = 3] = "Master";
+  DropsyAccount2[DropsyAccount2["Stats"] = 4] = "Stats";
   return DropsyAccount2;
 })(DropsyAccount || {});
 function identifyDropsyAccount(account) {
   const data = "data" in account ? account.data : account;
-  if ((0, import_kit4.containsBytes)(
+  if ((0, import_kit6.containsBytes)(
     data,
-    (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8).encode(
+    (0, import_kit6.fixEncoderSize)((0, import_kit6.getBytesEncoder)(), 8).encode(
       new Uint8Array([31, 112, 159, 158, 124, 237, 9, 241])
     ),
     0
   )) {
     return 0 /* Airdrop */;
   }
-  if ((0, import_kit4.containsBytes)(
+  if ((0, import_kit6.containsBytes)(
     data,
-    (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8).encode(
+    (0, import_kit6.fixEncoderSize)((0, import_kit6.getBytesEncoder)(), 8).encode(
       new Uint8Array([152, 161, 147, 85, 213, 38, 59, 48])
     ),
     0
   )) {
     return 1 /* BitmapAccount */;
   }
-  if ((0, import_kit4.containsBytes)(
+  if ((0, import_kit6.containsBytes)(
     data,
-    (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8).encode(
+    (0, import_kit6.fixEncoderSize)((0, import_kit6.getBytesEncoder)(), 8).encode(
       new Uint8Array([184, 79, 171, 0, 183, 43, 113, 110])
     ),
     0
   )) {
     return 2 /* Controller */;
   }
+  if ((0, import_kit6.containsBytes)(
+    data,
+    (0, import_kit6.fixEncoderSize)((0, import_kit6.getBytesEncoder)(), 8).encode(
+      new Uint8Array([168, 213, 193, 12, 77, 162, 58, 235])
+    ),
+    0
+  )) {
+    return 3 /* Master */;
+  }
+  if ((0, import_kit6.containsBytes)(
+    data,
+    (0, import_kit6.fixEncoderSize)((0, import_kit6.getBytesEncoder)(), 8).encode(
+      new Uint8Array([190, 125, 51, 63, 169, 197, 36, 238])
+    ),
+    0
+  )) {
+    return 4 /* Stats */;
+  }
   throw new Error(
     "The provided account could not be identified as a dropsy account."
   );
@@ -518,73 +667,93 @@ var DropsyInstruction = /* @__PURE__ */ ((DropsyInstruction2) => {
   DropsyInstruction2[DropsyInstruction2["InitializeAirdrop"] = 4] = "InitializeAirdrop";
   DropsyInstruction2[DropsyInstruction2["InitializeBitmap"] = 5] = "InitializeBitmap";
   DropsyInstruction2[DropsyInstruction2["InitializeController"] = 6] = "InitializeController";
+  DropsyInstruction2[DropsyInstruction2["InitializeMaster"] = 7] = "InitializeMaster";
+  DropsyInstruction2[DropsyInstruction2["WithdrawControllerFees"] = 8] = "WithdrawControllerFees";
   return DropsyInstruction2;
 })(DropsyInstruction || {});
 function identifyDropsyInstruction(instruction) {
   const data = "data" in instruction ? instruction.data : instruction;
-  if ((0, import_kit4.containsBytes)(
+  if ((0, import_kit6.containsBytes)(
     data,
-    (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8).encode(
+    (0, import_kit6.fixEncoderSize)((0, import_kit6.getBytesEncoder)(), 8).encode(
       new Uint8Array([108, 216, 210, 231, 0, 212, 42, 64])
     ),
     0
   )) {
     return 0 /* ClaimTokens */;
   }
-  if ((0, import_kit4.containsBytes)(
+  if ((0, import_kit6.containsBytes)(
     data,
-    (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8).encode(
+    (0, import_kit6.fixEncoderSize)((0, import_kit6.getBytesEncoder)(), 8).encode(
       new Uint8Array([85, 138, 99, 129, 104, 203, 94, 4])
     ),
     0
   )) {
     return 1 /* CloseAirdrop */;
   }
-  if ((0, import_kit4.containsBytes)(
+  if ((0, import_kit6.containsBytes)(
     data,
-    (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8).encode(
+    (0, import_kit6.fixEncoderSize)((0, import_kit6.getBytesEncoder)(), 8).encode(
       new Uint8Array([59, 123, 115, 204, 163, 227, 37, 118])
     ),
     0
   )) {
     return 2 /* CloseBitmap */;
   }
-  if ((0, import_kit4.containsBytes)(
+  if ((0, import_kit6.containsBytes)(
     data,
-    (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8).encode(
+    (0, import_kit6.fixEncoderSize)((0, import_kit6.getBytesEncoder)(), 8).encode(
       new Uint8Array([176, 83, 229, 18, 191, 143, 176, 150])
     ),
     0
   )) {
     return 3 /* DepositTokens */;
   }
-  if ((0, import_kit4.containsBytes)(
+  if ((0, import_kit6.containsBytes)(
     data,
-    (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8).encode(
+    (0, import_kit6.fixEncoderSize)((0, import_kit6.getBytesEncoder)(), 8).encode(
       new Uint8Array([96, 196, 74, 102, 61, 195, 48, 184])
     ),
     0
   )) {
     return 4 /* InitializeAirdrop */;
   }
-  if ((0, import_kit4.containsBytes)(
+  if ((0, import_kit6.containsBytes)(
     data,
-    (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8).encode(
+    (0, import_kit6.fixEncoderSize)((0, import_kit6.getBytesEncoder)(), 8).encode(
       new Uint8Array([25, 109, 200, 45, 209, 118, 74, 69])
     ),
     0
   )) {
     return 5 /* InitializeBitmap */;
   }
-  if ((0, import_kit4.containsBytes)(
+  if ((0, import_kit6.containsBytes)(
     data,
-    (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8).encode(
+    (0, import_kit6.fixEncoderSize)((0, import_kit6.getBytesEncoder)(), 8).encode(
       new Uint8Array([137, 255, 100, 190, 201, 247, 241, 81])
     ),
     0
   )) {
     return 6 /* InitializeController */;
   }
+  if ((0, import_kit6.containsBytes)(
+    data,
+    (0, import_kit6.fixEncoderSize)((0, import_kit6.getBytesEncoder)(), 8).encode(
+      new Uint8Array([206, 91, 246, 30, 216, 101, 134, 166])
+    ),
+    0
+  )) {
+    return 7 /* InitializeMaster */;
+  }
+  if ((0, import_kit6.containsBytes)(
+    data,
+    (0, import_kit6.fixEncoderSize)((0, import_kit6.getBytesEncoder)(), 8).encode(
+      new Uint8Array([252, 199, 14, 46, 100, 156, 176, 230])
+    ),
+    0
+  )) {
+    return 8 /* WithdrawControllerFees */;
+  }
   throw new Error(
     "The provided instruction could not be identified as a dropsy instruction."
   );
@@ -705,7 +874,7 @@ function getDropsyErrorMessage(code) {
   return "Error message not available in production bundles.";
 }
 function isDropsyError(error, transactionMessage, code) {
-  return (0, import_kit5.isProgramError)(
+  return (0, import_kit7.isProgramError)(
     error,
     transactionMessage,
     DROPSY_PROGRAM_ADDRESS,
@@ -714,10 +883,10 @@ function isDropsyError(error, transactionMessage, code) {
 }
 
 // src/instructions/claimTokens.ts
-var import_kit7 = require("@solana/kit");
+var import_kit9 = require("@solana/kit");
 
 // src/shared/index.ts
-var import_kit6 = require("@solana/kit");
+var import_kit8 = require("@solana/kit");
 function expectSome(value) {
   if (value == null) {
     throw new Error("Expected a value but received null or undefined.");
@@ -742,18 +911,19 @@ function getAccountMetaFactory(programAddress, optionalAccountStrategy) {
       if (optionalAccountStrategy === "omitted") return;
       return Object.freeze({
         address: programAddress,
-        role: import_kit6.AccountRole.READONLY
+        role: import_kit8.AccountRole.READONLY
       });
     }
-    const writableRole = account.isWritable ? import_kit6.AccountRole.WRITABLE : import_kit6.AccountRole.READONLY;
-    return Object.freeze(__spreadValues({
+    const writableRole = account.isWritable ? import_kit8.AccountRole.WRITABLE : import_kit8.AccountRole.READONLY;
+    return Object.freeze({
       address: expectAddress(account.value),
-      role: isTransactionSigner(account.value) ? (0, import_kit6.upgradeRoleToSigner)(writableRole) : writableRole
-    }, isTransactionSigner(account.value) ? { signer: account.value } : {}));
+      role: isTransactionSigner(account.value) ? (0, import_kit8.upgradeRoleToSigner)(writableRole) : writableRole,
+      ...isTransactionSigner(account.value) ? { signer: account.value } : {}
+    });
   };
 }
 function isTransactionSigner(value) {
-  return !!value && typeof value === "object" && "address" in value && (0, import_kit6.isTransactionSigner)(value);
+  return !!value && typeof value === "object" && "address" in value && (0, import_kit8.isTransactionSigner)(value);
 }
 
 // src/instructions/claimTokens.ts
@@ -768,56 +938,53 @@ var CLAIM_TOKENS_DISCRIMINATOR = new Uint8Array([
   64
 ]);
 function getClaimTokensDiscriminatorBytes() {
-  return (0, import_kit7.fixEncoderSize)((0, import_kit7.getBytesEncoder)(), 8).encode(
+  return (0, import_kit9.fixEncoderSize)((0, import_kit9.getBytesEncoder)(), 8).encode(
     CLAIM_TOKENS_DISCRIMINATOR
   );
 }
 function getClaimTokensInstructionDataEncoder() {
-  return (0, import_kit7.transformEncoder)(
-    (0, import_kit7.getStructEncoder)([
-      ["discriminator", (0, import_kit7.fixEncoderSize)((0, import_kit7.getBytesEncoder)(), 8)],
-      ["index", (0, import_kit7.getU64Encoder)()],
-      ["proof", (0, import_kit7.getArrayEncoder)((0, import_kit7.getArrayEncoder)((0, import_kit7.getU8Encoder)(), { size: 32 }))],
-      ["amount", (0, import_kit7.getU64Encoder)()]
+  return (0, import_kit9.transformEncoder)(
+    (0, import_kit9.getStructEncoder)([
+      ["discriminator", (0, import_kit9.fixEncoderSize)((0, import_kit9.getBytesEncoder)(), 8)],
+      ["index", (0, import_kit9.getU64Encoder)()],
+      ["proof", (0, import_kit9.getArrayEncoder)((0, import_kit9.getArrayEncoder)((0, import_kit9.getU8Encoder)(), { size: 32 }))],
+      ["amount", (0, import_kit9.getU64Encoder)()]
     ]),
-    (value) => __spreadProps(__spreadValues({}, value), { discriminator: CLAIM_TOKENS_DISCRIMINATOR })
+    (value) => ({ ...value, discriminator: CLAIM_TOKENS_DISCRIMINATOR })
   );
 }
 function getClaimTokensInstructionDataDecoder() {
-  return (0, import_kit7.getStructDecoder)([
-    ["discriminator", (0, import_kit7.fixDecoderSize)((0, import_kit7.getBytesDecoder)(), 8)],
-    ["index", (0, import_kit7.getU64Decoder)()],
-    ["proof", (0, import_kit7.getArrayDecoder)((0, import_kit7.getArrayDecoder)((0, import_kit7.getU8Decoder)(), { size: 32 }))],
-    ["amount", (0, import_kit7.getU64Decoder)()]
+  return (0, import_kit9.getStructDecoder)([
+    ["discriminator", (0, import_kit9.fixDecoderSize)((0, import_kit9.getBytesDecoder)(), 8)],
+    ["index", (0, import_kit9.getU64Decoder)()],
+    ["proof", (0, import_kit9.getArrayDecoder)((0, import_kit9.getArrayDecoder)((0, import_kit9.getU8Decoder)(), { size: 32 }))],
+    ["amount", (0, import_kit9.getU64Decoder)()]
   ]);
 }
 function getClaimTokensInstructionDataCodec() {
-  return (0, import_kit7.combineCodec)(
+  return (0, import_kit9.combineCodec)(
     getClaimTokensInstructionDataEncoder(),
     getClaimTokensInstructionDataDecoder()
   );
 }
 function getClaimTokensInstruction(input, config) {
-  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
-  const programAddress = (_a = config == null ? void 0 : config.programAddress) != null ? _a : DROPSY_PROGRAM_ADDRESS;
+  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
   const originalAccounts = {
-    vault: { value: (_b = input.vault) != null ? _b : null, isWritable: true },
+    vault: { value: input.vault ?? null, isWritable: true },
     destinationTokenAccount: {
-      value: (_c = input.destinationTokenAccount) != null ? _c : null,
+      value: input.destinationTokenAccount ?? null,
       isWritable: true
     },
-    airdrop: { value: (_d = input.airdrop) != null ? _d : null, isWritable: false },
-    bitmap: { value: (_e = input.bitmap) != null ? _e : null, isWritable: true },
-    mint: { value: (_f = input.mint) != null ? _f : null, isWritable: false },
-    feeVault: { value: (_g = input.feeVault) != null ? _g : null, isWritable: true },
-    controller: { value: (_h = input.controller) != null ? _h : null, isWritable: false },
-    claimer: { value: (_i = input.claimer) != null ? _i : null, isWritable: true },
-    treasury: { value: (_j = input.treasury) != null ? _j : null, isWritable: true },
-    tokenProgram: { value: (_k = input.tokenProgram) != null ? _k : null, isWritable: false },
-    systemProgram: { value: (_l = input.systemProgram) != null ? _l : null, isWritable: false }
+    airdrop: { value: input.airdrop ?? null, isWritable: false },
+    bitmap: { value: input.bitmap ?? null, isWritable: true },
+    mint: { value: input.mint ?? null, isWritable: false },
+    claimer: { value: input.claimer ?? null, isWritable: true },
+    treasury: { value: input.treasury ?? null, isWritable: true },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
   };
   const accounts = originalAccounts;
-  const args = __spreadValues({}, input);
+  const args = { ...input };
   if (!accounts.treasury.value) {
     accounts.treasury.value = "DHffy4rNMtuL8VKgyBEay4jcq8AYHyoAzxLKU6aEijUV";
   }
@@ -835,8 +1002,6 @@ function getClaimTokensInstruction(input, config) {
       getAccountMeta(accounts.airdrop),
       getAccountMeta(accounts.bitmap),
       getAccountMeta(accounts.mint),
-      getAccountMeta(accounts.feeVault),
-      getAccountMeta(accounts.controller),
       getAccountMeta(accounts.claimer),
       getAccountMeta(accounts.treasury),
       getAccountMeta(accounts.tokenProgram),
@@ -850,7 +1015,7 @@ function getClaimTokensInstruction(input, config) {
   return instruction;
 }
 function parseClaimTokensInstruction(instruction) {
-  if (instruction.accounts.length < 11) {
+  if (instruction.accounts.length < 9) {
     throw new Error("Not enough accounts");
   }
   let accountIndex = 0;
@@ -867,8 +1032,6 @@ function parseClaimTokensInstruction(instruction) {
       airdrop: getNextAccount(),
       bitmap: getNextAccount(),
       mint: getNextAccount(),
-      feeVault: getNextAccount(),
-      controller: getNextAccount(),
       claimer: getNextAccount(),
       treasury: getNextAccount(),
       tokenProgram: getNextAccount(),
@@ -879,7 +1042,7 @@ function parseClaimTokensInstruction(instruction) {
 }
 
 // src/instructions/closeAirdrop.ts
-var import_kit8 = require("@solana/kit");
+var import_kit10 = require("@solana/kit");
 var CLOSE_AIRDROP_DISCRIMINATOR = new Uint8Array([
   85,
   138,
@@ -891,54 +1054,124 @@ var CLOSE_AIRDROP_DISCRIMINATOR = new Uint8Array([
   4
 ]);
 function getCloseAirdropDiscriminatorBytes() {
-  return (0, import_kit8.fixEncoderSize)((0, import_kit8.getBytesEncoder)(), 8).encode(
+  return (0, import_kit10.fixEncoderSize)((0, import_kit10.getBytesEncoder)(), 8).encode(
     CLOSE_AIRDROP_DISCRIMINATOR
   );
 }
 function getCloseAirdropInstructionDataEncoder() {
-  return (0, import_kit8.transformEncoder)(
-    (0, import_kit8.getStructEncoder)([["discriminator", (0, import_kit8.fixEncoderSize)((0, import_kit8.getBytesEncoder)(), 8)]]),
-    (value) => __spreadProps(__spreadValues({}, value), { discriminator: CLOSE_AIRDROP_DISCRIMINATOR })
+  return (0, import_kit10.transformEncoder)(
+    (0, import_kit10.getStructEncoder)([["discriminator", (0, import_kit10.fixEncoderSize)((0, import_kit10.getBytesEncoder)(), 8)]]),
+    (value) => ({ ...value, discriminator: CLOSE_AIRDROP_DISCRIMINATOR })
   );
 }
 function getCloseAirdropInstructionDataDecoder() {
-  return (0, import_kit8.getStructDecoder)([
-    ["discriminator", (0, import_kit8.fixDecoderSize)((0, import_kit8.getBytesDecoder)(), 8)]
+  return (0, import_kit10.getStructDecoder)([
+    ["discriminator", (0, import_kit10.fixDecoderSize)((0, import_kit10.getBytesDecoder)(), 8)]
   ]);
 }
 function getCloseAirdropInstructionDataCodec() {
-  return (0, import_kit8.combineCodec)(
+  return (0, import_kit10.combineCodec)(
     getCloseAirdropInstructionDataEncoder(),
     getCloseAirdropInstructionDataDecoder()
   );
 }
+async function getCloseAirdropInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    stats: { value: input.stats ?? null, isWritable: true },
+    controller: { value: input.controller ?? null, isWritable: true },
+    feeVault: { value: input.feeVault ?? null, isWritable: true },
+    airdrop: { value: input.airdrop ?? null, isWritable: true },
+    vault: { value: input.vault ?? null, isWritable: true },
+    destinationTokenAccount: {
+      value: input.destinationTokenAccount ?? null,
+      isWritable: true
+    },
+    authority: { value: input.authority ?? null, isWritable: true },
+    mint: { value: input.mint ?? null, isWritable: false },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  if (!accounts.stats.value) {
+    accounts.stats.value = await (0, import_kit10.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit10.getBytesEncoder)().encode(new Uint8Array([115, 116, 97, 116, 115]))
+      ]
+    });
+  }
+  if (!accounts.feeVault.value) {
+    accounts.feeVault.value = await (0, import_kit10.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit10.getBytesEncoder)().encode(new Uint8Array([118, 97, 117, 108, 116])),
+        (0, import_kit10.getAddressEncoder)().encode(expectAddress(accounts.controller.value))
+      ]
+    });
+  }
+  if (!accounts.tokenProgram.value) {
+    accounts.tokenProgram.value = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  const instruction = {
+    accounts: [
+      getAccountMeta(accounts.stats),
+      getAccountMeta(accounts.controller),
+      getAccountMeta(accounts.feeVault),
+      getAccountMeta(accounts.airdrop),
+      getAccountMeta(accounts.vault),
+      getAccountMeta(accounts.destinationTokenAccount),
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.mint),
+      getAccountMeta(accounts.tokenProgram),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    programAddress,
+    data: getCloseAirdropInstructionDataEncoder().encode({})
+  };
+  return instruction;
+}
 function getCloseAirdropInstruction(input, config) {
-  var _a, _b, _c, _d, _e, _f, _g;
-  const programAddress = (_a = config == null ? void 0 : config.programAddress) != null ? _a : DROPSY_PROGRAM_ADDRESS;
+  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
   const originalAccounts = {
-    airdrop: { value: (_b = input.airdrop) != null ? _b : null, isWritable: true },
-    vault: { value: (_c = input.vault) != null ? _c : null, isWritable: true },
+    stats: { value: input.stats ?? null, isWritable: true },
+    controller: { value: input.controller ?? null, isWritable: true },
+    feeVault: { value: input.feeVault ?? null, isWritable: true },
+    airdrop: { value: input.airdrop ?? null, isWritable: true },
+    vault: { value: input.vault ?? null, isWritable: true },
     destinationTokenAccount: {
-      value: (_d = input.destinationTokenAccount) != null ? _d : null,
+      value: input.destinationTokenAccount ?? null,
       isWritable: true
     },
-    owner: { value: (_e = input.owner) != null ? _e : null, isWritable: true },
-    mint: { value: (_f = input.mint) != null ? _f : null, isWritable: false },
-    tokenProgram: { value: (_g = input.tokenProgram) != null ? _g : null, isWritable: false }
+    authority: { value: input.authority ?? null, isWritable: true },
+    mint: { value: input.mint ?? null, isWritable: false },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
   };
   const accounts = originalAccounts;
   if (!accounts.tokenProgram.value) {
     accounts.tokenProgram.value = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
   }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
   const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
   const instruction = {
     accounts: [
+      getAccountMeta(accounts.stats),
+      getAccountMeta(accounts.controller),
+      getAccountMeta(accounts.feeVault),
       getAccountMeta(accounts.airdrop),
       getAccountMeta(accounts.vault),
       getAccountMeta(accounts.destinationTokenAccount),
-      getAccountMeta(accounts.owner),
+      getAccountMeta(accounts.authority),
       getAccountMeta(accounts.mint),
-      getAccountMeta(accounts.tokenProgram)
+      getAccountMeta(accounts.tokenProgram),
+      getAccountMeta(accounts.systemProgram)
     ],
     programAddress,
     data: getCloseAirdropInstructionDataEncoder().encode({})
@@ -946,7 +1179,7 @@ function getCloseAirdropInstruction(input, config) {
   return instruction;
 }
 function parseCloseAirdropInstruction(instruction) {
-  if (instruction.accounts.length < 6) {
+  if (instruction.accounts.length < 10) {
     throw new Error("Not enough accounts");
   }
   let accountIndex = 0;
@@ -958,19 +1191,23 @@ function parseCloseAirdropInstruction(instruction) {
   return {
     programAddress: instruction.programAddress,
     accounts: {
+      stats: getNextAccount(),
+      controller: getNextAccount(),
+      feeVault: getNextAccount(),
       airdrop: getNextAccount(),
       vault: getNextAccount(),
       destinationTokenAccount: getNextAccount(),
-      owner: getNextAccount(),
+      authority: getNextAccount(),
       mint: getNextAccount(),
-      tokenProgram: getNextAccount()
+      tokenProgram: getNextAccount(),
+      systemProgram: getNextAccount()
     },
     data: getCloseAirdropInstructionDataDecoder().decode(instruction.data)
   };
 }
 
 // src/instructions/closeBitmap.ts
-var import_kit9 = require("@solana/kit");
+var import_kit11 = require("@solana/kit");
 var CLOSE_BITMAP_DISCRIMINATOR = new Uint8Array([
   59,
   123,
@@ -982,42 +1219,107 @@ var CLOSE_BITMAP_DISCRIMINATOR = new Uint8Array([
   118
 ]);
 function getCloseBitmapDiscriminatorBytes() {
-  return (0, import_kit9.fixEncoderSize)((0, import_kit9.getBytesEncoder)(), 8).encode(
+  return (0, import_kit11.fixEncoderSize)((0, import_kit11.getBytesEncoder)(), 8).encode(
     CLOSE_BITMAP_DISCRIMINATOR
   );
 }
 function getCloseBitmapInstructionDataEncoder() {
-  return (0, import_kit9.transformEncoder)(
-    (0, import_kit9.getStructEncoder)([["discriminator", (0, import_kit9.fixEncoderSize)((0, import_kit9.getBytesEncoder)(), 8)]]),
-    (value) => __spreadProps(__spreadValues({}, value), { discriminator: CLOSE_BITMAP_DISCRIMINATOR })
+  return (0, import_kit11.transformEncoder)(
+    (0, import_kit11.getStructEncoder)([["discriminator", (0, import_kit11.fixEncoderSize)((0, import_kit11.getBytesEncoder)(), 8)]]),
+    (value) => ({ ...value, discriminator: CLOSE_BITMAP_DISCRIMINATOR })
   );
 }
 function getCloseBitmapInstructionDataDecoder() {
-  return (0, import_kit9.getStructDecoder)([
-    ["discriminator", (0, import_kit9.fixDecoderSize)((0, import_kit9.getBytesDecoder)(), 8)]
+  return (0, import_kit11.getStructDecoder)([
+    ["discriminator", (0, import_kit11.fixDecoderSize)((0, import_kit11.getBytesDecoder)(), 8)]
   ]);
 }
 function getCloseBitmapInstructionDataCodec() {
-  return (0, import_kit9.combineCodec)(
+  return (0, import_kit11.combineCodec)(
     getCloseBitmapInstructionDataEncoder(),
     getCloseBitmapInstructionDataDecoder()
   );
 }
+async function getCloseBitmapInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    master: { value: input.master ?? null, isWritable: false },
+    stats: { value: input.stats ?? null, isWritable: true },
+    airdrop: { value: input.airdrop ?? null, isWritable: true },
+    bitmap: { value: input.bitmap ?? null, isWritable: true },
+    treasury: { value: input.treasury ?? null, isWritable: true },
+    authority: { value: input.authority ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  if (!accounts.master.value) {
+    accounts.master.value = await (0, import_kit11.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit11.getBytesEncoder)().encode(
+          new Uint8Array([109, 97, 115, 116, 101, 114, 51])
+        )
+      ]
+    });
+  }
+  if (!accounts.stats.value) {
+    accounts.stats.value = await (0, import_kit11.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit11.getBytesEncoder)().encode(new Uint8Array([115, 116, 97, 116, 115]))
+      ]
+    });
+  }
+  if (!accounts.treasury.value) {
+    accounts.treasury.value = "DHffy4rNMtuL8VKgyBEay4jcq8AYHyoAzxLKU6aEijUV";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  const instruction = {
+    accounts: [
+      getAccountMeta(accounts.master),
+      getAccountMeta(accounts.stats),
+      getAccountMeta(accounts.airdrop),
+      getAccountMeta(accounts.bitmap),
+      getAccountMeta(accounts.treasury),
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    programAddress,
+    data: getCloseBitmapInstructionDataEncoder().encode({})
+  };
+  return instruction;
+}
 function getCloseBitmapInstruction(input, config) {
-  var _a, _b, _c, _d;
-  const programAddress = (_a = config == null ? void 0 : config.programAddress) != null ? _a : DROPSY_PROGRAM_ADDRESS;
+  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
   const originalAccounts = {
-    airdrop: { value: (_b = input.airdrop) != null ? _b : null, isWritable: true },
-    bitmap: { value: (_c = input.bitmap) != null ? _c : null, isWritable: true },
-    owner: { value: (_d = input.owner) != null ? _d : null, isWritable: true }
+    master: { value: input.master ?? null, isWritable: false },
+    stats: { value: input.stats ?? null, isWritable: true },
+    airdrop: { value: input.airdrop ?? null, isWritable: true },
+    bitmap: { value: input.bitmap ?? null, isWritable: true },
+    treasury: { value: input.treasury ?? null, isWritable: true },
+    authority: { value: input.authority ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
   };
   const accounts = originalAccounts;
+  if (!accounts.treasury.value) {
+    accounts.treasury.value = "DHffy4rNMtuL8VKgyBEay4jcq8AYHyoAzxLKU6aEijUV";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
   const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
   const instruction = {
     accounts: [
+      getAccountMeta(accounts.master),
+      getAccountMeta(accounts.stats),
       getAccountMeta(accounts.airdrop),
       getAccountMeta(accounts.bitmap),
-      getAccountMeta(accounts.owner)
+      getAccountMeta(accounts.treasury),
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.systemProgram)
     ],
     programAddress,
     data: getCloseBitmapInstructionDataEncoder().encode({})
@@ -1025,7 +1327,7 @@ function getCloseBitmapInstruction(input, config) {
   return instruction;
 }
 function parseCloseBitmapInstruction(instruction) {
-  if (instruction.accounts.length < 3) {
+  if (instruction.accounts.length < 7) {
     throw new Error("Not enough accounts");
   }
   let accountIndex = 0;
@@ -1037,16 +1339,20 @@ function parseCloseBitmapInstruction(instruction) {
   return {
     programAddress: instruction.programAddress,
     accounts: {
+      master: getNextAccount(),
+      stats: getNextAccount(),
       airdrop: getNextAccount(),
       bitmap: getNextAccount(),
-      owner: getNextAccount()
+      treasury: getNextAccount(),
+      authority: getNextAccount(),
+      systemProgram: getNextAccount()
     },
     data: getCloseBitmapInstructionDataDecoder().decode(instruction.data)
   };
 }
 
 // src/instructions/depositTokens.ts
-var import_kit10 = require("@solana/kit");
+var import_kit12 = require("@solana/kit");
 var DEPOSIT_TOKENS_DISCRIMINATOR = new Uint8Array([
   176,
   83,
@@ -1058,47 +1364,46 @@ var DEPOSIT_TOKENS_DISCRIMINATOR = new Uint8Array([
   150
 ]);
 function getDepositTokensDiscriminatorBytes() {
-  return (0, import_kit10.fixEncoderSize)((0, import_kit10.getBytesEncoder)(), 8).encode(
+  return (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
     DEPOSIT_TOKENS_DISCRIMINATOR
   );
 }
 function getDepositTokensInstructionDataEncoder() {
-  return (0, import_kit10.transformEncoder)(
-    (0, import_kit10.getStructEncoder)([
-      ["discriminator", (0, import_kit10.fixEncoderSize)((0, import_kit10.getBytesEncoder)(), 8)],
-      ["amount", (0, import_kit10.getU64Encoder)()]
+  return (0, import_kit12.transformEncoder)(
+    (0, import_kit12.getStructEncoder)([
+      ["discriminator", (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8)],
+      ["amount", (0, import_kit12.getU64Encoder)()]
     ]),
-    (value) => __spreadProps(__spreadValues({}, value), { discriminator: DEPOSIT_TOKENS_DISCRIMINATOR })
+    (value) => ({ ...value, discriminator: DEPOSIT_TOKENS_DISCRIMINATOR })
   );
 }
 function getDepositTokensInstructionDataDecoder() {
-  return (0, import_kit10.getStructDecoder)([
-    ["discriminator", (0, import_kit10.fixDecoderSize)((0, import_kit10.getBytesDecoder)(), 8)],
-    ["amount", (0, import_kit10.getU64Decoder)()]
+  return (0, import_kit12.getStructDecoder)([
+    ["discriminator", (0, import_kit12.fixDecoderSize)((0, import_kit12.getBytesDecoder)(), 8)],
+    ["amount", (0, import_kit12.getU64Decoder)()]
   ]);
 }
 function getDepositTokensInstructionDataCodec() {
-  return (0, import_kit10.combineCodec)(
+  return (0, import_kit12.combineCodec)(
     getDepositTokensInstructionDataEncoder(),
     getDepositTokensInstructionDataDecoder()
   );
 }
 function getDepositTokensInstruction(input, config) {
-  var _a, _b, _c, _d, _e, _f, _g;
-  const programAddress = (_a = config == null ? void 0 : config.programAddress) != null ? _a : DROPSY_PROGRAM_ADDRESS;
+  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
   const originalAccounts = {
     sourceTokenAccount: {
-      value: (_b = input.sourceTokenAccount) != null ? _b : null,
+      value: input.sourceTokenAccount ?? null,
       isWritable: true
     },
-    vault: { value: (_c = input.vault) != null ? _c : null, isWritable: true },
-    airdrop: { value: (_d = input.airdrop) != null ? _d : null, isWritable: true },
-    mint: { value: (_e = input.mint) != null ? _e : null, isWritable: false },
-    owner: { value: (_f = input.owner) != null ? _f : null, isWritable: false },
-    tokenProgram: { value: (_g = input.tokenProgram) != null ? _g : null, isWritable: false }
+    vault: { value: input.vault ?? null, isWritable: true },
+    airdrop: { value: input.airdrop ?? null, isWritable: true },
+    mint: { value: input.mint ?? null, isWritable: false },
+    authority: { value: input.authority ?? null, isWritable: false },
+    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false }
   };
   const accounts = originalAccounts;
-  const args = __spreadValues({}, input);
+  const args = { ...input };
   if (!accounts.tokenProgram.value) {
     accounts.tokenProgram.value = "TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb";
   }
@@ -1109,7 +1414,7 @@ function getDepositTokensInstruction(input, config) {
       getAccountMeta(accounts.vault),
       getAccountMeta(accounts.airdrop),
       getAccountMeta(accounts.mint),
-      getAccountMeta(accounts.owner),
+      getAccountMeta(accounts.authority),
       getAccountMeta(accounts.tokenProgram)
     ],
     programAddress,
@@ -1136,7 +1441,7 @@ function parseDepositTokensInstruction(instruction) {
       vault: getNextAccount(),
       airdrop: getNextAccount(),
       mint: getNextAccount(),
-      owner: getNextAccount(),
+      authority: getNextAccount(),
       tokenProgram: getNextAccount()
     },
     data: getDepositTokensInstructionDataDecoder().decode(instruction.data)
@@ -1144,7 +1449,7 @@ function parseDepositTokensInstruction(instruction) {
 }
 
 // src/instructions/initializeAirdrop.ts
-var import_kit11 = require("@solana/kit");
+var import_kit13 = require("@solana/kit");
 var INITIALIZE_AIRDROP_DISCRIMINATOR = new Uint8Array([
   96,
   196,
@@ -1156,119 +1461,123 @@ var INITIALIZE_AIRDROP_DISCRIMINATOR = new Uint8Array([
   184
 ]);
 function getInitializeAirdropDiscriminatorBytes() {
-  return (0, import_kit11.fixEncoderSize)((0, import_kit11.getBytesEncoder)(), 8).encode(
+  return (0, import_kit13.fixEncoderSize)((0, import_kit13.getBytesEncoder)(), 8).encode(
     INITIALIZE_AIRDROP_DISCRIMINATOR
   );
 }
 function getInitializeAirdropInstructionDataEncoder() {
-  return (0, import_kit11.transformEncoder)(
-    (0, import_kit11.getStructEncoder)([
-      ["discriminator", (0, import_kit11.fixEncoderSize)((0, import_kit11.getBytesEncoder)(), 8)],
-      ["id", (0, import_kit11.getU64Encoder)()],
-      ["merkleRoot", (0, import_kit11.getArrayEncoder)((0, import_kit11.getU8Encoder)(), { size: 32 })],
-      ["startsTime", (0, import_kit11.getI64Encoder)()],
-      ["endTime", (0, import_kit11.getI64Encoder)()]
+  return (0, import_kit13.transformEncoder)(
+    (0, import_kit13.getStructEncoder)([
+      ["discriminator", (0, import_kit13.fixEncoderSize)((0, import_kit13.getBytesEncoder)(), 8)],
+      ["merkleRoot", (0, import_kit13.getArrayEncoder)((0, import_kit13.getU8Encoder)(), { size: 32 })],
+      ["startsTime", (0, import_kit13.getOptionEncoder)((0, import_kit13.getI64Encoder)())],
+      ["endTime", (0, import_kit13.getOptionEncoder)((0, import_kit13.getI64Encoder)())]
     ]),
-    (value) => __spreadProps(__spreadValues({}, value), { discriminator: INITIALIZE_AIRDROP_DISCRIMINATOR })
+    (value) => ({ ...value, discriminator: INITIALIZE_AIRDROP_DISCRIMINATOR })
   );
 }
 function getInitializeAirdropInstructionDataDecoder() {
-  return (0, import_kit11.getStructDecoder)([
-    ["discriminator", (0, import_kit11.fixDecoderSize)((0, import_kit11.getBytesDecoder)(), 8)],
-    ["id", (0, import_kit11.getU64Decoder)()],
-    ["merkleRoot", (0, import_kit11.getArrayDecoder)((0, import_kit11.getU8Decoder)(), { size: 32 })],
-    ["startsTime", (0, import_kit11.getI64Decoder)()],
-    ["endTime", (0, import_kit11.getI64Decoder)()]
+  return (0, import_kit13.getStructDecoder)([
+    ["discriminator", (0, import_kit13.fixDecoderSize)((0, import_kit13.getBytesDecoder)(), 8)],
+    ["merkleRoot", (0, import_kit13.getArrayDecoder)((0, import_kit13.getU8Decoder)(), { size: 32 })],
+    ["startsTime", (0, import_kit13.getOptionDecoder)((0, import_kit13.getI64Decoder)())],
+    ["endTime", (0, import_kit13.getOptionDecoder)((0, import_kit13.getI64Decoder)())]
   ]);
 }
 function getInitializeAirdropInstructionDataCodec() {
-  return (0, import_kit11.combineCodec)(
+  return (0, import_kit13.combineCodec)(
     getInitializeAirdropInstructionDataEncoder(),
     getInitializeAirdropInstructionDataDecoder()
   );
 }
-function getInitializeAirdropInstructionAsync(input, config) {
-  return __async(this, null, function* () {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
-    const programAddress = (_a = config == null ? void 0 : config.programAddress) != null ? _a : DROPSY_PROGRAM_ADDRESS;
-    const originalAccounts = {
-      mint: { value: (_b = input.mint) != null ? _b : null, isWritable: false },
-      airdrop: { value: (_c = input.airdrop) != null ? _c : null, isWritable: true },
-      controller: { value: (_d = input.controller) != null ? _d : null, isWritable: true },
-      feeVault: { value: (_e = input.feeVault) != null ? _e : null, isWritable: true },
-      owner: { value: (_f = input.owner) != null ? _f : null, isWritable: true },
-      treasury: { value: (_g = input.treasury) != null ? _g : null, isWritable: true },
-      systemProgram: { value: (_h = input.systemProgram) != null ? _h : null, isWritable: false }
-    };
-    const accounts = originalAccounts;
-    const args = __spreadValues({}, input);
-    if (!accounts.airdrop.value) {
-      accounts.airdrop.value = yield (0, import_kit11.getProgramDerivedAddress)({
-        programAddress,
-        seeds: [
-          (0, import_kit11.getBytesEncoder)().encode(
-            new Uint8Array([97, 105, 114, 100, 114, 111, 112])
-          ),
-          (0, import_kit11.getAddressEncoder)().encode(expectAddress(accounts.mint.value)),
-          (0, import_kit11.getAddressEncoder)().encode(expectAddress(accounts.owner.value)),
-          (0, import_kit11.getU64Encoder)().encode(expectSome(args.id))
-        ]
-      });
-    }
-    if (!accounts.treasury.value) {
-      accounts.treasury.value = "DHffy4rNMtuL8VKgyBEay4jcq8AYHyoAzxLKU6aEijUV";
-    }
-    if (!accounts.systemProgram.value) {
-      accounts.systemProgram.value = "11111111111111111111111111111111";
-    }
-    const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
-    const instruction = {
-      accounts: [
-        getAccountMeta(accounts.mint),
-        getAccountMeta(accounts.airdrop),
-        getAccountMeta(accounts.controller),
-        getAccountMeta(accounts.feeVault),
-        getAccountMeta(accounts.owner),
-        getAccountMeta(accounts.treasury),
-        getAccountMeta(accounts.systemProgram)
-      ],
+async function getInitializeAirdropInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    stats: { value: input.stats ?? null, isWritable: true },
+    controller: { value: input.controller ?? null, isWritable: true },
+    airdrop: { value: input.airdrop ?? null, isWritable: true },
+    feeVault: { value: input.feeVault ?? null, isWritable: true },
+    mint: { value: input.mint ?? null, isWritable: false },
+    authority: { value: input.authority ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.stats.value) {
+    accounts.stats.value = await (0, import_kit13.getProgramDerivedAddress)({
       programAddress,
-      data: getInitializeAirdropInstructionDataEncoder().encode(
-        args
-      )
-    };
-    return instruction;
-  });
+      seeds: [
+        (0, import_kit13.getBytesEncoder)().encode(new Uint8Array([115, 116, 97, 116, 115]))
+      ]
+    });
+  }
+  if (!accounts.airdrop.value) {
+    accounts.airdrop.value = await (0, import_kit13.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit13.getBytesEncoder)().encode(
+          new Uint8Array([97, 105, 114, 100, 114, 111, 112])
+        ),
+        (0, import_kit13.getAddressEncoder)().encode(expectAddress(accounts.mint.value)),
+        (0, import_kit13.getAddressEncoder)().encode(expectAddress(accounts.authority.value))
+      ]
+    });
+  }
+  if (!accounts.feeVault.value) {
+    accounts.feeVault.value = await (0, import_kit13.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit13.getBytesEncoder)().encode(new Uint8Array([118, 97, 117, 108, 116])),
+        (0, import_kit13.getAddressEncoder)().encode(expectAddress(accounts.controller.value))
+      ]
+    });
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  const instruction = {
+    accounts: [
+      getAccountMeta(accounts.stats),
+      getAccountMeta(accounts.controller),
+      getAccountMeta(accounts.airdrop),
+      getAccountMeta(accounts.feeVault),
+      getAccountMeta(accounts.mint),
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    programAddress,
+    data: getInitializeAirdropInstructionDataEncoder().encode(
+      args
+    )
+  };
+  return instruction;
 }
 function getInitializeAirdropInstruction(input, config) {
-  var _a, _b, _c, _d, _e, _f, _g, _h;
-  const programAddress = (_a = config == null ? void 0 : config.programAddress) != null ? _a : DROPSY_PROGRAM_ADDRESS;
+  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
   const originalAccounts = {
-    mint: { value: (_b = input.mint) != null ? _b : null, isWritable: false },
-    airdrop: { value: (_c = input.airdrop) != null ? _c : null, isWritable: true },
-    controller: { value: (_d = input.controller) != null ? _d : null, isWritable: true },
-    feeVault: { value: (_e = input.feeVault) != null ? _e : null, isWritable: true },
-    owner: { value: (_f = input.owner) != null ? _f : null, isWritable: true },
-    treasury: { value: (_g = input.treasury) != null ? _g : null, isWritable: true },
-    systemProgram: { value: (_h = input.systemProgram) != null ? _h : null, isWritable: false }
+    stats: { value: input.stats ?? null, isWritable: true },
+    controller: { value: input.controller ?? null, isWritable: true },
+    airdrop: { value: input.airdrop ?? null, isWritable: true },
+    feeVault: { value: input.feeVault ?? null, isWritable: true },
+    mint: { value: input.mint ?? null, isWritable: false },
+    authority: { value: input.authority ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
   };
   const accounts = originalAccounts;
-  const args = __spreadValues({}, input);
-  if (!accounts.treasury.value) {
-    accounts.treasury.value = "DHffy4rNMtuL8VKgyBEay4jcq8AYHyoAzxLKU6aEijUV";
-  }
+  const args = { ...input };
   if (!accounts.systemProgram.value) {
     accounts.systemProgram.value = "11111111111111111111111111111111";
   }
   const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
   const instruction = {
     accounts: [
-      getAccountMeta(accounts.mint),
-      getAccountMeta(accounts.airdrop),
+      getAccountMeta(accounts.stats),
       getAccountMeta(accounts.controller),
+      getAccountMeta(accounts.airdrop),
       getAccountMeta(accounts.feeVault),
-      getAccountMeta(accounts.owner),
-      getAccountMeta(accounts.treasury),
+      getAccountMeta(accounts.mint),
+      getAccountMeta(accounts.authority),
       getAccountMeta(accounts.systemProgram)
     ],
     programAddress,
@@ -1291,12 +1600,12 @@ function parseInitializeAirdropInstruction(instruction) {
   return {
     programAddress: instruction.programAddress,
     accounts: {
-      mint: getNextAccount(),
-      airdrop: getNextAccount(),
+      stats: getNextAccount(),
       controller: getNextAccount(),
+      airdrop: getNextAccount(),
       feeVault: getNextAccount(),
-      owner: getNextAccount(),
-      treasury: getNextAccount(),
+      mint: getNextAccount(),
+      authority: getNextAccount(),
       systemProgram: getNextAccount()
     },
     data: getInitializeAirdropInstructionDataDecoder().decode(instruction.data)
@@ -1304,7 +1613,7 @@ function parseInitializeAirdropInstruction(instruction) {
 }
 
 // src/instructions/initializeBitmap.ts
-var import_kit12 = require("@solana/kit");
+var import_kit14 = require("@solana/kit");
 var INITIALIZE_BITMAP_DISCRIMINATOR = new Uint8Array([
   25,
   109,
@@ -1316,94 +1625,126 @@ var INITIALIZE_BITMAP_DISCRIMINATOR = new Uint8Array([
   69
 ]);
 function getInitializeBitmapDiscriminatorBytes() {
-  return (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
+  return (0, import_kit14.fixEncoderSize)((0, import_kit14.getBytesEncoder)(), 8).encode(
     INITIALIZE_BITMAP_DISCRIMINATOR
   );
 }
 function getInitializeBitmapInstructionDataEncoder() {
-  return (0, import_kit12.transformEncoder)(
-    (0, import_kit12.getStructEncoder)([
-      ["discriminator", (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8)],
-      ["id", (0, import_kit12.getU8Encoder)()],
-      ["total", (0, import_kit12.getU64Encoder)()]
+  return (0, import_kit14.transformEncoder)(
+    (0, import_kit14.getStructEncoder)([
+      ["discriminator", (0, import_kit14.fixEncoderSize)((0, import_kit14.getBytesEncoder)(), 8)],
+      ["id", (0, import_kit14.getU8Encoder)()],
+      ["total", (0, import_kit14.getU64Encoder)()]
     ]),
-    (value) => __spreadProps(__spreadValues({}, value), { discriminator: INITIALIZE_BITMAP_DISCRIMINATOR })
+    (value) => ({ ...value, discriminator: INITIALIZE_BITMAP_DISCRIMINATOR })
   );
 }
 function getInitializeBitmapInstructionDataDecoder() {
-  return (0, import_kit12.getStructDecoder)([
-    ["discriminator", (0, import_kit12.fixDecoderSize)((0, import_kit12.getBytesDecoder)(), 8)],
-    ["id", (0, import_kit12.getU8Decoder)()],
-    ["total", (0, import_kit12.getU64Decoder)()]
+  return (0, import_kit14.getStructDecoder)([
+    ["discriminator", (0, import_kit14.fixDecoderSize)((0, import_kit14.getBytesDecoder)(), 8)],
+    ["id", (0, import_kit14.getU8Decoder)()],
+    ["total", (0, import_kit14.getU64Decoder)()]
   ]);
 }
 function getInitializeBitmapInstructionDataCodec() {
-  return (0, import_kit12.combineCodec)(
+  return (0, import_kit14.combineCodec)(
     getInitializeBitmapInstructionDataEncoder(),
     getInitializeBitmapInstructionDataDecoder()
   );
 }
-function getInitializeBitmapInstructionAsync(input, config) {
-  return __async(this, null, function* () {
-    var _a, _b, _c, _d, _e;
-    const programAddress = (_a = config == null ? void 0 : config.programAddress) != null ? _a : DROPSY_PROGRAM_ADDRESS;
-    const originalAccounts = {
-      bitmap: { value: (_b = input.bitmap) != null ? _b : null, isWritable: true },
-      airdrop: { value: (_c = input.airdrop) != null ? _c : null, isWritable: true },
-      owner: { value: (_d = input.owner) != null ? _d : null, isWritable: true },
-      systemProgram: { value: (_e = input.systemProgram) != null ? _e : null, isWritable: false }
-    };
-    const accounts = originalAccounts;
-    const args = __spreadValues({}, input);
-    if (!accounts.bitmap.value) {
-      accounts.bitmap.value = yield (0, import_kit12.getProgramDerivedAddress)({
-        programAddress,
-        seeds: [
-          (0, import_kit12.getBytesEncoder)().encode(new Uint8Array([98, 105, 116, 109, 97, 112])),
-          (0, import_kit12.getAddressEncoder)().encode(expectAddress(accounts.airdrop.value)),
-          (0, import_kit12.getU8Encoder)().encode(expectSome(args.id))
-        ]
-      });
-    }
-    if (!accounts.systemProgram.value) {
-      accounts.systemProgram.value = "11111111111111111111111111111111";
-    }
-    const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
-    const instruction = {
-      accounts: [
-        getAccountMeta(accounts.bitmap),
-        getAccountMeta(accounts.airdrop),
-        getAccountMeta(accounts.owner),
-        getAccountMeta(accounts.systemProgram)
-      ],
+async function getInitializeBitmapInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    master: { value: input.master ?? null, isWritable: false },
+    stats: { value: input.stats ?? null, isWritable: true },
+    bitmap: { value: input.bitmap ?? null, isWritable: true },
+    airdrop: { value: input.airdrop ?? null, isWritable: true },
+    treasury: { value: input.treasury ?? null, isWritable: true },
+    authority: { value: input.authority ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.master.value) {
+    accounts.master.value = await (0, import_kit14.getProgramDerivedAddress)({
       programAddress,
-      data: getInitializeBitmapInstructionDataEncoder().encode(
-        args
-      )
-    };
-    return instruction;
-  });
+      seeds: [
+        (0, import_kit14.getBytesEncoder)().encode(
+          new Uint8Array([109, 97, 115, 116, 101, 114, 51])
+        )
+      ]
+    });
+  }
+  if (!accounts.stats.value) {
+    accounts.stats.value = await (0, import_kit14.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit14.getBytesEncoder)().encode(new Uint8Array([115, 116, 97, 116, 115]))
+      ]
+    });
+  }
+  if (!accounts.bitmap.value) {
+    accounts.bitmap.value = await (0, import_kit14.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit14.getBytesEncoder)().encode(new Uint8Array([98, 105, 116, 109, 97, 112])),
+        (0, import_kit14.getAddressEncoder)().encode(expectAddress(accounts.airdrop.value)),
+        (0, import_kit14.getU8Encoder)().encode(expectSome(args.id))
+      ]
+    });
+  }
+  if (!accounts.treasury.value) {
+    accounts.treasury.value = "DHffy4rNMtuL8VKgyBEay4jcq8AYHyoAzxLKU6aEijUV";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  const instruction = {
+    accounts: [
+      getAccountMeta(accounts.master),
+      getAccountMeta(accounts.stats),
+      getAccountMeta(accounts.bitmap),
+      getAccountMeta(accounts.airdrop),
+      getAccountMeta(accounts.treasury),
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    programAddress,
+    data: getInitializeBitmapInstructionDataEncoder().encode(
+      args
+    )
+  };
+  return instruction;
 }
 function getInitializeBitmapInstruction(input, config) {
-  var _a, _b, _c, _d, _e;
-  const programAddress = (_a = config == null ? void 0 : config.programAddress) != null ? _a : DROPSY_PROGRAM_ADDRESS;
+  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
   const originalAccounts = {
-    bitmap: { value: (_b = input.bitmap) != null ? _b : null, isWritable: true },
-    airdrop: { value: (_c = input.airdrop) != null ? _c : null, isWritable: true },
-    owner: { value: (_d = input.owner) != null ? _d : null, isWritable: true },
-    systemProgram: { value: (_e = input.systemProgram) != null ? _e : null, isWritable: false }
+    master: { value: input.master ?? null, isWritable: false },
+    stats: { value: input.stats ?? null, isWritable: true },
+    bitmap: { value: input.bitmap ?? null, isWritable: true },
+    airdrop: { value: input.airdrop ?? null, isWritable: true },
+    treasury: { value: input.treasury ?? null, isWritable: true },
+    authority: { value: input.authority ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
   };
   const accounts = originalAccounts;
-  const args = __spreadValues({}, input);
+  const args = { ...input };
+  if (!accounts.treasury.value) {
+    accounts.treasury.value = "DHffy4rNMtuL8VKgyBEay4jcq8AYHyoAzxLKU6aEijUV";
+  }
   if (!accounts.systemProgram.value) {
     accounts.systemProgram.value = "11111111111111111111111111111111";
   }
   const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
   const instruction = {
     accounts: [
+      getAccountMeta(accounts.master),
+      getAccountMeta(accounts.stats),
       getAccountMeta(accounts.bitmap),
       getAccountMeta(accounts.airdrop),
-      getAccountMeta(accounts.owner),
+      getAccountMeta(accounts.treasury),
+      getAccountMeta(accounts.authority),
       getAccountMeta(accounts.systemProgram)
     ],
     programAddress,
@@ -1414,7 +1755,7 @@ function getInitializeBitmapInstruction(input, config) {
   return instruction;
 }
 function parseInitializeBitmapInstruction(instruction) {
-  if (instruction.accounts.length < 4) {
+  if (instruction.accounts.length < 7) {
     throw new Error("Not enough accounts");
   }
   let accountIndex = 0;
@@ -1426,9 +1767,12 @@ function parseInitializeBitmapInstruction(instruction) {
   return {
     programAddress: instruction.programAddress,
     accounts: {
+      master: getNextAccount(),
+      stats: getNextAccount(),
       bitmap: getNextAccount(),
       airdrop: getNextAccount(),
-      owner: getNextAccount(),
+      treasury: getNextAccount(),
+      authority: getNextAccount(),
       systemProgram: getNextAccount()
     },
     data: getInitializeBitmapInstructionDataDecoder().decode(instruction.data)
@@ -1436,7 +1780,7 @@ function parseInitializeBitmapInstruction(instruction) {
 }
 
 // src/instructions/initializeController.ts
-var import_kit13 = require("@solana/kit");
+var import_kit15 = require("@solana/kit");
 var INITIALIZE_CONTROLLER_DISCRIMINATOR = new Uint8Array([
   137,
   255,
@@ -1448,112 +1792,140 @@ var INITIALIZE_CONTROLLER_DISCRIMINATOR = new Uint8Array([
   81
 ]);
 function getInitializeControllerDiscriminatorBytes() {
-  return (0, import_kit13.fixEncoderSize)((0, import_kit13.getBytesEncoder)(), 8).encode(
+  return (0, import_kit15.fixEncoderSize)((0, import_kit15.getBytesEncoder)(), 8).encode(
     INITIALIZE_CONTROLLER_DISCRIMINATOR
   );
 }
 function getInitializeControllerInstructionDataEncoder() {
-  return (0, import_kit13.transformEncoder)(
-    (0, import_kit13.getStructEncoder)([
-      ["discriminator", (0, import_kit13.fixEncoderSize)((0, import_kit13.getBytesEncoder)(), 8)],
-      ["createFee", (0, import_kit13.getU64Encoder)()],
-      ["claimFee", (0, import_kit13.getU64Encoder)()]
+  return (0, import_kit15.transformEncoder)(
+    (0, import_kit15.getStructEncoder)([
+      ["discriminator", (0, import_kit15.fixEncoderSize)((0, import_kit15.getBytesEncoder)(), 8)],
+      ["feeLamports", (0, import_kit15.getU64Encoder)()]
     ]),
-    (value) => __spreadProps(__spreadValues({}, value), {
+    (value) => ({
+      ...value,
       discriminator: INITIALIZE_CONTROLLER_DISCRIMINATOR
     })
   );
 }
 function getInitializeControllerInstructionDataDecoder() {
-  return (0, import_kit13.getStructDecoder)([
-    ["discriminator", (0, import_kit13.fixDecoderSize)((0, import_kit13.getBytesDecoder)(), 8)],
-    ["createFee", (0, import_kit13.getU64Decoder)()],
-    ["claimFee", (0, import_kit13.getU64Decoder)()]
+  return (0, import_kit15.getStructDecoder)([
+    ["discriminator", (0, import_kit15.fixDecoderSize)((0, import_kit15.getBytesDecoder)(), 8)],
+    ["feeLamports", (0, import_kit15.getU64Decoder)()]
   ]);
 }
 function getInitializeControllerInstructionDataCodec() {
-  return (0, import_kit13.combineCodec)(
+  return (0, import_kit15.combineCodec)(
     getInitializeControllerInstructionDataEncoder(),
     getInitializeControllerInstructionDataDecoder()
   );
 }
-function getInitializeControllerInstructionAsync(input, config) {
-  return __async(this, null, function* () {
-    var _a, _b, _c, _d, _e, _f;
-    const programAddress = (_a = config == null ? void 0 : config.programAddress) != null ? _a : DROPSY_PROGRAM_ADDRESS;
-    const originalAccounts = {
-      controller: { value: (_b = input.controller) != null ? _b : null, isWritable: true },
-      feeVault: { value: (_c = input.feeVault) != null ? _c : null, isWritable: false },
-      treasury: { value: (_d = input.treasury) != null ? _d : null, isWritable: true },
-      payer: { value: (_e = input.payer) != null ? _e : null, isWritable: true },
-      systemProgram: { value: (_f = input.systemProgram) != null ? _f : null, isWritable: false }
-    };
-    const accounts = originalAccounts;
-    const args = __spreadValues({}, input);
-    if (!accounts.controller.value) {
-      accounts.controller.value = yield (0, import_kit13.getProgramDerivedAddress)({
-        programAddress,
-        seeds: [
-          (0, import_kit13.getBytesEncoder)().encode(
-            new Uint8Array([
-              99,
-              111,
-              110,
-              116,
-              114,
-              111,
-              108,
-              108,
-              101,
-              114,
-              45,
-              100,
-              114,
-              111,
-              112,
-              115,
-              121
-            ])
-          ),
-          (0, import_kit13.getAddressEncoder)().encode(expectAddress(accounts.payer.value))
-        ]
-      });
-    }
-    if (!accounts.treasury.value) {
-      accounts.treasury.value = "DHffy4rNMtuL8VKgyBEay4jcq8AYHyoAzxLKU6aEijUV";
-    }
-    if (!accounts.systemProgram.value) {
-      accounts.systemProgram.value = "11111111111111111111111111111111";
-    }
-    const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
-    const instruction = {
-      accounts: [
-        getAccountMeta(accounts.controller),
-        getAccountMeta(accounts.feeVault),
-        getAccountMeta(accounts.treasury),
-        getAccountMeta(accounts.payer),
-        getAccountMeta(accounts.systemProgram)
-      ],
+async function getInitializeControllerInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    master: { value: input.master ?? null, isWritable: false },
+    stats: { value: input.stats ?? null, isWritable: true },
+    controller: { value: input.controller ?? null, isWritable: true },
+    feeVault: { value: input.feeVault ?? null, isWritable: true },
+    treasury: { value: input.treasury ?? null, isWritable: true },
+    authority: { value: input.authority ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.master.value) {
+    accounts.master.value = await (0, import_kit15.getProgramDerivedAddress)({
       programAddress,
-      data: getInitializeControllerInstructionDataEncoder().encode(
-        args
-      )
-    };
-    return instruction;
-  });
+      seeds: [
+        (0, import_kit15.getBytesEncoder)().encode(
+          new Uint8Array([109, 97, 115, 116, 101, 114, 51])
+        )
+      ]
+    });
+  }
+  if (!accounts.stats.value) {
+    accounts.stats.value = await (0, import_kit15.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit15.getBytesEncoder)().encode(new Uint8Array([115, 116, 97, 116, 115]))
+      ]
+    });
+  }
+  if (!accounts.controller.value) {
+    accounts.controller.value = await (0, import_kit15.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit15.getBytesEncoder)().encode(
+          new Uint8Array([
+            99,
+            111,
+            110,
+            116,
+            114,
+            111,
+            108,
+            108,
+            101,
+            114,
+            45,
+            100,
+            114,
+            111,
+            112,
+            115,
+            121
+          ])
+        ),
+        (0, import_kit15.getAddressEncoder)().encode(expectAddress(accounts.authority.value))
+      ]
+    });
+  }
+  if (!accounts.feeVault.value) {
+    accounts.feeVault.value = await (0, import_kit15.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit15.getBytesEncoder)().encode(new Uint8Array([118, 97, 117, 108, 116])),
+        (0, import_kit15.getAddressEncoder)().encode(expectAddress(accounts.controller.value))
+      ]
+    });
+  }
+  if (!accounts.treasury.value) {
+    accounts.treasury.value = "DHffy4rNMtuL8VKgyBEay4jcq8AYHyoAzxLKU6aEijUV";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  const instruction = {
+    accounts: [
+      getAccountMeta(accounts.master),
+      getAccountMeta(accounts.stats),
+      getAccountMeta(accounts.controller),
+      getAccountMeta(accounts.feeVault),
+      getAccountMeta(accounts.treasury),
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    programAddress,
+    data: getInitializeControllerInstructionDataEncoder().encode(
+      args
+    )
+  };
+  return instruction;
 }
 function getInitializeControllerInstruction(input, config) {
-  var _a, _b, _c, _d, _e, _f;
-  const programAddress = (_a = config == null ? void 0 : config.programAddress) != null ? _a : DROPSY_PROGRAM_ADDRESS;
+  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
   const originalAccounts = {
-    controller: { value: (_b = input.controller) != null ? _b : null, isWritable: true },
-    feeVault: { value: (_c = input.feeVault) != null ? _c : null, isWritable: false },
-    treasury: { value: (_d = input.treasury) != null ? _d : null, isWritable: true },
-    payer: { value: (_e = input.payer) != null ? _e : null, isWritable: true },
-    systemProgram: { value: (_f = input.systemProgram) != null ? _f : null, isWritable: false }
+    master: { value: input.master ?? null, isWritable: false },
+    stats: { value: input.stats ?? null, isWritable: true },
+    controller: { value: input.controller ?? null, isWritable: true },
+    feeVault: { value: input.feeVault ?? null, isWritable: true },
+    treasury: { value: input.treasury ?? null, isWritable: true },
+    authority: { value: input.authority ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
   };
   const accounts = originalAccounts;
-  const args = __spreadValues({}, input);
+  const args = { ...input };
   if (!accounts.treasury.value) {
     accounts.treasury.value = "DHffy4rNMtuL8VKgyBEay4jcq8AYHyoAzxLKU6aEijUV";
   }
@@ -1563,10 +1935,12 @@ function getInitializeControllerInstruction(input, config) {
   const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
   const instruction = {
     accounts: [
+      getAccountMeta(accounts.master),
+      getAccountMeta(accounts.stats),
       getAccountMeta(accounts.controller),
       getAccountMeta(accounts.feeVault),
       getAccountMeta(accounts.treasury),
-      getAccountMeta(accounts.payer),
+      getAccountMeta(accounts.authority),
       getAccountMeta(accounts.systemProgram)
     ],
     programAddress,
@@ -1577,7 +1951,7 @@ function getInitializeControllerInstruction(input, config) {
   return instruction;
 }
 function parseInitializeControllerInstruction(instruction) {
-  if (instruction.accounts.length < 5) {
+  if (instruction.accounts.length < 7) {
     throw new Error("Not enough accounts");
   }
   let accountIndex = 0;
@@ -1589,10 +1963,12 @@ function parseInitializeControllerInstruction(instruction) {
   return {
     programAddress: instruction.programAddress,
     accounts: {
+      master: getNextAccount(),
+      stats: getNextAccount(),
       controller: getNextAccount(),
       feeVault: getNextAccount(),
       treasury: getNextAccount(),
-      payer: getNextAccount(),
+      authority: getNextAccount(),
       systemProgram: getNextAccount()
     },
     data: getInitializeControllerInstructionDataDecoder().decode(
@@ -1601,157 +1977,626 @@ function parseInitializeControllerInstruction(instruction) {
   };
 }
 
+// src/instructions/initializeMaster.ts
+var import_kit16 = require("@solana/kit");
+var INITIALIZE_MASTER_DISCRIMINATOR = new Uint8Array([
+  206,
+  91,
+  246,
+  30,
+  216,
+  101,
+  134,
+  166
+]);
+function getInitializeMasterDiscriminatorBytes() {
+  return (0, import_kit16.fixEncoderSize)((0, import_kit16.getBytesEncoder)(), 8).encode(
+    INITIALIZE_MASTER_DISCRIMINATOR
+  );
+}
+function getInitializeMasterInstructionDataEncoder() {
+  return (0, import_kit16.transformEncoder)(
+    (0, import_kit16.getStructEncoder)([
+      ["discriminator", (0, import_kit16.fixEncoderSize)((0, import_kit16.getBytesEncoder)(), 8)],
+      ["protocolFee", (0, import_kit16.getU64Encoder)()],
+      ["initControllerFee", (0, import_kit16.getU64Encoder)()],
+      ["withdrawFee", (0, import_kit16.getU64Encoder)()]
+    ]),
+    (value) => ({ ...value, discriminator: INITIALIZE_MASTER_DISCRIMINATOR })
+  );
+}
+function getInitializeMasterInstructionDataDecoder() {
+  return (0, import_kit16.getStructDecoder)([
+    ["discriminator", (0, import_kit16.fixDecoderSize)((0, import_kit16.getBytesDecoder)(), 8)],
+    ["protocolFee", (0, import_kit16.getU64Decoder)()],
+    ["initControllerFee", (0, import_kit16.getU64Decoder)()],
+    ["withdrawFee", (0, import_kit16.getU64Decoder)()]
+  ]);
+}
+function getInitializeMasterInstructionDataCodec() {
+  return (0, import_kit16.combineCodec)(
+    getInitializeMasterInstructionDataEncoder(),
+    getInitializeMasterInstructionDataDecoder()
+  );
+}
+async function getInitializeMasterInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    master: { value: input.master ?? null, isWritable: true },
+    stats: { value: input.stats ?? null, isWritable: true },
+    feeVault: { value: input.feeVault ?? null, isWritable: false },
+    authority: { value: input.authority ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.master.value) {
+    accounts.master.value = await (0, import_kit16.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit16.getBytesEncoder)().encode(
+          new Uint8Array([109, 97, 115, 116, 101, 114, 51])
+        )
+      ]
+    });
+  }
+  if (!accounts.stats.value) {
+    accounts.stats.value = await (0, import_kit16.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit16.getBytesEncoder)().encode(new Uint8Array([115, 116, 97, 116, 115]))
+      ]
+    });
+  }
+  if (!accounts.feeVault.value) {
+    accounts.feeVault.value = "DHffy4rNMtuL8VKgyBEay4jcq8AYHyoAzxLKU6aEijUV";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  const instruction = {
+    accounts: [
+      getAccountMeta(accounts.master),
+      getAccountMeta(accounts.stats),
+      getAccountMeta(accounts.feeVault),
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    programAddress,
+    data: getInitializeMasterInstructionDataEncoder().encode(
+      args
+    )
+  };
+  return instruction;
+}
+function getInitializeMasterInstruction(input, config) {
+  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    master: { value: input.master ?? null, isWritable: true },
+    stats: { value: input.stats ?? null, isWritable: true },
+    feeVault: { value: input.feeVault ?? null, isWritable: false },
+    authority: { value: input.authority ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.feeVault.value) {
+    accounts.feeVault.value = "DHffy4rNMtuL8VKgyBEay4jcq8AYHyoAzxLKU6aEijUV";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  const instruction = {
+    accounts: [
+      getAccountMeta(accounts.master),
+      getAccountMeta(accounts.stats),
+      getAccountMeta(accounts.feeVault),
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    programAddress,
+    data: getInitializeMasterInstructionDataEncoder().encode(
+      args
+    )
+  };
+  return instruction;
+}
+function parseInitializeMasterInstruction(instruction) {
+  if (instruction.accounts.length < 5) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      master: getNextAccount(),
+      stats: getNextAccount(),
+      feeVault: getNextAccount(),
+      authority: getNextAccount(),
+      systemProgram: getNextAccount()
+    },
+    data: getInitializeMasterInstructionDataDecoder().decode(instruction.data)
+  };
+}
+
+// src/instructions/withdrawControllerFees.ts
+var import_kit17 = require("@solana/kit");
+var WITHDRAW_CONTROLLER_FEES_DISCRIMINATOR = new Uint8Array([
+  252,
+  199,
+  14,
+  46,
+  100,
+  156,
+  176,
+  230
+]);
+function getWithdrawControllerFeesDiscriminatorBytes() {
+  return (0, import_kit17.fixEncoderSize)((0, import_kit17.getBytesEncoder)(), 8).encode(
+    WITHDRAW_CONTROLLER_FEES_DISCRIMINATOR
+  );
+}
+function getWithdrawControllerFeesInstructionDataEncoder() {
+  return (0, import_kit17.transformEncoder)(
+    (0, import_kit17.getStructEncoder)([
+      ["discriminator", (0, import_kit17.fixEncoderSize)((0, import_kit17.getBytesEncoder)(), 8)],
+      ["amount", (0, import_kit17.getU64Encoder)()]
+    ]),
+    (value) => ({
+      ...value,
+      discriminator: WITHDRAW_CONTROLLER_FEES_DISCRIMINATOR
+    })
+  );
+}
+function getWithdrawControllerFeesInstructionDataDecoder() {
+  return (0, import_kit17.getStructDecoder)([
+    ["discriminator", (0, import_kit17.fixDecoderSize)((0, import_kit17.getBytesDecoder)(), 8)],
+    ["amount", (0, import_kit17.getU64Decoder)()]
+  ]);
+}
+function getWithdrawControllerFeesInstructionDataCodec() {
+  return (0, import_kit17.combineCodec)(
+    getWithdrawControllerFeesInstructionDataEncoder(),
+    getWithdrawControllerFeesInstructionDataDecoder()
+  );
+}
+async function getWithdrawControllerFeesInstructionAsync(input, config) {
+  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    master: { value: input.master ?? null, isWritable: false },
+    controller: { value: input.controller ?? null, isWritable: false },
+    feeVault: { value: input.feeVault ?? null, isWritable: true },
+    authority: { value: input.authority ?? null, isWritable: true },
+    treasury: { value: input.treasury ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.master.value) {
+    accounts.master.value = await (0, import_kit17.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit17.getBytesEncoder)().encode(
+          new Uint8Array([109, 97, 115, 116, 101, 114, 51])
+        )
+      ]
+    });
+  }
+  if (!accounts.controller.value) {
+    accounts.controller.value = await (0, import_kit17.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit17.getBytesEncoder)().encode(
+          new Uint8Array([
+            99,
+            111,
+            110,
+            116,
+            114,
+            111,
+            108,
+            108,
+            101,
+            114,
+            45,
+            100,
+            114,
+            111,
+            112,
+            115,
+            121
+          ])
+        ),
+        (0, import_kit17.getAddressEncoder)().encode(expectAddress(accounts.authority.value))
+      ]
+    });
+  }
+  if (!accounts.feeVault.value) {
+    accounts.feeVault.value = await (0, import_kit17.getProgramDerivedAddress)({
+      programAddress,
+      seeds: [
+        (0, import_kit17.getBytesEncoder)().encode(new Uint8Array([118, 97, 117, 108, 116])),
+        (0, import_kit17.getAddressEncoder)().encode(expectAddress(accounts.controller.value))
+      ]
+    });
+  }
+  if (!accounts.treasury.value) {
+    accounts.treasury.value = "DHffy4rNMtuL8VKgyBEay4jcq8AYHyoAzxLKU6aEijUV";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  const instruction = {
+    accounts: [
+      getAccountMeta(accounts.master),
+      getAccountMeta(accounts.controller),
+      getAccountMeta(accounts.feeVault),
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.treasury),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    programAddress,
+    data: getWithdrawControllerFeesInstructionDataEncoder().encode(
+      args
+    )
+  };
+  return instruction;
+}
+function getWithdrawControllerFeesInstruction(input, config) {
+  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
+  const originalAccounts = {
+    master: { value: input.master ?? null, isWritable: false },
+    controller: { value: input.controller ?? null, isWritable: false },
+    feeVault: { value: input.feeVault ?? null, isWritable: true },
+    authority: { value: input.authority ?? null, isWritable: true },
+    treasury: { value: input.treasury ?? null, isWritable: true },
+    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
+  };
+  const accounts = originalAccounts;
+  const args = { ...input };
+  if (!accounts.treasury.value) {
+    accounts.treasury.value = "DHffy4rNMtuL8VKgyBEay4jcq8AYHyoAzxLKU6aEijUV";
+  }
+  if (!accounts.systemProgram.value) {
+    accounts.systemProgram.value = "11111111111111111111111111111111";
+  }
+  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+  const instruction = {
+    accounts: [
+      getAccountMeta(accounts.master),
+      getAccountMeta(accounts.controller),
+      getAccountMeta(accounts.feeVault),
+      getAccountMeta(accounts.authority),
+      getAccountMeta(accounts.treasury),
+      getAccountMeta(accounts.systemProgram)
+    ],
+    programAddress,
+    data: getWithdrawControllerFeesInstructionDataEncoder().encode(
+      args
+    )
+  };
+  return instruction;
+}
+function parseWithdrawControllerFeesInstruction(instruction) {
+  if (instruction.accounts.length < 6) {
+    throw new Error("Not enough accounts");
+  }
+  let accountIndex = 0;
+  const getNextAccount = () => {
+    const accountMeta = instruction.accounts[accountIndex];
+    accountIndex += 1;
+    return accountMeta;
+  };
+  return {
+    programAddress: instruction.programAddress,
+    accounts: {
+      master: getNextAccount(),
+      controller: getNextAccount(),
+      feeVault: getNextAccount(),
+      authority: getNextAccount(),
+      treasury: getNextAccount(),
+      systemProgram: getNextAccount()
+    },
+    data: getWithdrawControllerFeesInstructionDataDecoder().decode(
+      instruction.data
+    )
+  };
+}
+
 // src/types/airdropClosed.ts
-var import_kit14 = require("@solana/kit");
+var import_kit18 = require("@solana/kit");
 function getAirdropClosedEncoder() {
-  return (0, import_kit14.getStructEncoder)([
-    ["airdrop", (0, import_kit14.getAddressEncoder)()],
-    ["owner", (0, import_kit14.getAddressEncoder)()],
-    ["timestamp", (0, import_kit14.getI64Encoder)()]
+  return (0, import_kit18.getStructEncoder)([
+    ["airdrop", (0, import_kit18.getAddressEncoder)()],
+    ["authority", (0, import_kit18.getAddressEncoder)()],
+    ["timestamp", (0, import_kit18.getI64Encoder)()]
   ]);
 }
 function getAirdropClosedDecoder() {
-  return (0, import_kit14.getStructDecoder)([
-    ["airdrop", (0, import_kit14.getAddressDecoder)()],
-    ["owner", (0, import_kit14.getAddressDecoder)()],
-    ["timestamp", (0, import_kit14.getI64Decoder)()]
+  return (0, import_kit18.getStructDecoder)([
+    ["airdrop", (0, import_kit18.getAddressDecoder)()],
+    ["authority", (0, import_kit18.getAddressDecoder)()],
+    ["timestamp", (0, import_kit18.getI64Decoder)()]
   ]);
 }
 function getAirdropClosedCodec() {
-  return (0, import_kit14.combineCodec)(getAirdropClosedEncoder(), getAirdropClosedDecoder());
+  return (0, import_kit18.combineCodec)(getAirdropClosedEncoder(), getAirdropClosedDecoder());
 }
 
 // src/types/airdropInitialized.ts
-var import_kit15 = require("@solana/kit");
+var import_kit19 = require("@solana/kit");
 function getAirdropInitializedEncoder() {
-  return (0, import_kit15.getStructEncoder)([
-    ["airdrop", (0, import_kit15.getAddressEncoder)()],
-    ["mint", (0, import_kit15.getAddressEncoder)()],
-    ["owner", (0, import_kit15.getAddressEncoder)()],
-    ["controller", (0, import_kit15.getAddressEncoder)()],
-    ["controllerAuthority", (0, import_kit15.getAddressEncoder)()],
-    ["merkleRoot", (0, import_kit15.getArrayEncoder)((0, import_kit15.getU8Encoder)(), { size: 32 })],
-    ["startTime", (0, import_kit15.getI64Encoder)()],
-    ["endTime", (0, import_kit15.getI64Encoder)()],
-    ["timestamp", (0, import_kit15.getI64Encoder)()]
+  return (0, import_kit19.getStructEncoder)([
+    ["airdrop", (0, import_kit19.getAddressEncoder)()],
+    ["mint", (0, import_kit19.getAddressEncoder)()],
+    ["authority", (0, import_kit19.getAddressEncoder)()],
+    ["controller", (0, import_kit19.getAddressEncoder)()],
+    ["controllerFeeVault", (0, import_kit19.getAddressEncoder)()],
+    ["merkleRoot", (0, import_kit19.getArrayEncoder)((0, import_kit19.getU8Encoder)(), { size: 32 })],
+    ["startTime", (0, import_kit19.getI64Encoder)()],
+    ["endTime", (0, import_kit19.getI64Encoder)()],
+    ["timestamp", (0, import_kit19.getI64Encoder)()]
   ]);
 }
 function getAirdropInitializedDecoder() {
-  return (0, import_kit15.getStructDecoder)([
-    ["airdrop", (0, import_kit15.getAddressDecoder)()],
-    ["mint", (0, import_kit15.getAddressDecoder)()],
-    ["owner", (0, import_kit15.getAddressDecoder)()],
-    ["controller", (0, import_kit15.getAddressDecoder)()],
-    ["controllerAuthority", (0, import_kit15.getAddressDecoder)()],
-    ["merkleRoot", (0, import_kit15.getArrayDecoder)((0, import_kit15.getU8Decoder)(), { size: 32 })],
-    ["startTime", (0, import_kit15.getI64Decoder)()],
-    ["endTime", (0, import_kit15.getI64Decoder)()],
-    ["timestamp", (0, import_kit15.getI64Decoder)()]
+  return (0, import_kit19.getStructDecoder)([
+    ["airdrop", (0, import_kit19.getAddressDecoder)()],
+    ["mint", (0, import_kit19.getAddressDecoder)()],
+    ["authority", (0, import_kit19.getAddressDecoder)()],
+    ["controller", (0, import_kit19.getAddressDecoder)()],
+    ["controllerFeeVault", (0, import_kit19.getAddressDecoder)()],
+    ["merkleRoot", (0, import_kit19.getArrayDecoder)((0, import_kit19.getU8Decoder)(), { size: 32 })],
+    ["startTime", (0, import_kit19.getI64Decoder)()],
+    ["endTime", (0, import_kit19.getI64Decoder)()],
+    ["timestamp", (0, import_kit19.getI64Decoder)()]
   ]);
 }
 function getAirdropInitializedCodec() {
-  return (0, import_kit15.combineCodec)(
+  return (0, import_kit19.combineCodec)(
     getAirdropInitializedEncoder(),
     getAirdropInitializedDecoder()
   );
 }
 
 // src/types/bitmapClosed.ts
-var import_kit16 = require("@solana/kit");
+var import_kit20 = require("@solana/kit");
 function getBitmapClosedEncoder() {
-  return (0, import_kit16.getStructEncoder)([
-    ["airdrop", (0, import_kit16.getAddressEncoder)()],
-    ["bitmap", (0, import_kit16.getAddressEncoder)()],
-    ["owner", (0, import_kit16.getAddressEncoder)()]
+  return (0, import_kit20.getStructEncoder)([
+    ["airdrop", (0, import_kit20.getAddressEncoder)()],
+    ["bitmap", (0, import_kit20.getAddressEncoder)()],
+    ["authority", (0, import_kit20.getAddressEncoder)()]
   ]);
 }
 function getBitmapClosedDecoder() {
-  return (0, import_kit16.getStructDecoder)([
-    ["airdrop", (0, import_kit16.getAddressDecoder)()],
-    ["bitmap", (0, import_kit16.getAddressDecoder)()],
-    ["owner", (0, import_kit16.getAddressDecoder)()]
+  return (0, import_kit20.getStructDecoder)([
+    ["airdrop", (0, import_kit20.getAddressDecoder)()],
+    ["bitmap", (0, import_kit20.getAddressDecoder)()],
+    ["authority", (0, import_kit20.getAddressDecoder)()]
   ]);
 }
 function getBitmapClosedCodec() {
-  return (0, import_kit16.combineCodec)(getBitmapClosedEncoder(), getBitmapClosedDecoder());
+  return (0, import_kit20.combineCodec)(getBitmapClosedEncoder(), getBitmapClosedDecoder());
 }
 
 // src/types/bitmapInitialized.ts
-var import_kit17 = require("@solana/kit");
+var import_kit21 = require("@solana/kit");
 function getBitmapInitializedEncoder() {
-  return (0, import_kit17.getStructEncoder)([
-    ["airdrop", (0, import_kit17.getAddressEncoder)()],
-    ["bitmap", (0, import_kit17.getAddressEncoder)()],
-    ["bitmapId", (0, import_kit17.getU8Encoder)()],
-    ["totalClaims", (0, import_kit17.getU64Encoder)()]
+  return (0, import_kit21.getStructEncoder)([
+    ["airdrop", (0, import_kit21.getAddressEncoder)()],
+    ["bitmap", (0, import_kit21.getAddressEncoder)()],
+    ["bitmapId", (0, import_kit21.getU8Encoder)()],
+    ["totalClaims", (0, import_kit21.getU64Encoder)()]
   ]);
 }
 function getBitmapInitializedDecoder() {
-  return (0, import_kit17.getStructDecoder)([
-    ["airdrop", (0, import_kit17.getAddressDecoder)()],
-    ["bitmap", (0, import_kit17.getAddressDecoder)()],
-    ["bitmapId", (0, import_kit17.getU8Decoder)()],
-    ["totalClaims", (0, import_kit17.getU64Decoder)()]
+  return (0, import_kit21.getStructDecoder)([
+    ["airdrop", (0, import_kit21.getAddressDecoder)()],
+    ["bitmap", (0, import_kit21.getAddressDecoder)()],
+    ["bitmapId", (0, import_kit21.getU8Decoder)()],
+    ["totalClaims", (0, import_kit21.getU64Decoder)()]
   ]);
 }
 function getBitmapInitializedCodec() {
-  return (0, import_kit17.combineCodec)(
+  return (0, import_kit21.combineCodec)(
     getBitmapInitializedEncoder(),
     getBitmapInitializedDecoder()
   );
 }
 
 // src/types/controllerInitialized.ts
-var import_kit18 = require("@solana/kit");
+var import_kit22 = require("@solana/kit");
 function getControllerInitializedEncoder() {
-  return (0, import_kit18.getStructEncoder)([
-    ["authority", (0, import_kit18.getAddressEncoder)()],
-    ["feeVault", (0, import_kit18.getAddressEncoder)()],
-    ["createFee", (0, import_kit18.getU64Encoder)()],
-    ["claimFee", (0, import_kit18.getU64Encoder)()],
-    ["bump", (0, import_kit18.getU8Encoder)()],
-    ["timestamp", (0, import_kit18.getI64Encoder)()]
+  return (0, import_kit22.getStructEncoder)([
+    ["masterVault", (0, import_kit22.getAddressEncoder)()],
+    ["authority", (0, import_kit22.getAddressEncoder)()],
+    ["feeVault", (0, import_kit22.getAddressEncoder)()],
+    ["feeLamports", (0, import_kit22.getU64Encoder)()],
+    ["bump", (0, import_kit22.getU8Encoder)()],
+    ["timestamp", (0, import_kit22.getI64Encoder)()]
   ]);
 }
 function getControllerInitializedDecoder() {
-  return (0, import_kit18.getStructDecoder)([
-    ["authority", (0, import_kit18.getAddressDecoder)()],
-    ["feeVault", (0, import_kit18.getAddressDecoder)()],
-    ["createFee", (0, import_kit18.getU64Decoder)()],
-    ["claimFee", (0, import_kit18.getU64Decoder)()],
-    ["bump", (0, import_kit18.getU8Decoder)()],
-    ["timestamp", (0, import_kit18.getI64Decoder)()]
+  return (0, import_kit22.getStructDecoder)([
+    ["masterVault", (0, import_kit22.getAddressDecoder)()],
+    ["authority", (0, import_kit22.getAddressDecoder)()],
+    ["feeVault", (0, import_kit22.getAddressDecoder)()],
+    ["feeLamports", (0, import_kit22.getU64Decoder)()],
+    ["bump", (0, import_kit22.getU8Decoder)()],
+    ["timestamp", (0, import_kit22.getI64Decoder)()]
   ]);
 }
 function getControllerInitializedCodec() {
-  return (0, import_kit18.combineCodec)(
+  return (0, import_kit22.combineCodec)(
     getControllerInitializedEncoder(),
     getControllerInitializedDecoder()
   );
 }
 
+// src/types/feesCollected.ts
+var import_kit23 = require("@solana/kit");
+function getFeesCollectedEncoder() {
+  return (0, import_kit23.getStructEncoder)([
+    ["controller", (0, import_kit23.getAddressEncoder)()],
+    ["authority", (0, import_kit23.getAddressEncoder)()],
+    ["feeVault", (0, import_kit23.getAddressEncoder)()],
+    ["amount", (0, import_kit23.getU64Encoder)()],
+    ["timestamp", (0, import_kit23.getI64Encoder)()]
+  ]);
+}
+function getFeesCollectedDecoder() {
+  return (0, import_kit23.getStructDecoder)([
+    ["controller", (0, import_kit23.getAddressDecoder)()],
+    ["authority", (0, import_kit23.getAddressDecoder)()],
+    ["feeVault", (0, import_kit23.getAddressDecoder)()],
+    ["amount", (0, import_kit23.getU64Decoder)()],
+    ["timestamp", (0, import_kit23.getI64Decoder)()]
+  ]);
+}
+function getFeesCollectedCodec() {
+  return (0, import_kit23.combineCodec)(getFeesCollectedEncoder(), getFeesCollectedDecoder());
+}
+
+// src/types/masterInitialized.ts
+var import_kit24 = require("@solana/kit");
+function getMasterInitializedEncoder() {
+  return (0, import_kit24.getStructEncoder)([
+    ["authority", (0, import_kit24.getAddressEncoder)()],
+    ["feeVault", (0, import_kit24.getAddressEncoder)()],
+    ["protocolFee", (0, import_kit24.getU64Encoder)()],
+    ["initControllerFee", (0, import_kit24.getU64Encoder)()],
+    ["withdrawFee", (0, import_kit24.getU64Encoder)()],
+    ["bump", (0, import_kit24.getU8Encoder)()],
+    ["timestamp", (0, import_kit24.getI64Encoder)()]
+  ]);
+}
+function getMasterInitializedDecoder() {
+  return (0, import_kit24.getStructDecoder)([
+    ["authority", (0, import_kit24.getAddressDecoder)()],
+    ["feeVault", (0, import_kit24.getAddressDecoder)()],
+    ["protocolFee", (0, import_kit24.getU64Decoder)()],
+    ["initControllerFee", (0, import_kit24.getU64Decoder)()],
+    ["withdrawFee", (0, import_kit24.getU64Decoder)()],
+    ["bump", (0, import_kit24.getU8Decoder)()],
+    ["timestamp", (0, import_kit24.getI64Decoder)()]
+  ]);
+}
+function getMasterInitializedCodec() {
+  return (0, import_kit24.combineCodec)(
+    getMasterInitializedEncoder(),
+    getMasterInitializedDecoder()
+  );
+}
+
 // src/types/tokensDeposited.ts
-var import_kit19 = require("@solana/kit");
+var import_kit25 = require("@solana/kit");
 function getTokensDepositedEncoder() {
-  return (0, import_kit19.getStructEncoder)([
-    ["airdrop", (0, import_kit19.getAddressEncoder)()],
-    ["amount", (0, import_kit19.getU64Encoder)()],
-    ["newSupply", (0, import_kit19.getU64Encoder)()],
-    ["depositor", (0, import_kit19.getAddressEncoder)()],
-    ["timestamp", (0, import_kit19.getI64Encoder)()]
+  return (0, import_kit25.getStructEncoder)([
+    ["airdrop", (0, import_kit25.getAddressEncoder)()],
+    ["amount", (0, import_kit25.getU64Encoder)()],
+    ["newSupply", (0, import_kit25.getU64Encoder)()],
+    ["depositor", (0, import_kit25.getAddressEncoder)()],
+    ["timestamp", (0, import_kit25.getI64Encoder)()]
   ]);
 }
 function getTokensDepositedDecoder() {
-  return (0, import_kit19.getStructDecoder)([
-    ["airdrop", (0, import_kit19.getAddressDecoder)()],
-    ["amount", (0, import_kit19.getU64Decoder)()],
-    ["newSupply", (0, import_kit19.getU64Decoder)()],
-    ["depositor", (0, import_kit19.getAddressDecoder)()],
-    ["timestamp", (0, import_kit19.getI64Decoder)()]
+  return (0, import_kit25.getStructDecoder)([
+    ["airdrop", (0, import_kit25.getAddressDecoder)()],
+    ["amount", (0, import_kit25.getU64Decoder)()],
+    ["newSupply", (0, import_kit25.getU64Decoder)()],
+    ["depositor", (0, import_kit25.getAddressDecoder)()],
+    ["timestamp", (0, import_kit25.getI64Decoder)()]
   ]);
 }
 function getTokensDepositedCodec() {
-  return (0, import_kit19.combineCodec)(getTokensDepositedEncoder(), getTokensDepositedDecoder());
+  return (0, import_kit25.combineCodec)(getTokensDepositedEncoder(), getTokensDepositedDecoder());
+}
+
+// src/utils/client.ts
+var import_kit26 = require("@solana/kit");
+var generateKeyPairSignerWithSol = async (rpcClient, putativeLamports = 1000000000n) => {
+  const signer = await (0, import_kit26.generateKeyPairSigner)();
+  await (0, import_kit26.airdropFactory)(rpcClient)({
+    recipientAddress: signer.address,
+    lamports: (0, import_kit26.lamports)(putativeLamports),
+    commitment: "confirmed"
+  });
+  return signer;
+};
+var createDefaultSolanaClient = () => {
+  const rpc = (0, import_kit26.createSolanaRpc)("https://api.devnet.solana.com");
+  const rpcSubscriptions = (0, import_kit26.createSolanaRpcSubscriptions)(
+    "wss://api.devnet.solana.com"
+  );
+  return { rpc, rpcSubscriptions };
+};
+var createTransactionMessageFromInstruction = async (rpc, signer, instruction) => {
+  const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
+  return (0, import_kit26.pipe)(
+    (0, import_kit26.createTransactionMessage)({ version: 0 }),
+    (tx) => (0, import_kit26.setTransactionMessageLifetimeUsingBlockhash)(latestBlockhash, tx),
+    (tx) => (0, import_kit26.setTransactionMessageFeePayerSigner)(signer, tx),
+    (tx) => (0, import_kit26.appendTransactionMessageInstructions)(instruction, tx)
+  );
+};
+
+// src/utils/derive.ts
+var import_kit27 = require("@solana/kit");
+
+// src/constants/index.ts
+var masterSeed = "master3";
+var statsSeed = "stats";
+var controllerSeed = "controller-dropsy";
+var feeVaultSeed = "vault";
+var airdropSeed = "airdrop";
+var claimMapSeed = "bitmap";
+
+// src/utils/derive.ts
+async function getDropsyDerivedAddress(seeds) {
+  return await (0, import_kit27.getProgramDerivedAddress)({
+    seeds,
+    programAddress: DROPSY_PROGRAM_ADDRESS
+  });
+}
+async function getMasterDerivedAddress() {
+  return await getDropsyDerivedAddress([Buffer.from(masterSeed)]);
+}
+async function getStatsDerivedAddress() {
+  return await getDropsyDerivedAddress([Buffer.from(statsSeed)]);
+}
+async function getControllerDerivedAddress(authority) {
+  const seeds = [
+    Buffer.from(controllerSeed),
+    (0, import_kit27.getAddressEncoder)().encode(authority)
+  ];
+  return await getDropsyDerivedAddress(seeds);
+}
+async function getAirdropDerivedAddress(authority, mint) {
+  const seeds = [
+    Buffer.from(airdropSeed),
+    (0, import_kit27.getAddressEncoder)().encode(mint),
+    (0, import_kit27.getAddressEncoder)().encode(authority)
+  ];
+  return await getDropsyDerivedAddress(seeds);
+}
+async function getControllerVaultAddress(controller) {
+  const seeds = [Buffer.from(feeVaultSeed), (0, import_kit27.getAddressEncoder)().encode(controller)];
+  return await getDropsyDerivedAddress(seeds);
+}
+async function getClaimMapAddress(airdrop, id) {
+  const seeds = [
+    Buffer.from(claimMapSeed),
+    (0, import_kit27.getAddressEncoder)().encode(airdrop),
+    Buffer.from([id])
+  ];
+  return await getDropsyDerivedAddress(seeds);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -1819,26 +2664,44 @@ function getTokensDepositedCodec() {
   INITIALIZE_AIRDROP_DISCRIMINATOR,
   INITIALIZE_BITMAP_DISCRIMINATOR,
   INITIALIZE_CONTROLLER_DISCRIMINATOR,
+  INITIALIZE_MASTER_DISCRIMINATOR,
+  MASTER_DISCRIMINATOR,
+  STATS_DISCRIMINATOR,
+  WITHDRAW_CONTROLLER_FEES_DISCRIMINATOR,
+  createDefaultSolanaClient,
+  createTransactionMessageFromInstruction,
   decodeAirdrop,
   decodeBitmapAccount,
   decodeController,
+  decodeMaster,
+  decodeStats,
   fetchAirdrop,
   fetchAllAirdrop,
   fetchAllBitmapAccount,
   fetchAllController,
+  fetchAllMaster,
   fetchAllMaybeAirdrop,
   fetchAllMaybeBitmapAccount,
   fetchAllMaybeController,
+  fetchAllMaybeMaster,
+  fetchAllMaybeStats,
+  fetchAllStats,
   fetchBitmapAccount,
   fetchController,
+  fetchMaster,
   fetchMaybeAirdrop,
   fetchMaybeBitmapAccount,
   fetchMaybeController,
+  fetchMaybeMaster,
+  fetchMaybeStats,
+  fetchStats,
+  generateKeyPairSignerWithSol,
   getAirdropClosedCodec,
   getAirdropClosedDecoder,
   getAirdropClosedEncoder,
   getAirdropCodec,
   getAirdropDecoder,
+  getAirdropDerivedAddress,
   getAirdropDiscriminatorBytes,
   getAirdropEncoder,
   getAirdropInitializedCodec,
@@ -1854,6 +2717,7 @@ function getTokensDepositedCodec() {
   getBitmapInitializedCodec,
   getBitmapInitializedDecoder,
   getBitmapInitializedEncoder,
+  getClaimMapAddress,
   getClaimTokensDiscriminatorBytes,
   getClaimTokensInstruction,
   getClaimTokensInstructionDataCodec,
@@ -1861,27 +2725,35 @@ function getTokensDepositedCodec() {
   getClaimTokensInstructionDataEncoder,
   getCloseAirdropDiscriminatorBytes,
   getCloseAirdropInstruction,
+  getCloseAirdropInstructionAsync,
   getCloseAirdropInstructionDataCodec,
   getCloseAirdropInstructionDataDecoder,
   getCloseAirdropInstructionDataEncoder,
   getCloseBitmapDiscriminatorBytes,
   getCloseBitmapInstruction,
+  getCloseBitmapInstructionAsync,
   getCloseBitmapInstructionDataCodec,
   getCloseBitmapInstructionDataDecoder,
   getCloseBitmapInstructionDataEncoder,
   getControllerCodec,
   getControllerDecoder,
+  getControllerDerivedAddress,
   getControllerDiscriminatorBytes,
   getControllerEncoder,
   getControllerInitializedCodec,
   getControllerInitializedDecoder,
   getControllerInitializedEncoder,
+  getControllerVaultAddress,
   getDepositTokensDiscriminatorBytes,
   getDepositTokensInstruction,
   getDepositTokensInstructionDataCodec,
   getDepositTokensInstructionDataDecoder,
   getDepositTokensInstructionDataEncoder,
+  getDropsyDerivedAddress,
   getDropsyErrorMessage,
+  getFeesCollectedCodec,
+  getFeesCollectedDecoder,
+  getFeesCollectedEncoder,
   getInitializeAirdropDiscriminatorBytes,
   getInitializeAirdropInstruction,
   getInitializeAirdropInstructionAsync,
@@ -1900,9 +2772,34 @@ function getTokensDepositedCodec() {
   getInitializeControllerInstructionDataCodec,
   getInitializeControllerInstructionDataDecoder,
   getInitializeControllerInstructionDataEncoder,
+  getInitializeMasterDiscriminatorBytes,
+  getInitializeMasterInstruction,
+  getInitializeMasterInstructionAsync,
+  getInitializeMasterInstructionDataCodec,
+  getInitializeMasterInstructionDataDecoder,
+  getInitializeMasterInstructionDataEncoder,
+  getMasterCodec,
+  getMasterDecoder,
+  getMasterDerivedAddress,
+  getMasterDiscriminatorBytes,
+  getMasterEncoder,
+  getMasterInitializedCodec,
+  getMasterInitializedDecoder,
+  getMasterInitializedEncoder,
+  getStatsCodec,
+  getStatsDecoder,
+  getStatsDerivedAddress,
+  getStatsDiscriminatorBytes,
+  getStatsEncoder,
   getTokensDepositedCodec,
   getTokensDepositedDecoder,
   getTokensDepositedEncoder,
+  getWithdrawControllerFeesDiscriminatorBytes,
+  getWithdrawControllerFeesInstruction,
+  getWithdrawControllerFeesInstructionAsync,
+  getWithdrawControllerFeesInstructionDataCodec,
+  getWithdrawControllerFeesInstructionDataDecoder,
+  getWithdrawControllerFeesInstructionDataEncoder,
   identifyDropsyAccount,
   identifyDropsyInstruction,
   isDropsyError,
@@ -1912,5 +2809,8 @@ function getTokensDepositedCodec() {
   parseDepositTokensInstruction,
   parseInitializeAirdropInstruction,
   parseInitializeBitmapInstruction,
-  parseInitializeControllerInstruction
+  parseInitializeControllerInstruction,
+  parseInitializeMasterInstruction,
+  parseWithdrawControllerFeesInstruction
 });
+//# sourceMappingURL=index.js.map