@dropsy/airdrop 0.0.1 → 0.1.0

package/dist/index.mjs

@@ -1,43 +1,3 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
-
 // src/accounts/airdrop.ts
 import {
   assertAccountExists,
@@ -81,9 +41,8 @@ function getAirdropEncoder() {
   return transformEncoder(
     getStructEncoder([
       ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
-      ["id", getU64Encoder()],
+      ["authority", getAddressEncoder()],
       ["mint", getAddressEncoder()],
-      ["owner", getAddressEncoder()],
       ["controller", getAddressEncoder()],
       ["supply", getU64Encoder()],
       ["merkleRoot", getArrayEncoder(getU8Encoder(), { size: 32 })],
@@ -93,15 +52,14 @@ function getAirdropEncoder() {
       ["version", getU8Encoder()],
       ["bump", getU8Encoder()]
     ]),
-    (value) => __spreadProps(__spreadValues({}, value), { discriminator: AIRDROP_DISCRIMINATOR })
+    (value) => ({ ...value, discriminator: AIRDROP_DISCRIMINATOR })
   );
 }
 function getAirdropDecoder() {
   return getStructDecoder([
     ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
-    ["id", getU64Decoder()],
+    ["authority", getAddressDecoder()],
     ["mint", getAddressDecoder()],
-    ["owner", getAddressDecoder()],
     ["controller", getAddressDecoder()],
     ["supply", getU64Decoder()],
     ["merkleRoot", getArrayDecoder(getU8Decoder(), { size: 32 })],
@@ -121,31 +79,23 @@ function decodeAirdrop(encodedAccount) {
     getAirdropDecoder()
   );
 }
-function fetchAirdrop(rpc, address, config) {
-  return __async(this, null, function* () {
-    const maybeAccount = yield fetchMaybeAirdrop(rpc, address, config);
-    assertAccountExists(maybeAccount);
-    return maybeAccount;
-  });
+async function fetchAirdrop(rpc, address, config) {
+  const maybeAccount = await fetchMaybeAirdrop(rpc, address, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
 }
-function fetchMaybeAirdrop(rpc, address, config) {
-  return __async(this, null, function* () {
-    const maybeAccount = yield fetchEncodedAccount(rpc, address, config);
-    return decodeAirdrop(maybeAccount);
-  });
+async function fetchMaybeAirdrop(rpc, address, config) {
+  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  return decodeAirdrop(maybeAccount);
 }
-function fetchAllAirdrop(rpc, addresses, config) {
-  return __async(this, null, function* () {
-    const maybeAccounts = yield fetchAllMaybeAirdrop(rpc, addresses, config);
-    assertAccountsExist(maybeAccounts);
-    return maybeAccounts;
-  });
+async function fetchAllAirdrop(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeAirdrop(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
 }
-function fetchAllMaybeAirdrop(rpc, addresses, config) {
-  return __async(this, null, function* () {
-    const maybeAccounts = yield fetchEncodedAccounts(rpc, addresses, config);
-    return maybeAccounts.map((maybeAccount) => decodeAirdrop(maybeAccount));
-  });
+async function fetchAllMaybeAirdrop(rpc, addresses, config) {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeAirdrop(maybeAccount));
 }
 
 // src/accounts/bitmapAccount.ts
@@ -191,7 +141,7 @@ function getBitmapAccountEncoder() {
   return transformEncoder2(
     getStructEncoder2([
       ["discriminator", fixEncoderSize2(getBytesEncoder2(), 8)],
-      ["owner", getAddressEncoder2()],
+      ["authority", getAddressEncoder2()],
       ["airdrop", getAddressEncoder2()],
       [
         "claimedBitmap",
@@ -201,13 +151,13 @@ function getBitmapAccountEncoder() {
       ["version", getU8Encoder2()],
       ["bump", getU8Encoder2()]
     ]),
-    (value) => __spreadProps(__spreadValues({}, value), { discriminator: BITMAP_ACCOUNT_DISCRIMINATOR })
+    (value) => ({ ...value, discriminator: BITMAP_ACCOUNT_DISCRIMINATOR })
   );
 }
 function getBitmapAccountDecoder() {
   return getStructDecoder2([
     ["discriminator", fixDecoderSize2(getBytesDecoder2(), 8)],
-    ["owner", getAddressDecoder2()],
+    ["authority", getAddressDecoder2()],
     ["airdrop", getAddressDecoder2()],
     ["claimedBitmap", addDecoderSizePrefix(getBytesDecoder2(), getU32Decoder())],
     ["id", getU8Decoder2()],
@@ -224,35 +174,27 @@ function decodeBitmapAccount(encodedAccount) {
     getBitmapAccountDecoder()
   );
 }
-function fetchBitmapAccount(rpc, address, config) {
-  return __async(this, null, function* () {
-    const maybeAccount = yield fetchMaybeBitmapAccount(rpc, address, config);
-    assertAccountExists2(maybeAccount);
-    return maybeAccount;
-  });
+async function fetchBitmapAccount(rpc, address, config) {
+  const maybeAccount = await fetchMaybeBitmapAccount(rpc, address, config);
+  assertAccountExists2(maybeAccount);
+  return maybeAccount;
 }
-function fetchMaybeBitmapAccount(rpc, address, config) {
-  return __async(this, null, function* () {
-    const maybeAccount = yield fetchEncodedAccount2(rpc, address, config);
-    return decodeBitmapAccount(maybeAccount);
-  });
+async function fetchMaybeBitmapAccount(rpc, address, config) {
+  const maybeAccount = await fetchEncodedAccount2(rpc, address, config);
+  return decodeBitmapAccount(maybeAccount);
 }
-function fetchAllBitmapAccount(rpc, addresses, config) {
-  return __async(this, null, function* () {
-    const maybeAccounts = yield fetchAllMaybeBitmapAccount(
-      rpc,
-      addresses,
-      config
-    );
-    assertAccountsExist2(maybeAccounts);
-    return maybeAccounts;
-  });
+async function fetchAllBitmapAccount(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeBitmapAccount(
+    rpc,
+    addresses,
+    config
+  );
+  assertAccountsExist2(maybeAccounts);
+  return maybeAccounts;
 }
-function fetchAllMaybeBitmapAccount(rpc, addresses, config) {
-  return __async(this, null, function* () {
-    const maybeAccounts = yield fetchEncodedAccounts2(rpc, addresses, config);
-    return maybeAccounts.map((maybeAccount) => decodeBitmapAccount(maybeAccount));
-  });
+async function fetchAllMaybeBitmapAccount(rpc, addresses, config) {
+  const maybeAccounts = await fetchEncodedAccounts2(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeBitmapAccount(maybeAccount));
 }
 
 // src/accounts/controller.ts
@@ -296,12 +238,12 @@ function getControllerEncoder() {
       ["discriminator", fixEncoderSize3(getBytesEncoder3(), 8)],
       ["authority", getAddressEncoder3()],
       ["feeVault", getAddressEncoder3()],
-      ["createFee", getU64Encoder2()],
-      ["claimFee", getU64Encoder2()],
+      ["feeLamports", getU64Encoder2()],
       ["version", getU8Encoder3()],
-      ["bump", getU8Encoder3()]
+      ["bump", getU8Encoder3()],
+      ["feeVaultBump", getU8Encoder3()]
     ]),
-    (value) => __spreadProps(__spreadValues({}, value), { discriminator: CONTROLLER_DISCRIMINATOR })
+    (value) => ({ ...value, discriminator: CONTROLLER_DISCRIMINATOR })
   );
 }
 function getControllerDecoder() {
@@ -309,10 +251,10 @@ function getControllerDecoder() {
     ["discriminator", fixDecoderSize3(getBytesDecoder3(), 8)],
     ["authority", getAddressDecoder3()],
     ["feeVault", getAddressDecoder3()],
-    ["createFee", getU64Decoder2()],
-    ["claimFee", getU64Decoder2()],
+    ["feeLamports", getU64Decoder2()],
     ["version", getU8Decoder3()],
-    ["bump", getU8Decoder3()]
+    ["bump", getU8Decoder3()],
+    ["feeVaultBump", getU8Decoder3()]
   ]);
 }
 function getControllerCodec() {
@@ -324,31 +266,199 @@ function decodeController(encodedAccount) {
     getControllerDecoder()
   );
 }
-function fetchController(rpc, address, config) {
-  return __async(this, null, function* () {
-    const maybeAccount = yield fetchMaybeController(rpc, address, config);
-    assertAccountExists3(maybeAccount);
-    return maybeAccount;
-  });
+async function fetchController(rpc, address, config) {
+  const maybeAccount = await fetchMaybeController(rpc, address, config);
+  assertAccountExists3(maybeAccount);
+  return maybeAccount;
 }
-function fetchMaybeController(rpc, address, config) {
-  return __async(this, null, function* () {
-    const maybeAccount = yield fetchEncodedAccount3(rpc, address, config);
-    return decodeController(maybeAccount);
-  });
+async function fetchMaybeController(rpc, address, config) {
+  const maybeAccount = await fetchEncodedAccount3(rpc, address, config);
+  return decodeController(maybeAccount);
 }
-function fetchAllController(rpc, addresses, config) {
-  return __async(this, null, function* () {
-    const maybeAccounts = yield fetchAllMaybeController(rpc, addresses, config);
-    assertAccountsExist3(maybeAccounts);
-    return maybeAccounts;
-  });
+async function fetchAllController(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeController(rpc, addresses, config);
+  assertAccountsExist3(maybeAccounts);
+  return maybeAccounts;
 }
-function fetchAllMaybeController(rpc, addresses, config) {
-  return __async(this, null, function* () {
-    const maybeAccounts = yield fetchEncodedAccounts3(rpc, addresses, config);
-    return maybeAccounts.map((maybeAccount) => decodeController(maybeAccount));
-  });
+async function fetchAllMaybeController(rpc, addresses, config) {
+  const maybeAccounts = await fetchEncodedAccounts3(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeController(maybeAccount));
+}
+
+// src/accounts/master.ts
+import {
+  assertAccountExists as assertAccountExists4,
+  assertAccountsExist as assertAccountsExist4,
+  combineCodec as combineCodec4,
+  decodeAccount as decodeAccount4,
+  fetchEncodedAccount as fetchEncodedAccount4,
+  fetchEncodedAccounts as fetchEncodedAccounts4,
+  fixDecoderSize as fixDecoderSize4,
+  fixEncoderSize as fixEncoderSize4,
+  getAddressDecoder as getAddressDecoder4,
+  getAddressEncoder as getAddressEncoder4,
+  getBytesDecoder as getBytesDecoder4,
+  getBytesEncoder as getBytesEncoder4,
+  getStructDecoder as getStructDecoder4,
+  getStructEncoder as getStructEncoder4,
+  getU64Decoder as getU64Decoder3,
+  getU64Encoder as getU64Encoder3,
+  getU8Decoder as getU8Decoder4,
+  getU8Encoder as getU8Encoder4,
+  transformEncoder as transformEncoder4
+} from "@solana/kit";
+var MASTER_DISCRIMINATOR = new Uint8Array([
+  168,
+  213,
+  193,
+  12,
+  77,
+  162,
+  58,
+  235
+]);
+function getMasterDiscriminatorBytes() {
+  return fixEncoderSize4(getBytesEncoder4(), 8).encode(MASTER_DISCRIMINATOR);
+}
+function getMasterEncoder() {
+  return transformEncoder4(
+    getStructEncoder4([
+      ["discriminator", fixEncoderSize4(getBytesEncoder4(), 8)],
+      ["authority", getAddressEncoder4()],
+      ["feeVault", getAddressEncoder4()],
+      ["protocolFee", getU64Encoder3()],
+      ["withdrawFee", getU64Encoder3()],
+      ["initControllerFee", getU64Encoder3()],
+      ["version", getU8Encoder4()],
+      ["bump", getU8Encoder4()]
+    ]),
+    (value) => ({ ...value, discriminator: MASTER_DISCRIMINATOR })
+  );
+}
+function getMasterDecoder() {
+  return getStructDecoder4([
+    ["discriminator", fixDecoderSize4(getBytesDecoder4(), 8)],
+    ["authority", getAddressDecoder4()],
+    ["feeVault", getAddressDecoder4()],
+    ["protocolFee", getU64Decoder3()],
+    ["withdrawFee", getU64Decoder3()],
+    ["initControllerFee", getU64Decoder3()],
+    ["version", getU8Decoder4()],
+    ["bump", getU8Decoder4()]
+  ]);
+}
+function getMasterCodec() {
+  return combineCodec4(getMasterEncoder(), getMasterDecoder());
+}
+function decodeMaster(encodedAccount) {
+  return decodeAccount4(
+    encodedAccount,
+    getMasterDecoder()
+  );
+}
+async function fetchMaster(rpc, address, config) {
+  const maybeAccount = await fetchMaybeMaster(rpc, address, config);
+  assertAccountExists4(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeMaster(rpc, address, config) {
+  const maybeAccount = await fetchEncodedAccount4(rpc, address, config);
+  return decodeMaster(maybeAccount);
+}
+async function fetchAllMaster(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeMaster(rpc, addresses, config);
+  assertAccountsExist4(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeMaster(rpc, addresses, config) {
+  const maybeAccounts = await fetchEncodedAccounts4(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeMaster(maybeAccount));
+}
+
+// src/accounts/stats.ts
+import {
+  assertAccountExists as assertAccountExists5,
+  assertAccountsExist as assertAccountsExist5,
+  combineCodec as combineCodec5,
+  decodeAccount as decodeAccount5,
+  fetchEncodedAccount as fetchEncodedAccount5,
+  fetchEncodedAccounts as fetchEncodedAccounts5,
+  fixDecoderSize as fixDecoderSize5,
+  fixEncoderSize as fixEncoderSize5,
+  getBytesDecoder as getBytesDecoder5,
+  getBytesEncoder as getBytesEncoder5,
+  getStructDecoder as getStructDecoder5,
+  getStructEncoder as getStructEncoder5,
+  getU64Decoder as getU64Decoder4,
+  getU64Encoder as getU64Encoder4,
+  getU8Decoder as getU8Decoder5,
+  getU8Encoder as getU8Encoder5,
+  transformEncoder as transformEncoder5
+} from "@solana/kit";
+var STATS_DISCRIMINATOR = new Uint8Array([
+  190,
+  125,
+  51,
+  63,
+  169,
+  197,
+  36,
+  238
+]);
+function getStatsDiscriminatorBytes() {
+  return fixEncoderSize5(getBytesEncoder5(), 8).encode(STATS_DISCRIMINATOR);
+}
+function getStatsEncoder() {
+  return transformEncoder5(
+    getStructEncoder5([
+      ["discriminator", fixEncoderSize5(getBytesEncoder5(), 8)],
+      ["initializedControllers", getU64Encoder4()],
+      ["initializedAirdrops", getU64Encoder4()],
+      ["initializedClaimMaps", getU64Encoder4()],
+      ["closedAirdrops", getU64Encoder4()],
+      ["closedClaimMap", getU64Encoder4()],
+      ["bump", getU8Encoder5()]
+    ]),
+    (value) => ({ ...value, discriminator: STATS_DISCRIMINATOR })
+  );
+}
+function getStatsDecoder() {
+  return getStructDecoder5([
+    ["discriminator", fixDecoderSize5(getBytesDecoder5(), 8)],
+    ["initializedControllers", getU64Decoder4()],
+    ["initializedAirdrops", getU64Decoder4()],
+    ["initializedClaimMaps", getU64Decoder4()],
+    ["closedAirdrops", getU64Decoder4()],
+    ["closedClaimMap", getU64Decoder4()],
+    ["bump", getU8Decoder5()]
+  ]);
+}
+function getStatsCodec() {
+  return combineCodec5(getStatsEncoder(), getStatsDecoder());
+}
+function decodeStats(encodedAccount) {
+  return decodeAccount5(
+    encodedAccount,
+    getStatsDecoder()
+  );
+}
+async function fetchStats(rpc, address, config) {
+  const maybeAccount = await fetchMaybeStats(rpc, address, config);
+  assertAccountExists5(maybeAccount);
+  return maybeAccount;
+}
+async function fetchMaybeStats(rpc, address, config) {
+  const maybeAccount = await fetchEncodedAccount5(rpc, address, config);
+  return decodeStats(maybeAccount);
+}
+async function fetchAllStats(rpc, addresses, config) {
+  const maybeAccounts = await fetchAllMaybeStats(rpc, addresses, config);
+  assertAccountsExist5(maybeAccounts);
+  return maybeAccounts;
+}
+async function fetchAllMaybeStats(rpc, addresses, config) {
+  const maybeAccounts = await fetchEncodedAccounts5(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeStats(maybeAccount));
 }
 
 // src/errors/dropsy.ts
@@ -359,21 +469,23 @@ import {
 // src/programs/dropsy.ts
 import {
   containsBytes,
-  fixEncoderSize as fixEncoderSize4,
-  getBytesEncoder as getBytesEncoder4
+  fixEncoderSize as fixEncoderSize6,
+  getBytesEncoder as getBytesEncoder6
 } from "@solana/kit";
-var DROPSY_PROGRAM_ADDRESS = "DropyEMekkCgKmsWiJVcTCAEeFgvHpDAW19ipWebFaPv";
+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 (containsBytes(
     data,
-    fixEncoderSize4(getBytesEncoder4(), 8).encode(
+    fixEncoderSize6(getBytesEncoder6(), 8).encode(
       new Uint8Array([31, 112, 159, 158, 124, 237, 9, 241])
     ),
     0
@@ -382,7 +494,7 @@ function identifyDropsyAccount(account) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize4(getBytesEncoder4(), 8).encode(
+    fixEncoderSize6(getBytesEncoder6(), 8).encode(
       new Uint8Array([152, 161, 147, 85, 213, 38, 59, 48])
     ),
     0
@@ -391,13 +503,31 @@ function identifyDropsyAccount(account) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize4(getBytesEncoder4(), 8).encode(
+    fixEncoderSize6(getBytesEncoder6(), 8).encode(
       new Uint8Array([184, 79, 171, 0, 183, 43, 113, 110])
     ),
     0
   )) {
     return 2 /* Controller */;
   }
+  if (containsBytes(
+    data,
+    fixEncoderSize6(getBytesEncoder6(), 8).encode(
+      new Uint8Array([168, 213, 193, 12, 77, 162, 58, 235])
+    ),
+    0
+  )) {
+    return 3 /* Master */;
+  }
+  if (containsBytes(
+    data,
+    fixEncoderSize6(getBytesEncoder6(), 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."
   );
@@ -410,13 +540,15 @@ 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 (containsBytes(
     data,
-    fixEncoderSize4(getBytesEncoder4(), 8).encode(
+    fixEncoderSize6(getBytesEncoder6(), 8).encode(
       new Uint8Array([108, 216, 210, 231, 0, 212, 42, 64])
     ),
     0
@@ -425,7 +557,7 @@ function identifyDropsyInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize4(getBytesEncoder4(), 8).encode(
+    fixEncoderSize6(getBytesEncoder6(), 8).encode(
       new Uint8Array([85, 138, 99, 129, 104, 203, 94, 4])
     ),
     0
@@ -434,7 +566,7 @@ function identifyDropsyInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize4(getBytesEncoder4(), 8).encode(
+    fixEncoderSize6(getBytesEncoder6(), 8).encode(
       new Uint8Array([59, 123, 115, 204, 163, 227, 37, 118])
     ),
     0
@@ -443,7 +575,7 @@ function identifyDropsyInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize4(getBytesEncoder4(), 8).encode(
+    fixEncoderSize6(getBytesEncoder6(), 8).encode(
       new Uint8Array([176, 83, 229, 18, 191, 143, 176, 150])
     ),
     0
@@ -452,7 +584,7 @@ function identifyDropsyInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize4(getBytesEncoder4(), 8).encode(
+    fixEncoderSize6(getBytesEncoder6(), 8).encode(
       new Uint8Array([96, 196, 74, 102, 61, 195, 48, 184])
     ),
     0
@@ -461,7 +593,7 @@ function identifyDropsyInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize4(getBytesEncoder4(), 8).encode(
+    fixEncoderSize6(getBytesEncoder6(), 8).encode(
       new Uint8Array([25, 109, 200, 45, 209, 118, 74, 69])
     ),
     0
@@ -470,13 +602,31 @@ function identifyDropsyInstruction(instruction) {
   }
   if (containsBytes(
     data,
-    fixEncoderSize4(getBytesEncoder4(), 8).encode(
+    fixEncoderSize6(getBytesEncoder6(), 8).encode(
       new Uint8Array([137, 255, 100, 190, 201, 247, 241, 81])
     ),
     0
   )) {
     return 6 /* InitializeController */;
   }
+  if (containsBytes(
+    data,
+    fixEncoderSize6(getBytesEncoder6(), 8).encode(
+      new Uint8Array([206, 91, 246, 30, 216, 101, 134, 166])
+    ),
+    0
+  )) {
+    return 7 /* InitializeMaster */;
+  }
+  if (containsBytes(
+    data,
+    fixEncoderSize6(getBytesEncoder6(), 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."
   );
@@ -607,20 +757,20 @@ function isDropsyError(error, transactionMessage, code) {
 
 // src/instructions/claimTokens.ts
 import {
-  combineCodec as combineCodec4,
-  fixDecoderSize as fixDecoderSize4,
-  fixEncoderSize as fixEncoderSize5,
+  combineCodec as combineCodec6,
+  fixDecoderSize as fixDecoderSize6,
+  fixEncoderSize as fixEncoderSize7,
   getArrayDecoder as getArrayDecoder2,
   getArrayEncoder as getArrayEncoder2,
-  getBytesDecoder as getBytesDecoder4,
-  getBytesEncoder as getBytesEncoder5,
-  getStructDecoder as getStructDecoder4,
-  getStructEncoder as getStructEncoder4,
-  getU64Decoder as getU64Decoder3,
-  getU64Encoder as getU64Encoder3,
-  getU8Decoder as getU8Decoder4,
-  getU8Encoder as getU8Encoder4,
-  transformEncoder as transformEncoder4
+  getBytesDecoder as getBytesDecoder6,
+  getBytesEncoder as getBytesEncoder7,
+  getStructDecoder as getStructDecoder6,
+  getStructEncoder as getStructEncoder6,
+  getU64Decoder as getU64Decoder5,
+  getU64Encoder as getU64Encoder5,
+  getU8Decoder as getU8Decoder6,
+  getU8Encoder as getU8Encoder6,
+  transformEncoder as transformEncoder6
 } from "@solana/kit";
 
 // src/shared/index.ts
@@ -658,10 +808,11 @@ function getAccountMetaFactory(programAddress, optionalAccountStrategy) {
       });
     }
     const writableRole = account.isWritable ? AccountRole.WRITABLE : AccountRole.READONLY;
-    return Object.freeze(__spreadValues({
+    return Object.freeze({
       address: expectAddress(account.value),
-      role: isTransactionSigner(account.value) ? upgradeRoleToSigner(writableRole) : writableRole
-    }, isTransactionSigner(account.value) ? { signer: account.value } : {}));
+      role: isTransactionSigner(account.value) ? upgradeRoleToSigner(writableRole) : writableRole,
+      ...isTransactionSigner(account.value) ? { signer: account.value } : {}
+    });
   };
 }
 function isTransactionSigner(value) {
@@ -680,56 +831,53 @@ var CLAIM_TOKENS_DISCRIMINATOR = new Uint8Array([
   64
 ]);
 function getClaimTokensDiscriminatorBytes() {
-  return fixEncoderSize5(getBytesEncoder5(), 8).encode(
+  return fixEncoderSize7(getBytesEncoder7(), 8).encode(
     CLAIM_TOKENS_DISCRIMINATOR
   );
 }
 function getClaimTokensInstructionDataEncoder() {
-  return transformEncoder4(
-    getStructEncoder4([
-      ["discriminator", fixEncoderSize5(getBytesEncoder5(), 8)],
-      ["index", getU64Encoder3()],
-      ["proof", getArrayEncoder2(getArrayEncoder2(getU8Encoder4(), { size: 32 }))],
-      ["amount", getU64Encoder3()]
+  return transformEncoder6(
+    getStructEncoder6([
+      ["discriminator", fixEncoderSize7(getBytesEncoder7(), 8)],
+      ["index", getU64Encoder5()],
+      ["proof", getArrayEncoder2(getArrayEncoder2(getU8Encoder6(), { size: 32 }))],
+      ["amount", getU64Encoder5()]
     ]),
-    (value) => __spreadProps(__spreadValues({}, value), { discriminator: CLAIM_TOKENS_DISCRIMINATOR })
+    (value) => ({ ...value, discriminator: CLAIM_TOKENS_DISCRIMINATOR })
   );
 }
 function getClaimTokensInstructionDataDecoder() {
-  return getStructDecoder4([
-    ["discriminator", fixDecoderSize4(getBytesDecoder4(), 8)],
-    ["index", getU64Decoder3()],
-    ["proof", getArrayDecoder2(getArrayDecoder2(getU8Decoder4(), { size: 32 }))],
-    ["amount", getU64Decoder3()]
+  return getStructDecoder6([
+    ["discriminator", fixDecoderSize6(getBytesDecoder6(), 8)],
+    ["index", getU64Decoder5()],
+    ["proof", getArrayDecoder2(getArrayDecoder2(getU8Decoder6(), { size: 32 }))],
+    ["amount", getU64Decoder5()]
   ]);
 }
 function getClaimTokensInstructionDataCodec() {
-  return combineCodec4(
+  return combineCodec6(
     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";
   }
@@ -747,8 +895,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),
@@ -762,7 +908,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;
@@ -779,8 +925,6 @@ function parseClaimTokensInstruction(instruction) {
       airdrop: getNextAccount(),
       bitmap: getNextAccount(),
       mint: getNextAccount(),
-      feeVault: getNextAccount(),
-      controller: getNextAccount(),
       claimer: getNextAccount(),
       treasury: getNextAccount(),
       tokenProgram: getNextAccount(),
@@ -792,14 +936,16 @@ function parseClaimTokensInstruction(instruction) {
 
 // src/instructions/closeAirdrop.ts
 import {
-  combineCodec as combineCodec5,
-  fixDecoderSize as fixDecoderSize5,
-  fixEncoderSize as fixEncoderSize6,
-  getBytesDecoder as getBytesDecoder5,
-  getBytesEncoder as getBytesEncoder6,
-  getStructDecoder as getStructDecoder5,
-  getStructEncoder as getStructEncoder5,
-  transformEncoder as transformEncoder5
+  combineCodec as combineCodec7,
+  fixDecoderSize as fixDecoderSize7,
+  fixEncoderSize as fixEncoderSize8,
+  getAddressEncoder as getAddressEncoder5,
+  getBytesDecoder as getBytesDecoder7,
+  getBytesEncoder as getBytesEncoder8,
+  getProgramDerivedAddress,
+  getStructDecoder as getStructDecoder7,
+  getStructEncoder as getStructEncoder7,
+  transformEncoder as transformEncoder7
 } from "@solana/kit";
 var CLOSE_AIRDROP_DISCRIMINATOR = new Uint8Array([
   85,
@@ -812,54 +958,124 @@ var CLOSE_AIRDROP_DISCRIMINATOR = new Uint8Array([
   4
 ]);
 function getCloseAirdropDiscriminatorBytes() {
-  return fixEncoderSize6(getBytesEncoder6(), 8).encode(
+  return fixEncoderSize8(getBytesEncoder8(), 8).encode(
     CLOSE_AIRDROP_DISCRIMINATOR
   );
 }
 function getCloseAirdropInstructionDataEncoder() {
-  return transformEncoder5(
-    getStructEncoder5([["discriminator", fixEncoderSize6(getBytesEncoder6(), 8)]]),
-    (value) => __spreadProps(__spreadValues({}, value), { discriminator: CLOSE_AIRDROP_DISCRIMINATOR })
+  return transformEncoder7(
+    getStructEncoder7([["discriminator", fixEncoderSize8(getBytesEncoder8(), 8)]]),
+    (value) => ({ ...value, discriminator: CLOSE_AIRDROP_DISCRIMINATOR })
   );
 }
 function getCloseAirdropInstructionDataDecoder() {
-  return getStructDecoder5([
-    ["discriminator", fixDecoderSize5(getBytesDecoder5(), 8)]
+  return getStructDecoder7([
+    ["discriminator", fixDecoderSize7(getBytesDecoder7(), 8)]
   ]);
 }
 function getCloseAirdropInstructionDataCodec() {
-  return combineCodec5(
+  return combineCodec7(
     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 getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        getBytesEncoder8().encode(new Uint8Array([115, 116, 97, 116, 115]))
+      ]
+    });
+  }
+  if (!accounts.feeVault.value) {
+    accounts.feeVault.value = await getProgramDerivedAddress({
+      programAddress,
+      seeds: [
+        getBytesEncoder8().encode(new Uint8Array([118, 97, 117, 108, 116])),
+        getAddressEncoder5().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({})
@@ -867,7 +1083,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;
@@ -879,12 +1095,16 @@ 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)
   };
@@ -892,14 +1112,15 @@ function parseCloseAirdropInstruction(instruction) {
 
 // src/instructions/closeBitmap.ts
 import {
-  combineCodec as combineCodec6,
-  fixDecoderSize as fixDecoderSize6,
-  fixEncoderSize as fixEncoderSize7,
-  getBytesDecoder as getBytesDecoder6,
-  getBytesEncoder as getBytesEncoder7,
-  getStructDecoder as getStructDecoder6,
-  getStructEncoder as getStructEncoder6,
-  transformEncoder as transformEncoder6
+  combineCodec as combineCodec8,
+  fixDecoderSize as fixDecoderSize8,
+  fixEncoderSize as fixEncoderSize9,
+  getBytesDecoder as getBytesDecoder8,
+  getBytesEncoder as getBytesEncoder9,
+  getProgramDerivedAddress as getProgramDerivedAddress2,
+  getStructDecoder as getStructDecoder8,
+  getStructEncoder as getStructEncoder8,
+  transformEncoder as transformEncoder8
 } from "@solana/kit";
 var CLOSE_BITMAP_DISCRIMINATOR = new Uint8Array([
   59,
@@ -912,50 +1133,115 @@ var CLOSE_BITMAP_DISCRIMINATOR = new Uint8Array([
   118
 ]);
 function getCloseBitmapDiscriminatorBytes() {
-  return fixEncoderSize7(getBytesEncoder7(), 8).encode(
+  return fixEncoderSize9(getBytesEncoder9(), 8).encode(
     CLOSE_BITMAP_DISCRIMINATOR
   );
 }
 function getCloseBitmapInstructionDataEncoder() {
-  return transformEncoder6(
-    getStructEncoder6([["discriminator", fixEncoderSize7(getBytesEncoder7(), 8)]]),
-    (value) => __spreadProps(__spreadValues({}, value), { discriminator: CLOSE_BITMAP_DISCRIMINATOR })
+  return transformEncoder8(
+    getStructEncoder8([["discriminator", fixEncoderSize9(getBytesEncoder9(), 8)]]),
+    (value) => ({ ...value, discriminator: CLOSE_BITMAP_DISCRIMINATOR })
   );
 }
 function getCloseBitmapInstructionDataDecoder() {
-  return getStructDecoder6([
-    ["discriminator", fixDecoderSize6(getBytesDecoder6(), 8)]
+  return getStructDecoder8([
+    ["discriminator", fixDecoderSize8(getBytesDecoder8(), 8)]
   ]);
 }
 function getCloseBitmapInstructionDataCodec() {
-  return combineCodec6(
+  return combineCodec8(
     getCloseBitmapInstructionDataEncoder(),
     getCloseBitmapInstructionDataDecoder()
   );
 }
-function getCloseBitmapInstruction(input, config) {
-  var _a, _b, _c, _d;
-  const programAddress = (_a = config == null ? void 0 : config.programAddress) != null ? _a : DROPSY_PROGRAM_ADDRESS;
+async function getCloseBitmapInstructionAsync(input, config) {
+  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;
-  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
-  const instruction = {
-    accounts: [
-      getAccountMeta(accounts.airdrop),
-      getAccountMeta(accounts.bitmap),
-      getAccountMeta(accounts.owner)
-    ],
-    programAddress,
-    data: getCloseBitmapInstructionDataEncoder().encode({})
-  };
+  if (!accounts.master.value) {
+    accounts.master.value = await getProgramDerivedAddress2({
+      programAddress,
+      seeds: [
+        getBytesEncoder9().encode(
+          new Uint8Array([109, 97, 115, 116, 101, 114, 51])
+        )
+      ]
+    });
+  }
+  if (!accounts.stats.value) {
+    accounts.stats.value = await getProgramDerivedAddress2({
+      programAddress,
+      seeds: [
+        getBytesEncoder9().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) {
+  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.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 parseCloseBitmapInstruction(instruction) {
-  if (instruction.accounts.length < 3) {
+  if (instruction.accounts.length < 7) {
     throw new Error("Not enough accounts");
   }
   let accountIndex = 0;
@@ -967,9 +1253,13 @@ 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)
   };
@@ -977,16 +1267,16 @@ function parseCloseBitmapInstruction(instruction) {
 
 // src/instructions/depositTokens.ts
 import {
-  combineCodec as combineCodec7,
-  fixDecoderSize as fixDecoderSize7,
-  fixEncoderSize as fixEncoderSize8,
-  getBytesDecoder as getBytesDecoder7,
-  getBytesEncoder as getBytesEncoder8,
-  getStructDecoder as getStructDecoder7,
-  getStructEncoder as getStructEncoder7,
-  getU64Decoder as getU64Decoder4,
-  getU64Encoder as getU64Encoder4,
-  transformEncoder as transformEncoder7
+  combineCodec as combineCodec9,
+  fixDecoderSize as fixDecoderSize9,
+  fixEncoderSize as fixEncoderSize10,
+  getBytesDecoder as getBytesDecoder9,
+  getBytesEncoder as getBytesEncoder10,
+  getStructDecoder as getStructDecoder9,
+  getStructEncoder as getStructEncoder9,
+  getU64Decoder as getU64Decoder6,
+  getU64Encoder as getU64Encoder6,
+  transformEncoder as transformEncoder9
 } from "@solana/kit";
 var DEPOSIT_TOKENS_DISCRIMINATOR = new Uint8Array([
   176,
@@ -999,47 +1289,46 @@ var DEPOSIT_TOKENS_DISCRIMINATOR = new Uint8Array([
   150
 ]);
 function getDepositTokensDiscriminatorBytes() {
-  return fixEncoderSize8(getBytesEncoder8(), 8).encode(
+  return fixEncoderSize10(getBytesEncoder10(), 8).encode(
     DEPOSIT_TOKENS_DISCRIMINATOR
   );
 }
 function getDepositTokensInstructionDataEncoder() {
-  return transformEncoder7(
-    getStructEncoder7([
-      ["discriminator", fixEncoderSize8(getBytesEncoder8(), 8)],
-      ["amount", getU64Encoder4()]
+  return transformEncoder9(
+    getStructEncoder9([
+      ["discriminator", fixEncoderSize10(getBytesEncoder10(), 8)],
+      ["amount", getU64Encoder6()]
     ]),
-    (value) => __spreadProps(__spreadValues({}, value), { discriminator: DEPOSIT_TOKENS_DISCRIMINATOR })
+    (value) => ({ ...value, discriminator: DEPOSIT_TOKENS_DISCRIMINATOR })
   );
 }
 function getDepositTokensInstructionDataDecoder() {
-  return getStructDecoder7([
-    ["discriminator", fixDecoderSize7(getBytesDecoder7(), 8)],
-    ["amount", getU64Decoder4()]
+  return getStructDecoder9([
+    ["discriminator", fixDecoderSize9(getBytesDecoder9(), 8)],
+    ["amount", getU64Decoder6()]
   ]);
 }
 function getDepositTokensInstructionDataCodec() {
-  return combineCodec7(
+  return combineCodec9(
     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";
   }
@@ -1050,7 +1339,7 @@ function getDepositTokensInstruction(input, config) {
       getAccountMeta(accounts.vault),
       getAccountMeta(accounts.airdrop),
       getAccountMeta(accounts.mint),
-      getAccountMeta(accounts.owner),
+      getAccountMeta(accounts.authority),
       getAccountMeta(accounts.tokenProgram)
     ],
     programAddress,
@@ -1077,7 +1366,7 @@ function parseDepositTokensInstruction(instruction) {
       vault: getNextAccount(),
       airdrop: getNextAccount(),
       mint: getNextAccount(),
-      owner: getNextAccount(),
+      authority: getNextAccount(),
       tokenProgram: getNextAccount()
     },
     data: getDepositTokensInstructionDataDecoder().decode(instruction.data)
@@ -1086,24 +1375,24 @@ function parseDepositTokensInstruction(instruction) {
 
 // src/instructions/initializeAirdrop.ts
 import {
-  combineCodec as combineCodec8,
-  fixDecoderSize as fixDecoderSize8,
-  fixEncoderSize as fixEncoderSize9,
-  getAddressEncoder as getAddressEncoder4,
+  combineCodec as combineCodec10,
+  fixDecoderSize as fixDecoderSize10,
+  fixEncoderSize as fixEncoderSize11,
+  getAddressEncoder as getAddressEncoder6,
   getArrayDecoder as getArrayDecoder3,
   getArrayEncoder as getArrayEncoder3,
-  getBytesDecoder as getBytesDecoder8,
-  getBytesEncoder as getBytesEncoder9,
+  getBytesDecoder as getBytesDecoder10,
+  getBytesEncoder as getBytesEncoder11,
   getI64Decoder as getI64Decoder2,
   getI64Encoder as getI64Encoder2,
-  getProgramDerivedAddress,
-  getStructDecoder as getStructDecoder8,
-  getStructEncoder as getStructEncoder8,
-  getU64Decoder as getU64Decoder5,
-  getU64Encoder as getU64Encoder5,
-  getU8Decoder as getU8Decoder5,
-  getU8Encoder as getU8Encoder5,
-  transformEncoder as transformEncoder8
+  getOptionDecoder,
+  getOptionEncoder,
+  getProgramDerivedAddress as getProgramDerivedAddress3,
+  getStructDecoder as getStructDecoder10,
+  getStructEncoder as getStructEncoder10,
+  getU8Decoder as getU8Decoder7,
+  getU8Encoder as getU8Encoder7,
+  transformEncoder as transformEncoder10
 } from "@solana/kit";
 var INITIALIZE_AIRDROP_DISCRIMINATOR = new Uint8Array([
   96,
@@ -1116,119 +1405,123 @@ var INITIALIZE_AIRDROP_DISCRIMINATOR = new Uint8Array([
   184
 ]);
 function getInitializeAirdropDiscriminatorBytes() {
-  return fixEncoderSize9(getBytesEncoder9(), 8).encode(
+  return fixEncoderSize11(getBytesEncoder11(), 8).encode(
     INITIALIZE_AIRDROP_DISCRIMINATOR
   );
 }
 function getInitializeAirdropInstructionDataEncoder() {
-  return transformEncoder8(
-    getStructEncoder8([
-      ["discriminator", fixEncoderSize9(getBytesEncoder9(), 8)],
-      ["id", getU64Encoder5()],
-      ["merkleRoot", getArrayEncoder3(getU8Encoder5(), { size: 32 })],
-      ["startsTime", getI64Encoder2()],
-      ["endTime", getI64Encoder2()]
+  return transformEncoder10(
+    getStructEncoder10([
+      ["discriminator", fixEncoderSize11(getBytesEncoder11(), 8)],
+      ["merkleRoot", getArrayEncoder3(getU8Encoder7(), { size: 32 })],
+      ["startsTime", getOptionEncoder(getI64Encoder2())],
+      ["endTime", getOptionEncoder(getI64Encoder2())]
     ]),
-    (value) => __spreadProps(__spreadValues({}, value), { discriminator: INITIALIZE_AIRDROP_DISCRIMINATOR })
+    (value) => ({ ...value, discriminator: INITIALIZE_AIRDROP_DISCRIMINATOR })
   );
 }
 function getInitializeAirdropInstructionDataDecoder() {
-  return getStructDecoder8([
-    ["discriminator", fixDecoderSize8(getBytesDecoder8(), 8)],
-    ["id", getU64Decoder5()],
-    ["merkleRoot", getArrayDecoder3(getU8Decoder5(), { size: 32 })],
-    ["startsTime", getI64Decoder2()],
-    ["endTime", getI64Decoder2()]
+  return getStructDecoder10([
+    ["discriminator", fixDecoderSize10(getBytesDecoder10(), 8)],
+    ["merkleRoot", getArrayDecoder3(getU8Decoder7(), { size: 32 })],
+    ["startsTime", getOptionDecoder(getI64Decoder2())],
+    ["endTime", getOptionDecoder(getI64Decoder2())]
   ]);
 }
 function getInitializeAirdropInstructionDataCodec() {
-  return combineCodec8(
+  return combineCodec10(
     getInitializeAirdropInstructionDataEncoder(),
     getInitializeAirdropInstructionDataDecoder()
   );
 }
-function getInitializeAirdropInstructionAsync(input, config) {
-  return __async(this, null, function* () {
-    var _a, _b, _c, _d, _e, _f, _g, _h;
-    const programAddress = (_a = config == null ? void 0 : config.programAddress) != null ? _a : DROPSY_PROGRAM_ADDRESS;
-    const originalAccounts = {
-      mint: { value: (_b = input.mint) != null ? _b : null, isWritable: false },
-      airdrop: { value: (_c = input.airdrop) != null ? _c : null, isWritable: true },
-      controller: { value: (_d = input.controller) != null ? _d : null, isWritable: true },
-      feeVault: { value: (_e = input.feeVault) != null ? _e : null, isWritable: true },
-      owner: { value: (_f = input.owner) != null ? _f : null, isWritable: true },
-      treasury: { value: (_g = input.treasury) != null ? _g : null, isWritable: true },
-      systemProgram: { value: (_h = input.systemProgram) != null ? _h : null, isWritable: false }
-    };
-    const accounts = originalAccounts;
-    const args = __spreadValues({}, input);
-    if (!accounts.airdrop.value) {
-      accounts.airdrop.value = yield getProgramDerivedAddress({
-        programAddress,
-        seeds: [
-          getBytesEncoder9().encode(
-            new Uint8Array([97, 105, 114, 100, 114, 111, 112])
-          ),
-          getAddressEncoder4().encode(expectAddress(accounts.mint.value)),
-          getAddressEncoder4().encode(expectAddress(accounts.owner.value)),
-          getU64Encoder5().encode(expectSome(args.id))
-        ]
-      });
-    }
-    if (!accounts.treasury.value) {
-      accounts.treasury.value = "DHffy4rNMtuL8VKgyBEay4jcq8AYHyoAzxLKU6aEijUV";
-    }
-    if (!accounts.systemProgram.value) {
-      accounts.systemProgram.value = "11111111111111111111111111111111";
-    }
-    const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
-    const instruction = {
-      accounts: [
-        getAccountMeta(accounts.mint),
-        getAccountMeta(accounts.airdrop),
-        getAccountMeta(accounts.controller),
-        getAccountMeta(accounts.feeVault),
-        getAccountMeta(accounts.owner),
-        getAccountMeta(accounts.treasury),
-        getAccountMeta(accounts.systemProgram)
-      ],
+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 getProgramDerivedAddress3({
       programAddress,
-      data: getInitializeAirdropInstructionDataEncoder().encode(
-        args
-      )
-    };
-    return instruction;
-  });
+      seeds: [
+        getBytesEncoder11().encode(new Uint8Array([115, 116, 97, 116, 115]))
+      ]
+    });
+  }
+  if (!accounts.airdrop.value) {
+    accounts.airdrop.value = await getProgramDerivedAddress3({
+      programAddress,
+      seeds: [
+        getBytesEncoder11().encode(
+          new Uint8Array([97, 105, 114, 100, 114, 111, 112])
+        ),
+        getAddressEncoder6().encode(expectAddress(accounts.mint.value)),
+        getAddressEncoder6().encode(expectAddress(accounts.authority.value))
+      ]
+    });
+  }
+  if (!accounts.feeVault.value) {
+    accounts.feeVault.value = await getProgramDerivedAddress3({
+      programAddress,
+      seeds: [
+        getBytesEncoder11().encode(new Uint8Array([118, 97, 117, 108, 116])),
+        getAddressEncoder6().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,
@@ -1251,12 +1544,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)
@@ -1265,20 +1558,20 @@ function parseInitializeAirdropInstruction(instruction) {
 
 // src/instructions/initializeBitmap.ts
 import {
-  combineCodec as combineCodec9,
-  fixDecoderSize as fixDecoderSize9,
-  fixEncoderSize as fixEncoderSize10,
-  getAddressEncoder as getAddressEncoder5,
-  getBytesDecoder as getBytesDecoder9,
-  getBytesEncoder as getBytesEncoder10,
-  getProgramDerivedAddress as getProgramDerivedAddress2,
-  getStructDecoder as getStructDecoder9,
-  getStructEncoder as getStructEncoder9,
-  getU64Decoder as getU64Decoder6,
-  getU64Encoder as getU64Encoder6,
-  getU8Decoder as getU8Decoder6,
-  getU8Encoder as getU8Encoder6,
-  transformEncoder as transformEncoder9
+  combineCodec as combineCodec11,
+  fixDecoderSize as fixDecoderSize11,
+  fixEncoderSize as fixEncoderSize12,
+  getAddressEncoder as getAddressEncoder7,
+  getBytesDecoder as getBytesDecoder11,
+  getBytesEncoder as getBytesEncoder12,
+  getProgramDerivedAddress as getProgramDerivedAddress4,
+  getStructDecoder as getStructDecoder11,
+  getStructEncoder as getStructEncoder11,
+  getU64Decoder as getU64Decoder7,
+  getU64Encoder as getU64Encoder7,
+  getU8Decoder as getU8Decoder8,
+  getU8Encoder as getU8Encoder8,
+  transformEncoder as transformEncoder11
 } from "@solana/kit";
 var INITIALIZE_BITMAP_DISCRIMINATOR = new Uint8Array([
   25,
@@ -1291,94 +1584,126 @@ var INITIALIZE_BITMAP_DISCRIMINATOR = new Uint8Array([
   69
 ]);
 function getInitializeBitmapDiscriminatorBytes() {
-  return fixEncoderSize10(getBytesEncoder10(), 8).encode(
+  return fixEncoderSize12(getBytesEncoder12(), 8).encode(
     INITIALIZE_BITMAP_DISCRIMINATOR
   );
 }
 function getInitializeBitmapInstructionDataEncoder() {
-  return transformEncoder9(
-    getStructEncoder9([
-      ["discriminator", fixEncoderSize10(getBytesEncoder10(), 8)],
-      ["id", getU8Encoder6()],
-      ["total", getU64Encoder6()]
+  return transformEncoder11(
+    getStructEncoder11([
+      ["discriminator", fixEncoderSize12(getBytesEncoder12(), 8)],
+      ["id", getU8Encoder8()],
+      ["total", getU64Encoder7()]
     ]),
-    (value) => __spreadProps(__spreadValues({}, value), { discriminator: INITIALIZE_BITMAP_DISCRIMINATOR })
+    (value) => ({ ...value, discriminator: INITIALIZE_BITMAP_DISCRIMINATOR })
   );
 }
 function getInitializeBitmapInstructionDataDecoder() {
-  return getStructDecoder9([
-    ["discriminator", fixDecoderSize9(getBytesDecoder9(), 8)],
-    ["id", getU8Decoder6()],
-    ["total", getU64Decoder6()]
+  return getStructDecoder11([
+    ["discriminator", fixDecoderSize11(getBytesDecoder11(), 8)],
+    ["id", getU8Decoder8()],
+    ["total", getU64Decoder7()]
   ]);
 }
 function getInitializeBitmapInstructionDataCodec() {
-  return combineCodec9(
+  return combineCodec11(
     getInitializeBitmapInstructionDataEncoder(),
     getInitializeBitmapInstructionDataDecoder()
   );
 }
-function getInitializeBitmapInstructionAsync(input, config) {
-  return __async(this, null, function* () {
-    var _a, _b, _c, _d, _e;
-    const programAddress = (_a = config == null ? void 0 : config.programAddress) != null ? _a : DROPSY_PROGRAM_ADDRESS;
-    const originalAccounts = {
-      bitmap: { value: (_b = input.bitmap) != null ? _b : null, isWritable: true },
-      airdrop: { value: (_c = input.airdrop) != null ? _c : null, isWritable: true },
-      owner: { value: (_d = input.owner) != null ? _d : null, isWritable: true },
-      systemProgram: { value: (_e = input.systemProgram) != null ? _e : null, isWritable: false }
-    };
-    const accounts = originalAccounts;
-    const args = __spreadValues({}, input);
-    if (!accounts.bitmap.value) {
-      accounts.bitmap.value = yield getProgramDerivedAddress2({
-        programAddress,
-        seeds: [
-          getBytesEncoder10().encode(new Uint8Array([98, 105, 116, 109, 97, 112])),
-          getAddressEncoder5().encode(expectAddress(accounts.airdrop.value)),
-          getU8Encoder6().encode(expectSome(args.id))
-        ]
-      });
-    }
-    if (!accounts.systemProgram.value) {
-      accounts.systemProgram.value = "11111111111111111111111111111111";
-    }
-    const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
-    const instruction = {
-      accounts: [
-        getAccountMeta(accounts.bitmap),
-        getAccountMeta(accounts.airdrop),
-        getAccountMeta(accounts.owner),
-        getAccountMeta(accounts.systemProgram)
-      ],
+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 getProgramDerivedAddress4({
       programAddress,
-      data: getInitializeBitmapInstructionDataEncoder().encode(
-        args
-      )
-    };
-    return instruction;
-  });
+      seeds: [
+        getBytesEncoder12().encode(
+          new Uint8Array([109, 97, 115, 116, 101, 114, 51])
+        )
+      ]
+    });
+  }
+  if (!accounts.stats.value) {
+    accounts.stats.value = await getProgramDerivedAddress4({
+      programAddress,
+      seeds: [
+        getBytesEncoder12().encode(new Uint8Array([115, 116, 97, 116, 115]))
+      ]
+    });
+  }
+  if (!accounts.bitmap.value) {
+    accounts.bitmap.value = await getProgramDerivedAddress4({
+      programAddress,
+      seeds: [
+        getBytesEncoder12().encode(new Uint8Array([98, 105, 116, 109, 97, 112])),
+        getAddressEncoder7().encode(expectAddress(accounts.airdrop.value)),
+        getU8Encoder8().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,
@@ -1389,7 +1714,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;
@@ -1401,9 +1726,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)
@@ -1412,18 +1740,18 @@ function parseInitializeBitmapInstruction(instruction) {
 
 // src/instructions/initializeController.ts
 import {
-  combineCodec as combineCodec10,
-  fixDecoderSize as fixDecoderSize10,
-  fixEncoderSize as fixEncoderSize11,
-  getAddressEncoder as getAddressEncoder6,
-  getBytesDecoder as getBytesDecoder10,
-  getBytesEncoder as getBytesEncoder11,
-  getProgramDerivedAddress as getProgramDerivedAddress3,
-  getStructDecoder as getStructDecoder10,
-  getStructEncoder as getStructEncoder10,
-  getU64Decoder as getU64Decoder7,
-  getU64Encoder as getU64Encoder7,
-  transformEncoder as transformEncoder10
+  combineCodec as combineCodec12,
+  fixDecoderSize as fixDecoderSize12,
+  fixEncoderSize as fixEncoderSize13,
+  getAddressEncoder as getAddressEncoder8,
+  getBytesDecoder as getBytesDecoder12,
+  getBytesEncoder as getBytesEncoder13,
+  getProgramDerivedAddress as getProgramDerivedAddress5,
+  getStructDecoder as getStructDecoder12,
+  getStructEncoder as getStructEncoder12,
+  getU64Decoder as getU64Decoder8,
+  getU64Encoder as getU64Encoder8,
+  transformEncoder as transformEncoder12
 } from "@solana/kit";
 var INITIALIZE_CONTROLLER_DISCRIMINATOR = new Uint8Array([
   137,
@@ -1436,112 +1764,140 @@ var INITIALIZE_CONTROLLER_DISCRIMINATOR = new Uint8Array([
   81
 ]);
 function getInitializeControllerDiscriminatorBytes() {
-  return fixEncoderSize11(getBytesEncoder11(), 8).encode(
+  return fixEncoderSize13(getBytesEncoder13(), 8).encode(
     INITIALIZE_CONTROLLER_DISCRIMINATOR
   );
 }
 function getInitializeControllerInstructionDataEncoder() {
-  return transformEncoder10(
-    getStructEncoder10([
-      ["discriminator", fixEncoderSize11(getBytesEncoder11(), 8)],
-      ["createFee", getU64Encoder7()],
-      ["claimFee", getU64Encoder7()]
+  return transformEncoder12(
+    getStructEncoder12([
+      ["discriminator", fixEncoderSize13(getBytesEncoder13(), 8)],
+      ["feeLamports", getU64Encoder8()]
     ]),
-    (value) => __spreadProps(__spreadValues({}, value), {
+    (value) => ({
+      ...value,
       discriminator: INITIALIZE_CONTROLLER_DISCRIMINATOR
     })
   );
 }
 function getInitializeControllerInstructionDataDecoder() {
-  return getStructDecoder10([
-    ["discriminator", fixDecoderSize10(getBytesDecoder10(), 8)],
-    ["createFee", getU64Decoder7()],
-    ["claimFee", getU64Decoder7()]
+  return getStructDecoder12([
+    ["discriminator", fixDecoderSize12(getBytesDecoder12(), 8)],
+    ["feeLamports", getU64Decoder8()]
   ]);
 }
 function getInitializeControllerInstructionDataCodec() {
-  return combineCodec10(
+  return combineCodec12(
     getInitializeControllerInstructionDataEncoder(),
     getInitializeControllerInstructionDataDecoder()
   );
 }
-function getInitializeControllerInstructionAsync(input, config) {
-  return __async(this, null, function* () {
-    var _a, _b, _c, _d, _e, _f;
-    const programAddress = (_a = config == null ? void 0 : config.programAddress) != null ? _a : DROPSY_PROGRAM_ADDRESS;
-    const originalAccounts = {
-      controller: { value: (_b = input.controller) != null ? _b : null, isWritable: true },
-      feeVault: { value: (_c = input.feeVault) != null ? _c : null, isWritable: false },
-      treasury: { value: (_d = input.treasury) != null ? _d : null, isWritable: true },
-      payer: { value: (_e = input.payer) != null ? _e : null, isWritable: true },
-      systemProgram: { value: (_f = input.systemProgram) != null ? _f : null, isWritable: false }
-    };
-    const accounts = originalAccounts;
-    const args = __spreadValues({}, input);
-    if (!accounts.controller.value) {
-      accounts.controller.value = yield getProgramDerivedAddress3({
-        programAddress,
-        seeds: [
-          getBytesEncoder11().encode(
-            new Uint8Array([
-              99,
-              111,
-              110,
-              116,
-              114,
-              111,
-              108,
-              108,
-              101,
-              114,
-              45,
-              100,
-              114,
-              111,
-              112,
-              115,
-              121
-            ])
-          ),
-          getAddressEncoder6().encode(expectAddress(accounts.payer.value))
-        ]
-      });
-    }
-    if (!accounts.treasury.value) {
-      accounts.treasury.value = "DHffy4rNMtuL8VKgyBEay4jcq8AYHyoAzxLKU6aEijUV";
-    }
-    if (!accounts.systemProgram.value) {
-      accounts.systemProgram.value = "11111111111111111111111111111111";
-    }
-    const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
-    const instruction = {
-      accounts: [
-        getAccountMeta(accounts.controller),
-        getAccountMeta(accounts.feeVault),
-        getAccountMeta(accounts.treasury),
-        getAccountMeta(accounts.payer),
-        getAccountMeta(accounts.systemProgram)
-      ],
+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 getProgramDerivedAddress5({
       programAddress,
-      data: getInitializeControllerInstructionDataEncoder().encode(
-        args
-      )
-    };
-    return instruction;
-  });
+      seeds: [
+        getBytesEncoder13().encode(
+          new Uint8Array([109, 97, 115, 116, 101, 114, 51])
+        )
+      ]
+    });
+  }
+  if (!accounts.stats.value) {
+    accounts.stats.value = await getProgramDerivedAddress5({
+      programAddress,
+      seeds: [
+        getBytesEncoder13().encode(new Uint8Array([115, 116, 97, 116, 115]))
+      ]
+    });
+  }
+  if (!accounts.controller.value) {
+    accounts.controller.value = await getProgramDerivedAddress5({
+      programAddress,
+      seeds: [
+        getBytesEncoder13().encode(
+          new Uint8Array([
+            99,
+            111,
+            110,
+            116,
+            114,
+            111,
+            108,
+            108,
+            101,
+            114,
+            45,
+            100,
+            114,
+            111,
+            112,
+            115,
+            121
+          ])
+        ),
+        getAddressEncoder8().encode(expectAddress(accounts.authority.value))
+      ]
+    });
+  }
+  if (!accounts.feeVault.value) {
+    accounts.feeVault.value = await getProgramDerivedAddress5({
+      programAddress,
+      seeds: [
+        getBytesEncoder13().encode(new Uint8Array([118, 97, 117, 108, 116])),
+        getAddressEncoder8().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";
   }
@@ -1551,10 +1907,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,
@@ -1565,7 +1923,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;
@@ -1577,10 +1935,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(
@@ -1589,76 +1949,435 @@ function parseInitializeControllerInstruction(instruction) {
   };
 }
 
+// src/instructions/initializeMaster.ts
+import {
+  combineCodec as combineCodec13,
+  fixDecoderSize as fixDecoderSize13,
+  fixEncoderSize as fixEncoderSize14,
+  getBytesDecoder as getBytesDecoder13,
+  getBytesEncoder as getBytesEncoder14,
+  getProgramDerivedAddress as getProgramDerivedAddress6,
+  getStructDecoder as getStructDecoder13,
+  getStructEncoder as getStructEncoder13,
+  getU64Decoder as getU64Decoder9,
+  getU64Encoder as getU64Encoder9,
+  transformEncoder as transformEncoder13
+} from "@solana/kit";
+var INITIALIZE_MASTER_DISCRIMINATOR = new Uint8Array([
+  206,
+  91,
+  246,
+  30,
+  216,
+  101,
+  134,
+  166
+]);
+function getInitializeMasterDiscriminatorBytes() {
+  return fixEncoderSize14(getBytesEncoder14(), 8).encode(
+    INITIALIZE_MASTER_DISCRIMINATOR
+  );
+}
+function getInitializeMasterInstructionDataEncoder() {
+  return transformEncoder13(
+    getStructEncoder13([
+      ["discriminator", fixEncoderSize14(getBytesEncoder14(), 8)],
+      ["protocolFee", getU64Encoder9()],
+      ["initControllerFee", getU64Encoder9()],
+      ["withdrawFee", getU64Encoder9()]
+    ]),
+    (value) => ({ ...value, discriminator: INITIALIZE_MASTER_DISCRIMINATOR })
+  );
+}
+function getInitializeMasterInstructionDataDecoder() {
+  return getStructDecoder13([
+    ["discriminator", fixDecoderSize13(getBytesDecoder13(), 8)],
+    ["protocolFee", getU64Decoder9()],
+    ["initControllerFee", getU64Decoder9()],
+    ["withdrawFee", getU64Decoder9()]
+  ]);
+}
+function getInitializeMasterInstructionDataCodec() {
+  return combineCodec13(
+    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 getProgramDerivedAddress6({
+      programAddress,
+      seeds: [
+        getBytesEncoder14().encode(
+          new Uint8Array([109, 97, 115, 116, 101, 114, 51])
+        )
+      ]
+    });
+  }
+  if (!accounts.stats.value) {
+    accounts.stats.value = await getProgramDerivedAddress6({
+      programAddress,
+      seeds: [
+        getBytesEncoder14().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
+import {
+  combineCodec as combineCodec14,
+  fixDecoderSize as fixDecoderSize14,
+  fixEncoderSize as fixEncoderSize15,
+  getAddressEncoder as getAddressEncoder9,
+  getBytesDecoder as getBytesDecoder14,
+  getBytesEncoder as getBytesEncoder15,
+  getProgramDerivedAddress as getProgramDerivedAddress7,
+  getStructDecoder as getStructDecoder14,
+  getStructEncoder as getStructEncoder14,
+  getU64Decoder as getU64Decoder10,
+  getU64Encoder as getU64Encoder10,
+  transformEncoder as transformEncoder14
+} from "@solana/kit";
+var WITHDRAW_CONTROLLER_FEES_DISCRIMINATOR = new Uint8Array([
+  252,
+  199,
+  14,
+  46,
+  100,
+  156,
+  176,
+  230
+]);
+function getWithdrawControllerFeesDiscriminatorBytes() {
+  return fixEncoderSize15(getBytesEncoder15(), 8).encode(
+    WITHDRAW_CONTROLLER_FEES_DISCRIMINATOR
+  );
+}
+function getWithdrawControllerFeesInstructionDataEncoder() {
+  return transformEncoder14(
+    getStructEncoder14([
+      ["discriminator", fixEncoderSize15(getBytesEncoder15(), 8)],
+      ["amount", getU64Encoder10()]
+    ]),
+    (value) => ({
+      ...value,
+      discriminator: WITHDRAW_CONTROLLER_FEES_DISCRIMINATOR
+    })
+  );
+}
+function getWithdrawControllerFeesInstructionDataDecoder() {
+  return getStructDecoder14([
+    ["discriminator", fixDecoderSize14(getBytesDecoder14(), 8)],
+    ["amount", getU64Decoder10()]
+  ]);
+}
+function getWithdrawControllerFeesInstructionDataCodec() {
+  return combineCodec14(
+    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 getProgramDerivedAddress7({
+      programAddress,
+      seeds: [
+        getBytesEncoder15().encode(
+          new Uint8Array([109, 97, 115, 116, 101, 114, 51])
+        )
+      ]
+    });
+  }
+  if (!accounts.controller.value) {
+    accounts.controller.value = await getProgramDerivedAddress7({
+      programAddress,
+      seeds: [
+        getBytesEncoder15().encode(
+          new Uint8Array([
+            99,
+            111,
+            110,
+            116,
+            114,
+            111,
+            108,
+            108,
+            101,
+            114,
+            45,
+            100,
+            114,
+            111,
+            112,
+            115,
+            121
+          ])
+        ),
+        getAddressEncoder9().encode(expectAddress(accounts.authority.value))
+      ]
+    });
+  }
+  if (!accounts.feeVault.value) {
+    accounts.feeVault.value = await getProgramDerivedAddress7({
+      programAddress,
+      seeds: [
+        getBytesEncoder15().encode(new Uint8Array([118, 97, 117, 108, 116])),
+        getAddressEncoder9().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
 import {
-  combineCodec as combineCodec11,
-  getAddressDecoder as getAddressDecoder4,
-  getAddressEncoder as getAddressEncoder7,
+  combineCodec as combineCodec15,
+  getAddressDecoder as getAddressDecoder5,
+  getAddressEncoder as getAddressEncoder10,
   getI64Decoder as getI64Decoder3,
   getI64Encoder as getI64Encoder3,
-  getStructDecoder as getStructDecoder11,
-  getStructEncoder as getStructEncoder11
+  getStructDecoder as getStructDecoder15,
+  getStructEncoder as getStructEncoder15
 } from "@solana/kit";
 function getAirdropClosedEncoder() {
-  return getStructEncoder11([
-    ["airdrop", getAddressEncoder7()],
-    ["owner", getAddressEncoder7()],
+  return getStructEncoder15([
+    ["airdrop", getAddressEncoder10()],
+    ["authority", getAddressEncoder10()],
     ["timestamp", getI64Encoder3()]
   ]);
 }
 function getAirdropClosedDecoder() {
-  return getStructDecoder11([
-    ["airdrop", getAddressDecoder4()],
-    ["owner", getAddressDecoder4()],
+  return getStructDecoder15([
+    ["airdrop", getAddressDecoder5()],
+    ["authority", getAddressDecoder5()],
     ["timestamp", getI64Decoder3()]
   ]);
 }
 function getAirdropClosedCodec() {
-  return combineCodec11(getAirdropClosedEncoder(), getAirdropClosedDecoder());
+  return combineCodec15(getAirdropClosedEncoder(), getAirdropClosedDecoder());
 }
 
 // src/types/airdropInitialized.ts
 import {
-  combineCodec as combineCodec12,
-  getAddressDecoder as getAddressDecoder5,
-  getAddressEncoder as getAddressEncoder8,
+  combineCodec as combineCodec16,
+  getAddressDecoder as getAddressDecoder6,
+  getAddressEncoder as getAddressEncoder11,
   getArrayDecoder as getArrayDecoder4,
   getArrayEncoder as getArrayEncoder4,
   getI64Decoder as getI64Decoder4,
   getI64Encoder as getI64Encoder4,
-  getStructDecoder as getStructDecoder12,
-  getStructEncoder as getStructEncoder12,
-  getU8Decoder as getU8Decoder7,
-  getU8Encoder as getU8Encoder7
+  getStructDecoder as getStructDecoder16,
+  getStructEncoder as getStructEncoder16,
+  getU8Decoder as getU8Decoder9,
+  getU8Encoder as getU8Encoder9
 } from "@solana/kit";
 function getAirdropInitializedEncoder() {
-  return getStructEncoder12([
-    ["airdrop", getAddressEncoder8()],
-    ["mint", getAddressEncoder8()],
-    ["owner", getAddressEncoder8()],
-    ["controller", getAddressEncoder8()],
-    ["controllerAuthority", getAddressEncoder8()],
-    ["merkleRoot", getArrayEncoder4(getU8Encoder7(), { size: 32 })],
+  return getStructEncoder16([
+    ["airdrop", getAddressEncoder11()],
+    ["mint", getAddressEncoder11()],
+    ["authority", getAddressEncoder11()],
+    ["controller", getAddressEncoder11()],
+    ["controllerFeeVault", getAddressEncoder11()],
+    ["merkleRoot", getArrayEncoder4(getU8Encoder9(), { size: 32 })],
     ["startTime", getI64Encoder4()],
     ["endTime", getI64Encoder4()],
     ["timestamp", getI64Encoder4()]
   ]);
 }
 function getAirdropInitializedDecoder() {
-  return getStructDecoder12([
-    ["airdrop", getAddressDecoder5()],
-    ["mint", getAddressDecoder5()],
-    ["owner", getAddressDecoder5()],
-    ["controller", getAddressDecoder5()],
-    ["controllerAuthority", getAddressDecoder5()],
-    ["merkleRoot", getArrayDecoder4(getU8Decoder7(), { size: 32 })],
+  return getStructDecoder16([
+    ["airdrop", getAddressDecoder6()],
+    ["mint", getAddressDecoder6()],
+    ["authority", getAddressDecoder6()],
+    ["controller", getAddressDecoder6()],
+    ["controllerFeeVault", getAddressDecoder6()],
+    ["merkleRoot", getArrayDecoder4(getU8Decoder9(), { size: 32 })],
     ["startTime", getI64Decoder4()],
     ["endTime", getI64Decoder4()],
     ["timestamp", getI64Decoder4()]
   ]);
 }
 function getAirdropInitializedCodec() {
-  return combineCodec12(
+  return combineCodec16(
     getAirdropInitializedEncoder(),
     getAirdropInitializedDecoder()
   );
@@ -1666,60 +2385,60 @@ function getAirdropInitializedCodec() {
 
 // src/types/bitmapClosed.ts
 import {
-  combineCodec as combineCodec13,
-  getAddressDecoder as getAddressDecoder6,
-  getAddressEncoder as getAddressEncoder9,
-  getStructDecoder as getStructDecoder13,
-  getStructEncoder as getStructEncoder13
+  combineCodec as combineCodec17,
+  getAddressDecoder as getAddressDecoder7,
+  getAddressEncoder as getAddressEncoder12,
+  getStructDecoder as getStructDecoder17,
+  getStructEncoder as getStructEncoder17
 } from "@solana/kit";
 function getBitmapClosedEncoder() {
-  return getStructEncoder13([
-    ["airdrop", getAddressEncoder9()],
-    ["bitmap", getAddressEncoder9()],
-    ["owner", getAddressEncoder9()]
+  return getStructEncoder17([
+    ["airdrop", getAddressEncoder12()],
+    ["bitmap", getAddressEncoder12()],
+    ["authority", getAddressEncoder12()]
   ]);
 }
 function getBitmapClosedDecoder() {
-  return getStructDecoder13([
-    ["airdrop", getAddressDecoder6()],
-    ["bitmap", getAddressDecoder6()],
-    ["owner", getAddressDecoder6()]
+  return getStructDecoder17([
+    ["airdrop", getAddressDecoder7()],
+    ["bitmap", getAddressDecoder7()],
+    ["authority", getAddressDecoder7()]
   ]);
 }
 function getBitmapClosedCodec() {
-  return combineCodec13(getBitmapClosedEncoder(), getBitmapClosedDecoder());
+  return combineCodec17(getBitmapClosedEncoder(), getBitmapClosedDecoder());
 }
 
 // src/types/bitmapInitialized.ts
 import {
-  combineCodec as combineCodec14,
-  getAddressDecoder as getAddressDecoder7,
-  getAddressEncoder as getAddressEncoder10,
-  getStructDecoder as getStructDecoder14,
-  getStructEncoder as getStructEncoder14,
-  getU64Decoder as getU64Decoder8,
-  getU64Encoder as getU64Encoder8,
-  getU8Decoder as getU8Decoder8,
-  getU8Encoder as getU8Encoder8
+  combineCodec as combineCodec18,
+  getAddressDecoder as getAddressDecoder8,
+  getAddressEncoder as getAddressEncoder13,
+  getStructDecoder as getStructDecoder18,
+  getStructEncoder as getStructEncoder18,
+  getU64Decoder as getU64Decoder11,
+  getU64Encoder as getU64Encoder11,
+  getU8Decoder as getU8Decoder10,
+  getU8Encoder as getU8Encoder10
 } from "@solana/kit";
 function getBitmapInitializedEncoder() {
-  return getStructEncoder14([
-    ["airdrop", getAddressEncoder10()],
-    ["bitmap", getAddressEncoder10()],
-    ["bitmapId", getU8Encoder8()],
-    ["totalClaims", getU64Encoder8()]
+  return getStructEncoder18([
+    ["airdrop", getAddressEncoder13()],
+    ["bitmap", getAddressEncoder13()],
+    ["bitmapId", getU8Encoder10()],
+    ["totalClaims", getU64Encoder11()]
   ]);
 }
 function getBitmapInitializedDecoder() {
-  return getStructDecoder14([
-    ["airdrop", getAddressDecoder7()],
-    ["bitmap", getAddressDecoder7()],
-    ["bitmapId", getU8Decoder8()],
-    ["totalClaims", getU64Decoder8()]
+  return getStructDecoder18([
+    ["airdrop", getAddressDecoder8()],
+    ["bitmap", getAddressDecoder8()],
+    ["bitmapId", getU8Decoder10()],
+    ["totalClaims", getU64Decoder11()]
   ]);
 }
 function getBitmapInitializedCodec() {
-  return combineCodec14(
+  return combineCodec18(
     getBitmapInitializedEncoder(),
     getBitmapInitializedDecoder()
   );
@@ -1727,77 +2446,248 @@ function getBitmapInitializedCodec() {
 
 // src/types/controllerInitialized.ts
 import {
-  combineCodec as combineCodec15,
-  getAddressDecoder as getAddressDecoder8,
-  getAddressEncoder as getAddressEncoder11,
+  combineCodec as combineCodec19,
+  getAddressDecoder as getAddressDecoder9,
+  getAddressEncoder as getAddressEncoder14,
   getI64Decoder as getI64Decoder5,
   getI64Encoder as getI64Encoder5,
-  getStructDecoder as getStructDecoder15,
-  getStructEncoder as getStructEncoder15,
-  getU64Decoder as getU64Decoder9,
-  getU64Encoder as getU64Encoder9,
-  getU8Decoder as getU8Decoder9,
-  getU8Encoder as getU8Encoder9
+  getStructDecoder as getStructDecoder19,
+  getStructEncoder as getStructEncoder19,
+  getU64Decoder as getU64Decoder12,
+  getU64Encoder as getU64Encoder12,
+  getU8Decoder as getU8Decoder11,
+  getU8Encoder as getU8Encoder11
 } from "@solana/kit";
 function getControllerInitializedEncoder() {
-  return getStructEncoder15([
-    ["authority", getAddressEncoder11()],
-    ["feeVault", getAddressEncoder11()],
-    ["createFee", getU64Encoder9()],
-    ["claimFee", getU64Encoder9()],
-    ["bump", getU8Encoder9()],
+  return getStructEncoder19([
+    ["masterVault", getAddressEncoder14()],
+    ["authority", getAddressEncoder14()],
+    ["feeVault", getAddressEncoder14()],
+    ["feeLamports", getU64Encoder12()],
+    ["bump", getU8Encoder11()],
     ["timestamp", getI64Encoder5()]
   ]);
 }
 function getControllerInitializedDecoder() {
-  return getStructDecoder15([
-    ["authority", getAddressDecoder8()],
-    ["feeVault", getAddressDecoder8()],
-    ["createFee", getU64Decoder9()],
-    ["claimFee", getU64Decoder9()],
-    ["bump", getU8Decoder9()],
+  return getStructDecoder19([
+    ["masterVault", getAddressDecoder9()],
+    ["authority", getAddressDecoder9()],
+    ["feeVault", getAddressDecoder9()],
+    ["feeLamports", getU64Decoder12()],
+    ["bump", getU8Decoder11()],
     ["timestamp", getI64Decoder5()]
   ]);
 }
 function getControllerInitializedCodec() {
-  return combineCodec15(
+  return combineCodec19(
     getControllerInitializedEncoder(),
     getControllerInitializedDecoder()
   );
 }
 
-// src/types/tokensDeposited.ts
+// src/types/feesCollected.ts
 import {
-  combineCodec as combineCodec16,
-  getAddressDecoder as getAddressDecoder9,
-  getAddressEncoder as getAddressEncoder12,
+  combineCodec as combineCodec20,
+  getAddressDecoder as getAddressDecoder10,
+  getAddressEncoder as getAddressEncoder15,
   getI64Decoder as getI64Decoder6,
   getI64Encoder as getI64Encoder6,
-  getStructDecoder as getStructDecoder16,
-  getStructEncoder as getStructEncoder16,
-  getU64Decoder as getU64Decoder10,
-  getU64Encoder as getU64Encoder10
+  getStructDecoder as getStructDecoder20,
+  getStructEncoder as getStructEncoder20,
+  getU64Decoder as getU64Decoder13,
+  getU64Encoder as getU64Encoder13
 } from "@solana/kit";
-function getTokensDepositedEncoder() {
-  return getStructEncoder16([
-    ["airdrop", getAddressEncoder12()],
-    ["amount", getU64Encoder10()],
-    ["newSupply", getU64Encoder10()],
-    ["depositor", getAddressEncoder12()],
+function getFeesCollectedEncoder() {
+  return getStructEncoder20([
+    ["controller", getAddressEncoder15()],
+    ["authority", getAddressEncoder15()],
+    ["feeVault", getAddressEncoder15()],
+    ["amount", getU64Encoder13()],
     ["timestamp", getI64Encoder6()]
   ]);
 }
-function getTokensDepositedDecoder() {
-  return getStructDecoder16([
-    ["airdrop", getAddressDecoder9()],
-    ["amount", getU64Decoder10()],
-    ["newSupply", getU64Decoder10()],
-    ["depositor", getAddressDecoder9()],
+function getFeesCollectedDecoder() {
+  return getStructDecoder20([
+    ["controller", getAddressDecoder10()],
+    ["authority", getAddressDecoder10()],
+    ["feeVault", getAddressDecoder10()],
+    ["amount", getU64Decoder13()],
     ["timestamp", getI64Decoder6()]
   ]);
 }
+function getFeesCollectedCodec() {
+  return combineCodec20(getFeesCollectedEncoder(), getFeesCollectedDecoder());
+}
+
+// src/types/masterInitialized.ts
+import {
+  combineCodec as combineCodec21,
+  getAddressDecoder as getAddressDecoder11,
+  getAddressEncoder as getAddressEncoder16,
+  getI64Decoder as getI64Decoder7,
+  getI64Encoder as getI64Encoder7,
+  getStructDecoder as getStructDecoder21,
+  getStructEncoder as getStructEncoder21,
+  getU64Decoder as getU64Decoder14,
+  getU64Encoder as getU64Encoder14,
+  getU8Decoder as getU8Decoder12,
+  getU8Encoder as getU8Encoder12
+} from "@solana/kit";
+function getMasterInitializedEncoder() {
+  return getStructEncoder21([
+    ["authority", getAddressEncoder16()],
+    ["feeVault", getAddressEncoder16()],
+    ["protocolFee", getU64Encoder14()],
+    ["initControllerFee", getU64Encoder14()],
+    ["withdrawFee", getU64Encoder14()],
+    ["bump", getU8Encoder12()],
+    ["timestamp", getI64Encoder7()]
+  ]);
+}
+function getMasterInitializedDecoder() {
+  return getStructDecoder21([
+    ["authority", getAddressDecoder11()],
+    ["feeVault", getAddressDecoder11()],
+    ["protocolFee", getU64Decoder14()],
+    ["initControllerFee", getU64Decoder14()],
+    ["withdrawFee", getU64Decoder14()],
+    ["bump", getU8Decoder12()],
+    ["timestamp", getI64Decoder7()]
+  ]);
+}
+function getMasterInitializedCodec() {
+  return combineCodec21(
+    getMasterInitializedEncoder(),
+    getMasterInitializedDecoder()
+  );
+}
+
+// src/types/tokensDeposited.ts
+import {
+  combineCodec as combineCodec22,
+  getAddressDecoder as getAddressDecoder12,
+  getAddressEncoder as getAddressEncoder17,
+  getI64Decoder as getI64Decoder8,
+  getI64Encoder as getI64Encoder8,
+  getStructDecoder as getStructDecoder22,
+  getStructEncoder as getStructEncoder22,
+  getU64Decoder as getU64Decoder15,
+  getU64Encoder as getU64Encoder15
+} from "@solana/kit";
+function getTokensDepositedEncoder() {
+  return getStructEncoder22([
+    ["airdrop", getAddressEncoder17()],
+    ["amount", getU64Encoder15()],
+    ["newSupply", getU64Encoder15()],
+    ["depositor", getAddressEncoder17()],
+    ["timestamp", getI64Encoder8()]
+  ]);
+}
+function getTokensDepositedDecoder() {
+  return getStructDecoder22([
+    ["airdrop", getAddressDecoder12()],
+    ["amount", getU64Decoder15()],
+    ["newSupply", getU64Decoder15()],
+    ["depositor", getAddressDecoder12()],
+    ["timestamp", getI64Decoder8()]
+  ]);
+}
 function getTokensDepositedCodec() {
-  return combineCodec16(getTokensDepositedEncoder(), getTokensDepositedDecoder());
+  return combineCodec22(getTokensDepositedEncoder(), getTokensDepositedDecoder());
+}
+
+// src/utils/client.ts
+import {
+  airdropFactory,
+  appendTransactionMessageInstructions,
+  createSolanaRpc,
+  createSolanaRpcSubscriptions,
+  createTransactionMessage,
+  generateKeyPairSigner,
+  lamports,
+  pipe,
+  setTransactionMessageFeePayerSigner,
+  setTransactionMessageLifetimeUsingBlockhash
+} from "@solana/kit";
+var generateKeyPairSignerWithSol = async (rpcClient, putativeLamports = 1000000000n) => {
+  const signer = await generateKeyPairSigner();
+  await airdropFactory(rpcClient)({
+    recipientAddress: signer.address,
+    lamports: lamports(putativeLamports),
+    commitment: "confirmed"
+  });
+  return signer;
+};
+var createDefaultSolanaClient = () => {
+  const rpc = createSolanaRpc("https://api.devnet.solana.com");
+  const rpcSubscriptions = createSolanaRpcSubscriptions(
+    "wss://api.devnet.solana.com"
+  );
+  return { rpc, rpcSubscriptions };
+};
+var createTransactionMessageFromInstruction = async (rpc, signer, instruction) => {
+  const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
+  return pipe(
+    createTransactionMessage({ version: 0 }),
+    (tx) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
+    (tx) => setTransactionMessageFeePayerSigner(signer, tx),
+    (tx) => appendTransactionMessageInstructions(instruction, tx)
+  );
+};
+
+// src/utils/derive.ts
+import {
+  getAddressEncoder as getAddressEncoder18,
+  getProgramDerivedAddress as getProgramDerivedAddress8
+} from "@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 getProgramDerivedAddress8({
+    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),
+    getAddressEncoder18().encode(authority)
+  ];
+  return await getDropsyDerivedAddress(seeds);
+}
+async function getAirdropDerivedAddress(authority, mint) {
+  const seeds = [
+    Buffer.from(airdropSeed),
+    getAddressEncoder18().encode(mint),
+    getAddressEncoder18().encode(authority)
+  ];
+  return await getDropsyDerivedAddress(seeds);
+}
+async function getControllerVaultAddress(controller) {
+  const seeds = [Buffer.from(feeVaultSeed), getAddressEncoder18().encode(controller)];
+  return await getDropsyDerivedAddress(seeds);
+}
+async function getClaimMapAddress(airdrop, id) {
+  const seeds = [
+    Buffer.from(claimMapSeed),
+    getAddressEncoder18().encode(airdrop),
+    Buffer.from([id])
+  ];
+  return await getDropsyDerivedAddress(seeds);
 }
 export {
   AIRDROP_DISCRIMINATOR,
@@ -1864,26 +2754,44 @@ export {
   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,
@@ -1899,6 +2807,7 @@ export {
   getBitmapInitializedCodec,
   getBitmapInitializedDecoder,
   getBitmapInitializedEncoder,
+  getClaimMapAddress,
   getClaimTokensDiscriminatorBytes,
   getClaimTokensInstruction,
   getClaimTokensInstructionDataCodec,
@@ -1906,27 +2815,35 @@ export {
   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,
@@ -1945,9 +2862,34 @@ export {
   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,
@@ -1957,5 +2899,8 @@ export {
   parseDepositTokensInstruction,
   parseInitializeAirdropInstruction,
   parseInitializeBitmapInstruction,
-  parseInitializeControllerInstruction
+  parseInitializeControllerInstruction,
+  parseInitializeMasterInstruction,
+  parseWithdrawControllerFeesInstruction
 };
+//# sourceMappingURL=index.mjs.map