@dropsy/airdrop 0.2.7 → 0.4.0

package/dist/index.mjs

@@ -1,3741 +0,0 @@
-// src/accounts/affiliate.ts
-import {
-  assertAccountExists,
-  assertAccountsExist,
-  combineCodec,
-  decodeAccount,
-  fetchEncodedAccount,
-  fetchEncodedAccounts,
-  fixDecoderSize,
-  fixEncoderSize,
-  getAddressDecoder,
-  getAddressEncoder,
-  getBytesDecoder,
-  getBytesEncoder,
-  getStructDecoder,
-  getStructEncoder,
-  getU32Decoder,
-  getU32Encoder,
-  getU64Decoder,
-  getU64Encoder,
-  getU8Decoder,
-  getU8Encoder,
-  transformEncoder
-} from "@solana/kit";
-var AFFILIATE_DISCRIMINATOR = new Uint8Array([
-  136,
-  95,
-  107,
-  149,
-  36,
-  195,
-  146,
-  35
-]);
-function getAffiliateDiscriminatorBytes() {
-  return fixEncoderSize(getBytesEncoder(), 8).encode(AFFILIATE_DISCRIMINATOR);
-}
-function getAffiliateEncoder() {
-  return transformEncoder(
-    getStructEncoder([
-      ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
-      ["master", getAddressEncoder()],
-      ["authority", getAddressEncoder()],
-      ["totalEarned", getU64Encoder()],
-      ["referrals", getU32Encoder()],
-      ["level", getU8Encoder()],
-      ["bump", getU8Encoder()]
-    ]),
-    (value) => ({ ...value, discriminator: AFFILIATE_DISCRIMINATOR })
-  );
-}
-function getAffiliateDecoder() {
-  return getStructDecoder([
-    ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
-    ["master", getAddressDecoder()],
-    ["authority", getAddressDecoder()],
-    ["totalEarned", getU64Decoder()],
-    ["referrals", getU32Decoder()],
-    ["level", getU8Decoder()],
-    ["bump", getU8Decoder()]
-  ]);
-}
-function getAffiliateCodec() {
-  return combineCodec(getAffiliateEncoder(), getAffiliateDecoder());
-}
-function decodeAffiliate(encodedAccount) {
-  return decodeAccount(
-    encodedAccount,
-    getAffiliateDecoder()
-  );
-}
-async function fetchAffiliate(rpc, address2, config) {
-  const maybeAccount = await fetchMaybeAffiliate(rpc, address2, config);
-  assertAccountExists(maybeAccount);
-  return maybeAccount;
-}
-async function fetchMaybeAffiliate(rpc, address2, config) {
-  const maybeAccount = await fetchEncodedAccount(rpc, address2, config);
-  return decodeAffiliate(maybeAccount);
-}
-async function fetchAllAffiliate(rpc, addresses, config) {
-  const maybeAccounts = await fetchAllMaybeAffiliate(rpc, addresses, config);
-  assertAccountsExist(maybeAccounts);
-  return maybeAccounts;
-}
-async function fetchAllMaybeAffiliate(rpc, addresses, config) {
-  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
-  return maybeAccounts.map((maybeAccount) => decodeAffiliate(maybeAccount));
-}
-function getAffiliateSize() {
-  return 86;
-}
-
-// src/accounts/affiliateMaster.ts
-import {
-  assertAccountExists as assertAccountExists2,
-  assertAccountsExist as assertAccountsExist2,
-  combineCodec as combineCodec2,
-  decodeAccount as decodeAccount2,
-  fetchEncodedAccount as fetchEncodedAccount2,
-  fetchEncodedAccounts as fetchEncodedAccounts2,
-  fixDecoderSize as fixDecoderSize2,
-  fixEncoderSize as fixEncoderSize2,
-  getAddressDecoder as getAddressDecoder2,
-  getAddressEncoder as getAddressEncoder2,
-  getBytesDecoder as getBytesDecoder2,
-  getBytesEncoder as getBytesEncoder2,
-  getStructDecoder as getStructDecoder2,
-  getStructEncoder as getStructEncoder2,
-  getU16Decoder,
-  getU16Encoder,
-  getU64Decoder as getU64Decoder2,
-  getU64Encoder as getU64Encoder2,
-  getU8Decoder as getU8Decoder2,
-  getU8Encoder as getU8Encoder2,
-  transformEncoder as transformEncoder2
-} from "@solana/kit";
-var AFFILIATE_MASTER_DISCRIMINATOR = new Uint8Array([
-  25,
-  57,
-  134,
-  31,
-  30,
-  203,
-  219,
-  215
-]);
-function getAffiliateMasterDiscriminatorBytes() {
-  return fixEncoderSize2(getBytesEncoder2(), 8).encode(
-    AFFILIATE_MASTER_DISCRIMINATOR
-  );
-}
-function getAffiliateMasterEncoder() {
-  return transformEncoder2(
-    getStructEncoder2([
-      ["discriminator", fixEncoderSize2(getBytesEncoder2(), 8)],
-      ["authority", getAddressEncoder2()],
-      ["tokenMint", getAddressEncoder2()],
-      ["affiliatesCreated", getU64Encoder2()],
-      ["maxAffiliatesAllowed", getU64Encoder2()],
-      ["totalFeesCollected", getU64Encoder2()],
-      ["affiliateCreationFee", getU64Encoder2()],
-      ["affiliateUpgradeAmount", getU64Encoder2()],
-      ["affiliateWithdrawFeeBasis", getU16Encoder()],
-      ["burnPercentageBasis", getU16Encoder()],
-      ["treasuryPercentageBasis", getU16Encoder()],
-      ["upgradeRewardPercentageBasis", getU16Encoder()],
-      ["bump", getU8Encoder2()]
-    ]),
-    (value) => ({ ...value, discriminator: AFFILIATE_MASTER_DISCRIMINATOR })
-  );
-}
-function getAffiliateMasterDecoder() {
-  return getStructDecoder2([
-    ["discriminator", fixDecoderSize2(getBytesDecoder2(), 8)],
-    ["authority", getAddressDecoder2()],
-    ["tokenMint", getAddressDecoder2()],
-    ["affiliatesCreated", getU64Decoder2()],
-    ["maxAffiliatesAllowed", getU64Decoder2()],
-    ["totalFeesCollected", getU64Decoder2()],
-    ["affiliateCreationFee", getU64Decoder2()],
-    ["affiliateUpgradeAmount", getU64Decoder2()],
-    ["affiliateWithdrawFeeBasis", getU16Decoder()],
-    ["burnPercentageBasis", getU16Decoder()],
-    ["treasuryPercentageBasis", getU16Decoder()],
-    ["upgradeRewardPercentageBasis", getU16Decoder()],
-    ["bump", getU8Decoder2()]
-  ]);
-}
-function getAffiliateMasterCodec() {
-  return combineCodec2(getAffiliateMasterEncoder(), getAffiliateMasterDecoder());
-}
-function decodeAffiliateMaster(encodedAccount) {
-  return decodeAccount2(
-    encodedAccount,
-    getAffiliateMasterDecoder()
-  );
-}
-async function fetchAffiliateMaster(rpc, address2, config) {
-  const maybeAccount = await fetchMaybeAffiliateMaster(rpc, address2, config);
-  assertAccountExists2(maybeAccount);
-  return maybeAccount;
-}
-async function fetchMaybeAffiliateMaster(rpc, address2, config) {
-  const maybeAccount = await fetchEncodedAccount2(rpc, address2, config);
-  return decodeAffiliateMaster(maybeAccount);
-}
-async function fetchAllAffiliateMaster(rpc, addresses, config) {
-  const maybeAccounts = await fetchAllMaybeAffiliateMaster(
-    rpc,
-    addresses,
-    config
-  );
-  assertAccountsExist2(maybeAccounts);
-  return maybeAccounts;
-}
-async function fetchAllMaybeAffiliateMaster(rpc, addresses, config) {
-  const maybeAccounts = await fetchEncodedAccounts2(rpc, addresses, config);
-  return maybeAccounts.map(
-    (maybeAccount) => decodeAffiliateMaster(maybeAccount)
-  );
-}
-function getAffiliateMasterSize() {
-  return 121;
-}
-
-// src/accounts/airdrop.ts
-import {
-  assertAccountExists as assertAccountExists3,
-  assertAccountsExist as assertAccountsExist3,
-  combineCodec as combineCodec3,
-  decodeAccount as decodeAccount3,
-  fetchEncodedAccount as fetchEncodedAccount3,
-  fetchEncodedAccounts as fetchEncodedAccounts3,
-  fixDecoderSize as fixDecoderSize3,
-  fixEncoderSize as fixEncoderSize3,
-  getAddressDecoder as getAddressDecoder3,
-  getAddressEncoder as getAddressEncoder3,
-  getBytesDecoder as getBytesDecoder3,
-  getBytesEncoder as getBytesEncoder3,
-  getI64Decoder,
-  getI64Encoder,
-  getStructDecoder as getStructDecoder3,
-  getStructEncoder as getStructEncoder3,
-  getU16Decoder as getU16Decoder2,
-  getU16Encoder as getU16Encoder2,
-  getU64Decoder as getU64Decoder3,
-  getU64Encoder as getU64Encoder3,
-  getU8Decoder as getU8Decoder3,
-  getU8Encoder as getU8Encoder3,
-  transformEncoder as transformEncoder3
-} from "@solana/kit";
-var AIRDROP_DISCRIMINATOR = new Uint8Array([
-  31,
-  112,
-  159,
-  158,
-  124,
-  237,
-  9,
-  241
-]);
-function getAirdropDiscriminatorBytes() {
-  return fixEncoderSize3(getBytesEncoder3(), 8).encode(AIRDROP_DISCRIMINATOR);
-}
-function getAirdropEncoder() {
-  return transformEncoder3(
-    getStructEncoder3([
-      ["discriminator", fixEncoderSize3(getBytesEncoder3(), 8)],
-      ["master", getAddressEncoder3()],
-      ["authority", getAddressEncoder3()],
-      ["mint", getAddressEncoder3()],
-      ["delegateAuthority", getAddressEncoder3()],
-      ["presale", getAddressEncoder3()],
-      ["merkleRoot", fixEncoderSize3(getBytesEncoder3(), 32)],
-      ["supply", getU64Encoder3()],
-      ["boost", getU64Encoder3()],
-      ["startsAt", getI64Encoder()],
-      ["endsAt", getI64Encoder()],
-      ["bitmapCount", getU16Encoder2()],
-      ["delegatePermissions", getU8Encoder3()],
-      ["mutable", getU8Encoder3()],
-      ["state", getU8Encoder3()],
-      ["version", getU8Encoder3()],
-      ["bump", getU8Encoder3()],
-      ["padding", fixEncoderSize3(getBytesEncoder3(), 1)]
-    ]),
-    (value) => ({ ...value, discriminator: AIRDROP_DISCRIMINATOR })
-  );
-}
-function getAirdropDecoder() {
-  return getStructDecoder3([
-    ["discriminator", fixDecoderSize3(getBytesDecoder3(), 8)],
-    ["master", getAddressDecoder3()],
-    ["authority", getAddressDecoder3()],
-    ["mint", getAddressDecoder3()],
-    ["delegateAuthority", getAddressDecoder3()],
-    ["presale", getAddressDecoder3()],
-    ["merkleRoot", fixDecoderSize3(getBytesDecoder3(), 32)],
-    ["supply", getU64Decoder3()],
-    ["boost", getU64Decoder3()],
-    ["startsAt", getI64Decoder()],
-    ["endsAt", getI64Decoder()],
-    ["bitmapCount", getU16Decoder2()],
-    ["delegatePermissions", getU8Decoder3()],
-    ["mutable", getU8Decoder3()],
-    ["state", getU8Decoder3()],
-    ["version", getU8Decoder3()],
-    ["bump", getU8Decoder3()],
-    ["padding", fixDecoderSize3(getBytesDecoder3(), 1)]
-  ]);
-}
-function getAirdropCodec() {
-  return combineCodec3(getAirdropEncoder(), getAirdropDecoder());
-}
-function decodeAirdrop(encodedAccount) {
-  return decodeAccount3(
-    encodedAccount,
-    getAirdropDecoder()
-  );
-}
-async function fetchAirdrop(rpc, address2, config) {
-  const maybeAccount = await fetchMaybeAirdrop(rpc, address2, config);
-  assertAccountExists3(maybeAccount);
-  return maybeAccount;
-}
-async function fetchMaybeAirdrop(rpc, address2, config) {
-  const maybeAccount = await fetchEncodedAccount3(rpc, address2, config);
-  return decodeAirdrop(maybeAccount);
-}
-async function fetchAllAirdrop(rpc, addresses, config) {
-  const maybeAccounts = await fetchAllMaybeAirdrop(rpc, addresses, config);
-  assertAccountsExist3(maybeAccounts);
-  return maybeAccounts;
-}
-async function fetchAllMaybeAirdrop(rpc, addresses, config) {
-  const maybeAccounts = await fetchEncodedAccounts3(rpc, addresses, config);
-  return maybeAccounts.map((maybeAccount) => decodeAirdrop(maybeAccount));
-}
-function getAirdropSize() {
-  return 240;
-}
-
-// src/accounts/airdropConfig.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,
-  getBytesDecoder as getBytesDecoder4,
-  getBytesEncoder as getBytesEncoder4,
-  getI64Decoder as getI64Decoder2,
-  getI64Encoder as getI64Encoder2,
-  getStructDecoder as getStructDecoder4,
-  getStructEncoder as getStructEncoder4,
-  getU64Decoder as getU64Decoder4,
-  getU64Encoder as getU64Encoder4,
-  getU8Decoder as getU8Decoder4,
-  getU8Encoder as getU8Encoder4,
-  transformEncoder as transformEncoder4
-} from "@solana/kit";
-var AIRDROP_CONFIG_DISCRIMINATOR = new Uint8Array([
-  194,
-  149,
-  223,
-  142,
-  42,
-  98,
-  128,
-  16
-]);
-function getAirdropConfigDiscriminatorBytes() {
-  return fixEncoderSize4(getBytesEncoder4(), 8).encode(
-    AIRDROP_CONFIG_DISCRIMINATOR
-  );
-}
-function getAirdropConfigEncoder() {
-  return transformEncoder4(
-    getStructEncoder4([
-      ["discriminator", fixEncoderSize4(getBytesEncoder4(), 8)],
-      ["merkleRoot", fixEncoderSize4(getBytesEncoder4(), 32)],
-      ["minAirdropDuration", getI64Encoder2()],
-      ["maxAirdropDuration", getI64Encoder2()],
-      ["updateGracePeriod", getI64Encoder2()],
-      ["createAirdropMasterFee", getU64Encoder4()],
-      ["upgradeAirdropMasterFee", getU64Encoder4()],
-      ["withdrawFeeBasis", getU64Encoder4()],
-      ["perBoostAmount", getU64Encoder4()],
-      ["bump", getU8Encoder4()]
-    ]),
-    (value) => ({ ...value, discriminator: AIRDROP_CONFIG_DISCRIMINATOR })
-  );
-}
-function getAirdropConfigDecoder() {
-  return getStructDecoder4([
-    ["discriminator", fixDecoderSize4(getBytesDecoder4(), 8)],
-    ["merkleRoot", fixDecoderSize4(getBytesDecoder4(), 32)],
-    ["minAirdropDuration", getI64Decoder2()],
-    ["maxAirdropDuration", getI64Decoder2()],
-    ["updateGracePeriod", getI64Decoder2()],
-    ["createAirdropMasterFee", getU64Decoder4()],
-    ["upgradeAirdropMasterFee", getU64Decoder4()],
-    ["withdrawFeeBasis", getU64Decoder4()],
-    ["perBoostAmount", getU64Decoder4()],
-    ["bump", getU8Decoder4()]
-  ]);
-}
-function getAirdropConfigCodec() {
-  return combineCodec4(getAirdropConfigEncoder(), getAirdropConfigDecoder());
-}
-function decodeAirdropConfig(encodedAccount) {
-  return decodeAccount4(
-    encodedAccount,
-    getAirdropConfigDecoder()
-  );
-}
-async function fetchAirdropConfig(rpc, address2, config) {
-  const maybeAccount = await fetchMaybeAirdropConfig(rpc, address2, config);
-  assertAccountExists4(maybeAccount);
-  return maybeAccount;
-}
-async function fetchMaybeAirdropConfig(rpc, address2, config) {
-  const maybeAccount = await fetchEncodedAccount4(rpc, address2, config);
-  return decodeAirdropConfig(maybeAccount);
-}
-async function fetchAllAirdropConfig(rpc, addresses, config) {
-  const maybeAccounts = await fetchAllMaybeAirdropConfig(
-    rpc,
-    addresses,
-    config
-  );
-  assertAccountsExist4(maybeAccounts);
-  return maybeAccounts;
-}
-async function fetchAllMaybeAirdropConfig(rpc, addresses, config) {
-  const maybeAccounts = await fetchEncodedAccounts4(rpc, addresses, config);
-  return maybeAccounts.map((maybeAccount) => decodeAirdropConfig(maybeAccount));
-}
-function getAirdropConfigSize() {
-  return 97;
-}
-
-// src/accounts/airdropMaster.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,
-  getAddressDecoder as getAddressDecoder4,
-  getAddressEncoder as getAddressEncoder4,
-  getBytesDecoder as getBytesDecoder5,
-  getBytesEncoder as getBytesEncoder5,
-  getStructDecoder as getStructDecoder5,
-  getStructEncoder as getStructEncoder5,
-  getU64Decoder as getU64Decoder5,
-  getU64Encoder as getU64Encoder5,
-  getU8Decoder as getU8Decoder5,
-  getU8Encoder as getU8Encoder5,
-  transformEncoder as transformEncoder5
-} from "@solana/kit";
-var AIRDROP_MASTER_DISCRIMINATOR = new Uint8Array([
-  31,
-  109,
-  100,
-  62,
-  106,
-  173,
-  5,
-  4
-]);
-function getAirdropMasterDiscriminatorBytes() {
-  return fixEncoderSize5(getBytesEncoder5(), 8).encode(
-    AIRDROP_MASTER_DISCRIMINATOR
-  );
-}
-function getAirdropMasterEncoder() {
-  return transformEncoder5(
-    getStructEncoder5([
-      ["discriminator", fixEncoderSize5(getBytesEncoder5(), 8)],
-      ["affiliateMaster", getAddressEncoder4()],
-      ["authority", getAddressEncoder4()],
-      ["merkleRoot", fixEncoderSize5(getBytesEncoder5(), 32)],
-      ["airdropsCreated", getU64Encoder5()],
-      ["maxAirdropsAllowed", getU64Encoder5()],
-      ["bitmapCreated", getU64Encoder5()],
-      ["maxBitmapAllowed", getU64Encoder5()],
-      ["airdropCreationFee", getU64Encoder5()],
-      ["bitmapCreationFee", getU64Encoder5()],
-      ["airdropUpdateFee", getU64Encoder5()],
-      ["airdropClaimFee", getU64Encoder5()],
-      ["airdropDelegateFee", getU64Encoder5()],
-      ["airdropDepositFee", getU64Encoder5()],
-      ["bump", getU8Encoder5()],
-      ["padding", fixEncoderSize5(getBytesEncoder5(), 7)]
-    ]),
-    (value) => ({ ...value, discriminator: AIRDROP_MASTER_DISCRIMINATOR })
-  );
-}
-function getAirdropMasterDecoder() {
-  return getStructDecoder5([
-    ["discriminator", fixDecoderSize5(getBytesDecoder5(), 8)],
-    ["affiliateMaster", getAddressDecoder4()],
-    ["authority", getAddressDecoder4()],
-    ["merkleRoot", fixDecoderSize5(getBytesDecoder5(), 32)],
-    ["airdropsCreated", getU64Decoder5()],
-    ["maxAirdropsAllowed", getU64Decoder5()],
-    ["bitmapCreated", getU64Decoder5()],
-    ["maxBitmapAllowed", getU64Decoder5()],
-    ["airdropCreationFee", getU64Decoder5()],
-    ["bitmapCreationFee", getU64Decoder5()],
-    ["airdropUpdateFee", getU64Decoder5()],
-    ["airdropClaimFee", getU64Decoder5()],
-    ["airdropDelegateFee", getU64Decoder5()],
-    ["airdropDepositFee", getU64Decoder5()],
-    ["bump", getU8Decoder5()],
-    ["padding", fixDecoderSize5(getBytesDecoder5(), 7)]
-  ]);
-}
-function getAirdropMasterCodec() {
-  return combineCodec5(getAirdropMasterEncoder(), getAirdropMasterDecoder());
-}
-function decodeAirdropMaster(encodedAccount) {
-  return decodeAccount5(
-    encodedAccount,
-    getAirdropMasterDecoder()
-  );
-}
-async function fetchAirdropMaster(rpc, address2, config) {
-  const maybeAccount = await fetchMaybeAirdropMaster(rpc, address2, config);
-  assertAccountExists5(maybeAccount);
-  return maybeAccount;
-}
-async function fetchMaybeAirdropMaster(rpc, address2, config) {
-  const maybeAccount = await fetchEncodedAccount5(rpc, address2, config);
-  return decodeAirdropMaster(maybeAccount);
-}
-async function fetchAllAirdropMaster(rpc, addresses, config) {
-  const maybeAccounts = await fetchAllMaybeAirdropMaster(
-    rpc,
-    addresses,
-    config
-  );
-  assertAccountsExist5(maybeAccounts);
-  return maybeAccounts;
-}
-async function fetchAllMaybeAirdropMaster(rpc, addresses, config) {
-  const maybeAccounts = await fetchEncodedAccounts5(rpc, addresses, config);
-  return maybeAccounts.map((maybeAccount) => decodeAirdropMaster(maybeAccount));
-}
-function getAirdropMasterSize() {
-  return 192;
-}
-
-// src/accounts/claimMap.ts
-import {
-  assertAccountExists as assertAccountExists6,
-  assertAccountsExist as assertAccountsExist6,
-  combineCodec as combineCodec6,
-  decodeAccount as decodeAccount6,
-  fetchEncodedAccount as fetchEncodedAccount6,
-  fetchEncodedAccounts as fetchEncodedAccounts6,
-  fixDecoderSize as fixDecoderSize6,
-  fixEncoderSize as fixEncoderSize6,
-  getAddressDecoder as getAddressDecoder5,
-  getAddressEncoder as getAddressEncoder5,
-  getBytesDecoder as getBytesDecoder6,
-  getBytesEncoder as getBytesEncoder6,
-  getStructDecoder as getStructDecoder6,
-  getStructEncoder as getStructEncoder6,
-  getU16Decoder as getU16Decoder3,
-  getU16Encoder as getU16Encoder3,
-  getU32Decoder as getU32Decoder2,
-  getU32Encoder as getU32Encoder2,
-  getU8Decoder as getU8Decoder6,
-  getU8Encoder as getU8Encoder6,
-  transformEncoder as transformEncoder6
-} from "@solana/kit";
-var CLAIM_MAP_DISCRIMINATOR = new Uint8Array([
-  193,
-  62,
-  74,
-  131,
-  13,
-  161,
-  53,
-  215
-]);
-function getClaimMapDiscriminatorBytes() {
-  return fixEncoderSize6(getBytesEncoder6(), 8).encode(CLAIM_MAP_DISCRIMINATOR);
-}
-function getClaimMapEncoder() {
-  return transformEncoder6(
-    getStructEncoder6([
-      ["discriminator", fixEncoderSize6(getBytesEncoder6(), 8)],
-      ["authority", getAddressEncoder5()],
-      ["airdrop", getAddressEncoder5()],
-      ["claimedBitmap", fixEncoderSize6(getBytesEncoder6(), 8e3)],
-      ["total", getU32Encoder2()],
-      ["id", getU16Encoder3()],
-      ["version", getU8Encoder6()],
-      ["bump", getU8Encoder6()]
-    ]),
-    (value) => ({ ...value, discriminator: CLAIM_MAP_DISCRIMINATOR })
-  );
-}
-function getClaimMapDecoder() {
-  return getStructDecoder6([
-    ["discriminator", fixDecoderSize6(getBytesDecoder6(), 8)],
-    ["authority", getAddressDecoder5()],
-    ["airdrop", getAddressDecoder5()],
-    ["claimedBitmap", fixDecoderSize6(getBytesDecoder6(), 8e3)],
-    ["total", getU32Decoder2()],
-    ["id", getU16Decoder3()],
-    ["version", getU8Decoder6()],
-    ["bump", getU8Decoder6()]
-  ]);
-}
-function getClaimMapCodec() {
-  return combineCodec6(getClaimMapEncoder(), getClaimMapDecoder());
-}
-function decodeClaimMap(encodedAccount) {
-  return decodeAccount6(
-    encodedAccount,
-    getClaimMapDecoder()
-  );
-}
-async function fetchClaimMap(rpc, address2, config) {
-  const maybeAccount = await fetchMaybeClaimMap(rpc, address2, config);
-  assertAccountExists6(maybeAccount);
-  return maybeAccount;
-}
-async function fetchMaybeClaimMap(rpc, address2, config) {
-  const maybeAccount = await fetchEncodedAccount6(rpc, address2, config);
-  return decodeClaimMap(maybeAccount);
-}
-async function fetchAllClaimMap(rpc, addresses, config) {
-  const maybeAccounts = await fetchAllMaybeClaimMap(rpc, addresses, config);
-  assertAccountsExist6(maybeAccounts);
-  return maybeAccounts;
-}
-async function fetchAllMaybeClaimMap(rpc, addresses, config) {
-  const maybeAccounts = await fetchEncodedAccounts6(rpc, addresses, config);
-  return maybeAccounts.map((maybeAccount) => decodeClaimMap(maybeAccount));
-}
-function getClaimMapSize() {
-  return 8080;
-}
-
-// src/accounts/master.ts
-import {
-  assertAccountExists as assertAccountExists7,
-  assertAccountsExist as assertAccountsExist7,
-  combineCodec as combineCodec7,
-  decodeAccount as decodeAccount7,
-  fetchEncodedAccount as fetchEncodedAccount7,
-  fetchEncodedAccounts as fetchEncodedAccounts7,
-  fixDecoderSize as fixDecoderSize7,
-  fixEncoderSize as fixEncoderSize7,
-  getAddressDecoder as getAddressDecoder6,
-  getAddressEncoder as getAddressEncoder6,
-  getBytesDecoder as getBytesDecoder7,
-  getBytesEncoder as getBytesEncoder7,
-  getStructDecoder as getStructDecoder7,
-  getStructEncoder as getStructEncoder7,
-  getU64Decoder as getU64Decoder6,
-  getU64Encoder as getU64Encoder6,
-  getU8Decoder as getU8Decoder7,
-  getU8Encoder as getU8Encoder7,
-  transformEncoder as transformEncoder7
-} from "@solana/kit";
-var MASTER_DISCRIMINATOR = new Uint8Array([
-  168,
-  213,
-  193,
-  12,
-  77,
-  162,
-  58,
-  235
-]);
-function getMasterDiscriminatorBytes() {
-  return fixEncoderSize7(getBytesEncoder7(), 8).encode(MASTER_DISCRIMINATOR);
-}
-function getMasterEncoder() {
-  return transformEncoder7(
-    getStructEncoder7([
-      ["discriminator", fixEncoderSize7(getBytesEncoder7(), 8)],
-      ["authority", getAddressEncoder6()],
-      ["treasury", getAddressEncoder6()],
-      ["tokenMint", getAddressEncoder6()],
-      ["protocolFee", getU64Encoder6()],
-      ["bump", getU8Encoder7()]
-    ]),
-    (value) => ({ ...value, discriminator: MASTER_DISCRIMINATOR })
-  );
-}
-function getMasterDecoder() {
-  return getStructDecoder7([
-    ["discriminator", fixDecoderSize7(getBytesDecoder7(), 8)],
-    ["authority", getAddressDecoder6()],
-    ["treasury", getAddressDecoder6()],
-    ["tokenMint", getAddressDecoder6()],
-    ["protocolFee", getU64Decoder6()],
-    ["bump", getU8Decoder7()]
-  ]);
-}
-function getMasterCodec() {
-  return combineCodec7(getMasterEncoder(), getMasterDecoder());
-}
-function decodeMaster(encodedAccount) {
-  return decodeAccount7(
-    encodedAccount,
-    getMasterDecoder()
-  );
-}
-async function fetchMaster(rpc, address2, config) {
-  const maybeAccount = await fetchMaybeMaster(rpc, address2, config);
-  assertAccountExists7(maybeAccount);
-  return maybeAccount;
-}
-async function fetchMaybeMaster(rpc, address2, config) {
-  const maybeAccount = await fetchEncodedAccount7(rpc, address2, config);
-  return decodeMaster(maybeAccount);
-}
-async function fetchAllMaster(rpc, addresses, config) {
-  const maybeAccounts = await fetchAllMaybeMaster(rpc, addresses, config);
-  assertAccountsExist7(maybeAccounts);
-  return maybeAccounts;
-}
-async function fetchAllMaybeMaster(rpc, addresses, config) {
-  const maybeAccounts = await fetchEncodedAccounts7(rpc, addresses, config);
-  return maybeAccounts.map((maybeAccount) => decodeMaster(maybeAccount));
-}
-function getMasterSize() {
-  return 113;
-}
-
-// src/errors/dropsy.ts
-import {
-  isProgramError
-} from "@solana/kit";
-
-// src/programs/dropsy.ts
-import {
-  containsBytes,
-  fixEncoderSize as fixEncoderSize8,
-  getBytesEncoder as getBytesEncoder8
-} from "@solana/kit";
-var DROPSY_PROGRAM_ADDRESS = "6Bd4YUkwyvZTPMt1bu13zvw9t4TtoMTd6CFVMmaswB2M";
-var DropsyAccount = /* @__PURE__ */ ((DropsyAccount2) => {
-  DropsyAccount2[DropsyAccount2["Affiliate"] = 0] = "Affiliate";
-  DropsyAccount2[DropsyAccount2["AffiliateMaster"] = 1] = "AffiliateMaster";
-  DropsyAccount2[DropsyAccount2["Airdrop"] = 2] = "Airdrop";
-  DropsyAccount2[DropsyAccount2["AirdropConfig"] = 3] = "AirdropConfig";
-  DropsyAccount2[DropsyAccount2["AirdropMaster"] = 4] = "AirdropMaster";
-  DropsyAccount2[DropsyAccount2["ClaimMap"] = 5] = "ClaimMap";
-  DropsyAccount2[DropsyAccount2["Master"] = 6] = "Master";
-  return DropsyAccount2;
-})(DropsyAccount || {});
-function identifyDropsyAccount(account) {
-  const data = "data" in account ? account.data : account;
-  if (containsBytes(
-    data,
-    fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([136, 95, 107, 149, 36, 195, 146, 35])
-    ),
-    0
-  )) {
-    return 0 /* Affiliate */;
-  }
-  if (containsBytes(
-    data,
-    fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([25, 57, 134, 31, 30, 203, 219, 215])
-    ),
-    0
-  )) {
-    return 1 /* AffiliateMaster */;
-  }
-  if (containsBytes(
-    data,
-    fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([31, 112, 159, 158, 124, 237, 9, 241])
-    ),
-    0
-  )) {
-    return 2 /* Airdrop */;
-  }
-  if (containsBytes(
-    data,
-    fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([194, 149, 223, 142, 42, 98, 128, 16])
-    ),
-    0
-  )) {
-    return 3 /* AirdropConfig */;
-  }
-  if (containsBytes(
-    data,
-    fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([31, 109, 100, 62, 106, 173, 5, 4])
-    ),
-    0
-  )) {
-    return 4 /* AirdropMaster */;
-  }
-  if (containsBytes(
-    data,
-    fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([193, 62, 74, 131, 13, 161, 53, 215])
-    ),
-    0
-  )) {
-    return 5 /* ClaimMap */;
-  }
-  if (containsBytes(
-    data,
-    fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([168, 213, 193, 12, 77, 162, 58, 235])
-    ),
-    0
-  )) {
-    return 6 /* Master */;
-  }
-  throw new Error(
-    "The provided account could not be identified as a dropsy account."
-  );
-}
-var DropsyInstruction = /* @__PURE__ */ ((DropsyInstruction2) => {
-  DropsyInstruction2[DropsyInstruction2["ClaimAirdrop"] = 0] = "ClaimAirdrop";
-  DropsyInstruction2[DropsyInstruction2["CreateAirdrop"] = 1] = "CreateAirdrop";
-  DropsyInstruction2[DropsyInstruction2["CreateClaimMap"] = 2] = "CreateClaimMap";
-  DropsyInstruction2[DropsyInstruction2["DepositTokens"] = 3] = "DepositTokens";
-  DropsyInstruction2[DropsyInstruction2["InitializeAirdropMaster"] = 4] = "InitializeAirdropMaster";
-  DropsyInstruction2[DropsyInstruction2["InitializeMaster"] = 5] = "InitializeMaster";
-  DropsyInstruction2[DropsyInstruction2["RedeemAirdropTokens"] = 6] = "RedeemAirdropTokens";
-  return DropsyInstruction2;
-})(DropsyInstruction || {});
-function identifyDropsyInstruction(instruction) {
-  const data = "data" in instruction ? instruction.data : instruction;
-  if (containsBytes(
-    data,
-    fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([137, 50, 122, 111, 89, 254, 8, 20])
-    ),
-    0
-  )) {
-    return 0 /* ClaimAirdrop */;
-  }
-  if (containsBytes(
-    data,
-    fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([227, 135, 208, 66, 137, 177, 80, 94])
-    ),
-    0
-  )) {
-    return 1 /* CreateAirdrop */;
-  }
-  if (containsBytes(
-    data,
-    fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([22, 150, 81, 49, 214, 142, 189, 122])
-    ),
-    0
-  )) {
-    return 2 /* CreateClaimMap */;
-  }
-  if (containsBytes(
-    data,
-    fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([176, 83, 229, 18, 191, 143, 176, 150])
-    ),
-    0
-  )) {
-    return 3 /* DepositTokens */;
-  }
-  if (containsBytes(
-    data,
-    fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([163, 197, 170, 44, 57, 57, 90, 65])
-    ),
-    0
-  )) {
-    return 4 /* InitializeAirdropMaster */;
-  }
-  if (containsBytes(
-    data,
-    fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([206, 91, 246, 30, 216, 101, 134, 166])
-    ),
-    0
-  )) {
-    return 5 /* InitializeMaster */;
-  }
-  if (containsBytes(
-    data,
-    fixEncoderSize8(getBytesEncoder8(), 8).encode(
-      new Uint8Array([102, 70, 115, 13, 97, 198, 59, 103])
-    ),
-    0
-  )) {
-    return 6 /* RedeemAirdropTokens */;
-  }
-  throw new Error(
-    "The provided instruction could not be identified as a dropsy instruction."
-  );
-}
-
-// src/errors/dropsy.ts
-var DROPSY_ERROR__VALUE_OUT_OF_RANGE = 6001;
-var DROPSY_ERROR__VALUE_BELOW_THE_MINIMUM = 6002;
-var DROPSY_ERROR__VALUE_EXCEEDS_MAXIMUM = 6003;
-var DROPSY_ERROR__INVALID_PERCENTAGE = 6004;
-var DROPSY_ERROR__INVALID_TIMESTAMP = 6006;
-var DROPSY_ERROR__NON_ZERO_VALUE_REQUIRED = 6007;
-var DROPSY_ERROR__INVALID_PUB_KEY = 6008;
-var DROPSY_ERROR__UN_AUTHORIZED = 6009;
-var DROPSY_ERROR__INVALID_MUTABILITY = 6010;
-var DROPSY_ERROR__INVALID_DELEGATE_PERMISSION = 6011;
-var DROPSY_ERROR__AIRDROP_NOT_STARTED = 6100;
-var DROPSY_ERROR__AIRDROP_ENDED = 6101;
-var DROPSY_ERROR__AIRDROP_NOT_ENDED = 6102;
-var DROPSY_ERROR__DURATION_TOO_SHORT = 6103;
-var DROPSY_ERROR__INVALID_END_TIME = 6104;
-var DROPSY_ERROR__INVALID_VESTING_SCHEDULE = 6105;
-var DROPSY_ERROR__IMMUTABLE_AIRDROP = 6106;
-var DROPSY_ERROR__IMMUTABLE_FIELD = 6107;
-var DROPSY_ERROR__UPDATE_CUTOFF_TIME_PASSED = 6108;
-var DROPSY_ERROR__MAX_AIRDROPS_REACHED = 6109;
-var DROPSY_ERROR__MAX_CLAIM_MAPS_REACHED = 6110;
-var DROPSY_ERROR__INVALID_ADMIN = 6200;
-var DROPSY_ERROR__OWNER_MISMATCH = 6201;
-var DROPSY_ERROR__INVALID_VAULT_AUTHORITY = 6202;
-var DROPSY_ERROR__INVALID_DESTINATION_OWNER = 6203;
-var DROPSY_ERROR__INVALID_AFFILIATE_PDA = 6204;
-var DROPSY_ERROR__UNAUTHORIZED = 6205;
-var DROPSY_ERROR__INVALID_OWNER = 6206;
-var DROPSY_ERROR__INVALID_MINT = 6300;
-var DROPSY_ERROR__MINT_MISMATCH = 6301;
-var DROPSY_ERROR__VAULT_MINT_MISMATCH = 6302;
-var DROPSY_ERROR__DESTINATION_MINT_MISMATCH = 6303;
-var DROPSY_ERROR__MINT_IS_FROZEN = 6304;
-var DROPSY_ERROR__INVALID_MINT_OWNER = 6305;
-var DROPSY_ERROR__MINT_IS_NOT_INITIALIZED = 6306;
-var DROPSY_ERROR__MINT_HAS_FREEZE_AUTHORITY = 6307;
-var DROPSY_ERROR__NFT_NOT_ALLOWED = 6308;
-var DROPSY_ERROR__VAULT_HAS_DELEGATE = 6401;
-var DROPSY_ERROR__VAULT_FROZEN = 6402;
-var DROPSY_ERROR__VAULT_HAS_CLOSE_AUTHORITY = 6403;
-var DROPSY_ERROR__INVALID_AIRDROP_PDA = 6404;
-var DROPSY_ERROR__VAULT_NOT_INITIALIZED = 6405;
-var DROPSY_ERROR__INSUFFICIENT_VAULT_FUNDS = 6406;
-var DROPSY_ERROR__SOURCE_HAS_DELEGATE = 6450;
-var DROPSY_ERROR__SOURCE_ACCOUNT_FROZEN = 6451;
-var DROPSY_ERROR__SOURCE_HAS_CLOSE_AUTHORITY = 6452;
-var DROPSY_ERROR__INVALID_PROOF = 6500;
-var DROPSY_ERROR__ALREADY_CLAIMED = 6501;
-var DROPSY_ERROR__MISSING_BITMAP_PDA = 6502;
-var DROPSY_ERROR__INVALID_BITMAP_ACCOUNT = 6503;
-var DROPSY_ERROR__INVALID_BITMAP_INDEX = 6504;
-var DROPSY_ERROR__TOO_MANY_BITMAPS = 6505;
-var DROPSY_ERROR__BITMAP_TOO_LARGE = 6506;
-var DROPSY_ERROR__INVALID_TOTAL = 6507;
-var DROPSY_ERROR__BITMAP_AIRDROP_MISMATCH = 6508;
-var DROPSY_ERROR__ACTIVE_BITMAPS_EXIST = 6509;
-var DROPSY_ERROR__BITMAP_COUNT_UNDERFLOW = 6510;
-var DROPSY_ERROR__INSUFFICIENT_DEPOSIT = 6600;
-var DROPSY_ERROR__CREATE_FEE_TOO_HIGH = 6601;
-var DROPSY_ERROR__CLAIM_FEE_TOO_HIGH = 6602;
-var DROPSY_ERROR__INSUFFICIENT_FUNDS_FOR_FEE = 6603;
-var DROPSY_ERROR__INVALID_FEE_VAULT = 6604;
-var DROPSY_ERROR__INVALID_FEE_VAULT_OWNER = 6605;
-var DROPSY_ERROR__INVALID_FEE_VAULT_CURVE = 6606;
-var DROPSY_ERROR__INVALID_PDA = 6700;
-var DROPSY_ERROR__INVALID_AMOUNT = 6701;
-var DROPSY_ERROR__OVERFLOW = 6702;
-var DROPSY_ERROR__VAULT_NOT_RENT_EXEMPT = 6703;
-var DROPSY_ERROR__INVALID_TREASURY_ACCOUNT = 6704;
-var DROPSY_ERROR__INVALID_AIRDROP_VERSION = 6705;
-var DROPSY_ERROR__INVALID_VESTING_TYPE = 6707;
-var DROPSY_ERROR__VESTING_ACCOUNT_REQUIRED = 6708;
-var DROPSY_ERROR__INVALID_PARENT_ACCOUNT = 6709;
-var DROPSY_ERROR__INVALID_AIRDROP_VESTING_VERSION = 6710;
-var DROPSY_ERROR__INVALID_AIRDROP_MASTER_ACCOUNT = 6711;
-var dropsyErrorMessages;
-if (process.env.NODE_ENV !== "production") {
-  dropsyErrorMessages = {
-    [DROPSY_ERROR__ACTIVE_BITMAPS_EXIST]: `Active bitmaps exist`,
-    [DROPSY_ERROR__AIRDROP_ENDED]: `Airdrop has already ended`,
-    [DROPSY_ERROR__AIRDROP_NOT_ENDED]: `Airdrop not yet ended`,
-    [DROPSY_ERROR__AIRDROP_NOT_STARTED]: `Airdrop has not started yet`,
-    [DROPSY_ERROR__ALREADY_CLAIMED]: `Tokens already claimed`,
-    [DROPSY_ERROR__BITMAP_AIRDROP_MISMATCH]: `Bitmap/airdrop mismatch`,
-    [DROPSY_ERROR__BITMAP_COUNT_UNDERFLOW]: `Bitmaps already closed`,
-    [DROPSY_ERROR__BITMAP_TOO_LARGE]: `Bitmap size exceeds limit`,
-    [DROPSY_ERROR__CLAIM_FEE_TOO_HIGH]: `Claim fee too high (>0.005 SOL)`,
-    [DROPSY_ERROR__CREATE_FEE_TOO_HIGH]: `Create fee too high (>0.05 SOL)`,
-    [DROPSY_ERROR__DESTINATION_MINT_MISMATCH]: `Destination mint doesn't match`,
-    [DROPSY_ERROR__DURATION_TOO_SHORT]: `Airdrop duration must be at least 24 hours`,
-    [DROPSY_ERROR__IMMUTABLE_AIRDROP]: `Airdrop is immutable`,
-    [DROPSY_ERROR__IMMUTABLE_FIELD]: `The target field is immutable`,
-    [DROPSY_ERROR__INSUFFICIENT_DEPOSIT]: `Insufficient SOL deposit`,
-    [DROPSY_ERROR__INSUFFICIENT_FUNDS_FOR_FEE]: `Insufficient funds for fee`,
-    [DROPSY_ERROR__INSUFFICIENT_VAULT_FUNDS]: `Insufficient vault funds`,
-    [DROPSY_ERROR__INVALID_ADMIN]: `This Request Requires Admin Privileges`,
-    [DROPSY_ERROR__INVALID_AFFILIATE_PDA]: `Mismatched affiliate PDA`,
-    [DROPSY_ERROR__INVALID_AIRDROP_MASTER_ACCOUNT]: `Invalid Airdrop Master`,
-    [DROPSY_ERROR__INVALID_AIRDROP_PDA]: `Invalid vault account`,
-    [DROPSY_ERROR__INVALID_AIRDROP_VERSION]: `invalid airdrop version`,
-    [DROPSY_ERROR__INVALID_AIRDROP_VESTING_VERSION]: `Airdrop version don't support vesting`,
-    [DROPSY_ERROR__INVALID_AMOUNT]: `Invalid amount`,
-    [DROPSY_ERROR__INVALID_BITMAP_ACCOUNT]: `Invalid bitmap account`,
-    [DROPSY_ERROR__INVALID_BITMAP_INDEX]: `Invalid bitmap index`,
-    [DROPSY_ERROR__INVALID_DELEGATE_PERMISSION]: `Invalid delegate permission Value`,
-    [DROPSY_ERROR__INVALID_DESTINATION_OWNER]: `Destination account owner is not the signer`,
-    [DROPSY_ERROR__INVALID_END_TIME]: `Airdrop must end at least 24 hours in the future`,
-    [DROPSY_ERROR__INVALID_FEE_VAULT]: `Invalid fee vault`,
-    [DROPSY_ERROR__INVALID_FEE_VAULT_CURVE]: `Fee vault not in curve`,
-    [DROPSY_ERROR__INVALID_FEE_VAULT_OWNER]: `Invalid fee vault owner`,
-    [DROPSY_ERROR__INVALID_MINT]: `Mint does not match stored state`,
-    [DROPSY_ERROR__INVALID_MINT_OWNER]: `Invalid token program owner`,
-    [DROPSY_ERROR__INVALID_MUTABILITY]: `Invalid mutability Value`,
-    [DROPSY_ERROR__INVALID_OWNER]: `Transaction sender is not the owner`,
-    [DROPSY_ERROR__INVALID_PARENT_ACCOUNT]: `Invalid Parent account provided`,
-    [DROPSY_ERROR__INVALID_PDA]: `Invalid PDA account`,
-    [DROPSY_ERROR__INVALID_PERCENTAGE]: `Invalid percentage (must be 0-100)`,
-    [DROPSY_ERROR__INVALID_PROOF]: `Invalid merkle proof`,
-    [DROPSY_ERROR__INVALID_PUB_KEY]: `Invalid Pubkey provided`,
-    [DROPSY_ERROR__INVALID_TIMESTAMP]: `Invalid timestamp or duration`,
-    [DROPSY_ERROR__INVALID_TOTAL]: `Invalid total claimers`,
-    [DROPSY_ERROR__INVALID_TREASURY_ACCOUNT]: `invalid treasury account`,
-    [DROPSY_ERROR__INVALID_VAULT_AUTHORITY]: `Invalid vault authority`,
-    [DROPSY_ERROR__INVALID_VESTING_SCHEDULE]: `Vesting schedule is invalid`,
-    [DROPSY_ERROR__INVALID_VESTING_TYPE]: `Invalid vesting type`,
-    [DROPSY_ERROR__MAX_AIRDROPS_REACHED]: `Airdrop quota reached. Upgrade required for Airdrop Master.`,
-    [DROPSY_ERROR__MAX_CLAIM_MAPS_REACHED]: `ClaimMap quota reached. Upgrade required for Airdrop Master.`,
-    [DROPSY_ERROR__MINT_HAS_FREEZE_AUTHORITY]: `Mint has freeze authority`,
-    [DROPSY_ERROR__MINT_IS_FROZEN]: `Mint is frozen`,
-    [DROPSY_ERROR__MINT_IS_NOT_INITIALIZED]: `Mint must be initialized`,
-    [DROPSY_ERROR__MINT_MISMATCH]: `Provided mint doesn't match expected mint`,
-    [DROPSY_ERROR__MISSING_BITMAP_PDA]: `Missing bitmap PDA`,
-    [DROPSY_ERROR__NFT_NOT_ALLOWED]: `Fungible tokens only (no NFTs)`,
-    [DROPSY_ERROR__NON_ZERO_VALUE_REQUIRED]: `Number must be non-zero`,
-    [DROPSY_ERROR__OVERFLOW]: `Arithmetic overflow`,
-    [DROPSY_ERROR__OWNER_MISMATCH]: `Airdrop owner mismatch`,
-    [DROPSY_ERROR__SOURCE_ACCOUNT_FROZEN]: `Source account is frozen`,
-    [DROPSY_ERROR__SOURCE_HAS_CLOSE_AUTHORITY]: `Source has close authority`,
-    [DROPSY_ERROR__SOURCE_HAS_DELEGATE]: `Source has delegate set`,
-    [DROPSY_ERROR__TOO_MANY_BITMAPS]: `Too many bitmap accounts`,
-    [DROPSY_ERROR__UNAUTHORIZED]: `Not Authorized`,
-    [DROPSY_ERROR__UN_AUTHORIZED]: `Invalid Authority Pubkey`,
-    [DROPSY_ERROR__UPDATE_CUTOFF_TIME_PASSED]: `Airdrop updates are only allowed until cutoff time before start`,
-    [DROPSY_ERROR__VALUE_BELOW_THE_MINIMUM]: `Value below the minimum`,
-    [DROPSY_ERROR__VALUE_EXCEEDS_MAXIMUM]: `Value exceeds the maximum`,
-    [DROPSY_ERROR__VALUE_OUT_OF_RANGE]: `Value out of range`,
-    [DROPSY_ERROR__VAULT_FROZEN]: `Vault is frozen`,
-    [DROPSY_ERROR__VAULT_HAS_CLOSE_AUTHORITY]: `Vault has close authority`,
-    [DROPSY_ERROR__VAULT_HAS_DELEGATE]: `Vault has delegate set`,
-    [DROPSY_ERROR__VAULT_MINT_MISMATCH]: `Vault mint doesn't match airdrop mint`,
-    [DROPSY_ERROR__VAULT_NOT_INITIALIZED]: `Vault not initialized`,
-    [DROPSY_ERROR__VAULT_NOT_RENT_EXEMPT]: `Vault not rent exempt`,
-    [DROPSY_ERROR__VESTING_ACCOUNT_REQUIRED]: `vesting account required for vested airdrop`
-  };
-}
-function getDropsyErrorMessage(code) {
-  if (process.env.NODE_ENV !== "production") {
-    return dropsyErrorMessages[code];
-  }
-  return "Error message not available in production bundles.";
-}
-function isDropsyError(error, transactionMessage, code) {
-  return isProgramError(
-    error,
-    transactionMessage,
-    DROPSY_PROGRAM_ADDRESS,
-    code
-  );
-}
-
-// src/instructions/claimAirdrop.ts
-import {
-  combineCodec as combineCodec8,
-  fixDecoderSize as fixDecoderSize8,
-  fixEncoderSize as fixEncoderSize9,
-  getAddressEncoder as getAddressEncoder7,
-  getArrayDecoder,
-  getArrayEncoder,
-  getBytesDecoder as getBytesDecoder8,
-  getBytesEncoder as getBytesEncoder9,
-  getProgramDerivedAddress,
-  getStructDecoder as getStructDecoder8,
-  getStructEncoder as getStructEncoder8,
-  getU16Decoder as getU16Decoder4,
-  getU16Encoder as getU16Encoder4,
-  getU64Decoder as getU64Decoder7,
-  getU64Encoder as getU64Encoder7,
-  transformEncoder as transformEncoder8
-} from "@solana/kit";
-
-// src/shared/index.ts
-import {
-  AccountRole,
-  isProgramDerivedAddress,
-  isTransactionSigner as kitIsTransactionSigner,
-  upgradeRoleToSigner
-} from "@solana/kit";
-function expectSome(value) {
-  if (value === null || value === void 0) {
-    throw new Error("Expected a value but received null or undefined.");
-  }
-  return value;
-}
-function expectAddress(value) {
-  if (!value) {
-    throw new Error("Expected a Address.");
-  }
-  if (typeof value === "object" && "address" in value) {
-    return value.address;
-  }
-  if (Array.isArray(value)) {
-    return value[0];
-  }
-  return value;
-}
-function getAccountMetaFactory(programAddress, optionalAccountStrategy) {
-  return (account) => {
-    if (!account.value) {
-      if (optionalAccountStrategy === "omitted") return;
-      return Object.freeze({
-        address: programAddress,
-        role: AccountRole.READONLY
-      });
-    }
-    const writableRole = account.isWritable ? AccountRole.WRITABLE : AccountRole.READONLY;
-    return Object.freeze({
-      address: expectAddress(account.value),
-      role: isTransactionSigner(account.value) ? upgradeRoleToSigner(writableRole) : writableRole,
-      ...isTransactionSigner(account.value) ? { signer: account.value } : {}
-    });
-  };
-}
-function isTransactionSigner(value) {
-  return !!value && typeof value === "object" && "address" in value && kitIsTransactionSigner(value);
-}
-
-// src/instructions/claimAirdrop.ts
-var CLAIM_AIRDROP_DISCRIMINATOR = new Uint8Array([
-  137,
-  50,
-  122,
-  111,
-  89,
-  254,
-  8,
-  20
-]);
-function getClaimAirdropDiscriminatorBytes() {
-  return fixEncoderSize9(getBytesEncoder9(), 8).encode(
-    CLAIM_AIRDROP_DISCRIMINATOR
-  );
-}
-function getClaimAirdropInstructionDataEncoder() {
-  return transformEncoder8(
-    getStructEncoder8([
-      ["discriminator", fixEncoderSize9(getBytesEncoder9(), 8)],
-      ["index", getU64Encoder7()],
-      ["proof", getArrayEncoder(fixEncoderSize9(getBytesEncoder9(), 32))],
-      ["amount", getU64Encoder7()],
-      ["claimMapIndex", getU16Encoder4()]
-    ]),
-    (value) => ({ ...value, discriminator: CLAIM_AIRDROP_DISCRIMINATOR })
-  );
-}
-function getClaimAirdropInstructionDataDecoder() {
-  return getStructDecoder8([
-    ["discriminator", fixDecoderSize8(getBytesDecoder8(), 8)],
-    ["index", getU64Decoder7()],
-    ["proof", getArrayDecoder(fixDecoderSize8(getBytesDecoder8(), 32))],
-    ["amount", getU64Decoder7()],
-    ["claimMapIndex", getU16Decoder4()]
-  ]);
-}
-function getClaimAirdropInstructionDataCodec() {
-  return combineCodec8(
-    getClaimAirdropInstructionDataEncoder(),
-    getClaimAirdropInstructionDataDecoder()
-  );
-}
-async function getClaimAirdropInstructionAsync(input, config) {
-  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    master: { value: input.master ?? null, isWritable: false },
-    config: { value: input.config ?? null, isWritable: false },
-    treasury: { value: input.treasury ?? null, isWritable: true },
-    airdropMaster: { value: input.airdropMaster ?? null, isWritable: true },
-    affiliate: { value: input.affiliate ?? null, isWritable: true },
-    sourceTokenAccount: {
-      value: input.sourceTokenAccount ?? null,
-      isWritable: true
-    },
-    destinationTokenAccount: {
-      value: input.destinationTokenAccount ?? null,
-      isWritable: true
-    },
-    airdrop: { value: input.airdrop ?? null, isWritable: false },
-    authority: { value: input.authority ?? null, isWritable: false },
-    bitmap: { value: input.bitmap ?? null, isWritable: true },
-    mint: { value: input.mint ?? null, isWritable: false },
-    claimer: { value: input.claimer ?? null, isWritable: true },
-    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
-    associatedTokenProgram: {
-      value: input.associatedTokenProgram ?? null,
-      isWritable: false
-    },
-    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
-  };
-  const accounts = originalAccounts;
-  const args = { ...input };
-  if (!accounts.master.value) {
-    accounts.master.value = await getProgramDerivedAddress({
-      programAddress,
-      seeds: [
-        getBytesEncoder9().encode(new Uint8Array([109, 97, 115, 116, 101, 114]))
-      ]
-    });
-  }
-  if (!accounts.config.value) {
-    accounts.config.value = await getProgramDerivedAddress({
-      programAddress,
-      seeds: [
-        getBytesEncoder9().encode(
-          new Uint8Array([
-            97,
-            105,
-            114,
-            100,
-            114,
-            111,
-            112,
-            95,
-            99,
-            111,
-            110,
-            102,
-            105,
-            103
-          ])
-        )
-      ]
-    });
-  }
-  if (!accounts.tokenProgram.value) {
-    accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
-  }
-  if (!accounts.destinationTokenAccount.value) {
-    accounts.destinationTokenAccount.value = await getProgramDerivedAddress({
-      programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
-      seeds: [
-        getAddressEncoder7().encode(expectAddress(accounts.claimer.value)),
-        getAddressEncoder7().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder7().encode(expectAddress(accounts.mint.value))
-      ]
-    });
-  }
-  if (!accounts.airdrop.value) {
-    accounts.airdrop.value = await getProgramDerivedAddress({
-      programAddress,
-      seeds: [
-        getBytesEncoder9().encode(
-          new Uint8Array([97, 105, 114, 100, 114, 111, 112])
-        ),
-        getAddressEncoder7().encode(expectAddress(accounts.mint.value)),
-        getAddressEncoder7().encode(expectAddress(accounts.authority.value))
-      ]
-    });
-  }
-  if (!accounts.associatedTokenProgram.value) {
-    accounts.associatedTokenProgram.value = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
-  }
-  if (!accounts.systemProgram.value) {
-    accounts.systemProgram.value = "11111111111111111111111111111111";
-  }
-  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
-  return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.master),
-      getAccountMeta(accounts.config),
-      getAccountMeta(accounts.treasury),
-      getAccountMeta(accounts.airdropMaster),
-      getAccountMeta(accounts.affiliate),
-      getAccountMeta(accounts.sourceTokenAccount),
-      getAccountMeta(accounts.destinationTokenAccount),
-      getAccountMeta(accounts.airdrop),
-      getAccountMeta(accounts.authority),
-      getAccountMeta(accounts.bitmap),
-      getAccountMeta(accounts.mint),
-      getAccountMeta(accounts.claimer),
-      getAccountMeta(accounts.tokenProgram),
-      getAccountMeta(accounts.associatedTokenProgram),
-      getAccountMeta(accounts.systemProgram)
-    ],
-    data: getClaimAirdropInstructionDataEncoder().encode(
-      args
-    ),
-    programAddress
-  });
-}
-function getClaimAirdropInstruction(input, config) {
-  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    master: { value: input.master ?? null, isWritable: false },
-    config: { value: input.config ?? null, isWritable: false },
-    treasury: { value: input.treasury ?? null, isWritable: true },
-    airdropMaster: { value: input.airdropMaster ?? null, isWritable: true },
-    affiliate: { value: input.affiliate ?? null, isWritable: true },
-    sourceTokenAccount: {
-      value: input.sourceTokenAccount ?? null,
-      isWritable: true
-    },
-    destinationTokenAccount: {
-      value: input.destinationTokenAccount ?? null,
-      isWritable: true
-    },
-    airdrop: { value: input.airdrop ?? null, isWritable: false },
-    authority: { value: input.authority ?? null, isWritable: false },
-    bitmap: { value: input.bitmap ?? null, isWritable: true },
-    mint: { value: input.mint ?? null, isWritable: false },
-    claimer: { value: input.claimer ?? null, isWritable: true },
-    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
-    associatedTokenProgram: {
-      value: input.associatedTokenProgram ?? null,
-      isWritable: false
-    },
-    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
-  };
-  const accounts = originalAccounts;
-  const args = { ...input };
-  if (!accounts.tokenProgram.value) {
-    accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
-  }
-  if (!accounts.associatedTokenProgram.value) {
-    accounts.associatedTokenProgram.value = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
-  }
-  if (!accounts.systemProgram.value) {
-    accounts.systemProgram.value = "11111111111111111111111111111111";
-  }
-  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
-  return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.master),
-      getAccountMeta(accounts.config),
-      getAccountMeta(accounts.treasury),
-      getAccountMeta(accounts.airdropMaster),
-      getAccountMeta(accounts.affiliate),
-      getAccountMeta(accounts.sourceTokenAccount),
-      getAccountMeta(accounts.destinationTokenAccount),
-      getAccountMeta(accounts.airdrop),
-      getAccountMeta(accounts.authority),
-      getAccountMeta(accounts.bitmap),
-      getAccountMeta(accounts.mint),
-      getAccountMeta(accounts.claimer),
-      getAccountMeta(accounts.tokenProgram),
-      getAccountMeta(accounts.associatedTokenProgram),
-      getAccountMeta(accounts.systemProgram)
-    ],
-    data: getClaimAirdropInstructionDataEncoder().encode(
-      args
-    ),
-    programAddress
-  });
-}
-function parseClaimAirdropInstruction(instruction) {
-  if (instruction.accounts.length < 15) {
-    throw new Error("Not enough accounts");
-  }
-  let accountIndex = 0;
-  const getNextAccount = () => {
-    const accountMeta = instruction.accounts[accountIndex];
-    accountIndex += 1;
-    return accountMeta;
-  };
-  const getNextOptionalAccount = () => {
-    const accountMeta = getNextAccount();
-    return accountMeta.address === DROPSY_PROGRAM_ADDRESS ? void 0 : accountMeta;
-  };
-  return {
-    programAddress: instruction.programAddress,
-    accounts: {
-      master: getNextAccount(),
-      config: getNextAccount(),
-      treasury: getNextAccount(),
-      airdropMaster: getNextAccount(),
-      affiliate: getNextOptionalAccount(),
-      sourceTokenAccount: getNextAccount(),
-      destinationTokenAccount: getNextAccount(),
-      airdrop: getNextAccount(),
-      authority: getNextAccount(),
-      bitmap: getNextAccount(),
-      mint: getNextAccount(),
-      claimer: getNextAccount(),
-      tokenProgram: getNextAccount(),
-      associatedTokenProgram: getNextAccount(),
-      systemProgram: getNextAccount()
-    },
-    data: getClaimAirdropInstructionDataDecoder().decode(instruction.data)
-  };
-}
-
-// src/instructions/createAirdrop.ts
-import {
-  combineCodec as combineCodec9,
-  fixDecoderSize as fixDecoderSize9,
-  fixEncoderSize as fixEncoderSize10,
-  getAddressDecoder as getAddressDecoder7,
-  getAddressEncoder as getAddressEncoder9,
-  getBytesDecoder as getBytesDecoder9,
-  getBytesEncoder as getBytesEncoder10,
-  getI64Decoder as getI64Decoder3,
-  getI64Encoder as getI64Encoder3,
-  getOptionDecoder,
-  getOptionEncoder,
-  getProgramDerivedAddress as getProgramDerivedAddress3,
-  getStructDecoder as getStructDecoder9,
-  getStructEncoder as getStructEncoder9,
-  getU8Decoder as getU8Decoder8,
-  getU8Encoder as getU8Encoder8,
-  transformEncoder as transformEncoder9
-} from "@solana/kit";
-
-// src/constants/index.ts
-import { address } from "@solana/kit";
-var DROPSY_MASTER_SEED = "master";
-var AIRDROP_CONFIG_SEED = "airdrop_config";
-var AFFILIATE_MASTER_SEED = "affiliate_master";
-var AIRDROP_MASTER_SEED = "airdrop_master";
-var AIRDROP_SEED = "airdrop";
-var AFFILIATE_SEED = "affiliate";
-var BITMAP_SEED = "bitmap";
-var VESTING_SEED = "vesting";
-var PRESALE_SEED = "presale";
-var VAULT_SEED = "vault";
-var ADMIN = address("8mtUD2XrkNnTxnjCehZ4DEtTXeGR1yrepSEGhCaSj2kT");
-var DROPSY_TREASURY = address("8mtUD2XrkNnTxnjCehZ4DEtTXeGR1yrepSEGhCaSj2kT");
-var DEFAULT_MASTER_PDA = address("8mtUD2XrkNnTxnjCehZ4DEtTXeGR1yrepSEGhCaSj2kT");
-var DEFAULT_MASTER_PDA_AUTHORITY = address("8mtUD2XrkNnTxnjCehZ4DEtTXeGR1yrepSEGhCaSj2kT");
-var BITMAP_SIZE = 8e3;
-var MAX_BITMAP_CLAIM = BITMAP_SIZE * 8;
-var VERSION_BASIC = 0;
-var VERSION_VESTED = 1;
-var STATE_INITIALIZED = 0;
-var STATE_DELEGATED = 1;
-var STATE_REDEEMED = 2;
-var MUTABLE_NONE = 0;
-
-// 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 createTransactionMessageFromInstructions = 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 getAddressEncoder8,
-  getProgramDerivedAddress as getProgramDerivedAddress2
-} from "@solana/kit";
-async function getDropsyDerivedAddress(seeds) {
-  return await getProgramDerivedAddress2({
-    seeds,
-    programAddress: DROPSY_PROGRAM_ADDRESS
-  });
-}
-async function getMasterDerivedAddress() {
-  return await getDropsyDerivedAddress([DROPSY_MASTER_SEED]);
-}
-async function getAirdropConfigDerivedAddress() {
-  return await getDropsyDerivedAddress([AIRDROP_CONFIG_SEED]);
-}
-async function getAirdropMasterDerivedAddress(authority) {
-  const seeds = [
-    AIRDROP_MASTER_SEED,
-    getAddressEncoder8().encode(authority)
-  ];
-  return await getDropsyDerivedAddress(seeds);
-}
-async function getAffiliateDerivedAddress(authority) {
-  const seeds = [
-    AFFILIATE_SEED,
-    getAddressEncoder8().encode(authority)
-  ];
-  return await getDropsyDerivedAddress(seeds);
-}
-async function getAirdropDerivedAddress(authority, mint) {
-  const seeds = [
-    AIRDROP_SEED,
-    getAddressEncoder8().encode(mint),
-    getAddressEncoder8().encode(authority)
-  ];
-  return await getDropsyDerivedAddress(seeds);
-}
-async function getClaimMapDerivedAddress(airdrop, id) {
-  const idBuffer = Buffer.alloc(2);
-  idBuffer.writeUInt16LE(id);
-  const seeds = [
-    BITMAP_SEED,
-    getAddressEncoder8().encode(airdrop),
-    idBuffer
-  ];
-  return await getDropsyDerivedAddress(seeds);
-}
-
-// src/utils/helper.ts
-function toUnixTimestamp(date) {
-  if (!date) return null;
-  return Math.floor(date.getTime() / 1e3);
-}
-
-// src/utils/merkle.ts
-import { createHash } from "crypto";
-import MerkleTree from "merkletreejs";
-function hashLeaf(index, address2, amount) {
-  const data = `${index}:${address2}:${amount.toString()}`;
-  return createHash("sha256").update(data).digest();
-}
-function hashAddress(address2) {
-  return createHash("sha256").update(address2).digest();
-}
-var createWLMerkleTree = (wallets) => {
-  const leaves = wallets.map((address2) => hashAddress(address2));
-  return new MerkleTree(
-    leaves,
-    (data) => createHash("sha256").update(data).digest(),
-    { sortPairs: true }
-  );
-};
-var getSimpleMerkleProof = (merkleTree, address2) => {
-  const leaf = hashAddress(address2);
-  return merkleTree.getProof(leaf).map((p) => p.data);
-};
-var getMerkleRootArray = (merkleTree) => {
-  const root = merkleTree.getRoot();
-  if (root.length !== 32) {
-    throw new Error("Merkle root must be 32 bytes");
-  }
-  const uint8Root = new Uint8Array(root);
-  return uint8Root;
-};
-var createMerkleTree = (claimList) => {
-  const leaves = claimList.map(
-    ({ index, address: address2, amount }) => hashLeaf(index, address2, amount)
-  );
-  const merkleTree = new MerkleTree(
-    leaves,
-    (data) => createHash("sha256").update(data).digest(),
-    { sortPairs: true }
-  );
-  return merkleTree;
-};
-
-// src/instructions/createAirdrop.ts
-var CREATE_AIRDROP_DISCRIMINATOR = new Uint8Array([
-  227,
-  135,
-  208,
-  66,
-  137,
-  177,
-  80,
-  94
-]);
-function getCreateAirdropDiscriminatorBytes() {
-  return fixEncoderSize10(getBytesEncoder10(), 8).encode(
-    CREATE_AIRDROP_DISCRIMINATOR
-  );
-}
-function getCreateAirdropInstructionDataEncoder() {
-  return transformEncoder9(
-    getStructEncoder9([
-      ["discriminator", fixEncoderSize10(getBytesEncoder10(), 8)],
-      ["merkleRoot", getOptionEncoder(fixEncoderSize10(getBytesEncoder10(), 32))],
-      ["startsAt", getOptionEncoder(getI64Encoder3())],
-      ["endsAt", getOptionEncoder(getI64Encoder3())],
-      ["version", getOptionEncoder(getU8Encoder8())],
-      ["mutable", getOptionEncoder(getU8Encoder8())],
-      ["delegateAuthority", getOptionEncoder(getAddressEncoder9())],
-      ["delegatePermissions", getOptionEncoder(getU8Encoder8())]
-    ]),
-    (value) => ({ ...value, discriminator: CREATE_AIRDROP_DISCRIMINATOR })
-  );
-}
-function getCreateAirdropInstructionDataDecoder() {
-  return getStructDecoder9([
-    ["discriminator", fixDecoderSize9(getBytesDecoder9(), 8)],
-    ["merkleRoot", getOptionDecoder(fixDecoderSize9(getBytesDecoder9(), 32))],
-    ["startsAt", getOptionDecoder(getI64Decoder3())],
-    ["endsAt", getOptionDecoder(getI64Decoder3())],
-    ["version", getOptionDecoder(getU8Decoder8())],
-    ["mutable", getOptionDecoder(getU8Decoder8())],
-    ["delegateAuthority", getOptionDecoder(getAddressDecoder7())],
-    ["delegatePermissions", getOptionDecoder(getU8Decoder8())]
-  ]);
-}
-function getCreateAirdropInstructionDataCodec() {
-  return combineCodec9(
-    getCreateAirdropInstructionDataEncoder(),
-    getCreateAirdropInstructionDataDecoder()
-  );
-}
-async function getCreateAirdropInstructionAsync(input, config) {
-  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    master: { value: input.master ?? null, isWritable: false },
-    config: { value: input.config ?? null, isWritable: false },
-    treasury: { value: input.treasury ?? null, isWritable: true },
-    airdropMaster: { value: input.airdropMaster ?? null, isWritable: true },
-    affiliate: { value: input.affiliate ?? null, isWritable: true },
-    airdrop: { value: input.airdrop ?? 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.master.value) {
-    accounts.master.value = await getProgramDerivedAddress3({
-      programAddress,
-      seeds: [
-        getBytesEncoder10().encode(new Uint8Array([109, 97, 115, 116, 101, 114]))
-      ]
-    });
-  }
-  if (!accounts.config.value) {
-    accounts.config.value = await getProgramDerivedAddress3({
-      programAddress,
-      seeds: [
-        getBytesEncoder10().encode(
-          new Uint8Array([
-            97,
-            105,
-            114,
-            100,
-            114,
-            111,
-            112,
-            95,
-            99,
-            111,
-            110,
-            102,
-            105,
-            103
-          ])
-        )
-      ]
-    });
-  }
-  if (!accounts.airdrop.value) {
-    accounts.airdrop.value = await getProgramDerivedAddress3({
-      programAddress,
-      seeds: [
-        getBytesEncoder10().encode(
-          new Uint8Array([97, 105, 114, 100, 114, 111, 112])
-        ),
-        getAddressEncoder9().encode(expectAddress(accounts.mint.value)),
-        getAddressEncoder9().encode(expectAddress(accounts.authority.value))
-      ]
-    });
-  }
-  if (!accounts.systemProgram.value) {
-    accounts.systemProgram.value = "11111111111111111111111111111111";
-  }
-  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
-  return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.master),
-      getAccountMeta(accounts.config),
-      getAccountMeta(accounts.treasury),
-      getAccountMeta(accounts.airdropMaster),
-      getAccountMeta(accounts.affiliate),
-      getAccountMeta(accounts.airdrop),
-      getAccountMeta(accounts.mint),
-      getAccountMeta(accounts.authority),
-      getAccountMeta(accounts.systemProgram)
-    ],
-    data: getCreateAirdropInstructionDataEncoder().encode(
-      args
-    ),
-    programAddress
-  });
-}
-function getCreateAirdropInstruction(input, config) {
-  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    master: { value: input.master ?? null, isWritable: false },
-    config: { value: input.config ?? null, isWritable: false },
-    treasury: { value: input.treasury ?? null, isWritable: true },
-    airdropMaster: { value: input.airdropMaster ?? null, isWritable: true },
-    affiliate: { value: input.affiliate ?? null, isWritable: true },
-    airdrop: { value: input.airdrop ?? 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.systemProgram.value) {
-    accounts.systemProgram.value = "11111111111111111111111111111111";
-  }
-  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
-  return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.master),
-      getAccountMeta(accounts.config),
-      getAccountMeta(accounts.treasury),
-      getAccountMeta(accounts.airdropMaster),
-      getAccountMeta(accounts.affiliate),
-      getAccountMeta(accounts.airdrop),
-      getAccountMeta(accounts.mint),
-      getAccountMeta(accounts.authority),
-      getAccountMeta(accounts.systemProgram)
-    ],
-    data: getCreateAirdropInstructionDataEncoder().encode(
-      args
-    ),
-    programAddress
-  });
-}
-function parseCreateAirdropInstruction(instruction) {
-  if (instruction.accounts.length < 9) {
-    throw new Error("Not enough accounts");
-  }
-  let accountIndex = 0;
-  const getNextAccount = () => {
-    const accountMeta = instruction.accounts[accountIndex];
-    accountIndex += 1;
-    return accountMeta;
-  };
-  const getNextOptionalAccount = () => {
-    const accountMeta = getNextAccount();
-    return accountMeta.address === DROPSY_PROGRAM_ADDRESS ? void 0 : accountMeta;
-  };
-  return {
-    programAddress: instruction.programAddress,
-    accounts: {
-      master: getNextAccount(),
-      config: getNextAccount(),
-      treasury: getNextAccount(),
-      airdropMaster: getNextAccount(),
-      affiliate: getNextOptionalAccount(),
-      airdrop: getNextAccount(),
-      mint: getNextAccount(),
-      authority: getNextAccount(),
-      systemProgram: getNextAccount()
-    },
-    data: getCreateAirdropInstructionDataDecoder().decode(instruction.data)
-  };
-}
-async function getCreateAirdropV0Instruction(input) {
-  return await getCreateAirdropInstructionAsync({
-    airdropMaster: input.airdropMaster ?? DEFAULT_MASTER_PDA,
-    treasury: DROPSY_TREASURY,
-    airdrop: input.airdrop,
-    mint: input.mint,
-    authority: input.authority,
-    merkleRoot: input.merkleRoot ?? null,
-    startsAt: toUnixTimestamp(input.startsAt),
-    endsAt: toUnixTimestamp(input.endsAt),
-    version: 0,
-    mutable: null,
-    delegateAuthority: null,
-    delegatePermissions: null
-  });
-}
-
-// src/instructions/createClaimMap.ts
-import {
-  combineCodec as combineCodec10,
-  fixDecoderSize as fixDecoderSize10,
-  fixEncoderSize as fixEncoderSize11,
-  getAddressEncoder as getAddressEncoder10,
-  getBytesDecoder as getBytesDecoder10,
-  getBytesEncoder as getBytesEncoder11,
-  getProgramDerivedAddress as getProgramDerivedAddress4,
-  getStructDecoder as getStructDecoder10,
-  getStructEncoder as getStructEncoder10,
-  getU16Decoder as getU16Decoder5,
-  getU16Encoder as getU16Encoder5,
-  getU32Decoder as getU32Decoder3,
-  getU32Encoder as getU32Encoder3,
-  transformEncoder as transformEncoder10
-} from "@solana/kit";
-var CREATE_CLAIM_MAP_DISCRIMINATOR = new Uint8Array([
-  22,
-  150,
-  81,
-  49,
-  214,
-  142,
-  189,
-  122
-]);
-function getCreateClaimMapDiscriminatorBytes() {
-  return fixEncoderSize11(getBytesEncoder11(), 8).encode(
-    CREATE_CLAIM_MAP_DISCRIMINATOR
-  );
-}
-function getCreateClaimMapInstructionDataEncoder() {
-  return transformEncoder10(
-    getStructEncoder10([
-      ["discriminator", fixEncoderSize11(getBytesEncoder11(), 8)],
-      ["id", getU16Encoder5()],
-      ["total", getU32Encoder3()]
-    ]),
-    (value) => ({ ...value, discriminator: CREATE_CLAIM_MAP_DISCRIMINATOR })
-  );
-}
-function getCreateClaimMapInstructionDataDecoder() {
-  return getStructDecoder10([
-    ["discriminator", fixDecoderSize10(getBytesDecoder10(), 8)],
-    ["id", getU16Decoder5()],
-    ["total", getU32Decoder3()]
-  ]);
-}
-function getCreateClaimMapInstructionDataCodec() {
-  return combineCodec10(
-    getCreateClaimMapInstructionDataEncoder(),
-    getCreateClaimMapInstructionDataDecoder()
-  );
-}
-async function getCreateClaimMapInstructionAsync(input, config) {
-  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    master: { value: input.master ?? null, isWritable: false },
-    config: { value: input.config ?? null, isWritable: false },
-    treasury: { value: input.treasury ?? null, isWritable: true },
-    airdropMaster: { value: input.airdropMaster ?? null, isWritable: true },
-    affiliate: { value: input.affiliate ?? null, isWritable: true },
-    airdrop: { value: input.airdrop ?? null, isWritable: true },
-    mint: { value: input.mint ?? null, isWritable: false },
-    bitmap: { value: input.bitmap ?? 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,
-      seeds: [
-        getBytesEncoder11().encode(new Uint8Array([109, 97, 115, 116, 101, 114]))
-      ]
-    });
-  }
-  if (!accounts.config.value) {
-    accounts.config.value = await getProgramDerivedAddress4({
-      programAddress,
-      seeds: [
-        getBytesEncoder11().encode(
-          new Uint8Array([
-            97,
-            105,
-            114,
-            100,
-            114,
-            111,
-            112,
-            95,
-            99,
-            111,
-            110,
-            102,
-            105,
-            103
-          ])
-        )
-      ]
-    });
-  }
-  if (!accounts.airdrop.value) {
-    accounts.airdrop.value = await getProgramDerivedAddress4({
-      programAddress,
-      seeds: [
-        getBytesEncoder11().encode(
-          new Uint8Array([97, 105, 114, 100, 114, 111, 112])
-        ),
-        getAddressEncoder10().encode(expectAddress(accounts.mint.value)),
-        getAddressEncoder10().encode(expectAddress(accounts.authority.value))
-      ]
-    });
-  }
-  if (!accounts.bitmap.value) {
-    accounts.bitmap.value = await getProgramDerivedAddress4({
-      programAddress,
-      seeds: [
-        getBytesEncoder11().encode(new Uint8Array([98, 105, 116, 109, 97, 112])),
-        getAddressEncoder10().encode(expectAddress(accounts.airdrop.value)),
-        getU16Encoder5().encode(expectSome(args.id))
-      ]
-    });
-  }
-  if (!accounts.systemProgram.value) {
-    accounts.systemProgram.value = "11111111111111111111111111111111";
-  }
-  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
-  return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.master),
-      getAccountMeta(accounts.config),
-      getAccountMeta(accounts.treasury),
-      getAccountMeta(accounts.airdropMaster),
-      getAccountMeta(accounts.affiliate),
-      getAccountMeta(accounts.airdrop),
-      getAccountMeta(accounts.mint),
-      getAccountMeta(accounts.bitmap),
-      getAccountMeta(accounts.authority),
-      getAccountMeta(accounts.systemProgram)
-    ],
-    data: getCreateClaimMapInstructionDataEncoder().encode(
-      args
-    ),
-    programAddress
-  });
-}
-function getCreateClaimMapInstruction(input, config) {
-  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    master: { value: input.master ?? null, isWritable: false },
-    config: { value: input.config ?? null, isWritable: false },
-    treasury: { value: input.treasury ?? null, isWritable: true },
-    airdropMaster: { value: input.airdropMaster ?? null, isWritable: true },
-    affiliate: { value: input.affiliate ?? null, isWritable: true },
-    airdrop: { value: input.airdrop ?? null, isWritable: true },
-    mint: { value: input.mint ?? null, isWritable: false },
-    bitmap: { value: input.bitmap ?? 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.systemProgram.value) {
-    accounts.systemProgram.value = "11111111111111111111111111111111";
-  }
-  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
-  return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.master),
-      getAccountMeta(accounts.config),
-      getAccountMeta(accounts.treasury),
-      getAccountMeta(accounts.airdropMaster),
-      getAccountMeta(accounts.affiliate),
-      getAccountMeta(accounts.airdrop),
-      getAccountMeta(accounts.mint),
-      getAccountMeta(accounts.bitmap),
-      getAccountMeta(accounts.authority),
-      getAccountMeta(accounts.systemProgram)
-    ],
-    data: getCreateClaimMapInstructionDataEncoder().encode(
-      args
-    ),
-    programAddress
-  });
-}
-function parseCreateClaimMapInstruction(instruction) {
-  if (instruction.accounts.length < 10) {
-    throw new Error("Not enough accounts");
-  }
-  let accountIndex = 0;
-  const getNextAccount = () => {
-    const accountMeta = instruction.accounts[accountIndex];
-    accountIndex += 1;
-    return accountMeta;
-  };
-  const getNextOptionalAccount = () => {
-    const accountMeta = getNextAccount();
-    return accountMeta.address === DROPSY_PROGRAM_ADDRESS ? void 0 : accountMeta;
-  };
-  return {
-    programAddress: instruction.programAddress,
-    accounts: {
-      master: getNextAccount(),
-      config: getNextAccount(),
-      treasury: getNextAccount(),
-      airdropMaster: getNextAccount(),
-      affiliate: getNextOptionalAccount(),
-      airdrop: getNextAccount(),
-      mint: getNextAccount(),
-      bitmap: getNextAccount(),
-      authority: getNextAccount(),
-      systemProgram: getNextAccount()
-    },
-    data: getCreateClaimMapInstructionDataDecoder().decode(instruction.data)
-  };
-}
-async function getCreateClaimMapV0Instruction(input) {
-  return await getCreateClaimMapInstructionAsync({
-    airdropMaster: input.airdropMaster ?? DEFAULT_MASTER_PDA,
-    treasury: DROPSY_TREASURY,
-    airdrop: input.airdrop,
-    bitmap: input.claimMap,
-    mint: input.mint,
-    authority: input.authority,
-    id: input.id ?? 0,
-    total: input.total ?? MAX_BITMAP_CLAIM
-  });
-}
-
-// src/instructions/depositTokens.ts
-import {
-  combineCodec as combineCodec11,
-  fixDecoderSize as fixDecoderSize11,
-  fixEncoderSize as fixEncoderSize12,
-  getAddressEncoder as getAddressEncoder11,
-  getBytesDecoder as getBytesDecoder11,
-  getBytesEncoder as getBytesEncoder12,
-  getProgramDerivedAddress as getProgramDerivedAddress5,
-  getStructDecoder as getStructDecoder11,
-  getStructEncoder as getStructEncoder11,
-  getU64Decoder as getU64Decoder8,
-  getU64Encoder as getU64Encoder8,
-  transformEncoder as transformEncoder11
-} from "@solana/kit";
-var DEPOSIT_TOKENS_DISCRIMINATOR = new Uint8Array([
-  176,
-  83,
-  229,
-  18,
-  191,
-  143,
-  176,
-  150
-]);
-function getDepositTokensDiscriminatorBytes() {
-  return fixEncoderSize12(getBytesEncoder12(), 8).encode(
-    DEPOSIT_TOKENS_DISCRIMINATOR
-  );
-}
-function getDepositTokensInstructionDataEncoder() {
-  return transformEncoder11(
-    getStructEncoder11([
-      ["discriminator", fixEncoderSize12(getBytesEncoder12(), 8)],
-      ["amount", getU64Encoder8()]
-    ]),
-    (value) => ({ ...value, discriminator: DEPOSIT_TOKENS_DISCRIMINATOR })
-  );
-}
-function getDepositTokensInstructionDataDecoder() {
-  return getStructDecoder11([
-    ["discriminator", fixDecoderSize11(getBytesDecoder11(), 8)],
-    ["amount", getU64Decoder8()]
-  ]);
-}
-function getDepositTokensInstructionDataCodec() {
-  return combineCodec11(
-    getDepositTokensInstructionDataEncoder(),
-    getDepositTokensInstructionDataDecoder()
-  );
-}
-async function getDepositTokensInstructionAsync(input, config) {
-  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    master: { value: input.master ?? null, isWritable: false },
-    config: { value: input.config ?? null, isWritable: false },
-    treasury: { value: input.treasury ?? null, isWritable: true },
-    airdropMaster: { value: input.airdropMaster ?? null, isWritable: true },
-    affiliate: { value: input.affiliate ?? null, isWritable: true },
-    sourceTokenAccount: {
-      value: input.sourceTokenAccount ?? null,
-      isWritable: true
-    },
-    destinationTokenAccount: {
-      value: input.destinationTokenAccount ?? null,
-      isWritable: true
-    },
-    airdrop: { value: input.airdrop ?? null, isWritable: true },
-    mint: { value: input.mint ?? null, isWritable: false },
-    authority: { value: input.authority ?? null, isWritable: true },
-    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
-    associatedTokenProgram: {
-      value: input.associatedTokenProgram ?? null,
-      isWritable: false
-    },
-    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
-  };
-  const accounts = originalAccounts;
-  const args = { ...input };
-  if (!accounts.master.value) {
-    accounts.master.value = await getProgramDerivedAddress5({
-      programAddress,
-      seeds: [
-        getBytesEncoder12().encode(new Uint8Array([109, 97, 115, 116, 101, 114]))
-      ]
-    });
-  }
-  if (!accounts.config.value) {
-    accounts.config.value = await getProgramDerivedAddress5({
-      programAddress,
-      seeds: [
-        getBytesEncoder12().encode(
-          new Uint8Array([
-            97,
-            105,
-            114,
-            100,
-            114,
-            111,
-            112,
-            95,
-            99,
-            111,
-            110,
-            102,
-            105,
-            103
-          ])
-        )
-      ]
-    });
-  }
-  if (!accounts.airdropMaster.value) {
-    accounts.airdropMaster.value = DEFAULT_MASTER_PDA;
-  }
-  if (!accounts.treasury.value) {
-    accounts.treasury.value = DROPSY_TREASURY;
-  }
-  if (!accounts.airdrop.value) {
-    accounts.airdrop.value = await getProgramDerivedAddress5({
-      programAddress,
-      seeds: [
-        getBytesEncoder12().encode(
-          new Uint8Array([97, 105, 114, 100, 114, 111, 112])
-        ),
-        getAddressEncoder11().encode(expectAddress(accounts.mint.value)),
-        getAddressEncoder11().encode(expectAddress(accounts.authority.value))
-      ]
-    });
-  }
-  if (!accounts.tokenProgram.value) {
-    accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
-  }
-  if (!accounts.destinationTokenAccount.value) {
-    accounts.destinationTokenAccount.value = await getProgramDerivedAddress5({
-      programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
-      seeds: [
-        getAddressEncoder11().encode(expectAddress(accounts.airdrop.value)),
-        getAddressEncoder11().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder11().encode(expectAddress(accounts.mint.value))
-      ]
-    });
-  }
-  if (!accounts.associatedTokenProgram.value) {
-    accounts.associatedTokenProgram.value = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
-  }
-  if (!accounts.systemProgram.value) {
-    accounts.systemProgram.value = "11111111111111111111111111111111";
-  }
-  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
-  return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.master),
-      getAccountMeta(accounts.config),
-      getAccountMeta(accounts.treasury),
-      getAccountMeta(accounts.airdropMaster),
-      getAccountMeta(accounts.affiliate),
-      getAccountMeta(accounts.sourceTokenAccount),
-      getAccountMeta(accounts.destinationTokenAccount),
-      getAccountMeta(accounts.airdrop),
-      getAccountMeta(accounts.mint),
-      getAccountMeta(accounts.authority),
-      getAccountMeta(accounts.tokenProgram),
-      getAccountMeta(accounts.associatedTokenProgram),
-      getAccountMeta(accounts.systemProgram)
-    ],
-    data: getDepositTokensInstructionDataEncoder().encode(
-      args
-    ),
-    programAddress
-  });
-}
-function getDepositTokensInstruction(input, config) {
-  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    master: { value: input.master ?? null, isWritable: false },
-    config: { value: input.config ?? null, isWritable: false },
-    treasury: { value: input.treasury ?? null, isWritable: true },
-    airdropMaster: { value: input.airdropMaster ?? null, isWritable: true },
-    affiliate: { value: input.affiliate ?? null, isWritable: true },
-    sourceTokenAccount: {
-      value: input.sourceTokenAccount ?? null,
-      isWritable: true
-    },
-    destinationTokenAccount: {
-      value: input.destinationTokenAccount ?? null,
-      isWritable: true
-    },
-    airdrop: { value: input.airdrop ?? null, isWritable: true },
-    mint: { value: input.mint ?? null, isWritable: false },
-    authority: { value: input.authority ?? null, isWritable: true },
-    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
-    associatedTokenProgram: {
-      value: input.associatedTokenProgram ?? null,
-      isWritable: false
-    },
-    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
-  };
-  const accounts = originalAccounts;
-  const args = { ...input };
-  if (!accounts.tokenProgram.value) {
-    accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
-  }
-  if (!accounts.associatedTokenProgram.value) {
-    accounts.associatedTokenProgram.value = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
-  }
-  if (!accounts.systemProgram.value) {
-    accounts.systemProgram.value = "11111111111111111111111111111111";
-  }
-  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
-  return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.master),
-      getAccountMeta(accounts.config),
-      getAccountMeta(accounts.treasury),
-      getAccountMeta(accounts.airdropMaster),
-      getAccountMeta(accounts.affiliate),
-      getAccountMeta(accounts.sourceTokenAccount),
-      getAccountMeta(accounts.destinationTokenAccount),
-      getAccountMeta(accounts.airdrop),
-      getAccountMeta(accounts.mint),
-      getAccountMeta(accounts.authority),
-      getAccountMeta(accounts.tokenProgram),
-      getAccountMeta(accounts.associatedTokenProgram),
-      getAccountMeta(accounts.systemProgram)
-    ],
-    data: getDepositTokensInstructionDataEncoder().encode(
-      args
-    ),
-    programAddress
-  });
-}
-function parseDepositTokensInstruction(instruction) {
-  if (instruction.accounts.length < 13) {
-    throw new Error("Not enough accounts");
-  }
-  let accountIndex = 0;
-  const getNextAccount = () => {
-    const accountMeta = instruction.accounts[accountIndex];
-    accountIndex += 1;
-    return accountMeta;
-  };
-  const getNextOptionalAccount = () => {
-    const accountMeta = getNextAccount();
-    return accountMeta.address === DROPSY_PROGRAM_ADDRESS ? void 0 : accountMeta;
-  };
-  return {
-    programAddress: instruction.programAddress,
-    accounts: {
-      master: getNextAccount(),
-      config: getNextAccount(),
-      treasury: getNextAccount(),
-      airdropMaster: getNextAccount(),
-      affiliate: getNextOptionalAccount(),
-      sourceTokenAccount: getNextAccount(),
-      destinationTokenAccount: getNextAccount(),
-      airdrop: getNextAccount(),
-      mint: getNextAccount(),
-      authority: getNextAccount(),
-      tokenProgram: getNextAccount(),
-      associatedTokenProgram: getNextAccount(),
-      systemProgram: getNextAccount()
-    },
-    data: getDepositTokensInstructionDataDecoder().decode(instruction.data)
-  };
-}
-
-// src/instructions/initializeAirdropMaster.ts
-import {
-  combineCodec as combineCodec27,
-  fixDecoderSize as fixDecoderSize14,
-  fixEncoderSize as fixEncoderSize15,
-  getAddressEncoder as getAddressEncoder22,
-  getArrayDecoder as getArrayDecoder2,
-  getArrayEncoder as getArrayEncoder2,
-  getBytesDecoder as getBytesDecoder14,
-  getBytesEncoder as getBytesEncoder15,
-  getOptionDecoder as getOptionDecoder4,
-  getOptionEncoder as getOptionEncoder4,
-  getProgramDerivedAddress as getProgramDerivedAddress6,
-  getStructDecoder as getStructDecoder27,
-  getStructEncoder as getStructEncoder27,
-  getU64Decoder as getU64Decoder15,
-  getU64Encoder as getU64Encoder15,
-  transformEncoder as transformEncoder12
-} from "@solana/kit";
-
-// src/types/advancedFeeConfig.ts
-import {
-  combineCodec as combineCodec12,
-  getStructDecoder as getStructDecoder12,
-  getStructEncoder as getStructEncoder12,
-  getU64Decoder as getU64Decoder9,
-  getU64Encoder as getU64Encoder9
-} from "@solana/kit";
-function getAdvancedFeeConfigEncoder() {
-  return getStructEncoder12([
-    ["claimFee", getU64Encoder9()],
-    ["depositFee", getU64Encoder9()],
-    ["delegateFee", getU64Encoder9()]
-  ]);
-}
-function getAdvancedFeeConfigDecoder() {
-  return getStructDecoder12([
-    ["claimFee", getU64Decoder9()],
-    ["depositFee", getU64Decoder9()],
-    ["delegateFee", getU64Decoder9()]
-  ]);
-}
-function getAdvancedFeeConfigCodec() {
-  return combineCodec12(
-    getAdvancedFeeConfigEncoder(),
-    getAdvancedFeeConfigDecoder()
-  );
-}
-
-// src/types/airdropBoosted.ts
-import {
-  combineCodec as combineCodec13,
-  getAddressDecoder as getAddressDecoder8,
-  getAddressEncoder as getAddressEncoder12,
-  getI64Decoder as getI64Decoder4,
-  getI64Encoder as getI64Encoder4,
-  getStructDecoder as getStructDecoder13,
-  getStructEncoder as getStructEncoder13,
-  getU64Decoder as getU64Decoder10,
-  getU64Encoder as getU64Encoder10
-} from "@solana/kit";
-function getAirdropBoostedEncoder() {
-  return getStructEncoder13([
-    ["airdrop", getAddressEncoder12()],
-    ["boostedBy", getAddressEncoder12()],
-    ["boostAmount", getU64Encoder10()],
-    ["timestamp", getI64Encoder4()]
-  ]);
-}
-function getAirdropBoostedDecoder() {
-  return getStructDecoder13([
-    ["airdrop", getAddressDecoder8()],
-    ["boostedBy", getAddressDecoder8()],
-    ["boostAmount", getU64Decoder10()],
-    ["timestamp", getI64Decoder4()]
-  ]);
-}
-function getAirdropBoostedCodec() {
-  return combineCodec13(getAirdropBoostedEncoder(), getAirdropBoostedDecoder());
-}
-
-// src/types/airdropClosed.ts
-import {
-  combineCodec as combineCodec14,
-  getAddressDecoder as getAddressDecoder9,
-  getAddressEncoder as getAddressEncoder13,
-  getI64Decoder as getI64Decoder5,
-  getI64Encoder as getI64Encoder5,
-  getStructDecoder as getStructDecoder14,
-  getStructEncoder as getStructEncoder14
-} from "@solana/kit";
-function getAirdropClosedEncoder() {
-  return getStructEncoder14([
-    ["airdrop", getAddressEncoder13()],
-    ["authority", getAddressEncoder13()],
-    ["timestamp", getI64Encoder5()]
-  ]);
-}
-function getAirdropClosedDecoder() {
-  return getStructDecoder14([
-    ["airdrop", getAddressDecoder9()],
-    ["authority", getAddressDecoder9()],
-    ["timestamp", getI64Decoder5()]
-  ]);
-}
-function getAirdropClosedCodec() {
-  return combineCodec14(getAirdropClosedEncoder(), getAirdropClosedDecoder());
-}
-
-// src/types/airdropDelegated.ts
-import {
-  combineCodec as combineCodec15,
-  getAddressDecoder as getAddressDecoder10,
-  getAddressEncoder as getAddressEncoder14,
-  getStructDecoder as getStructDecoder15,
-  getStructEncoder as getStructEncoder15,
-  getU8Decoder as getU8Decoder9,
-  getU8Encoder as getU8Encoder9
-} from "@solana/kit";
-function getAirdropDelegatedEncoder() {
-  return getStructEncoder15([
-    ["airdrop", getAddressEncoder14()],
-    ["authority", getAddressEncoder14()],
-    ["delegate", getAddressEncoder14()],
-    ["permissions", getU8Encoder9()]
-  ]);
-}
-function getAirdropDelegatedDecoder() {
-  return getStructDecoder15([
-    ["airdrop", getAddressDecoder10()],
-    ["authority", getAddressDecoder10()],
-    ["delegate", getAddressDecoder10()],
-    ["permissions", getU8Decoder9()]
-  ]);
-}
-function getAirdropDelegatedCodec() {
-  return combineCodec15(
-    getAirdropDelegatedEncoder(),
-    getAirdropDelegatedDecoder()
-  );
-}
-
-// src/types/airdropInitialized.ts
-import {
-  combineCodec as combineCodec16,
-  fixDecoderSize as fixDecoderSize12,
-  fixEncoderSize as fixEncoderSize13,
-  getAddressDecoder as getAddressDecoder11,
-  getAddressEncoder as getAddressEncoder15,
-  getBytesDecoder as getBytesDecoder12,
-  getBytesEncoder as getBytesEncoder13,
-  getI64Decoder as getI64Decoder6,
-  getI64Encoder as getI64Encoder6,
-  getStructDecoder as getStructDecoder16,
-  getStructEncoder as getStructEncoder16
-} from "@solana/kit";
-function getAirdropInitializedEncoder() {
-  return getStructEncoder16([
-    ["airdrop", getAddressEncoder15()],
-    ["mint", getAddressEncoder15()],
-    ["authority", getAddressEncoder15()],
-    ["controller", getAddressEncoder15()],
-    ["merkleRoot", fixEncoderSize13(getBytesEncoder13(), 32)],
-    ["startTime", getI64Encoder6()],
-    ["endTime", getI64Encoder6()],
-    ["timestamp", getI64Encoder6()]
-  ]);
-}
-function getAirdropInitializedDecoder() {
-  return getStructDecoder16([
-    ["airdrop", getAddressDecoder11()],
-    ["mint", getAddressDecoder11()],
-    ["authority", getAddressDecoder11()],
-    ["controller", getAddressDecoder11()],
-    ["merkleRoot", fixDecoderSize12(getBytesDecoder12(), 32)],
-    ["startTime", getI64Decoder6()],
-    ["endTime", getI64Decoder6()],
-    ["timestamp", getI64Decoder6()]
-  ]);
-}
-function getAirdropInitializedCodec() {
-  return combineCodec16(
-    getAirdropInitializedEncoder(),
-    getAirdropInitializedDecoder()
-  );
-}
-
-// src/types/airdropUpdated.ts
-import {
-  combineCodec as combineCodec17,
-  getAddressDecoder as getAddressDecoder12,
-  getAddressEncoder as getAddressEncoder16,
-  getStructDecoder as getStructDecoder17,
-  getStructEncoder as getStructEncoder17
-} from "@solana/kit";
-function getAirdropUpdatedEncoder() {
-  return getStructEncoder17([
-    ["airdrop", getAddressEncoder16()],
-    ["updatedBy", getAddressEncoder16()]
-  ]);
-}
-function getAirdropUpdatedDecoder() {
-  return getStructDecoder17([
-    ["airdrop", getAddressDecoder12()],
-    ["updatedBy", getAddressDecoder12()]
-  ]);
-}
-function getAirdropUpdatedCodec() {
-  return combineCodec17(getAirdropUpdatedEncoder(), getAirdropUpdatedDecoder());
-}
-
-// src/types/baseDurationConfig.ts
-import {
-  combineCodec as combineCodec18,
-  getI64Decoder as getI64Decoder7,
-  getI64Encoder as getI64Encoder7,
-  getStructDecoder as getStructDecoder18,
-  getStructEncoder as getStructEncoder18
-} from "@solana/kit";
-function getBaseDurationConfigEncoder() {
-  return getStructEncoder18([
-    ["minimum", getI64Encoder7()],
-    ["maximum", getI64Encoder7()],
-    ["updateGrace", getI64Encoder7()]
-  ]);
-}
-function getBaseDurationConfigDecoder() {
-  return getStructDecoder18([
-    ["minimum", getI64Decoder7()],
-    ["maximum", getI64Decoder7()],
-    ["updateGrace", getI64Decoder7()]
-  ]);
-}
-function getBaseDurationConfigCodec() {
-  return combineCodec18(
-    getBaseDurationConfigEncoder(),
-    getBaseDurationConfigDecoder()
-  );
-}
-
-// src/types/baseFeatureFeeConfig.ts
-import {
-  combineCodec as combineCodec19,
-  getStructDecoder as getStructDecoder19,
-  getStructEncoder as getStructEncoder19,
-  getU64Decoder as getU64Decoder11,
-  getU64Encoder as getU64Encoder11
-} from "@solana/kit";
-function getBaseFeatureFeeConfigEncoder() {
-  return getStructEncoder19([
-    ["creationFee", getU64Encoder11()],
-    ["upgradeFee", getU64Encoder11()],
-    ["withdrawFeeBasis", getU64Encoder11()]
-  ]);
-}
-function getBaseFeatureFeeConfigDecoder() {
-  return getStructDecoder19([
-    ["creationFee", getU64Decoder11()],
-    ["upgradeFee", getU64Decoder11()],
-    ["withdrawFeeBasis", getU64Decoder11()]
-  ]);
-}
-function getBaseFeatureFeeConfigCodec() {
-  return combineCodec19(
-    getBaseFeatureFeeConfigEncoder(),
-    getBaseFeatureFeeConfigDecoder()
-  );
-}
-
-// src/types/baseFeeConfig.ts
-import {
-  combineCodec as combineCodec20,
-  getOptionDecoder as getOptionDecoder2,
-  getOptionEncoder as getOptionEncoder2,
-  getStructDecoder as getStructDecoder20,
-  getStructEncoder as getStructEncoder20,
-  getU64Decoder as getU64Decoder12,
-  getU64Encoder as getU64Encoder12
-} from "@solana/kit";
-function getBaseFeeConfigEncoder() {
-  return getStructEncoder20([
-    ["creationFee", getU64Encoder12()],
-    ["updateFee", getOptionEncoder2(getU64Encoder12())],
-    ["closeFee", getU64Encoder12()]
-  ]);
-}
-function getBaseFeeConfigDecoder() {
-  return getStructDecoder20([
-    ["creationFee", getU64Decoder12()],
-    ["updateFee", getOptionDecoder2(getU64Decoder12())],
-    ["closeFee", getU64Decoder12()]
-  ]);
-}
-function getBaseFeeConfigCodec() {
-  return combineCodec20(getBaseFeeConfigEncoder(), getBaseFeeConfigDecoder());
-}
-
-// src/types/claimMapClosed.ts
-import {
-  combineCodec as combineCodec21,
-  getAddressDecoder as getAddressDecoder13,
-  getAddressEncoder as getAddressEncoder17,
-  getStructDecoder as getStructDecoder21,
-  getStructEncoder as getStructEncoder21
-} from "@solana/kit";
-function getClaimMapClosedEncoder() {
-  return getStructEncoder21([
-    ["airdrop", getAddressEncoder17()],
-    ["bitmap", getAddressEncoder17()],
-    ["authority", getAddressEncoder17()]
-  ]);
-}
-function getClaimMapClosedDecoder() {
-  return getStructDecoder21([
-    ["airdrop", getAddressDecoder13()],
-    ["bitmap", getAddressDecoder13()],
-    ["authority", getAddressDecoder13()]
-  ]);
-}
-function getClaimMapClosedCodec() {
-  return combineCodec21(getClaimMapClosedEncoder(), getClaimMapClosedDecoder());
-}
-
-// src/types/claimMapInitialized.ts
-import {
-  combineCodec as combineCodec22,
-  getAddressDecoder as getAddressDecoder14,
-  getAddressEncoder as getAddressEncoder18,
-  getI64Decoder as getI64Decoder8,
-  getI64Encoder as getI64Encoder8,
-  getStructDecoder as getStructDecoder22,
-  getStructEncoder as getStructEncoder22,
-  getU16Decoder as getU16Decoder6,
-  getU16Encoder as getU16Encoder6
-} from "@solana/kit";
-function getClaimMapInitializedEncoder() {
-  return getStructEncoder22([
-    ["airdrop", getAddressEncoder18()],
-    ["bitmap", getAddressEncoder18()],
-    ["bitmapId", getU16Encoder6()],
-    ["timestamp", getI64Encoder8()]
-  ]);
-}
-function getClaimMapInitializedDecoder() {
-  return getStructDecoder22([
-    ["airdrop", getAddressDecoder14()],
-    ["bitmap", getAddressDecoder14()],
-    ["bitmapId", getU16Decoder6()],
-    ["timestamp", getI64Decoder8()]
-  ]);
-}
-function getClaimMapInitializedCodec() {
-  return combineCodec22(
-    getClaimMapInitializedEncoder(),
-    getClaimMapInitializedDecoder()
-  );
-}
-
-// src/types/initAirdropConfigArgs.ts
-import {
-  combineCodec as combineCodec23,
-  fixDecoderSize as fixDecoderSize13,
-  fixEncoderSize as fixEncoderSize14,
-  getBytesDecoder as getBytesDecoder13,
-  getBytesEncoder as getBytesEncoder14,
-  getOptionDecoder as getOptionDecoder3,
-  getOptionEncoder as getOptionEncoder3,
-  getStructDecoder as getStructDecoder23,
-  getStructEncoder as getStructEncoder23,
-  getU64Decoder as getU64Decoder13,
-  getU64Encoder as getU64Encoder13
-} from "@solana/kit";
-function getInitAirdropConfigArgsEncoder() {
-  return getStructEncoder23([
-    ["merkleRoot", getOptionEncoder3(fixEncoderSize14(getBytesEncoder14(), 32))],
-    ["durationConfig", getBaseDurationConfigEncoder()],
-    ["masterConfig", getBaseFeatureFeeConfigEncoder()],
-    ["bitmapActionFee", getU64Encoder13()],
-    ["perBoostAmount", getU64Encoder13()]
-  ]);
-}
-function getInitAirdropConfigArgsDecoder() {
-  return getStructDecoder23([
-    ["merkleRoot", getOptionDecoder3(fixDecoderSize13(getBytesDecoder13(), 32))],
-    ["durationConfig", getBaseDurationConfigDecoder()],
-    ["masterConfig", getBaseFeatureFeeConfigDecoder()],
-    ["bitmapActionFee", getU64Decoder13()],
-    ["perBoostAmount", getU64Decoder13()]
-  ]);
-}
-function getInitAirdropConfigArgsCodec() {
-  return combineCodec23(
-    getInitAirdropConfigArgsEncoder(),
-    getInitAirdropConfigArgsDecoder()
-  );
-}
-
-// src/types/masterInitialized.ts
-import {
-  combineCodec as combineCodec24,
-  getAddressDecoder as getAddressDecoder15,
-  getAddressEncoder as getAddressEncoder19,
-  getI64Decoder as getI64Decoder9,
-  getI64Encoder as getI64Encoder9,
-  getStructDecoder as getStructDecoder24,
-  getStructEncoder as getStructEncoder24
-} from "@solana/kit";
-function getMasterInitializedEncoder() {
-  return getStructEncoder24([
-    ["address", getAddressEncoder19()],
-    ["authority", getAddressEncoder19()],
-    ["treasury", getAddressEncoder19()],
-    ["timestamp", getI64Encoder9()]
-  ]);
-}
-function getMasterInitializedDecoder() {
-  return getStructDecoder24([
-    ["address", getAddressDecoder15()],
-    ["authority", getAddressDecoder15()],
-    ["treasury", getAddressDecoder15()],
-    ["timestamp", getI64Decoder9()]
-  ]);
-}
-function getMasterInitializedCodec() {
-  return combineCodec24(
-    getMasterInitializedEncoder(),
-    getMasterInitializedDecoder()
-  );
-}
-
-// src/types/tokensDeposited.ts
-import {
-  combineCodec as combineCodec25,
-  getAddressDecoder as getAddressDecoder16,
-  getAddressEncoder as getAddressEncoder20,
-  getI64Decoder as getI64Decoder10,
-  getI64Encoder as getI64Encoder10,
-  getStructDecoder as getStructDecoder25,
-  getStructEncoder as getStructEncoder25,
-  getU64Decoder as getU64Decoder14,
-  getU64Encoder as getU64Encoder14
-} from "@solana/kit";
-function getTokensDepositedEncoder() {
-  return getStructEncoder25([
-    ["airdrop", getAddressEncoder20()],
-    ["amount", getU64Encoder14()],
-    ["newSupply", getU64Encoder14()],
-    ["depositor", getAddressEncoder20()],
-    ["timestamp", getI64Encoder10()]
-  ]);
-}
-function getTokensDepositedDecoder() {
-  return getStructDecoder25([
-    ["airdrop", getAddressDecoder16()],
-    ["amount", getU64Decoder14()],
-    ["newSupply", getU64Decoder14()],
-    ["depositor", getAddressDecoder16()],
-    ["timestamp", getI64Decoder10()]
-  ]);
-}
-function getTokensDepositedCodec() {
-  return combineCodec25(getTokensDepositedEncoder(), getTokensDepositedDecoder());
-}
-
-// src/types/tokensRedeemed.ts
-import {
-  combineCodec as combineCodec26,
-  getAddressDecoder as getAddressDecoder17,
-  getAddressEncoder as getAddressEncoder21,
-  getI64Decoder as getI64Decoder11,
-  getI64Encoder as getI64Encoder11,
-  getStructDecoder as getStructDecoder26,
-  getStructEncoder as getStructEncoder26
-} from "@solana/kit";
-function getTokensRedeemedEncoder() {
-  return getStructEncoder26([
-    ["airdrop", getAddressEncoder21()],
-    ["authority", getAddressEncoder21()],
-    ["timestamp", getI64Encoder11()]
-  ]);
-}
-function getTokensRedeemedDecoder() {
-  return getStructDecoder26([
-    ["airdrop", getAddressDecoder17()],
-    ["authority", getAddressDecoder17()],
-    ["timestamp", getI64Decoder11()]
-  ]);
-}
-function getTokensRedeemedCodec() {
-  return combineCodec26(getTokensRedeemedEncoder(), getTokensRedeemedDecoder());
-}
-
-// src/instructions/initializeAirdropMaster.ts
-var INITIALIZE_AIRDROP_MASTER_DISCRIMINATOR = new Uint8Array([
-  163,
-  197,
-  170,
-  44,
-  57,
-  57,
-  90,
-  65
-]);
-function getInitializeAirdropMasterDiscriminatorBytes() {
-  return fixEncoderSize15(getBytesEncoder15(), 8).encode(
-    INITIALIZE_AIRDROP_MASTER_DISCRIMINATOR
-  );
-}
-function getInitializeAirdropMasterInstructionDataEncoder() {
-  return transformEncoder12(
-    getStructEncoder27([
-      ["discriminator", fixEncoderSize15(getBytesEncoder15(), 8)],
-      ["merkleRoot", getOptionEncoder4(fixEncoderSize15(getBytesEncoder15(), 32))],
-      ["airdropCreateFee", getOptionEncoder4(getU64Encoder15())],
-      ["airdropUpdateFee", getOptionEncoder4(getU64Encoder15())],
-      ["bitmapCreateFee", getOptionEncoder4(getU64Encoder15())],
-      ["advancedConfig", getOptionEncoder4(getAdvancedFeeConfigEncoder())],
-      [
-        "wlProof",
-        getOptionEncoder4(
-          getArrayEncoder2(fixEncoderSize15(getBytesEncoder15(), 32))
-        )
-      ]
-    ]),
-    (value) => ({
-      ...value,
-      discriminator: INITIALIZE_AIRDROP_MASTER_DISCRIMINATOR
-    })
-  );
-}
-function getInitializeAirdropMasterInstructionDataDecoder() {
-  return getStructDecoder27([
-    ["discriminator", fixDecoderSize14(getBytesDecoder14(), 8)],
-    ["merkleRoot", getOptionDecoder4(fixDecoderSize14(getBytesDecoder14(), 32))],
-    ["airdropCreateFee", getOptionDecoder4(getU64Decoder15())],
-    ["airdropUpdateFee", getOptionDecoder4(getU64Decoder15())],
-    ["bitmapCreateFee", getOptionDecoder4(getU64Decoder15())],
-    ["advancedConfig", getOptionDecoder4(getAdvancedFeeConfigDecoder())],
-    [
-      "wlProof",
-      getOptionDecoder4(getArrayDecoder2(fixDecoderSize14(getBytesDecoder14(), 32)))
-    ]
-  ]);
-}
-function getInitializeAirdropMasterInstructionDataCodec() {
-  return combineCodec27(
-    getInitializeAirdropMasterInstructionDataEncoder(),
-    getInitializeAirdropMasterInstructionDataDecoder()
-  );
-}
-async function getInitializeAirdropMasterInstructionAsync(input, config) {
-  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    master: { value: input.master ?? null, isWritable: false },
-    config: { value: input.config ?? null, isWritable: false },
-    treasury: { value: input.treasury ?? null, isWritable: true },
-    affiliateMaster: {
-      value: input.affiliateMaster ?? null,
-      isWritable: false
-    },
-    airdropMaster: { value: input.airdropMaster ?? 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 getProgramDerivedAddress6({
-      programAddress,
-      seeds: [
-        getBytesEncoder15().encode(new Uint8Array([109, 97, 115, 116, 101, 114]))
-      ]
-    });
-  }
-  if (!accounts.config.value) {
-    accounts.config.value = await getProgramDerivedAddress6({
-      programAddress,
-      seeds: [
-        getBytesEncoder15().encode(
-          new Uint8Array([
-            97,
-            105,
-            114,
-            100,
-            114,
-            111,
-            112,
-            95,
-            99,
-            111,
-            110,
-            102,
-            105,
-            103
-          ])
-        )
-      ]
-    });
-  }
-  if (!accounts.airdropMaster.value) {
-    accounts.airdropMaster.value = await getProgramDerivedAddress6({
-      programAddress,
-      seeds: [
-        getBytesEncoder15().encode(
-          new Uint8Array([
-            97,
-            105,
-            114,
-            100,
-            114,
-            111,
-            112,
-            95,
-            109,
-            97,
-            115,
-            116,
-            101,
-            114
-          ])
-        ),
-        getAddressEncoder22().encode(expectAddress(accounts.authority.value))
-      ]
-    });
-  }
-  if (!accounts.systemProgram.value) {
-    accounts.systemProgram.value = "11111111111111111111111111111111";
-  }
-  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
-  return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.master),
-      getAccountMeta(accounts.config),
-      getAccountMeta(accounts.treasury),
-      getAccountMeta(accounts.affiliateMaster),
-      getAccountMeta(accounts.airdropMaster),
-      getAccountMeta(accounts.authority),
-      getAccountMeta(accounts.systemProgram)
-    ],
-    data: getInitializeAirdropMasterInstructionDataEncoder().encode(
-      args
-    ),
-    programAddress
-  });
-}
-function getInitializeAirdropMasterInstruction(input, config) {
-  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    master: { value: input.master ?? null, isWritable: false },
-    config: { value: input.config ?? null, isWritable: false },
-    treasury: { value: input.treasury ?? null, isWritable: true },
-    affiliateMaster: {
-      value: input.affiliateMaster ?? null,
-      isWritable: false
-    },
-    airdropMaster: { value: input.airdropMaster ?? 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.systemProgram.value) {
-    accounts.systemProgram.value = "11111111111111111111111111111111";
-  }
-  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
-  return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.master),
-      getAccountMeta(accounts.config),
-      getAccountMeta(accounts.treasury),
-      getAccountMeta(accounts.affiliateMaster),
-      getAccountMeta(accounts.airdropMaster),
-      getAccountMeta(accounts.authority),
-      getAccountMeta(accounts.systemProgram)
-    ],
-    data: getInitializeAirdropMasterInstructionDataEncoder().encode(
-      args
-    ),
-    programAddress
-  });
-}
-function parseInitializeAirdropMasterInstruction(instruction) {
-  if (instruction.accounts.length < 7) {
-    throw new Error("Not enough accounts");
-  }
-  let accountIndex = 0;
-  const getNextAccount = () => {
-    const accountMeta = instruction.accounts[accountIndex];
-    accountIndex += 1;
-    return accountMeta;
-  };
-  const getNextOptionalAccount = () => {
-    const accountMeta = getNextAccount();
-    return accountMeta.address === DROPSY_PROGRAM_ADDRESS ? void 0 : accountMeta;
-  };
-  return {
-    programAddress: instruction.programAddress,
-    accounts: {
-      master: getNextAccount(),
-      config: getNextAccount(),
-      treasury: getNextAccount(),
-      affiliateMaster: getNextOptionalAccount(),
-      airdropMaster: getNextAccount(),
-      authority: getNextAccount(),
-      systemProgram: getNextAccount()
-    },
-    data: getInitializeAirdropMasterInstructionDataDecoder().decode(
-      instruction.data
-    )
-  };
-}
-
-// src/instructions/initializeMaster.ts
-import {
-  combineCodec as combineCodec28,
-  fixDecoderSize as fixDecoderSize15,
-  fixEncoderSize as fixEncoderSize16,
-  getBytesDecoder as getBytesDecoder15,
-  getBytesEncoder as getBytesEncoder16,
-  getProgramDerivedAddress as getProgramDerivedAddress7,
-  getStructDecoder as getStructDecoder28,
-  getStructEncoder as getStructEncoder28,
-  getU64Decoder as getU64Decoder16,
-  getU64Encoder as getU64Encoder16,
-  transformEncoder as transformEncoder13
-} from "@solana/kit";
-var INITIALIZE_MASTER_DISCRIMINATOR = new Uint8Array([
-  206,
-  91,
-  246,
-  30,
-  216,
-  101,
-  134,
-  166
-]);
-function getInitializeMasterDiscriminatorBytes() {
-  return fixEncoderSize16(getBytesEncoder16(), 8).encode(
-    INITIALIZE_MASTER_DISCRIMINATOR
-  );
-}
-function getInitializeMasterInstructionDataEncoder() {
-  return transformEncoder13(
-    getStructEncoder28([
-      ["discriminator", fixEncoderSize16(getBytesEncoder16(), 8)],
-      ["airdropConfig", getInitAirdropConfigArgsEncoder()],
-      ["protocolFee", getU64Encoder16()]
-    ]),
-    (value) => ({ ...value, discriminator: INITIALIZE_MASTER_DISCRIMINATOR })
-  );
-}
-function getInitializeMasterInstructionDataDecoder() {
-  return getStructDecoder28([
-    ["discriminator", fixDecoderSize15(getBytesDecoder15(), 8)],
-    ["airdropConfig", getInitAirdropConfigArgsDecoder()],
-    ["protocolFee", getU64Decoder16()]
-  ]);
-}
-function getInitializeMasterInstructionDataCodec() {
-  return combineCodec28(
-    getInitializeMasterInstructionDataEncoder(),
-    getInitializeMasterInstructionDataDecoder()
-  );
-}
-async function getInitializeMasterInstructionAsync(input, config) {
-  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    master: { value: input.master ?? null, isWritable: true },
-    config: { value: input.config ?? null, isWritable: true },
-    treasury: { value: input.treasury ?? null, isWritable: false },
-    tokenMint: { value: input.tokenMint ?? 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 getProgramDerivedAddress7({
-      programAddress,
-      seeds: [
-        getBytesEncoder16().encode(new Uint8Array([109, 97, 115, 116, 101, 114]))
-      ]
-    });
-  }
-  if (!accounts.config.value) {
-    accounts.config.value = await getProgramDerivedAddress7({
-      programAddress,
-      seeds: [
-        getBytesEncoder16().encode(
-          new Uint8Array([
-            97,
-            105,
-            114,
-            100,
-            114,
-            111,
-            112,
-            95,
-            99,
-            111,
-            110,
-            102,
-            105,
-            103
-          ])
-        )
-      ]
-    });
-  }
-  if (!accounts.authority.value) {
-    accounts.authority.value = "8mtUD2XrkNnTxnjCehZ4DEtTXeGR1yrepSEGhCaSj2kT";
-  }
-  if (!accounts.systemProgram.value) {
-    accounts.systemProgram.value = "11111111111111111111111111111111";
-  }
-  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
-  return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.master),
-      getAccountMeta(accounts.config),
-      getAccountMeta(accounts.treasury),
-      getAccountMeta(accounts.tokenMint),
-      getAccountMeta(accounts.authority),
-      getAccountMeta(accounts.systemProgram)
-    ],
-    data: getInitializeMasterInstructionDataEncoder().encode(
-      args
-    ),
-    programAddress
-  });
-}
-function getInitializeMasterInstruction(input, config) {
-  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    master: { value: input.master ?? null, isWritable: true },
-    config: { value: input.config ?? null, isWritable: true },
-    treasury: { value: input.treasury ?? null, isWritable: false },
-    tokenMint: { value: input.tokenMint ?? 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.authority.value) {
-    accounts.authority.value = "8mtUD2XrkNnTxnjCehZ4DEtTXeGR1yrepSEGhCaSj2kT";
-  }
-  if (!accounts.systemProgram.value) {
-    accounts.systemProgram.value = "11111111111111111111111111111111";
-  }
-  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
-  return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.master),
-      getAccountMeta(accounts.config),
-      getAccountMeta(accounts.treasury),
-      getAccountMeta(accounts.tokenMint),
-      getAccountMeta(accounts.authority),
-      getAccountMeta(accounts.systemProgram)
-    ],
-    data: getInitializeMasterInstructionDataEncoder().encode(
-      args
-    ),
-    programAddress
-  });
-}
-function parseInitializeMasterInstruction(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;
-  };
-  const getNextOptionalAccount = () => {
-    const accountMeta = getNextAccount();
-    return accountMeta.address === DROPSY_PROGRAM_ADDRESS ? void 0 : accountMeta;
-  };
-  return {
-    programAddress: instruction.programAddress,
-    accounts: {
-      master: getNextAccount(),
-      config: getNextAccount(),
-      treasury: getNextAccount(),
-      tokenMint: getNextOptionalAccount(),
-      authority: getNextAccount(),
-      systemProgram: getNextAccount()
-    },
-    data: getInitializeMasterInstructionDataDecoder().decode(instruction.data)
-  };
-}
-
-// src/instructions/redeemAirdropTokens.ts
-import {
-  combineCodec as combineCodec29,
-  fixDecoderSize as fixDecoderSize16,
-  fixEncoderSize as fixEncoderSize17,
-  getAddressEncoder as getAddressEncoder23,
-  getBytesDecoder as getBytesDecoder16,
-  getBytesEncoder as getBytesEncoder17,
-  getProgramDerivedAddress as getProgramDerivedAddress8,
-  getStructDecoder as getStructDecoder29,
-  getStructEncoder as getStructEncoder29,
-  transformEncoder as transformEncoder14
-} from "@solana/kit";
-var REDEEM_AIRDROP_TOKENS_DISCRIMINATOR = new Uint8Array([
-  102,
-  70,
-  115,
-  13,
-  97,
-  198,
-  59,
-  103
-]);
-function getRedeemAirdropTokensDiscriminatorBytes() {
-  return fixEncoderSize17(getBytesEncoder17(), 8).encode(
-    REDEEM_AIRDROP_TOKENS_DISCRIMINATOR
-  );
-}
-function getRedeemAirdropTokensInstructionDataEncoder() {
-  return transformEncoder14(
-    getStructEncoder29([["discriminator", fixEncoderSize17(getBytesEncoder17(), 8)]]),
-    (value) => ({
-      ...value,
-      discriminator: REDEEM_AIRDROP_TOKENS_DISCRIMINATOR
-    })
-  );
-}
-function getRedeemAirdropTokensInstructionDataDecoder() {
-  return getStructDecoder29([
-    ["discriminator", fixDecoderSize16(getBytesDecoder16(), 8)]
-  ]);
-}
-function getRedeemAirdropTokensInstructionDataCodec() {
-  return combineCodec29(
-    getRedeemAirdropTokensInstructionDataEncoder(),
-    getRedeemAirdropTokensInstructionDataDecoder()
-  );
-}
-async function getRedeemAirdropTokensInstructionAsync(input, config) {
-  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    master: { value: input.master ?? null, isWritable: false },
-    config: { value: input.config ?? null, isWritable: false },
-    treasury: { value: input.treasury ?? null, isWritable: true },
-    airdropMaster: { value: input.airdropMaster ?? null, isWritable: true },
-    affiliate: { value: input.affiliate ?? null, isWritable: true },
-    sourceTokenAccount: {
-      value: input.sourceTokenAccount ?? null,
-      isWritable: true
-    },
-    destinationTokenAccount: {
-      value: input.destinationTokenAccount ?? null,
-      isWritable: true
-    },
-    airdrop: { value: input.airdrop ?? null, isWritable: true },
-    mint: { value: input.mint ?? null, isWritable: false },
-    authority: { value: input.authority ?? null, isWritable: true },
-    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
-    associatedTokenProgram: {
-      value: input.associatedTokenProgram ?? null,
-      isWritable: false
-    },
-    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
-  };
-  const accounts = originalAccounts;
-  if (!accounts.master.value) {
-    accounts.master.value = await getProgramDerivedAddress8({
-      programAddress,
-      seeds: [
-        getBytesEncoder17().encode(new Uint8Array([109, 97, 115, 116, 101, 114]))
-      ]
-    });
-  }
-  if (!accounts.config.value) {
-    accounts.config.value = await getProgramDerivedAddress8({
-      programAddress,
-      seeds: [
-        getBytesEncoder17().encode(
-          new Uint8Array([
-            97,
-            105,
-            114,
-            100,
-            114,
-            111,
-            112,
-            95,
-            99,
-            111,
-            110,
-            102,
-            105,
-            103
-          ])
-        )
-      ]
-    });
-  }
-  if (!accounts.airdrop.value) {
-    accounts.airdrop.value = await getProgramDerivedAddress8({
-      programAddress,
-      seeds: [
-        getBytesEncoder17().encode(
-          new Uint8Array([97, 105, 114, 100, 114, 111, 112])
-        ),
-        getAddressEncoder23().encode(expectAddress(accounts.mint.value)),
-        getAddressEncoder23().encode(expectAddress(accounts.authority.value))
-      ]
-    });
-  }
-  if (!accounts.tokenProgram.value) {
-    accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
-  }
-  if (!accounts.destinationTokenAccount.value) {
-    accounts.destinationTokenAccount.value = await getProgramDerivedAddress8({
-      programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
-      seeds: [
-        getAddressEncoder23().encode(expectAddress(accounts.airdrop.value)),
-        getAddressEncoder23().encode(expectAddress(accounts.tokenProgram.value)),
-        getAddressEncoder23().encode(expectAddress(accounts.mint.value))
-      ]
-    });
-  }
-  if (!accounts.associatedTokenProgram.value) {
-    accounts.associatedTokenProgram.value = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
-  }
-  if (!accounts.systemProgram.value) {
-    accounts.systemProgram.value = "11111111111111111111111111111111";
-  }
-  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
-  return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.master),
-      getAccountMeta(accounts.config),
-      getAccountMeta(accounts.treasury),
-      getAccountMeta(accounts.airdropMaster),
-      getAccountMeta(accounts.affiliate),
-      getAccountMeta(accounts.sourceTokenAccount),
-      getAccountMeta(accounts.destinationTokenAccount),
-      getAccountMeta(accounts.airdrop),
-      getAccountMeta(accounts.mint),
-      getAccountMeta(accounts.authority),
-      getAccountMeta(accounts.tokenProgram),
-      getAccountMeta(accounts.associatedTokenProgram),
-      getAccountMeta(accounts.systemProgram)
-    ],
-    data: getRedeemAirdropTokensInstructionDataEncoder().encode({}),
-    programAddress
-  });
-}
-function getRedeemAirdropTokensInstruction(input, config) {
-  const programAddress = config?.programAddress ?? DROPSY_PROGRAM_ADDRESS;
-  const originalAccounts = {
-    master: { value: input.master ?? null, isWritable: false },
-    config: { value: input.config ?? null, isWritable: false },
-    treasury: { value: input.treasury ?? null, isWritable: true },
-    airdropMaster: { value: input.airdropMaster ?? null, isWritable: true },
-    affiliate: { value: input.affiliate ?? null, isWritable: true },
-    sourceTokenAccount: {
-      value: input.sourceTokenAccount ?? null,
-      isWritable: true
-    },
-    destinationTokenAccount: {
-      value: input.destinationTokenAccount ?? null,
-      isWritable: true
-    },
-    airdrop: { value: input.airdrop ?? null, isWritable: true },
-    mint: { value: input.mint ?? null, isWritable: false },
-    authority: { value: input.authority ?? null, isWritable: true },
-    tokenProgram: { value: input.tokenProgram ?? null, isWritable: false },
-    associatedTokenProgram: {
-      value: input.associatedTokenProgram ?? null,
-      isWritable: false
-    },
-    systemProgram: { value: input.systemProgram ?? null, isWritable: false }
-  };
-  const accounts = originalAccounts;
-  if (!accounts.tokenProgram.value) {
-    accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
-  }
-  if (!accounts.associatedTokenProgram.value) {
-    accounts.associatedTokenProgram.value = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
-  }
-  if (!accounts.systemProgram.value) {
-    accounts.systemProgram.value = "11111111111111111111111111111111";
-  }
-  const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
-  return Object.freeze({
-    accounts: [
-      getAccountMeta(accounts.master),
-      getAccountMeta(accounts.config),
-      getAccountMeta(accounts.treasury),
-      getAccountMeta(accounts.airdropMaster),
-      getAccountMeta(accounts.affiliate),
-      getAccountMeta(accounts.sourceTokenAccount),
-      getAccountMeta(accounts.destinationTokenAccount),
-      getAccountMeta(accounts.airdrop),
-      getAccountMeta(accounts.mint),
-      getAccountMeta(accounts.authority),
-      getAccountMeta(accounts.tokenProgram),
-      getAccountMeta(accounts.associatedTokenProgram),
-      getAccountMeta(accounts.systemProgram)
-    ],
-    data: getRedeemAirdropTokensInstructionDataEncoder().encode({}),
-    programAddress
-  });
-}
-function parseRedeemAirdropTokensInstruction(instruction) {
-  if (instruction.accounts.length < 13) {
-    throw new Error("Not enough accounts");
-  }
-  let accountIndex = 0;
-  const getNextAccount = () => {
-    const accountMeta = instruction.accounts[accountIndex];
-    accountIndex += 1;
-    return accountMeta;
-  };
-  const getNextOptionalAccount = () => {
-    const accountMeta = getNextAccount();
-    return accountMeta.address === DROPSY_PROGRAM_ADDRESS ? void 0 : accountMeta;
-  };
-  return {
-    programAddress: instruction.programAddress,
-    accounts: {
-      master: getNextAccount(),
-      config: getNextAccount(),
-      treasury: getNextAccount(),
-      airdropMaster: getNextAccount(),
-      affiliate: getNextOptionalAccount(),
-      sourceTokenAccount: getNextAccount(),
-      destinationTokenAccount: getNextAccount(),
-      airdrop: getNextAccount(),
-      mint: getNextAccount(),
-      authority: getNextAccount(),
-      tokenProgram: getNextAccount(),
-      associatedTokenProgram: getNextAccount(),
-      systemProgram: getNextAccount()
-    },
-    data: getRedeemAirdropTokensInstructionDataDecoder().decode(
-      instruction.data
-    )
-  };
-}
-export {
-  ADMIN,
-  AFFILIATE_DISCRIMINATOR,
-  AFFILIATE_MASTER_DISCRIMINATOR,
-  AFFILIATE_MASTER_SEED,
-  AFFILIATE_SEED,
-  AIRDROP_CONFIG_DISCRIMINATOR,
-  AIRDROP_CONFIG_SEED,
-  AIRDROP_DISCRIMINATOR,
-  AIRDROP_MASTER_DISCRIMINATOR,
-  AIRDROP_MASTER_SEED,
-  AIRDROP_SEED,
-  BITMAP_SEED,
-  BITMAP_SIZE,
-  CLAIM_AIRDROP_DISCRIMINATOR,
-  CLAIM_MAP_DISCRIMINATOR,
-  CREATE_AIRDROP_DISCRIMINATOR,
-  CREATE_CLAIM_MAP_DISCRIMINATOR,
-  DEFAULT_MASTER_PDA,
-  DEFAULT_MASTER_PDA_AUTHORITY,
-  DEPOSIT_TOKENS_DISCRIMINATOR,
-  DROPSY_ERROR__ACTIVE_BITMAPS_EXIST,
-  DROPSY_ERROR__AIRDROP_ENDED,
-  DROPSY_ERROR__AIRDROP_NOT_ENDED,
-  DROPSY_ERROR__AIRDROP_NOT_STARTED,
-  DROPSY_ERROR__ALREADY_CLAIMED,
-  DROPSY_ERROR__BITMAP_AIRDROP_MISMATCH,
-  DROPSY_ERROR__BITMAP_COUNT_UNDERFLOW,
-  DROPSY_ERROR__BITMAP_TOO_LARGE,
-  DROPSY_ERROR__CLAIM_FEE_TOO_HIGH,
-  DROPSY_ERROR__CREATE_FEE_TOO_HIGH,
-  DROPSY_ERROR__DESTINATION_MINT_MISMATCH,
-  DROPSY_ERROR__DURATION_TOO_SHORT,
-  DROPSY_ERROR__IMMUTABLE_AIRDROP,
-  DROPSY_ERROR__IMMUTABLE_FIELD,
-  DROPSY_ERROR__INSUFFICIENT_DEPOSIT,
-  DROPSY_ERROR__INSUFFICIENT_FUNDS_FOR_FEE,
-  DROPSY_ERROR__INSUFFICIENT_VAULT_FUNDS,
-  DROPSY_ERROR__INVALID_ADMIN,
-  DROPSY_ERROR__INVALID_AFFILIATE_PDA,
-  DROPSY_ERROR__INVALID_AIRDROP_MASTER_ACCOUNT,
-  DROPSY_ERROR__INVALID_AIRDROP_PDA,
-  DROPSY_ERROR__INVALID_AIRDROP_VERSION,
-  DROPSY_ERROR__INVALID_AIRDROP_VESTING_VERSION,
-  DROPSY_ERROR__INVALID_AMOUNT,
-  DROPSY_ERROR__INVALID_BITMAP_ACCOUNT,
-  DROPSY_ERROR__INVALID_BITMAP_INDEX,
-  DROPSY_ERROR__INVALID_DELEGATE_PERMISSION,
-  DROPSY_ERROR__INVALID_DESTINATION_OWNER,
-  DROPSY_ERROR__INVALID_END_TIME,
-  DROPSY_ERROR__INVALID_FEE_VAULT,
-  DROPSY_ERROR__INVALID_FEE_VAULT_CURVE,
-  DROPSY_ERROR__INVALID_FEE_VAULT_OWNER,
-  DROPSY_ERROR__INVALID_MINT,
-  DROPSY_ERROR__INVALID_MINT_OWNER,
-  DROPSY_ERROR__INVALID_MUTABILITY,
-  DROPSY_ERROR__INVALID_OWNER,
-  DROPSY_ERROR__INVALID_PARENT_ACCOUNT,
-  DROPSY_ERROR__INVALID_PDA,
-  DROPSY_ERROR__INVALID_PERCENTAGE,
-  DROPSY_ERROR__INVALID_PROOF,
-  DROPSY_ERROR__INVALID_PUB_KEY,
-  DROPSY_ERROR__INVALID_TIMESTAMP,
-  DROPSY_ERROR__INVALID_TOTAL,
-  DROPSY_ERROR__INVALID_TREASURY_ACCOUNT,
-  DROPSY_ERROR__INVALID_VAULT_AUTHORITY,
-  DROPSY_ERROR__INVALID_VESTING_SCHEDULE,
-  DROPSY_ERROR__INVALID_VESTING_TYPE,
-  DROPSY_ERROR__MAX_AIRDROPS_REACHED,
-  DROPSY_ERROR__MAX_CLAIM_MAPS_REACHED,
-  DROPSY_ERROR__MINT_HAS_FREEZE_AUTHORITY,
-  DROPSY_ERROR__MINT_IS_FROZEN,
-  DROPSY_ERROR__MINT_IS_NOT_INITIALIZED,
-  DROPSY_ERROR__MINT_MISMATCH,
-  DROPSY_ERROR__MISSING_BITMAP_PDA,
-  DROPSY_ERROR__NFT_NOT_ALLOWED,
-  DROPSY_ERROR__NON_ZERO_VALUE_REQUIRED,
-  DROPSY_ERROR__OVERFLOW,
-  DROPSY_ERROR__OWNER_MISMATCH,
-  DROPSY_ERROR__SOURCE_ACCOUNT_FROZEN,
-  DROPSY_ERROR__SOURCE_HAS_CLOSE_AUTHORITY,
-  DROPSY_ERROR__SOURCE_HAS_DELEGATE,
-  DROPSY_ERROR__TOO_MANY_BITMAPS,
-  DROPSY_ERROR__UNAUTHORIZED,
-  DROPSY_ERROR__UN_AUTHORIZED,
-  DROPSY_ERROR__UPDATE_CUTOFF_TIME_PASSED,
-  DROPSY_ERROR__VALUE_BELOW_THE_MINIMUM,
-  DROPSY_ERROR__VALUE_EXCEEDS_MAXIMUM,
-  DROPSY_ERROR__VALUE_OUT_OF_RANGE,
-  DROPSY_ERROR__VAULT_FROZEN,
-  DROPSY_ERROR__VAULT_HAS_CLOSE_AUTHORITY,
-  DROPSY_ERROR__VAULT_HAS_DELEGATE,
-  DROPSY_ERROR__VAULT_MINT_MISMATCH,
-  DROPSY_ERROR__VAULT_NOT_INITIALIZED,
-  DROPSY_ERROR__VAULT_NOT_RENT_EXEMPT,
-  DROPSY_ERROR__VESTING_ACCOUNT_REQUIRED,
-  DROPSY_MASTER_SEED,
-  DROPSY_PROGRAM_ADDRESS,
-  DROPSY_TREASURY,
-  DropsyAccount,
-  DropsyInstruction,
-  INITIALIZE_AIRDROP_MASTER_DISCRIMINATOR,
-  INITIALIZE_MASTER_DISCRIMINATOR,
-  MASTER_DISCRIMINATOR,
-  MAX_BITMAP_CLAIM,
-  MUTABLE_NONE,
-  PRESALE_SEED,
-  REDEEM_AIRDROP_TOKENS_DISCRIMINATOR,
-  STATE_DELEGATED,
-  STATE_INITIALIZED,
-  STATE_REDEEMED,
-  VAULT_SEED,
-  VERSION_BASIC,
-  VERSION_VESTED,
-  VESTING_SEED,
-  createDefaultSolanaClient,
-  createMerkleTree,
-  createTransactionMessageFromInstructions,
-  createWLMerkleTree,
-  decodeAffiliate,
-  decodeAffiliateMaster,
-  decodeAirdrop,
-  decodeAirdropConfig,
-  decodeAirdropMaster,
-  decodeClaimMap,
-  decodeMaster,
-  fetchAffiliate,
-  fetchAffiliateMaster,
-  fetchAirdrop,
-  fetchAirdropConfig,
-  fetchAirdropMaster,
-  fetchAllAffiliate,
-  fetchAllAffiliateMaster,
-  fetchAllAirdrop,
-  fetchAllAirdropConfig,
-  fetchAllAirdropMaster,
-  fetchAllClaimMap,
-  fetchAllMaster,
-  fetchAllMaybeAffiliate,
-  fetchAllMaybeAffiliateMaster,
-  fetchAllMaybeAirdrop,
-  fetchAllMaybeAirdropConfig,
-  fetchAllMaybeAirdropMaster,
-  fetchAllMaybeClaimMap,
-  fetchAllMaybeMaster,
-  fetchClaimMap,
-  fetchMaster,
-  fetchMaybeAffiliate,
-  fetchMaybeAffiliateMaster,
-  fetchMaybeAirdrop,
-  fetchMaybeAirdropConfig,
-  fetchMaybeAirdropMaster,
-  fetchMaybeClaimMap,
-  fetchMaybeMaster,
-  generateKeyPairSignerWithSol,
-  getAdvancedFeeConfigCodec,
-  getAdvancedFeeConfigDecoder,
-  getAdvancedFeeConfigEncoder,
-  getAffiliateCodec,
-  getAffiliateDecoder,
-  getAffiliateDerivedAddress,
-  getAffiliateDiscriminatorBytes,
-  getAffiliateEncoder,
-  getAffiliateMasterCodec,
-  getAffiliateMasterDecoder,
-  getAffiliateMasterDiscriminatorBytes,
-  getAffiliateMasterEncoder,
-  getAffiliateMasterSize,
-  getAffiliateSize,
-  getAirdropBoostedCodec,
-  getAirdropBoostedDecoder,
-  getAirdropBoostedEncoder,
-  getAirdropClosedCodec,
-  getAirdropClosedDecoder,
-  getAirdropClosedEncoder,
-  getAirdropCodec,
-  getAirdropConfigCodec,
-  getAirdropConfigDecoder,
-  getAirdropConfigDerivedAddress,
-  getAirdropConfigDiscriminatorBytes,
-  getAirdropConfigEncoder,
-  getAirdropConfigSize,
-  getAirdropDecoder,
-  getAirdropDelegatedCodec,
-  getAirdropDelegatedDecoder,
-  getAirdropDelegatedEncoder,
-  getAirdropDerivedAddress,
-  getAirdropDiscriminatorBytes,
-  getAirdropEncoder,
-  getAirdropInitializedCodec,
-  getAirdropInitializedDecoder,
-  getAirdropInitializedEncoder,
-  getAirdropMasterCodec,
-  getAirdropMasterDecoder,
-  getAirdropMasterDerivedAddress,
-  getAirdropMasterDiscriminatorBytes,
-  getAirdropMasterEncoder,
-  getAirdropMasterSize,
-  getAirdropSize,
-  getAirdropUpdatedCodec,
-  getAirdropUpdatedDecoder,
-  getAirdropUpdatedEncoder,
-  getBaseDurationConfigCodec,
-  getBaseDurationConfigDecoder,
-  getBaseDurationConfigEncoder,
-  getBaseFeatureFeeConfigCodec,
-  getBaseFeatureFeeConfigDecoder,
-  getBaseFeatureFeeConfigEncoder,
-  getBaseFeeConfigCodec,
-  getBaseFeeConfigDecoder,
-  getBaseFeeConfigEncoder,
-  getClaimAirdropDiscriminatorBytes,
-  getClaimAirdropInstruction,
-  getClaimAirdropInstructionAsync,
-  getClaimAirdropInstructionDataCodec,
-  getClaimAirdropInstructionDataDecoder,
-  getClaimAirdropInstructionDataEncoder,
-  getClaimMapClosedCodec,
-  getClaimMapClosedDecoder,
-  getClaimMapClosedEncoder,
-  getClaimMapCodec,
-  getClaimMapDecoder,
-  getClaimMapDerivedAddress,
-  getClaimMapDiscriminatorBytes,
-  getClaimMapEncoder,
-  getClaimMapInitializedCodec,
-  getClaimMapInitializedDecoder,
-  getClaimMapInitializedEncoder,
-  getClaimMapSize,
-  getCreateAirdropDiscriminatorBytes,
-  getCreateAirdropInstruction,
-  getCreateAirdropInstructionAsync,
-  getCreateAirdropInstructionDataCodec,
-  getCreateAirdropInstructionDataDecoder,
-  getCreateAirdropInstructionDataEncoder,
-  getCreateAirdropV0Instruction,
-  getCreateClaimMapDiscriminatorBytes,
-  getCreateClaimMapInstruction,
-  getCreateClaimMapInstructionAsync,
-  getCreateClaimMapInstructionDataCodec,
-  getCreateClaimMapInstructionDataDecoder,
-  getCreateClaimMapInstructionDataEncoder,
-  getCreateClaimMapV0Instruction,
-  getDepositTokensDiscriminatorBytes,
-  getDepositTokensInstruction,
-  getDepositTokensInstructionAsync,
-  getDepositTokensInstructionDataCodec,
-  getDepositTokensInstructionDataDecoder,
-  getDepositTokensInstructionDataEncoder,
-  getDropsyDerivedAddress,
-  getDropsyErrorMessage,
-  getInitAirdropConfigArgsCodec,
-  getInitAirdropConfigArgsDecoder,
-  getInitAirdropConfigArgsEncoder,
-  getInitializeAirdropMasterDiscriminatorBytes,
-  getInitializeAirdropMasterInstruction,
-  getInitializeAirdropMasterInstructionAsync,
-  getInitializeAirdropMasterInstructionDataCodec,
-  getInitializeAirdropMasterInstructionDataDecoder,
-  getInitializeAirdropMasterInstructionDataEncoder,
-  getInitializeMasterDiscriminatorBytes,
-  getInitializeMasterInstruction,
-  getInitializeMasterInstructionAsync,
-  getInitializeMasterInstructionDataCodec,
-  getInitializeMasterInstructionDataDecoder,
-  getInitializeMasterInstructionDataEncoder,
-  getMasterCodec,
-  getMasterDecoder,
-  getMasterDerivedAddress,
-  getMasterDiscriminatorBytes,
-  getMasterEncoder,
-  getMasterInitializedCodec,
-  getMasterInitializedDecoder,
-  getMasterInitializedEncoder,
-  getMasterSize,
-  getMerkleRootArray,
-  getRedeemAirdropTokensDiscriminatorBytes,
-  getRedeemAirdropTokensInstruction,
-  getRedeemAirdropTokensInstructionAsync,
-  getRedeemAirdropTokensInstructionDataCodec,
-  getRedeemAirdropTokensInstructionDataDecoder,
-  getRedeemAirdropTokensInstructionDataEncoder,
-  getSimpleMerkleProof,
-  getTokensDepositedCodec,
-  getTokensDepositedDecoder,
-  getTokensDepositedEncoder,
-  getTokensRedeemedCodec,
-  getTokensRedeemedDecoder,
-  getTokensRedeemedEncoder,
-  identifyDropsyAccount,
-  identifyDropsyInstruction,
-  isDropsyError,
-  parseClaimAirdropInstruction,
-  parseCreateAirdropInstruction,
-  parseCreateClaimMapInstruction,
-  parseDepositTokensInstruction,
-  parseInitializeAirdropMasterInstruction,
-  parseInitializeMasterInstruction,
-  parseRedeemAirdropTokensInstruction,
-  toUnixTimestamp
-};
-//# sourceMappingURL=index.mjs.map