@dropsy/airdrop 0.3.0 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (8) hide show
  1. package/dist/{index.mjs → index.cjs} +628 -674
  2. package/dist/index.cjs.map +1 -0
  3. package/dist/{index.d.mts → index.d.cts} +11 -15
  4. package/dist/index.d.ts +11 -15
  5. package/dist/index.js +661 -641
  6. package/dist/index.js.map +1 -1
  7. package/package.json +5 -2
  8. package/dist/index.mjs.map +0 -1
package/dist/{index.mjs → index.cjs} RENAMED
@@ -1,29 +1,218 @@
1
+ "use strict";
2
+ var __defProp = Object.defineProperty;
3
+ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
4
+ var __getOwnPropNames = Object.getOwnPropertyNames;
5
+ var __hasOwnProp = Object.prototype.hasOwnProperty;
6
+ var __export = (target, all) => {
7
+ for (var name in all)
8
+ __defProp(target, name, { get: all[name], enumerable: true });
9
+ };
10
+ var __copyProps = (to, from, except, desc) => {
11
+ if (from && typeof from === "object" || typeof from === "function") {
12
+ for (let key of __getOwnPropNames(from))
13
+ if (!__hasOwnProp.call(to, key) && key !== except)
14
+ __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
15
+ }
16
+ return to;
17
+ };
18
+ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
19
+
20
+ // src/index.ts
21
+ var index_exports = {};
22
+ __export(index_exports, {
23
+ AIRDROP_CONFIG_DISCRIMINATOR: () => AIRDROP_CONFIG_DISCRIMINATOR,
24
+ AIRDROP_DISCRIMINATOR: () => AIRDROP_DISCRIMINATOR,
25
+ AIRDROP_MASTER_DISCRIMINATOR: () => AIRDROP_MASTER_DISCRIMINATOR,
26
+ BITMAP_ACCOUNT_DISCRIMINATOR: () => BITMAP_ACCOUNT_DISCRIMINATOR,
27
+ CLAIM_AIRDROP_DISCRIMINATOR: () => CLAIM_AIRDROP_DISCRIMINATOR,
28
+ CREATE_AIRDROP_DISCRIMINATOR: () => CREATE_AIRDROP_DISCRIMINATOR,
29
+ CREATE_BITMAP_DISCRIMINATOR: () => CREATE_BITMAP_DISCRIMINATOR,
30
+ DEPOSIT_TOKENS_DISCRIMINATOR: () => DEPOSIT_TOKENS_DISCRIMINATOR,
31
+ DROPSY_AIRDROP_ERROR__ACTION_FEE_TOO_HIGH: () => DROPSY_AIRDROP_ERROR__ACTION_FEE_TOO_HIGH,
32
+ DROPSY_AIRDROP_ERROR__ACTIVE_BITMAPS_EXIST: () => DROPSY_AIRDROP_ERROR__ACTIVE_BITMAPS_EXIST,
33
+ DROPSY_AIRDROP_ERROR__AIRDROP_ENDED: () => DROPSY_AIRDROP_ERROR__AIRDROP_ENDED,
34
+ DROPSY_AIRDROP_ERROR__AIRDROP_NOT_ENDED: () => DROPSY_AIRDROP_ERROR__AIRDROP_NOT_ENDED,
35
+ DROPSY_AIRDROP_ERROR__AIRDROP_NOT_STARTED: () => DROPSY_AIRDROP_ERROR__AIRDROP_NOT_STARTED,
36
+ DROPSY_AIRDROP_ERROR__ALREADY_CLAIMED: () => DROPSY_AIRDROP_ERROR__ALREADY_CLAIMED,
37
+ DROPSY_AIRDROP_ERROR__BITMAP_AIRDROP_MISMATCH: () => DROPSY_AIRDROP_ERROR__BITMAP_AIRDROP_MISMATCH,
38
+ DROPSY_AIRDROP_ERROR__BITMAP_COUNT_UNDERFLOW: () => DROPSY_AIRDROP_ERROR__BITMAP_COUNT_UNDERFLOW,
39
+ DROPSY_AIRDROP_ERROR__BITMAP_TOO_LARGE: () => DROPSY_AIRDROP_ERROR__BITMAP_TOO_LARGE,
40
+ DROPSY_AIRDROP_ERROR__CLAIM_FEE_TOO_HIGH: () => DROPSY_AIRDROP_ERROR__CLAIM_FEE_TOO_HIGH,
41
+ DROPSY_AIRDROP_ERROR__CREATE_FEE_TOO_HIGH: () => DROPSY_AIRDROP_ERROR__CREATE_FEE_TOO_HIGH,
42
+ DROPSY_AIRDROP_ERROR__DESTINATION_MINT_MISMATCH: () => DROPSY_AIRDROP_ERROR__DESTINATION_MINT_MISMATCH,
43
+ DROPSY_AIRDROP_ERROR__DURATION_TOO_SHORT: () => DROPSY_AIRDROP_ERROR__DURATION_TOO_SHORT,
44
+ DROPSY_AIRDROP_ERROR__IMMUTABLE_AIRDROP: () => DROPSY_AIRDROP_ERROR__IMMUTABLE_AIRDROP,
45
+ DROPSY_AIRDROP_ERROR__IMMUTABLE_FIELD: () => DROPSY_AIRDROP_ERROR__IMMUTABLE_FIELD,
46
+ DROPSY_AIRDROP_ERROR__INSUFFICIENT_DEPOSIT: () => DROPSY_AIRDROP_ERROR__INSUFFICIENT_DEPOSIT,
47
+ DROPSY_AIRDROP_ERROR__INSUFFICIENT_FUNDS_FOR_FEE: () => DROPSY_AIRDROP_ERROR__INSUFFICIENT_FUNDS_FOR_FEE,
48
+ DROPSY_AIRDROP_ERROR__INSUFFICIENT_VAULT_FUNDS: () => DROPSY_AIRDROP_ERROR__INSUFFICIENT_VAULT_FUNDS,
49
+ DROPSY_AIRDROP_ERROR__INVALID_ADMIN: () => DROPSY_AIRDROP_ERROR__INVALID_ADMIN,
50
+ DROPSY_AIRDROP_ERROR__INVALID_AFFILIATE_PDA: () => DROPSY_AIRDROP_ERROR__INVALID_AFFILIATE_PDA,
51
+ DROPSY_AIRDROP_ERROR__INVALID_AIRDROP_PDA: () => DROPSY_AIRDROP_ERROR__INVALID_AIRDROP_PDA,
52
+ DROPSY_AIRDROP_ERROR__INVALID_AIRDROP_VERSION: () => DROPSY_AIRDROP_ERROR__INVALID_AIRDROP_VERSION,
53
+ DROPSY_AIRDROP_ERROR__INVALID_AIRDROP_VESTING_VERSION: () => DROPSY_AIRDROP_ERROR__INVALID_AIRDROP_VESTING_VERSION,
54
+ DROPSY_AIRDROP_ERROR__INVALID_AMOUNT: () => DROPSY_AIRDROP_ERROR__INVALID_AMOUNT,
55
+ DROPSY_AIRDROP_ERROR__INVALID_BITMAP_ACCOUNT: () => DROPSY_AIRDROP_ERROR__INVALID_BITMAP_ACCOUNT,
56
+ DROPSY_AIRDROP_ERROR__INVALID_BITMAP_INDEX: () => DROPSY_AIRDROP_ERROR__INVALID_BITMAP_INDEX,
57
+ DROPSY_AIRDROP_ERROR__INVALID_DELEGATE_PERMISSION: () => DROPSY_AIRDROP_ERROR__INVALID_DELEGATE_PERMISSION,
58
+ DROPSY_AIRDROP_ERROR__INVALID_DESTINATION_OWNER: () => DROPSY_AIRDROP_ERROR__INVALID_DESTINATION_OWNER,
59
+ DROPSY_AIRDROP_ERROR__INVALID_END_TIME: () => DROPSY_AIRDROP_ERROR__INVALID_END_TIME,
60
+ DROPSY_AIRDROP_ERROR__INVALID_FEE_VAULT: () => DROPSY_AIRDROP_ERROR__INVALID_FEE_VAULT,
61
+ DROPSY_AIRDROP_ERROR__INVALID_FEE_VAULT_CURVE: () => DROPSY_AIRDROP_ERROR__INVALID_FEE_VAULT_CURVE,
62
+ DROPSY_AIRDROP_ERROR__INVALID_FEE_VAULT_OWNER: () => DROPSY_AIRDROP_ERROR__INVALID_FEE_VAULT_OWNER,
63
+ DROPSY_AIRDROP_ERROR__INVALID_MINT: () => DROPSY_AIRDROP_ERROR__INVALID_MINT,
64
+ DROPSY_AIRDROP_ERROR__INVALID_MINT_OWNER: () => DROPSY_AIRDROP_ERROR__INVALID_MINT_OWNER,
65
+ DROPSY_AIRDROP_ERROR__INVALID_MUTABILITY: () => DROPSY_AIRDROP_ERROR__INVALID_MUTABILITY,
66
+ DROPSY_AIRDROP_ERROR__INVALID_OWNER: () => DROPSY_AIRDROP_ERROR__INVALID_OWNER,
67
+ DROPSY_AIRDROP_ERROR__INVALID_PARENT_ACCOUNT: () => DROPSY_AIRDROP_ERROR__INVALID_PARENT_ACCOUNT,
68
+ DROPSY_AIRDROP_ERROR__INVALID_PDA: () => DROPSY_AIRDROP_ERROR__INVALID_PDA,
69
+ DROPSY_AIRDROP_ERROR__INVALID_PERCENTAGE: () => DROPSY_AIRDROP_ERROR__INVALID_PERCENTAGE,
70
+ DROPSY_AIRDROP_ERROR__INVALID_PROOF: () => DROPSY_AIRDROP_ERROR__INVALID_PROOF,
71
+ DROPSY_AIRDROP_ERROR__INVALID_PUB_KEY: () => DROPSY_AIRDROP_ERROR__INVALID_PUB_KEY,
72
+ DROPSY_AIRDROP_ERROR__INVALID_TIMESTAMP: () => DROPSY_AIRDROP_ERROR__INVALID_TIMESTAMP,
73
+ DROPSY_AIRDROP_ERROR__INVALID_TOTAL: () => DROPSY_AIRDROP_ERROR__INVALID_TOTAL,
74
+ DROPSY_AIRDROP_ERROR__INVALID_TREASURY_ACCOUNT: () => DROPSY_AIRDROP_ERROR__INVALID_TREASURY_ACCOUNT,
75
+ DROPSY_AIRDROP_ERROR__INVALID_VAULT_AUTHORITY: () => DROPSY_AIRDROP_ERROR__INVALID_VAULT_AUTHORITY,
76
+ DROPSY_AIRDROP_ERROR__INVALID_VESTING_SCHEDULE: () => DROPSY_AIRDROP_ERROR__INVALID_VESTING_SCHEDULE,
77
+ DROPSY_AIRDROP_ERROR__INVALID_VESTING_TYPE: () => DROPSY_AIRDROP_ERROR__INVALID_VESTING_TYPE,
78
+ DROPSY_AIRDROP_ERROR__MINT_HAS_FREEZE_AUTHORITY: () => DROPSY_AIRDROP_ERROR__MINT_HAS_FREEZE_AUTHORITY,
79
+ DROPSY_AIRDROP_ERROR__MINT_IS_FROZEN: () => DROPSY_AIRDROP_ERROR__MINT_IS_FROZEN,
80
+ DROPSY_AIRDROP_ERROR__MINT_IS_NOT_INITIALIZED: () => DROPSY_AIRDROP_ERROR__MINT_IS_NOT_INITIALIZED,
81
+ DROPSY_AIRDROP_ERROR__MINT_MISMATCH: () => DROPSY_AIRDROP_ERROR__MINT_MISMATCH,
82
+ DROPSY_AIRDROP_ERROR__MISSING_BITMAP_PDA: () => DROPSY_AIRDROP_ERROR__MISSING_BITMAP_PDA,
83
+ DROPSY_AIRDROP_ERROR__NFT_NOT_ALLOWED: () => DROPSY_AIRDROP_ERROR__NFT_NOT_ALLOWED,
84
+ DROPSY_AIRDROP_ERROR__NON_ZERO_VALUE_REQUIRED: () => DROPSY_AIRDROP_ERROR__NON_ZERO_VALUE_REQUIRED,
85
+ DROPSY_AIRDROP_ERROR__OVERFLOW: () => DROPSY_AIRDROP_ERROR__OVERFLOW,
86
+ DROPSY_AIRDROP_ERROR__OWNER_MISMATCH: () => DROPSY_AIRDROP_ERROR__OWNER_MISMATCH,
87
+ DROPSY_AIRDROP_ERROR__SOURCE_ACCOUNT_FROZEN: () => DROPSY_AIRDROP_ERROR__SOURCE_ACCOUNT_FROZEN,
88
+ DROPSY_AIRDROP_ERROR__SOURCE_HAS_CLOSE_AUTHORITY: () => DROPSY_AIRDROP_ERROR__SOURCE_HAS_CLOSE_AUTHORITY,
89
+ DROPSY_AIRDROP_ERROR__SOURCE_HAS_DELEGATE: () => DROPSY_AIRDROP_ERROR__SOURCE_HAS_DELEGATE,
90
+ DROPSY_AIRDROP_ERROR__TOO_MANY_BITMAPS: () => DROPSY_AIRDROP_ERROR__TOO_MANY_BITMAPS,
91
+ DROPSY_AIRDROP_ERROR__UNAUTHORIZED: () => DROPSY_AIRDROP_ERROR__UNAUTHORIZED,
92
+ DROPSY_AIRDROP_ERROR__UN_AUTHORIZED: () => DROPSY_AIRDROP_ERROR__UN_AUTHORIZED,
93
+ DROPSY_AIRDROP_ERROR__UPDATE_CUTOFF_TIME_PASSED: () => DROPSY_AIRDROP_ERROR__UPDATE_CUTOFF_TIME_PASSED,
94
+ DROPSY_AIRDROP_ERROR__VALUE_BELOW_THE_MINIMUM: () => DROPSY_AIRDROP_ERROR__VALUE_BELOW_THE_MINIMUM,
95
+ DROPSY_AIRDROP_ERROR__VALUE_EXCEEDS_MAXIMUM: () => DROPSY_AIRDROP_ERROR__VALUE_EXCEEDS_MAXIMUM,
96
+ DROPSY_AIRDROP_ERROR__VALUE_OUT_OF_RANGE: () => DROPSY_AIRDROP_ERROR__VALUE_OUT_OF_RANGE,
97
+ DROPSY_AIRDROP_ERROR__VAULT_FROZEN: () => DROPSY_AIRDROP_ERROR__VAULT_FROZEN,
98
+ DROPSY_AIRDROP_ERROR__VAULT_HAS_CLOSE_AUTHORITY: () => DROPSY_AIRDROP_ERROR__VAULT_HAS_CLOSE_AUTHORITY,
99
+ DROPSY_AIRDROP_ERROR__VAULT_HAS_DELEGATE: () => DROPSY_AIRDROP_ERROR__VAULT_HAS_DELEGATE,
100
+ DROPSY_AIRDROP_ERROR__VAULT_MINT_MISMATCH: () => DROPSY_AIRDROP_ERROR__VAULT_MINT_MISMATCH,
101
+ DROPSY_AIRDROP_ERROR__VAULT_NOT_INITIALIZED: () => DROPSY_AIRDROP_ERROR__VAULT_NOT_INITIALIZED,
102
+ DROPSY_AIRDROP_ERROR__VAULT_NOT_RENT_EXEMPT: () => DROPSY_AIRDROP_ERROR__VAULT_NOT_RENT_EXEMPT,
103
+ DROPSY_AIRDROP_ERROR__VESTING_ACCOUNT_REQUIRED: () => DROPSY_AIRDROP_ERROR__VESTING_ACCOUNT_REQUIRED,
104
+ DROPSY_AIRDROP_PROGRAM_ADDRESS: () => DROPSY_AIRDROP_PROGRAM_ADDRESS,
105
+ DropsyAirdropAccount: () => DropsyAirdropAccount,
106
+ DropsyAirdropInstruction: () => DropsyAirdropInstruction,
107
+ INITIALIZE_AIRDROP_CONFIG_DISCRIMINATOR: () => INITIALIZE_AIRDROP_CONFIG_DISCRIMINATOR,
108
+ INITIALIZE_AIRDROP_MASTER_DISCRIMINATOR: () => INITIALIZE_AIRDROP_MASTER_DISCRIMINATOR,
109
+ decodeAirdrop: () => decodeAirdrop,
110
+ decodeAirdropConfig: () => decodeAirdropConfig,
111
+ decodeAirdropMaster: () => decodeAirdropMaster,
112
+ decodeBitmapAccount: () => decodeBitmapAccount,
113
+ fetchAirdrop: () => fetchAirdrop,
114
+ fetchAirdropConfig: () => fetchAirdropConfig,
115
+ fetchAirdropMaster: () => fetchAirdropMaster,
116
+ fetchAllAirdrop: () => fetchAllAirdrop,
117
+ fetchAllAirdropConfig: () => fetchAllAirdropConfig,
118
+ fetchAllAirdropMaster: () => fetchAllAirdropMaster,
119
+ fetchAllBitmapAccount: () => fetchAllBitmapAccount,
120
+ fetchAllMaybeAirdrop: () => fetchAllMaybeAirdrop,
121
+ fetchAllMaybeAirdropConfig: () => fetchAllMaybeAirdropConfig,
122
+ fetchAllMaybeAirdropMaster: () => fetchAllMaybeAirdropMaster,
123
+ fetchAllMaybeBitmapAccount: () => fetchAllMaybeBitmapAccount,
124
+ fetchBitmapAccount: () => fetchBitmapAccount,
125
+ fetchMaybeAirdrop: () => fetchMaybeAirdrop,
126
+ fetchMaybeAirdropConfig: () => fetchMaybeAirdropConfig,
127
+ fetchMaybeAirdropMaster: () => fetchMaybeAirdropMaster,
128
+ fetchMaybeBitmapAccount: () => fetchMaybeBitmapAccount,
129
+ getAirdropCodec: () => getAirdropCodec,
130
+ getAirdropConfigCodec: () => getAirdropConfigCodec,
131
+ getAirdropConfigDecoder: () => getAirdropConfigDecoder,
132
+ getAirdropConfigDiscriminatorBytes: () => getAirdropConfigDiscriminatorBytes,
133
+ getAirdropConfigEncoder: () => getAirdropConfigEncoder,
134
+ getAirdropConfigSize: () => getAirdropConfigSize,
135
+ getAirdropDecoder: () => getAirdropDecoder,
136
+ getAirdropDiscriminatorBytes: () => getAirdropDiscriminatorBytes,
137
+ getAirdropEncoder: () => getAirdropEncoder,
138
+ getAirdropInitializedCodec: () => getAirdropInitializedCodec,
139
+ getAirdropInitializedDecoder: () => getAirdropInitializedDecoder,
140
+ getAirdropInitializedEncoder: () => getAirdropInitializedEncoder,
141
+ getAirdropMasterCodec: () => getAirdropMasterCodec,
142
+ getAirdropMasterDecoder: () => getAirdropMasterDecoder,
143
+ getAirdropMasterDiscriminatorBytes: () => getAirdropMasterDiscriminatorBytes,
144
+ getAirdropMasterEncoder: () => getAirdropMasterEncoder,
145
+ getAirdropMasterSize: () => getAirdropMasterSize,
146
+ getAirdropSize: () => getAirdropSize,
147
+ getBitmapAccountCodec: () => getBitmapAccountCodec,
148
+ getBitmapAccountDecoder: () => getBitmapAccountDecoder,
149
+ getBitmapAccountDiscriminatorBytes: () => getBitmapAccountDiscriminatorBytes,
150
+ getBitmapAccountEncoder: () => getBitmapAccountEncoder,
151
+ getBitmapAccountSize: () => getBitmapAccountSize,
152
+ getBitmapClosedCodec: () => getBitmapClosedCodec,
153
+ getBitmapClosedDecoder: () => getBitmapClosedDecoder,
154
+ getBitmapClosedEncoder: () => getBitmapClosedEncoder,
155
+ getBitmapInitializedCodec: () => getBitmapInitializedCodec,
156
+ getBitmapInitializedDecoder: () => getBitmapInitializedDecoder,
157
+ getBitmapInitializedEncoder: () => getBitmapInitializedEncoder,
158
+ getClaimAirdropDiscriminatorBytes: () => getClaimAirdropDiscriminatorBytes,
159
+ getClaimAirdropInstruction: () => getClaimAirdropInstruction,
160
+ getClaimAirdropInstructionAsync: () => getClaimAirdropInstructionAsync,
161
+ getClaimAirdropInstructionDataCodec: () => getClaimAirdropInstructionDataCodec,
162
+ getClaimAirdropInstructionDataDecoder: () => getClaimAirdropInstructionDataDecoder,
163
+ getClaimAirdropInstructionDataEncoder: () => getClaimAirdropInstructionDataEncoder,
164
+ getCreateAirdropDiscriminatorBytes: () => getCreateAirdropDiscriminatorBytes,
165
+ getCreateAirdropInstruction: () => getCreateAirdropInstruction,
166
+ getCreateAirdropInstructionAsync: () => getCreateAirdropInstructionAsync,
167
+ getCreateAirdropInstructionDataCodec: () => getCreateAirdropInstructionDataCodec,
168
+ getCreateAirdropInstructionDataDecoder: () => getCreateAirdropInstructionDataDecoder,
169
+ getCreateAirdropInstructionDataEncoder: () => getCreateAirdropInstructionDataEncoder,
170
+ getCreateBitmapDiscriminatorBytes: () => getCreateBitmapDiscriminatorBytes,
171
+ getCreateBitmapInstruction: () => getCreateBitmapInstruction,
172
+ getCreateBitmapInstructionAsync: () => getCreateBitmapInstructionAsync,
173
+ getCreateBitmapInstructionDataCodec: () => getCreateBitmapInstructionDataCodec,
174
+ getCreateBitmapInstructionDataDecoder: () => getCreateBitmapInstructionDataDecoder,
175
+ getCreateBitmapInstructionDataEncoder: () => getCreateBitmapInstructionDataEncoder,
176
+ getDepositTokensDiscriminatorBytes: () => getDepositTokensDiscriminatorBytes,
177
+ getDepositTokensInstruction: () => getDepositTokensInstruction,
178
+ getDepositTokensInstructionAsync: () => getDepositTokensInstructionAsync,
179
+ getDepositTokensInstructionDataCodec: () => getDepositTokensInstructionDataCodec,
180
+ getDepositTokensInstructionDataDecoder: () => getDepositTokensInstructionDataDecoder,
181
+ getDepositTokensInstructionDataEncoder: () => getDepositTokensInstructionDataEncoder,
182
+ getDropsyAirdropErrorMessage: () => getDropsyAirdropErrorMessage,
183
+ getInitializeAirdropConfigDiscriminatorBytes: () => getInitializeAirdropConfigDiscriminatorBytes,
184
+ getInitializeAirdropConfigInstruction: () => getInitializeAirdropConfigInstruction,
185
+ getInitializeAirdropConfigInstructionAsync: () => getInitializeAirdropConfigInstructionAsync,
186
+ getInitializeAirdropConfigInstructionDataCodec: () => getInitializeAirdropConfigInstructionDataCodec,
187
+ getInitializeAirdropConfigInstructionDataDecoder: () => getInitializeAirdropConfigInstructionDataDecoder,
188
+ getInitializeAirdropConfigInstructionDataEncoder: () => getInitializeAirdropConfigInstructionDataEncoder,
189
+ getInitializeAirdropMasterDiscriminatorBytes: () => getInitializeAirdropMasterDiscriminatorBytes,
190
+ getInitializeAirdropMasterInstruction: () => getInitializeAirdropMasterInstruction,
191
+ getInitializeAirdropMasterInstructionAsync: () => getInitializeAirdropMasterInstructionAsync,
192
+ getInitializeAirdropMasterInstructionDataCodec: () => getInitializeAirdropMasterInstructionDataCodec,
193
+ getInitializeAirdropMasterInstructionDataDecoder: () => getInitializeAirdropMasterInstructionDataDecoder,
194
+ getInitializeAirdropMasterInstructionDataEncoder: () => getInitializeAirdropMasterInstructionDataEncoder,
195
+ getTokensDepositedCodec: () => getTokensDepositedCodec,
196
+ getTokensDepositedDecoder: () => getTokensDepositedDecoder,
197
+ getTokensDepositedEncoder: () => getTokensDepositedEncoder,
198
+ getTokensRedeemedCodec: () => getTokensRedeemedCodec,
199
+ getTokensRedeemedDecoder: () => getTokensRedeemedDecoder,
200
+ getTokensRedeemedEncoder: () => getTokensRedeemedEncoder,
201
+ identifyDropsyAirdropAccount: () => identifyDropsyAirdropAccount,
202
+ identifyDropsyAirdropInstruction: () => identifyDropsyAirdropInstruction,
203
+ isDropsyAirdropError: () => isDropsyAirdropError,
204
+ parseClaimAirdropInstruction: () => parseClaimAirdropInstruction,
205
+ parseCreateAirdropInstruction: () => parseCreateAirdropInstruction,
206
+ parseCreateBitmapInstruction: () => parseCreateBitmapInstruction,
207
+ parseDepositTokensInstruction: () => parseDepositTokensInstruction,
208
+ parseDropsyAirdropInstruction: () => parseDropsyAirdropInstruction,
209
+ parseInitializeAirdropConfigInstruction: () => parseInitializeAirdropConfigInstruction,
210
+ parseInitializeAirdropMasterInstruction: () => parseInitializeAirdropMasterInstruction
211
+ });
212
+ module.exports = __toCommonJS(index_exports);
213
+
1
214
  // src/accounts/airdrop.ts
2
- import {
3
- assertAccountExists,
4
- assertAccountsExist,
5
- combineCodec,
6
- decodeAccount,
7
- fetchEncodedAccount,
8
- fetchEncodedAccounts,
9
- fixDecoderSize,
10
- fixEncoderSize,
11
- getAddressDecoder,
12
- getAddressEncoder,
13
- getBytesDecoder,
14
- getBytesEncoder,
15
- getI64Decoder,
16
- getI64Encoder,
17
- getStructDecoder,
18
- getStructEncoder,
19
- getU16Decoder,
20
- getU16Encoder,
21
- getU64Decoder,
22
- getU64Encoder,
23
- getU8Decoder,
24
- getU8Encoder,
25
- transformEncoder
26
- } from "@solana/kit";
215
+ var import_kit = require("@solana/kit");
27
216
  var AIRDROP_DISCRIMINATOR = new Uint8Array([
28
217
  31,
29
218
  112,
@@ -35,110 +224,84 @@ var AIRDROP_DISCRIMINATOR = new Uint8Array([
35
224
  241
36
225
  ]);
37
226
  function getAirdropDiscriminatorBytes() {
38
- return fixEncoderSize(getBytesEncoder(), 8).encode(AIRDROP_DISCRIMINATOR);
227
+ return (0, import_kit.fixEncoderSize)((0, import_kit.getBytesEncoder)(), 8).encode(AIRDROP_DISCRIMINATOR);
39
228
  }
40
229
  function getAirdropEncoder() {
41
- return transformEncoder(
42
- getStructEncoder([
43
- ["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
44
- ["master", getAddressEncoder()],
45
- ["authority", getAddressEncoder()],
46
- ["mint", getAddressEncoder()],
47
- ["delegateAuthority", getAddressEncoder()],
48
- ["merkleRoot", fixEncoderSize(getBytesEncoder(), 32)],
49
- ["supply", getU64Encoder()],
50
- ["boost", getU64Encoder()],
51
- ["startsAt", getI64Encoder()],
52
- ["endsAt", getI64Encoder()],
53
- ["bitmapCount", getU16Encoder()],
54
- ["delegatePermissions", getU8Encoder()],
55
- ["mutable", getU8Encoder()],
56
- ["state", getU8Encoder()],
57
- ["version", getU8Encoder()],
58
- ["bump", getU8Encoder()],
59
- ["padding", fixEncoderSize(getBytesEncoder(), 1)]
230
+ return (0, import_kit.transformEncoder)(
231
+ (0, import_kit.getStructEncoder)([
232
+ ["discriminator", (0, import_kit.fixEncoderSize)((0, import_kit.getBytesEncoder)(), 8)],
233
+ ["master", (0, import_kit.getAddressEncoder)()],
234
+ ["authority", (0, import_kit.getAddressEncoder)()],
235
+ ["mint", (0, import_kit.getAddressEncoder)()],
236
+ ["delegateAuthority", (0, import_kit.getAddressEncoder)()],
237
+ ["merkleRoot", (0, import_kit.fixEncoderSize)((0, import_kit.getBytesEncoder)(), 32)],
238
+ ["id", (0, import_kit.getU64Encoder)()],
239
+ ["supply", (0, import_kit.getU64Encoder)()],
240
+ ["boost", (0, import_kit.getU64Encoder)()],
241
+ ["startsAt", (0, import_kit.getI64Encoder)()],
242
+ ["endsAt", (0, import_kit.getI64Encoder)()],
243
+ ["bitmapCount", (0, import_kit.getU16Encoder)()],
244
+ ["state", (0, import_kit.getU8Encoder)()],
245
+ ["version", (0, import_kit.getU8Encoder)()],
246
+ ["bump", (0, import_kit.getU8Encoder)()],
247
+ ["padding", (0, import_kit.fixEncoderSize)((0, import_kit.getBytesEncoder)(), 3)]
60
248
  ]),
61
249
  (value) => ({ ...value, discriminator: AIRDROP_DISCRIMINATOR })
62
250
  );
63
251
  }
64
252
  function getAirdropDecoder() {
65
- return getStructDecoder([
66
- ["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
67
- ["master", getAddressDecoder()],
68
- ["authority", getAddressDecoder()],
69
- ["mint", getAddressDecoder()],
70
- ["delegateAuthority", getAddressDecoder()],
71
- ["merkleRoot", fixDecoderSize(getBytesDecoder(), 32)],
72
- ["supply", getU64Decoder()],
73
- ["boost", getU64Decoder()],
74
- ["startsAt", getI64Decoder()],
75
- ["endsAt", getI64Decoder()],
76
- ["bitmapCount", getU16Decoder()],
77
- ["delegatePermissions", getU8Decoder()],
78
- ["mutable", getU8Decoder()],
79
- ["state", getU8Decoder()],
80
- ["version", getU8Decoder()],
81
- ["bump", getU8Decoder()],
82
- ["padding", fixDecoderSize(getBytesDecoder(), 1)]
253
+ return (0, import_kit.getStructDecoder)([
254
+ ["discriminator", (0, import_kit.fixDecoderSize)((0, import_kit.getBytesDecoder)(), 8)],
255
+ ["master", (0, import_kit.getAddressDecoder)()],
256
+ ["authority", (0, import_kit.getAddressDecoder)()],
257
+ ["mint", (0, import_kit.getAddressDecoder)()],
258
+ ["delegateAuthority", (0, import_kit.getAddressDecoder)()],
259
+ ["merkleRoot", (0, import_kit.fixDecoderSize)((0, import_kit.getBytesDecoder)(), 32)],
260
+ ["id", (0, import_kit.getU64Decoder)()],
261
+ ["supply", (0, import_kit.getU64Decoder)()],
262
+ ["boost", (0, import_kit.getU64Decoder)()],
263
+ ["startsAt", (0, import_kit.getI64Decoder)()],
264
+ ["endsAt", (0, import_kit.getI64Decoder)()],
265
+ ["bitmapCount", (0, import_kit.getU16Decoder)()],
266
+ ["state", (0, import_kit.getU8Decoder)()],
267
+ ["version", (0, import_kit.getU8Decoder)()],
268
+ ["bump", (0, import_kit.getU8Decoder)()],
269
+ ["padding", (0, import_kit.fixDecoderSize)((0, import_kit.getBytesDecoder)(), 3)]
83
270
  ]);
84
271
  }
85
272
  function getAirdropCodec() {
86
- return combineCodec(getAirdropEncoder(), getAirdropDecoder());
273
+ return (0, import_kit.combineCodec)(getAirdropEncoder(), getAirdropDecoder());
87
274
  }
88
275
  function decodeAirdrop(encodedAccount) {
89
- return decodeAccount(
276
+ return (0, import_kit.decodeAccount)(
90
277
  encodedAccount,
91
278
  getAirdropDecoder()
92
279
  );
93
280
  }
94
281
  async function fetchAirdrop(rpc, address, config) {
95
282
  const maybeAccount = await fetchMaybeAirdrop(rpc, address, config);
96
- assertAccountExists(maybeAccount);
283
+ (0, import_kit.assertAccountExists)(maybeAccount);
97
284
  return maybeAccount;
98
285
  }
99
286
  async function fetchMaybeAirdrop(rpc, address, config) {
100
- const maybeAccount = await fetchEncodedAccount(rpc, address, config);
287
+ const maybeAccount = await (0, import_kit.fetchEncodedAccount)(rpc, address, config);
101
288
  return decodeAirdrop(maybeAccount);
102
289
  }
103
290
  async function fetchAllAirdrop(rpc, addresses, config) {
104
291
  const maybeAccounts = await fetchAllMaybeAirdrop(rpc, addresses, config);
105
- assertAccountsExist(maybeAccounts);
292
+ (0, import_kit.assertAccountsExist)(maybeAccounts);
106
293
  return maybeAccounts;
107
294
  }
108
295
  async function fetchAllMaybeAirdrop(rpc, addresses, config) {
109
- const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
296
+ const maybeAccounts = await (0, import_kit.fetchEncodedAccounts)(rpc, addresses, config);
110
297
  return maybeAccounts.map((maybeAccount) => decodeAirdrop(maybeAccount));
111
298
  }
112
299
  function getAirdropSize() {
113
- return 208;
300
+ return 216;
114
301
  }
115
302
 
116
303
  // src/accounts/airdropConfig.ts
117
- import {
118
- assertAccountExists as assertAccountExists2,
119
- assertAccountsExist as assertAccountsExist2,
120
- combineCodec as combineCodec2,
121
- decodeAccount as decodeAccount2,
122
- fetchEncodedAccount as fetchEncodedAccount2,
123
- fetchEncodedAccounts as fetchEncodedAccounts2,
124
- fixDecoderSize as fixDecoderSize2,
125
- fixEncoderSize as fixEncoderSize2,
126
- getAddressDecoder as getAddressDecoder2,
127
- getAddressEncoder as getAddressEncoder2,
128
- getBytesDecoder as getBytesDecoder2,
129
- getBytesEncoder as getBytesEncoder2,
130
- getI64Decoder as getI64Decoder2,
131
- getI64Encoder as getI64Encoder2,
132
- getStructDecoder as getStructDecoder2,
133
- getStructEncoder as getStructEncoder2,
134
- getU16Decoder as getU16Decoder2,
135
- getU16Encoder as getU16Encoder2,
136
- getU64Decoder as getU64Decoder2,
137
- getU64Encoder as getU64Encoder2,
138
- getU8Decoder as getU8Decoder2,
139
- getU8Encoder as getU8Encoder2,
140
- transformEncoder as transformEncoder2
141
- } from "@solana/kit";
304
+ var import_kit2 = require("@solana/kit");
142
305
  var AIRDROP_CONFIG_DISCRIMINATOR = new Uint8Array([
143
306
  194,
144
307
  149,
@@ -150,71 +313,71 @@ var AIRDROP_CONFIG_DISCRIMINATOR = new Uint8Array([
150
313
  16
151
314
  ]);
152
315
  function getAirdropConfigDiscriminatorBytes() {
153
- return fixEncoderSize2(getBytesEncoder2(), 8).encode(
316
+ return (0, import_kit2.fixEncoderSize)((0, import_kit2.getBytesEncoder)(), 8).encode(
154
317
  AIRDROP_CONFIG_DISCRIMINATOR
155
318
  );
156
319
  }
157
320
  function getAirdropConfigEncoder() {
158
- return transformEncoder2(
159
- getStructEncoder2([
160
- ["discriminator", fixEncoderSize2(getBytesEncoder2(), 8)],
161
- ["authority", getAddressEncoder2()],
162
- ["protocolTreasury", getAddressEncoder2()],
163
- ["wlRoot", fixEncoderSize2(getBytesEncoder2(), 32)],
164
- ["protocolFee", getU64Encoder2()],
165
- ["airdropMasterCreateFee", getU64Encoder2()],
166
- ["maxClaimFee", getU64Encoder2()],
167
- ["maxActionFee", getU64Encoder2()],
168
- ["minAirdropDuration", getI64Encoder2()],
169
- ["defaultAirdropDuration", getI64Encoder2()],
170
- ["maxAirdropDuration", getI64Encoder2()],
171
- ["updateGracePeriod", getI64Encoder2()],
172
- ["masterFeeBps", getU16Encoder2()],
173
- ["version", getU8Encoder2()],
174
- ["bump", getU8Encoder2()],
175
- ["padding", fixEncoderSize2(getBytesEncoder2(), 4)],
176
- ["reserved", fixEncoderSize2(getBytesEncoder2(), 256)]
321
+ return (0, import_kit2.transformEncoder)(
322
+ (0, import_kit2.getStructEncoder)([
323
+ ["discriminator", (0, import_kit2.fixEncoderSize)((0, import_kit2.getBytesEncoder)(), 8)],
324
+ ["authority", (0, import_kit2.getAddressEncoder)()],
325
+ ["protocolTreasury", (0, import_kit2.getAddressEncoder)()],
326
+ ["wlRoot", (0, import_kit2.fixEncoderSize)((0, import_kit2.getBytesEncoder)(), 32)],
327
+ ["protocolFee", (0, import_kit2.getU64Encoder)()],
328
+ ["airdropMasterCreateFee", (0, import_kit2.getU64Encoder)()],
329
+ ["maxClaimFee", (0, import_kit2.getU64Encoder)()],
330
+ ["maxActionFee", (0, import_kit2.getU64Encoder)()],
331
+ ["minAirdropDuration", (0, import_kit2.getI64Encoder)()],
332
+ ["defaultAirdropDuration", (0, import_kit2.getI64Encoder)()],
333
+ ["maxAirdropDuration", (0, import_kit2.getI64Encoder)()],
334
+ ["updateGracePeriod", (0, import_kit2.getI64Encoder)()],
335
+ ["masterFeeBps", (0, import_kit2.getU16Encoder)()],
336
+ ["version", (0, import_kit2.getU8Encoder)()],
337
+ ["bump", (0, import_kit2.getU8Encoder)()],
338
+ ["padding", (0, import_kit2.fixEncoderSize)((0, import_kit2.getBytesEncoder)(), 4)],
339
+ ["reserved", (0, import_kit2.fixEncoderSize)((0, import_kit2.getBytesEncoder)(), 256)]
177
340
  ]),
178
341
  (value) => ({ ...value, discriminator: AIRDROP_CONFIG_DISCRIMINATOR })
179
342
  );
180
343
  }
181
344
  function getAirdropConfigDecoder() {
182
- return getStructDecoder2([
183
- ["discriminator", fixDecoderSize2(getBytesDecoder2(), 8)],
184
- ["authority", getAddressDecoder2()],
185
- ["protocolTreasury", getAddressDecoder2()],
186
- ["wlRoot", fixDecoderSize2(getBytesDecoder2(), 32)],
187
- ["protocolFee", getU64Decoder2()],
188
- ["airdropMasterCreateFee", getU64Decoder2()],
189
- ["maxClaimFee", getU64Decoder2()],
190
- ["maxActionFee", getU64Decoder2()],
191
- ["minAirdropDuration", getI64Decoder2()],
192
- ["defaultAirdropDuration", getI64Decoder2()],
193
- ["maxAirdropDuration", getI64Decoder2()],
194
- ["updateGracePeriod", getI64Decoder2()],
195
- ["masterFeeBps", getU16Decoder2()],
196
- ["version", getU8Decoder2()],
197
- ["bump", getU8Decoder2()],
198
- ["padding", fixDecoderSize2(getBytesDecoder2(), 4)],
199
- ["reserved", fixDecoderSize2(getBytesDecoder2(), 256)]
345
+ return (0, import_kit2.getStructDecoder)([
346
+ ["discriminator", (0, import_kit2.fixDecoderSize)((0, import_kit2.getBytesDecoder)(), 8)],
347
+ ["authority", (0, import_kit2.getAddressDecoder)()],
348
+ ["protocolTreasury", (0, import_kit2.getAddressDecoder)()],
349
+ ["wlRoot", (0, import_kit2.fixDecoderSize)((0, import_kit2.getBytesDecoder)(), 32)],
350
+ ["protocolFee", (0, import_kit2.getU64Decoder)()],
351
+ ["airdropMasterCreateFee", (0, import_kit2.getU64Decoder)()],
352
+ ["maxClaimFee", (0, import_kit2.getU64Decoder)()],
353
+ ["maxActionFee", (0, import_kit2.getU64Decoder)()],
354
+ ["minAirdropDuration", (0, import_kit2.getI64Decoder)()],
355
+ ["defaultAirdropDuration", (0, import_kit2.getI64Decoder)()],
356
+ ["maxAirdropDuration", (0, import_kit2.getI64Decoder)()],
357
+ ["updateGracePeriod", (0, import_kit2.getI64Decoder)()],
358
+ ["masterFeeBps", (0, import_kit2.getU16Decoder)()],
359
+ ["version", (0, import_kit2.getU8Decoder)()],
360
+ ["bump", (0, import_kit2.getU8Decoder)()],
361
+ ["padding", (0, import_kit2.fixDecoderSize)((0, import_kit2.getBytesDecoder)(), 4)],
362
+ ["reserved", (0, import_kit2.fixDecoderSize)((0, import_kit2.getBytesDecoder)(), 256)]
200
363
  ]);
201
364
  }
202
365
  function getAirdropConfigCodec() {
203
- return combineCodec2(getAirdropConfigEncoder(), getAirdropConfigDecoder());
366
+ return (0, import_kit2.combineCodec)(getAirdropConfigEncoder(), getAirdropConfigDecoder());
204
367
  }
205
368
  function decodeAirdropConfig(encodedAccount) {
206
- return decodeAccount2(
369
+ return (0, import_kit2.decodeAccount)(
207
370
  encodedAccount,
208
371
  getAirdropConfigDecoder()
209
372
  );
210
373
  }
211
374
  async function fetchAirdropConfig(rpc, address, config) {
212
375
  const maybeAccount = await fetchMaybeAirdropConfig(rpc, address, config);
213
- assertAccountExists2(maybeAccount);
376
+ (0, import_kit2.assertAccountExists)(maybeAccount);
214
377
  return maybeAccount;
215
378
  }
216
379
  async function fetchMaybeAirdropConfig(rpc, address, config) {
217
- const maybeAccount = await fetchEncodedAccount2(rpc, address, config);
380
+ const maybeAccount = await (0, import_kit2.fetchEncodedAccount)(rpc, address, config);
218
381
  return decodeAirdropConfig(maybeAccount);
219
382
  }
220
383
  async function fetchAllAirdropConfig(rpc, addresses, config) {
@@ -223,11 +386,11 @@ async function fetchAllAirdropConfig(rpc, addresses, config) {
223
386
  addresses,
224
387
  config
225
388
  );
226
- assertAccountsExist2(maybeAccounts);
389
+ (0, import_kit2.assertAccountsExist)(maybeAccounts);
227
390
  return maybeAccounts;
228
391
  }
229
392
  async function fetchAllMaybeAirdropConfig(rpc, addresses, config) {
230
- const maybeAccounts = await fetchEncodedAccounts2(rpc, addresses, config);
393
+ const maybeAccounts = await (0, import_kit2.fetchEncodedAccounts)(rpc, addresses, config);
231
394
  return maybeAccounts.map((maybeAccount) => decodeAirdropConfig(maybeAccount));
232
395
  }
233
396
  function getAirdropConfigSize() {
@@ -235,27 +398,7 @@ function getAirdropConfigSize() {
235
398
  }
236
399
 
237
400
  // src/accounts/airdropMaster.ts
238
- import {
239
- assertAccountExists as assertAccountExists3,
240
- assertAccountsExist as assertAccountsExist3,
241
- combineCodec as combineCodec3,
242
- decodeAccount as decodeAccount3,
243
- fetchEncodedAccount as fetchEncodedAccount3,
244
- fetchEncodedAccounts as fetchEncodedAccounts3,
245
- fixDecoderSize as fixDecoderSize3,
246
- fixEncoderSize as fixEncoderSize3,
247
- getAddressDecoder as getAddressDecoder3,
248
- getAddressEncoder as getAddressEncoder3,
249
- getBytesDecoder as getBytesDecoder3,
250
- getBytesEncoder as getBytesEncoder3,
251
- getStructDecoder as getStructDecoder3,
252
- getStructEncoder as getStructEncoder3,
253
- getU64Decoder as getU64Decoder3,
254
- getU64Encoder as getU64Encoder3,
255
- getU8Decoder as getU8Decoder3,
256
- getU8Encoder as getU8Encoder3,
257
- transformEncoder as transformEncoder3
258
- } from "@solana/kit";
401
+ var import_kit3 = require("@solana/kit");
259
402
  var AIRDROP_MASTER_DISCRIMINATOR = new Uint8Array([
260
403
  31,
261
404
  109,
@@ -267,67 +410,69 @@ var AIRDROP_MASTER_DISCRIMINATOR = new Uint8Array([
267
410
  4
268
411
  ]);
269
412
  function getAirdropMasterDiscriminatorBytes() {
270
- return fixEncoderSize3(getBytesEncoder3(), 8).encode(
413
+ return (0, import_kit3.fixEncoderSize)((0, import_kit3.getBytesEncoder)(), 8).encode(
271
414
  AIRDROP_MASTER_DISCRIMINATOR
272
415
  );
273
416
  }
274
417
  function getAirdropMasterEncoder() {
275
- return transformEncoder3(
276
- getStructEncoder3([
277
- ["discriminator", fixEncoderSize3(getBytesEncoder3(), 8)],
278
- ["creator", getAddressEncoder3()],
279
- ["authority", getAddressEncoder3()],
280
- ["treasury", getAddressEncoder3()],
281
- ["points", getU64Encoder3()],
282
- ["totalClaimCount", getU64Encoder3()],
283
- ["monetizedClaimQuota", getU64Encoder3()],
284
- ["monetizedClaimCount", getU64Encoder3()],
285
- ["airdropUpdateFee", getU64Encoder3()],
286
- ["airdropCreationFee", getU64Encoder3()],
287
- ["airdropClaimFee", getU64Encoder3()],
288
- ["airdropDelegateFee", getU64Encoder3()],
289
- ["bitmapCreationFee", getU64Encoder3()],
290
- ["bump", getU8Encoder3()],
291
- ["padding", fixEncoderSize3(getBytesEncoder3(), 7)]
418
+ return (0, import_kit3.transformEncoder)(
419
+ (0, import_kit3.getStructEncoder)([
420
+ ["discriminator", (0, import_kit3.fixEncoderSize)((0, import_kit3.getBytesEncoder)(), 8)],
421
+ ["creator", (0, import_kit3.getAddressEncoder)()],
422
+ ["authority", (0, import_kit3.getAddressEncoder)()],
423
+ ["treasury", (0, import_kit3.getAddressEncoder)()],
424
+ ["createdAirdrops", (0, import_kit3.getU64Encoder)()],
425
+ ["points", (0, import_kit3.getU64Encoder)()],
426
+ ["totalClaimCount", (0, import_kit3.getU64Encoder)()],
427
+ ["monetizedClaimQuota", (0, import_kit3.getU64Encoder)()],
428
+ ["monetizedClaimCount", (0, import_kit3.getU64Encoder)()],
429
+ ["airdropUpdateFee", (0, import_kit3.getU64Encoder)()],
430
+ ["airdropCreationFee", (0, import_kit3.getU64Encoder)()],
431
+ ["airdropClaimFee", (0, import_kit3.getU64Encoder)()],
432
+ ["airdropDelegateFee", (0, import_kit3.getU64Encoder)()],
433
+ ["bitmapCreationFee", (0, import_kit3.getU64Encoder)()],
434
+ ["bump", (0, import_kit3.getU8Encoder)()],
435
+ ["padding", (0, import_kit3.fixEncoderSize)((0, import_kit3.getBytesEncoder)(), 7)]
292
436
  ]),
293
437
  (value) => ({ ...value, discriminator: AIRDROP_MASTER_DISCRIMINATOR })
294
438
  );
295
439
  }
296
440
  function getAirdropMasterDecoder() {
297
- return getStructDecoder3([
298
- ["discriminator", fixDecoderSize3(getBytesDecoder3(), 8)],
299
- ["creator", getAddressDecoder3()],
300
- ["authority", getAddressDecoder3()],
301
- ["treasury", getAddressDecoder3()],
302
- ["points", getU64Decoder3()],
303
- ["totalClaimCount", getU64Decoder3()],
304
- ["monetizedClaimQuota", getU64Decoder3()],
305
- ["monetizedClaimCount", getU64Decoder3()],
306
- ["airdropUpdateFee", getU64Decoder3()],
307
- ["airdropCreationFee", getU64Decoder3()],
308
- ["airdropClaimFee", getU64Decoder3()],
309
- ["airdropDelegateFee", getU64Decoder3()],
310
- ["bitmapCreationFee", getU64Decoder3()],
311
- ["bump", getU8Decoder3()],
312
- ["padding", fixDecoderSize3(getBytesDecoder3(), 7)]
441
+ return (0, import_kit3.getStructDecoder)([
442
+ ["discriminator", (0, import_kit3.fixDecoderSize)((0, import_kit3.getBytesDecoder)(), 8)],
443
+ ["creator", (0, import_kit3.getAddressDecoder)()],
444
+ ["authority", (0, import_kit3.getAddressDecoder)()],
445
+ ["treasury", (0, import_kit3.getAddressDecoder)()],
446
+ ["createdAirdrops", (0, import_kit3.getU64Decoder)()],
447
+ ["points", (0, import_kit3.getU64Decoder)()],
448
+ ["totalClaimCount", (0, import_kit3.getU64Decoder)()],
449
+ ["monetizedClaimQuota", (0, import_kit3.getU64Decoder)()],
450
+ ["monetizedClaimCount", (0, import_kit3.getU64Decoder)()],
451
+ ["airdropUpdateFee", (0, import_kit3.getU64Decoder)()],
452
+ ["airdropCreationFee", (0, import_kit3.getU64Decoder)()],
453
+ ["airdropClaimFee", (0, import_kit3.getU64Decoder)()],
454
+ ["airdropDelegateFee", (0, import_kit3.getU64Decoder)()],
455
+ ["bitmapCreationFee", (0, import_kit3.getU64Decoder)()],
456
+ ["bump", (0, import_kit3.getU8Decoder)()],
457
+ ["padding", (0, import_kit3.fixDecoderSize)((0, import_kit3.getBytesDecoder)(), 7)]
313
458
  ]);
314
459
  }
315
460
  function getAirdropMasterCodec() {
316
- return combineCodec3(getAirdropMasterEncoder(), getAirdropMasterDecoder());
461
+ return (0, import_kit3.combineCodec)(getAirdropMasterEncoder(), getAirdropMasterDecoder());
317
462
  }
318
463
  function decodeAirdropMaster(encodedAccount) {
319
- return decodeAccount3(
464
+ return (0, import_kit3.decodeAccount)(
320
465
  encodedAccount,
321
466
  getAirdropMasterDecoder()
322
467
  );
323
468
  }
324
469
  async function fetchAirdropMaster(rpc, address, config) {
325
470
  const maybeAccount = await fetchMaybeAirdropMaster(rpc, address, config);
326
- assertAccountExists3(maybeAccount);
471
+ (0, import_kit3.assertAccountExists)(maybeAccount);
327
472
  return maybeAccount;
328
473
  }
329
474
  async function fetchMaybeAirdropMaster(rpc, address, config) {
330
- const maybeAccount = await fetchEncodedAccount3(rpc, address, config);
475
+ const maybeAccount = await (0, import_kit3.fetchEncodedAccount)(rpc, address, config);
331
476
  return decodeAirdropMaster(maybeAccount);
332
477
  }
333
478
  async function fetchAllAirdropMaster(rpc, addresses, config) {
@@ -336,41 +481,19 @@ async function fetchAllAirdropMaster(rpc, addresses, config) {
336
481
  addresses,
337
482
  config
338
483
  );
339
- assertAccountsExist3(maybeAccounts);
484
+ (0, import_kit3.assertAccountsExist)(maybeAccounts);
340
485
  return maybeAccounts;
341
486
  }
342
487
  async function fetchAllMaybeAirdropMaster(rpc, addresses, config) {
343
- const maybeAccounts = await fetchEncodedAccounts3(rpc, addresses, config);
488
+ const maybeAccounts = await (0, import_kit3.fetchEncodedAccounts)(rpc, addresses, config);
344
489
  return maybeAccounts.map((maybeAccount) => decodeAirdropMaster(maybeAccount));
345
490
  }
346
491
  function getAirdropMasterSize() {
347
- return 184;
492
+ return 192;
348
493
  }
349
494
 
350
495
  // src/accounts/bitmapAccount.ts
351
- import {
352
- assertAccountExists as assertAccountExists4,
353
- assertAccountsExist as assertAccountsExist4,
354
- combineCodec as combineCodec4,
355
- decodeAccount as decodeAccount4,
356
- fetchEncodedAccount as fetchEncodedAccount4,
357
- fetchEncodedAccounts as fetchEncodedAccounts4,
358
- fixDecoderSize as fixDecoderSize4,
359
- fixEncoderSize as fixEncoderSize4,
360
- getAddressDecoder as getAddressDecoder4,
361
- getAddressEncoder as getAddressEncoder4,
362
- getBytesDecoder as getBytesDecoder4,
363
- getBytesEncoder as getBytesEncoder4,
364
- getStructDecoder as getStructDecoder4,
365
- getStructEncoder as getStructEncoder4,
366
- getU16Decoder as getU16Decoder3,
367
- getU16Encoder as getU16Encoder3,
368
- getU32Decoder,
369
- getU32Encoder,
370
- getU8Decoder as getU8Decoder4,
371
- getU8Encoder as getU8Encoder4,
372
- transformEncoder as transformEncoder4
373
- } from "@solana/kit";
496
+ var import_kit4 = require("@solana/kit");
374
497
  var BITMAP_ACCOUNT_DISCRIMINATOR = new Uint8Array([
375
498
  152,
376
499
  161,
@@ -382,53 +505,53 @@ var BITMAP_ACCOUNT_DISCRIMINATOR = new Uint8Array([
382
505
  48
383
506
  ]);
384
507
  function getBitmapAccountDiscriminatorBytes() {
385
- return fixEncoderSize4(getBytesEncoder4(), 8).encode(
508
+ return (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8).encode(
386
509
  BITMAP_ACCOUNT_DISCRIMINATOR
387
510
  );
388
511
  }
389
512
  function getBitmapAccountEncoder() {
390
- return transformEncoder4(
391
- getStructEncoder4([
392
- ["discriminator", fixEncoderSize4(getBytesEncoder4(), 8)],
393
- ["authority", getAddressEncoder4()],
394
- ["airdrop", getAddressEncoder4()],
395
- ["total", getU32Encoder()],
396
- ["claimedBitmap", fixEncoderSize4(getBytesEncoder4(), 8e3)],
397
- ["id", getU16Encoder3()],
398
- ["version", getU8Encoder4()],
399
- ["bump", getU8Encoder4()]
513
+ return (0, import_kit4.transformEncoder)(
514
+ (0, import_kit4.getStructEncoder)([
515
+ ["discriminator", (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 8)],
516
+ ["authority", (0, import_kit4.getAddressEncoder)()],
517
+ ["airdrop", (0, import_kit4.getAddressEncoder)()],
518
+ ["total", (0, import_kit4.getU32Encoder)()],
519
+ ["claimedBitmap", (0, import_kit4.fixEncoderSize)((0, import_kit4.getBytesEncoder)(), 1e3)],
520
+ ["id", (0, import_kit4.getU16Encoder)()],
521
+ ["version", (0, import_kit4.getU8Encoder)()],
522
+ ["bump", (0, import_kit4.getU8Encoder)()]
400
523
  ]),
401
524
  (value) => ({ ...value, discriminator: BITMAP_ACCOUNT_DISCRIMINATOR })
402
525
  );
403
526
  }
404
527
  function getBitmapAccountDecoder() {
405
- return getStructDecoder4([
406
- ["discriminator", fixDecoderSize4(getBytesDecoder4(), 8)],
407
- ["authority", getAddressDecoder4()],
408
- ["airdrop", getAddressDecoder4()],
409
- ["total", getU32Decoder()],
410
- ["claimedBitmap", fixDecoderSize4(getBytesDecoder4(), 8e3)],
411
- ["id", getU16Decoder3()],
412
- ["version", getU8Decoder4()],
413
- ["bump", getU8Decoder4()]
528
+ return (0, import_kit4.getStructDecoder)([
529
+ ["discriminator", (0, import_kit4.fixDecoderSize)((0, import_kit4.getBytesDecoder)(), 8)],
530
+ ["authority", (0, import_kit4.getAddressDecoder)()],
531
+ ["airdrop", (0, import_kit4.getAddressDecoder)()],
532
+ ["total", (0, import_kit4.getU32Decoder)()],
533
+ ["claimedBitmap", (0, import_kit4.fixDecoderSize)((0, import_kit4.getBytesDecoder)(), 1e3)],
534
+ ["id", (0, import_kit4.getU16Decoder)()],
535
+ ["version", (0, import_kit4.getU8Decoder)()],
536
+ ["bump", (0, import_kit4.getU8Decoder)()]
414
537
  ]);
415
538
  }
416
539
  function getBitmapAccountCodec() {
417
- return combineCodec4(getBitmapAccountEncoder(), getBitmapAccountDecoder());
540
+ return (0, import_kit4.combineCodec)(getBitmapAccountEncoder(), getBitmapAccountDecoder());
418
541
  }
419
542
  function decodeBitmapAccount(encodedAccount) {
420
- return decodeAccount4(
543
+ return (0, import_kit4.decodeAccount)(
421
544
  encodedAccount,
422
545
  getBitmapAccountDecoder()
423
546
  );
424
547
  }
425
548
  async function fetchBitmapAccount(rpc, address, config) {
426
549
  const maybeAccount = await fetchMaybeBitmapAccount(rpc, address, config);
427
- assertAccountExists4(maybeAccount);
550
+ (0, import_kit4.assertAccountExists)(maybeAccount);
428
551
  return maybeAccount;
429
552
  }
430
553
  async function fetchMaybeBitmapAccount(rpc, address, config) {
431
- const maybeAccount = await fetchEncodedAccount4(rpc, address, config);
554
+ const maybeAccount = await (0, import_kit4.fetchEncodedAccount)(rpc, address, config);
432
555
  return decodeBitmapAccount(maybeAccount);
433
556
  }
434
557
  async function fetchAllBitmapAccount(rpc, addresses, config) {
@@ -437,57 +560,28 @@ async function fetchAllBitmapAccount(rpc, addresses, config) {
437
560
  addresses,
438
561
  config
439
562
  );
440
- assertAccountsExist4(maybeAccounts);
563
+ (0, import_kit4.assertAccountsExist)(maybeAccounts);
441
564
  return maybeAccounts;
442
565
  }
443
566
  async function fetchAllMaybeBitmapAccount(rpc, addresses, config) {
444
- const maybeAccounts = await fetchEncodedAccounts4(rpc, addresses, config);
567
+ const maybeAccounts = await (0, import_kit4.fetchEncodedAccounts)(rpc, addresses, config);
445
568
  return maybeAccounts.map((maybeAccount) => decodeBitmapAccount(maybeAccount));
446
569
  }
447
570
  function getBitmapAccountSize() {
448
- return 8080;
571
+ return 1080;
449
572
  }
450
573
 
451
574
  // src/errors/dropsyAirdrop.ts
452
- import {
453
- isProgramError
454
- } from "@solana/kit";
575
+ var import_kit13 = require("@solana/kit");
455
576
 
456
577
  // src/programs/dropsyAirdrop.ts
457
- import {
458
- assertIsInstructionWithAccounts,
459
- containsBytes,
460
- fixEncoderSize as fixEncoderSize11,
461
- getBytesEncoder as getBytesEncoder11
462
- } from "@solana/kit";
578
+ var import_kit12 = require("@solana/kit");
463
579
 
464
580
  // src/instructions/claimAirdrop.ts
465
- import {
466
- combineCodec as combineCodec5,
467
- fixDecoderSize as fixDecoderSize5,
468
- fixEncoderSize as fixEncoderSize5,
469
- getAddressEncoder as getAddressEncoder5,
470
- getArrayDecoder,
471
- getArrayEncoder,
472
- getBytesDecoder as getBytesDecoder5,
473
- getBytesEncoder as getBytesEncoder5,
474
- getProgramDerivedAddress,
475
- getStructDecoder as getStructDecoder5,
476
- getStructEncoder as getStructEncoder5,
477
- getU16Decoder as getU16Decoder4,
478
- getU16Encoder as getU16Encoder4,
479
- getU64Decoder as getU64Decoder4,
480
- getU64Encoder as getU64Encoder4,
481
- transformEncoder as transformEncoder5
482
- } from "@solana/kit";
581
+ var import_kit6 = require("@solana/kit");
483
582
 
484
583
  // src/shared/index.ts
485
- import {
486
- AccountRole,
487
- isProgramDerivedAddress,
488
- isTransactionSigner as kitIsTransactionSigner,
489
- upgradeRoleToSigner
490
- } from "@solana/kit";
584
+ var import_kit5 = require("@solana/kit");
491
585
  function expectSome(value) {
492
586
  if (value === null || value === void 0) {
493
587
  throw new Error("Expected a value but received null or undefined.");
@@ -512,19 +606,19 @@ function getAccountMetaFactory(programAddress, optionalAccountStrategy) {
512
606
  if (optionalAccountStrategy === "omitted") return;
513
607
  return Object.freeze({
514
608
  address: programAddress,
515
- role: AccountRole.READONLY
609
+ role: import_kit5.AccountRole.READONLY
516
610
  });
517
611
  }
518
- const writableRole = account.isWritable ? AccountRole.WRITABLE : AccountRole.READONLY;
612
+ const writableRole = account.isWritable ? import_kit5.AccountRole.WRITABLE : import_kit5.AccountRole.READONLY;
519
613
  return Object.freeze({
520
614
  address: expectAddress(account.value),
521
- role: isTransactionSigner(account.value) ? upgradeRoleToSigner(writableRole) : writableRole,
615
+ role: isTransactionSigner(account.value) ? (0, import_kit5.upgradeRoleToSigner)(writableRole) : writableRole,
522
616
  ...isTransactionSigner(account.value) ? { signer: account.value } : {}
523
617
  });
524
618
  };
525
619
  }
526
620
  function isTransactionSigner(value) {
527
- return !!value && typeof value === "object" && "address" in value && kitIsTransactionSigner(value);
621
+ return !!value && typeof value === "object" && "address" in value && (0, import_kit5.isTransactionSigner)(value);
528
622
  }
529
623
 
530
624
  // src/instructions/claimAirdrop.ts
@@ -539,33 +633,33 @@ var CLAIM_AIRDROP_DISCRIMINATOR = new Uint8Array([
539
633
  20
540
634
  ]);
541
635
  function getClaimAirdropDiscriminatorBytes() {
542
- return fixEncoderSize5(getBytesEncoder5(), 8).encode(
636
+ return (0, import_kit6.fixEncoderSize)((0, import_kit6.getBytesEncoder)(), 8).encode(
543
637
  CLAIM_AIRDROP_DISCRIMINATOR
544
638
  );
545
639
  }
546
640
  function getClaimAirdropInstructionDataEncoder() {
547
- return transformEncoder5(
548
- getStructEncoder5([
549
- ["discriminator", fixEncoderSize5(getBytesEncoder5(), 8)],
550
- ["index", getU64Encoder4()],
551
- ["proof", getArrayEncoder(fixEncoderSize5(getBytesEncoder5(), 32))],
552
- ["amount", getU64Encoder4()],
553
- ["claimMapIndex", getU16Encoder4()]
641
+ return (0, import_kit6.transformEncoder)(
642
+ (0, import_kit6.getStructEncoder)([
643
+ ["discriminator", (0, import_kit6.fixEncoderSize)((0, import_kit6.getBytesEncoder)(), 8)],
644
+ ["index", (0, import_kit6.getU64Encoder)()],
645
+ ["proof", (0, import_kit6.getArrayEncoder)((0, import_kit6.fixEncoderSize)((0, import_kit6.getBytesEncoder)(), 32))],
646
+ ["amount", (0, import_kit6.getU64Encoder)()],
647
+ ["claimMapIndex", (0, import_kit6.getU16Encoder)()]
554
648
  ]),
555
649
  (value) => ({ ...value, discriminator: CLAIM_AIRDROP_DISCRIMINATOR })
556
650
  );
557
651
  }
558
652
  function getClaimAirdropInstructionDataDecoder() {
559
- return getStructDecoder5([
560
- ["discriminator", fixDecoderSize5(getBytesDecoder5(), 8)],
561
- ["index", getU64Decoder4()],
562
- ["proof", getArrayDecoder(fixDecoderSize5(getBytesDecoder5(), 32))],
563
- ["amount", getU64Decoder4()],
564
- ["claimMapIndex", getU16Decoder4()]
653
+ return (0, import_kit6.getStructDecoder)([
654
+ ["discriminator", (0, import_kit6.fixDecoderSize)((0, import_kit6.getBytesDecoder)(), 8)],
655
+ ["index", (0, import_kit6.getU64Decoder)()],
656
+ ["proof", (0, import_kit6.getArrayDecoder)((0, import_kit6.fixDecoderSize)((0, import_kit6.getBytesDecoder)(), 32))],
657
+ ["amount", (0, import_kit6.getU64Decoder)()],
658
+ ["claimMapIndex", (0, import_kit6.getU16Decoder)()]
565
659
  ]);
566
660
  }
567
661
  function getClaimAirdropInstructionDataCodec() {
568
- return combineCodec5(
662
+ return (0, import_kit6.combineCodec)(
569
663
  getClaimAirdropInstructionDataEncoder(),
570
664
  getClaimAirdropInstructionDataDecoder()
571
665
  );
@@ -607,12 +701,12 @@ async function getClaimAirdropInstructionAsync(input, config) {
607
701
  accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
608
702
  }
609
703
  if (!accounts.destinationTokenAccount.value) {
610
- accounts.destinationTokenAccount.value = await getProgramDerivedAddress({
704
+ accounts.destinationTokenAccount.value = await (0, import_kit6.getProgramDerivedAddress)({
611
705
  programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
612
706
  seeds: [
613
- getAddressEncoder5().encode(expectAddress(accounts.claimer.value)),
614
- getAddressEncoder5().encode(expectAddress(accounts.tokenProgram.value)),
615
- getAddressEncoder5().encode(expectAddress(accounts.mint.value))
707
+ (0, import_kit6.getAddressEncoder)().encode(expectAddress(accounts.claimer.value)),
708
+ (0, import_kit6.getAddressEncoder)().encode(expectAddress(accounts.tokenProgram.value)),
709
+ (0, import_kit6.getAddressEncoder)().encode(expectAddress(accounts.mint.value))
616
710
  ]
617
711
  });
618
712
  }
@@ -623,10 +717,10 @@ async function getClaimAirdropInstructionAsync(input, config) {
623
717
  accounts.systemProgram.value = "11111111111111111111111111111111";
624
718
  }
625
719
  if (!accounts.airdropConfig.value) {
626
- accounts.airdropConfig.value = await getProgramDerivedAddress({
720
+ accounts.airdropConfig.value = await (0, import_kit6.getProgramDerivedAddress)({
627
721
  programAddress,
628
722
  seeds: [
629
- getBytesEncoder5().encode(
723
+ (0, import_kit6.getBytesEncoder)().encode(
630
724
  new Uint8Array([
631
725
  97,
632
726
  105,
@@ -648,10 +742,10 @@ async function getClaimAirdropInstructionAsync(input, config) {
648
742
  });
649
743
  }
650
744
  if (!accounts.airdropMaster.value) {
651
- accounts.airdropMaster.value = await getProgramDerivedAddress({
745
+ accounts.airdropMaster.value = await (0, import_kit6.getProgramDerivedAddress)({
652
746
  programAddress,
653
747
  seeds: [
654
- getBytesEncoder5().encode(
748
+ (0, import_kit6.getBytesEncoder)().encode(
655
749
  new Uint8Array([
656
750
  97,
657
751
  105,
@@ -669,7 +763,7 @@ async function getClaimAirdropInstructionAsync(input, config) {
669
763
  114
670
764
  ])
671
765
  ),
672
- getAddressEncoder5().encode(expectAddress(accounts.masterCreator.value))
766
+ (0, import_kit6.getAddressEncoder)().encode(expectAddress(accounts.masterCreator.value))
673
767
  ]
674
768
  });
675
769
  }
@@ -799,25 +893,7 @@ function parseClaimAirdropInstruction(instruction) {
799
893
  }
800
894
 
801
895
  // src/instructions/createAirdrop.ts
802
- import {
803
- combineCodec as combineCodec6,
804
- fixDecoderSize as fixDecoderSize6,
805
- fixEncoderSize as fixEncoderSize6,
806
- getAddressDecoder as getAddressDecoder5,
807
- getAddressEncoder as getAddressEncoder6,
808
- getBytesDecoder as getBytesDecoder6,
809
- getBytesEncoder as getBytesEncoder6,
810
- getI64Decoder as getI64Decoder3,
811
- getI64Encoder as getI64Encoder3,
812
- getOptionDecoder,
813
- getOptionEncoder,
814
- getProgramDerivedAddress as getProgramDerivedAddress2,
815
- getStructDecoder as getStructDecoder6,
816
- getStructEncoder as getStructEncoder6,
817
- getU8Decoder as getU8Decoder5,
818
- getU8Encoder as getU8Encoder5,
819
- transformEncoder as transformEncoder6
820
- } from "@solana/kit";
896
+ var import_kit7 = require("@solana/kit");
821
897
  var CREATE_AIRDROP_DISCRIMINATOR = new Uint8Array([
822
898
  227,
823
899
  135,
@@ -829,39 +905,37 @@ var CREATE_AIRDROP_DISCRIMINATOR = new Uint8Array([
829
905
  94
830
906
  ]);
831
907
  function getCreateAirdropDiscriminatorBytes() {
832
- return fixEncoderSize6(getBytesEncoder6(), 8).encode(
908
+ return (0, import_kit7.fixEncoderSize)((0, import_kit7.getBytesEncoder)(), 8).encode(
833
909
  CREATE_AIRDROP_DISCRIMINATOR
834
910
  );
835
911
  }
836
912
  function getCreateAirdropInstructionDataEncoder() {
837
- return transformEncoder6(
838
- getStructEncoder6([
839
- ["discriminator", fixEncoderSize6(getBytesEncoder6(), 8)],
840
- ["merkleRoot", getOptionEncoder(fixEncoderSize6(getBytesEncoder6(), 32))],
841
- ["startsAt", getOptionEncoder(getI64Encoder3())],
842
- ["endsAt", getOptionEncoder(getI64Encoder3())],
843
- ["version", getOptionEncoder(getU8Encoder5())],
844
- ["mutable", getOptionEncoder(getU8Encoder5())],
845
- ["delegateAuthority", getOptionEncoder(getAddressEncoder6())],
846
- ["delegatePermissions", getOptionEncoder(getU8Encoder5())]
913
+ return (0, import_kit7.transformEncoder)(
914
+ (0, import_kit7.getStructEncoder)([
915
+ ["discriminator", (0, import_kit7.fixEncoderSize)((0, import_kit7.getBytesEncoder)(), 8)],
916
+ ["id", (0, import_kit7.getU64Encoder)()],
917
+ ["merkleRoot", (0, import_kit7.getOptionEncoder)((0, import_kit7.fixEncoderSize)((0, import_kit7.getBytesEncoder)(), 32))],
918
+ ["startsAt", (0, import_kit7.getOptionEncoder)((0, import_kit7.getI64Encoder)())],
919
+ ["endsAt", (0, import_kit7.getOptionEncoder)((0, import_kit7.getI64Encoder)())],
920
+ ["version", (0, import_kit7.getOptionEncoder)((0, import_kit7.getU8Encoder)())],
921
+ ["delegateAuthority", (0, import_kit7.getOptionEncoder)((0, import_kit7.getAddressEncoder)())]
847
922
  ]),
848
923
  (value) => ({ ...value, discriminator: CREATE_AIRDROP_DISCRIMINATOR })
849
924
  );
850
925
  }
851
926
  function getCreateAirdropInstructionDataDecoder() {
852
- return getStructDecoder6([
853
- ["discriminator", fixDecoderSize6(getBytesDecoder6(), 8)],
854
- ["merkleRoot", getOptionDecoder(fixDecoderSize6(getBytesDecoder6(), 32))],
855
- ["startsAt", getOptionDecoder(getI64Decoder3())],
856
- ["endsAt", getOptionDecoder(getI64Decoder3())],
857
- ["version", getOptionDecoder(getU8Decoder5())],
858
- ["mutable", getOptionDecoder(getU8Decoder5())],
859
- ["delegateAuthority", getOptionDecoder(getAddressDecoder5())],
860
- ["delegatePermissions", getOptionDecoder(getU8Decoder5())]
927
+ return (0, import_kit7.getStructDecoder)([
928
+ ["discriminator", (0, import_kit7.fixDecoderSize)((0, import_kit7.getBytesDecoder)(), 8)],
929
+ ["id", (0, import_kit7.getU64Decoder)()],
930
+ ["merkleRoot", (0, import_kit7.getOptionDecoder)((0, import_kit7.fixDecoderSize)((0, import_kit7.getBytesDecoder)(), 32))],
931
+ ["startsAt", (0, import_kit7.getOptionDecoder)((0, import_kit7.getI64Decoder)())],
932
+ ["endsAt", (0, import_kit7.getOptionDecoder)((0, import_kit7.getI64Decoder)())],
933
+ ["version", (0, import_kit7.getOptionDecoder)((0, import_kit7.getU8Decoder)())],
934
+ ["delegateAuthority", (0, import_kit7.getOptionDecoder)((0, import_kit7.getAddressDecoder)())]
861
935
  ]);
862
936
  }
863
937
  function getCreateAirdropInstructionDataCodec() {
864
- return combineCodec6(
938
+ return (0, import_kit7.combineCodec)(
865
939
  getCreateAirdropInstructionDataEncoder(),
866
940
  getCreateAirdropInstructionDataDecoder()
867
941
  );
@@ -885,10 +959,10 @@ async function getCreateAirdropInstructionAsync(input, config) {
885
959
  const accounts = originalAccounts;
886
960
  const args = { ...input };
887
961
  if (!accounts.airdropConfig.value) {
888
- accounts.airdropConfig.value = await getProgramDerivedAddress2({
962
+ accounts.airdropConfig.value = await (0, import_kit7.getProgramDerivedAddress)({
889
963
  programAddress,
890
964
  seeds: [
891
- getBytesEncoder6().encode(
965
+ (0, import_kit7.getBytesEncoder)().encode(
892
966
  new Uint8Array([
893
967
  97,
894
968
  105,
@@ -910,10 +984,10 @@ async function getCreateAirdropInstructionAsync(input, config) {
910
984
  });
911
985
  }
912
986
  if (!accounts.airdropMaster.value) {
913
- accounts.airdropMaster.value = await getProgramDerivedAddress2({
987
+ accounts.airdropMaster.value = await (0, import_kit7.getProgramDerivedAddress)({
914
988
  programAddress,
915
989
  seeds: [
916
- getBytesEncoder6().encode(
990
+ (0, import_kit7.getBytesEncoder)().encode(
917
991
  new Uint8Array([
918
992
  97,
919
993
  105,
@@ -931,19 +1005,7 @@ async function getCreateAirdropInstructionAsync(input, config) {
931
1005
  114
932
1006
  ])
933
1007
  ),
934
- getAddressEncoder6().encode(expectAddress(accounts.masterCreator.value))
935
- ]
936
- });
937
- }
938
- if (!accounts.airdrop.value) {
939
- accounts.airdrop.value = await getProgramDerivedAddress2({
940
- programAddress,
941
- seeds: [
942
- getBytesEncoder6().encode(
943
- new Uint8Array([97, 105, 114, 100, 114, 111, 112])
944
- ),
945
- getAddressEncoder6().encode(expectAddress(accounts.authority.value)),
946
- getAddressEncoder6().encode(expectAddress(accounts.mint.value))
1008
+ (0, import_kit7.getAddressEncoder)().encode(expectAddress(accounts.masterCreator.value))
947
1009
  ]
948
1010
  });
949
1011
  }
@@ -1037,22 +1099,7 @@ function parseCreateAirdropInstruction(instruction) {
1037
1099
  }
1038
1100
 
1039
1101
  // src/instructions/createBitmap.ts
1040
- import {
1041
- combineCodec as combineCodec7,
1042
- fixDecoderSize as fixDecoderSize7,
1043
- fixEncoderSize as fixEncoderSize7,
1044
- getAddressEncoder as getAddressEncoder7,
1045
- getBytesDecoder as getBytesDecoder7,
1046
- getBytesEncoder as getBytesEncoder7,
1047
- getProgramDerivedAddress as getProgramDerivedAddress3,
1048
- getStructDecoder as getStructDecoder7,
1049
- getStructEncoder as getStructEncoder7,
1050
- getU16Decoder as getU16Decoder5,
1051
- getU16Encoder as getU16Encoder5,
1052
- getU32Decoder as getU32Decoder2,
1053
- getU32Encoder as getU32Encoder2,
1054
- transformEncoder as transformEncoder7
1055
- } from "@solana/kit";
1102
+ var import_kit8 = require("@solana/kit");
1056
1103
  var CREATE_BITMAP_DISCRIMINATOR = new Uint8Array([
1057
1104
  69,
1058
1105
  92,
@@ -1064,29 +1111,29 @@ var CREATE_BITMAP_DISCRIMINATOR = new Uint8Array([
1064
1111
  247
1065
1112
  ]);
1066
1113
  function getCreateBitmapDiscriminatorBytes() {
1067
- return fixEncoderSize7(getBytesEncoder7(), 8).encode(
1114
+ return (0, import_kit8.fixEncoderSize)((0, import_kit8.getBytesEncoder)(), 8).encode(
1068
1115
  CREATE_BITMAP_DISCRIMINATOR
1069
1116
  );
1070
1117
  }
1071
1118
  function getCreateBitmapInstructionDataEncoder() {
1072
- return transformEncoder7(
1073
- getStructEncoder7([
1074
- ["discriminator", fixEncoderSize7(getBytesEncoder7(), 8)],
1075
- ["id", getU16Encoder5()],
1076
- ["total", getU32Encoder2()]
1119
+ return (0, import_kit8.transformEncoder)(
1120
+ (0, import_kit8.getStructEncoder)([
1121
+ ["discriminator", (0, import_kit8.fixEncoderSize)((0, import_kit8.getBytesEncoder)(), 8)],
1122
+ ["id", (0, import_kit8.getU16Encoder)()],
1123
+ ["total", (0, import_kit8.getU32Encoder)()]
1077
1124
  ]),
1078
1125
  (value) => ({ ...value, discriminator: CREATE_BITMAP_DISCRIMINATOR })
1079
1126
  );
1080
1127
  }
1081
1128
  function getCreateBitmapInstructionDataDecoder() {
1082
- return getStructDecoder7([
1083
- ["discriminator", fixDecoderSize7(getBytesDecoder7(), 8)],
1084
- ["id", getU16Decoder5()],
1085
- ["total", getU32Decoder2()]
1129
+ return (0, import_kit8.getStructDecoder)([
1130
+ ["discriminator", (0, import_kit8.fixDecoderSize)((0, import_kit8.getBytesDecoder)(), 8)],
1131
+ ["id", (0, import_kit8.getU16Decoder)()],
1132
+ ["total", (0, import_kit8.getU32Decoder)()]
1086
1133
  ]);
1087
1134
  }
1088
1135
  function getCreateBitmapInstructionDataCodec() {
1089
- return combineCodec7(
1136
+ return (0, import_kit8.combineCodec)(
1090
1137
  getCreateBitmapInstructionDataEncoder(),
1091
1138
  getCreateBitmapInstructionDataDecoder()
1092
1139
  );
@@ -1111,10 +1158,10 @@ async function getCreateBitmapInstructionAsync(input, config) {
1111
1158
  const accounts = originalAccounts;
1112
1159
  const args = { ...input };
1113
1160
  if (!accounts.airdropConfig.value) {
1114
- accounts.airdropConfig.value = await getProgramDerivedAddress3({
1161
+ accounts.airdropConfig.value = await (0, import_kit8.getProgramDerivedAddress)({
1115
1162
  programAddress,
1116
1163
  seeds: [
1117
- getBytesEncoder7().encode(
1164
+ (0, import_kit8.getBytesEncoder)().encode(
1118
1165
  new Uint8Array([
1119
1166
  97,
1120
1167
  105,
@@ -1136,10 +1183,10 @@ async function getCreateBitmapInstructionAsync(input, config) {
1136
1183
  });
1137
1184
  }
1138
1185
  if (!accounts.airdropMaster.value) {
1139
- accounts.airdropMaster.value = await getProgramDerivedAddress3({
1186
+ accounts.airdropMaster.value = await (0, import_kit8.getProgramDerivedAddress)({
1140
1187
  programAddress,
1141
1188
  seeds: [
1142
- getBytesEncoder7().encode(
1189
+ (0, import_kit8.getBytesEncoder)().encode(
1143
1190
  new Uint8Array([
1144
1191
  97,
1145
1192
  105,
@@ -1157,29 +1204,29 @@ async function getCreateBitmapInstructionAsync(input, config) {
1157
1204
  114
1158
1205
  ])
1159
1206
  ),
1160
- getAddressEncoder7().encode(expectAddress(accounts.masterCreator.value))
1207
+ (0, import_kit8.getAddressEncoder)().encode(expectAddress(accounts.masterCreator.value))
1161
1208
  ]
1162
1209
  });
1163
1210
  }
1164
1211
  if (!accounts.airdrop.value) {
1165
- accounts.airdrop.value = await getProgramDerivedAddress3({
1212
+ accounts.airdrop.value = await (0, import_kit8.getProgramDerivedAddress)({
1166
1213
  programAddress,
1167
1214
  seeds: [
1168
- getBytesEncoder7().encode(
1215
+ (0, import_kit8.getBytesEncoder)().encode(
1169
1216
  new Uint8Array([97, 105, 114, 100, 114, 111, 112])
1170
1217
  ),
1171
- getAddressEncoder7().encode(expectAddress(accounts.authority.value)),
1172
- getAddressEncoder7().encode(expectAddress(accounts.mint.value))
1218
+ (0, import_kit8.getAddressEncoder)().encode(expectAddress(accounts.authority.value)),
1219
+ (0, import_kit8.getAddressEncoder)().encode(expectAddress(accounts.mint.value))
1173
1220
  ]
1174
1221
  });
1175
1222
  }
1176
1223
  if (!accounts.bitmap.value) {
1177
- accounts.bitmap.value = await getProgramDerivedAddress3({
1224
+ accounts.bitmap.value = await (0, import_kit8.getProgramDerivedAddress)({
1178
1225
  programAddress,
1179
1226
  seeds: [
1180
- getBytesEncoder7().encode(new Uint8Array([98, 105, 116, 109, 97, 112])),
1181
- getAddressEncoder7().encode(expectAddress(accounts.airdrop.value)),
1182
- getU16Encoder5().encode(expectSome(args.id))
1227
+ (0, import_kit8.getBytesEncoder)().encode(new Uint8Array([98, 105, 116, 109, 97, 112])),
1228
+ (0, import_kit8.getAddressEncoder)().encode(expectAddress(accounts.airdrop.value)),
1229
+ (0, import_kit8.getU16Encoder)().encode(expectSome(args.id))
1183
1230
  ]
1184
1231
  });
1185
1232
  }
@@ -1277,20 +1324,7 @@ function parseCreateBitmapInstruction(instruction) {
1277
1324
  }
1278
1325
 
1279
1326
  // src/instructions/depositTokens.ts
1280
- import {
1281
- combineCodec as combineCodec8,
1282
- fixDecoderSize as fixDecoderSize8,
1283
- fixEncoderSize as fixEncoderSize8,
1284
- getAddressEncoder as getAddressEncoder8,
1285
- getBytesDecoder as getBytesDecoder8,
1286
- getBytesEncoder as getBytesEncoder8,
1287
- getProgramDerivedAddress as getProgramDerivedAddress4,
1288
- getStructDecoder as getStructDecoder8,
1289
- getStructEncoder as getStructEncoder8,
1290
- getU64Decoder as getU64Decoder5,
1291
- getU64Encoder as getU64Encoder5,
1292
- transformEncoder as transformEncoder8
1293
- } from "@solana/kit";
1327
+ var import_kit9 = require("@solana/kit");
1294
1328
  var DEPOSIT_TOKENS_DISCRIMINATOR = new Uint8Array([
1295
1329
  176,
1296
1330
  83,
@@ -1302,27 +1336,27 @@ var DEPOSIT_TOKENS_DISCRIMINATOR = new Uint8Array([
1302
1336
  150
1303
1337
  ]);
1304
1338
  function getDepositTokensDiscriminatorBytes() {
1305
- return fixEncoderSize8(getBytesEncoder8(), 8).encode(
1339
+ return (0, import_kit9.fixEncoderSize)((0, import_kit9.getBytesEncoder)(), 8).encode(
1306
1340
  DEPOSIT_TOKENS_DISCRIMINATOR
1307
1341
  );
1308
1342
  }
1309
1343
  function getDepositTokensInstructionDataEncoder() {
1310
- return transformEncoder8(
1311
- getStructEncoder8([
1312
- ["discriminator", fixEncoderSize8(getBytesEncoder8(), 8)],
1313
- ["amount", getU64Encoder5()]
1344
+ return (0, import_kit9.transformEncoder)(
1345
+ (0, import_kit9.getStructEncoder)([
1346
+ ["discriminator", (0, import_kit9.fixEncoderSize)((0, import_kit9.getBytesEncoder)(), 8)],
1347
+ ["amount", (0, import_kit9.getU64Encoder)()]
1314
1348
  ]),
1315
1349
  (value) => ({ ...value, discriminator: DEPOSIT_TOKENS_DISCRIMINATOR })
1316
1350
  );
1317
1351
  }
1318
1352
  function getDepositTokensInstructionDataDecoder() {
1319
- return getStructDecoder8([
1320
- ["discriminator", fixDecoderSize8(getBytesDecoder8(), 8)],
1321
- ["amount", getU64Decoder5()]
1353
+ return (0, import_kit9.getStructDecoder)([
1354
+ ["discriminator", (0, import_kit9.fixDecoderSize)((0, import_kit9.getBytesDecoder)(), 8)],
1355
+ ["amount", (0, import_kit9.getU64Decoder)()]
1322
1356
  ]);
1323
1357
  }
1324
1358
  function getDepositTokensInstructionDataCodec() {
1325
- return combineCodec8(
1359
+ return (0, import_kit9.combineCodec)(
1326
1360
  getDepositTokensInstructionDataEncoder(),
1327
1361
  getDepositTokensInstructionDataDecoder()
1328
1362
  );
@@ -1348,14 +1382,14 @@ async function getDepositTokensInstructionAsync(input, config) {
1348
1382
  const accounts = originalAccounts;
1349
1383
  const args = { ...input };
1350
1384
  if (!accounts.airdrop.value) {
1351
- accounts.airdrop.value = await getProgramDerivedAddress4({
1385
+ accounts.airdrop.value = await (0, import_kit9.getProgramDerivedAddress)({
1352
1386
  programAddress,
1353
1387
  seeds: [
1354
- getBytesEncoder8().encode(
1388
+ (0, import_kit9.getBytesEncoder)().encode(
1355
1389
  new Uint8Array([97, 105, 114, 100, 114, 111, 112])
1356
1390
  ),
1357
- getAddressEncoder8().encode(expectAddress(accounts.authority.value)),
1358
- getAddressEncoder8().encode(expectAddress(accounts.mint.value))
1391
+ (0, import_kit9.getAddressEncoder)().encode(expectAddress(accounts.authority.value)),
1392
+ (0, import_kit9.getAddressEncoder)().encode(expectAddress(accounts.mint.value))
1359
1393
  ]
1360
1394
  });
1361
1395
  }
@@ -1363,12 +1397,12 @@ async function getDepositTokensInstructionAsync(input, config) {
1363
1397
  accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
1364
1398
  }
1365
1399
  if (!accounts.vault.value) {
1366
- accounts.vault.value = await getProgramDerivedAddress4({
1400
+ accounts.vault.value = await (0, import_kit9.getProgramDerivedAddress)({
1367
1401
  programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
1368
1402
  seeds: [
1369
- getAddressEncoder8().encode(expectAddress(accounts.airdrop.value)),
1370
- getAddressEncoder8().encode(expectAddress(accounts.tokenProgram.value)),
1371
- getAddressEncoder8().encode(expectAddress(accounts.mint.value))
1403
+ (0, import_kit9.getAddressEncoder)().encode(expectAddress(accounts.airdrop.value)),
1404
+ (0, import_kit9.getAddressEncoder)().encode(expectAddress(accounts.tokenProgram.value)),
1405
+ (0, import_kit9.getAddressEncoder)().encode(expectAddress(accounts.mint.value))
1372
1406
  ]
1373
1407
  });
1374
1408
  }
@@ -1470,25 +1504,7 @@ function parseDepositTokensInstruction(instruction) {
1470
1504
  }
1471
1505
 
1472
1506
  // src/instructions/initializeAirdropConfig.ts
1473
- import {
1474
- combineCodec as combineCodec9,
1475
- fixDecoderSize as fixDecoderSize9,
1476
- fixEncoderSize as fixEncoderSize9,
1477
- getBytesDecoder as getBytesDecoder9,
1478
- getBytesEncoder as getBytesEncoder9,
1479
- getI64Decoder as getI64Decoder4,
1480
- getI64Encoder as getI64Encoder4,
1481
- getOptionDecoder as getOptionDecoder2,
1482
- getOptionEncoder as getOptionEncoder2,
1483
- getProgramDerivedAddress as getProgramDerivedAddress5,
1484
- getStructDecoder as getStructDecoder9,
1485
- getStructEncoder as getStructEncoder9,
1486
- getU16Decoder as getU16Decoder6,
1487
- getU16Encoder as getU16Encoder6,
1488
- getU64Decoder as getU64Decoder6,
1489
- getU64Encoder as getU64Encoder6,
1490
- transformEncoder as transformEncoder9
1491
- } from "@solana/kit";
1507
+ var import_kit10 = require("@solana/kit");
1492
1508
  var INITIALIZE_AIRDROP_CONFIG_DISCRIMINATOR = new Uint8Array([
1493
1509
  160,
1494
1510
  68,
@@ -1500,24 +1516,24 @@ var INITIALIZE_AIRDROP_CONFIG_DISCRIMINATOR = new Uint8Array([
1500
1516
  94
1501
1517
  ]);
1502
1518
  function getInitializeAirdropConfigDiscriminatorBytes() {
1503
- return fixEncoderSize9(getBytesEncoder9(), 8).encode(
1519
+ return (0, import_kit10.fixEncoderSize)((0, import_kit10.getBytesEncoder)(), 8).encode(
1504
1520
  INITIALIZE_AIRDROP_CONFIG_DISCRIMINATOR
1505
1521
  );
1506
1522
  }
1507
1523
  function getInitializeAirdropConfigInstructionDataEncoder() {
1508
- return transformEncoder9(
1509
- getStructEncoder9([
1510
- ["discriminator", fixEncoderSize9(getBytesEncoder9(), 8)],
1511
- ["wlRoot", getOptionEncoder2(fixEncoderSize9(getBytesEncoder9(), 32))],
1512
- ["airdropMasterCreateFee", getOptionEncoder2(getU64Encoder6())],
1513
- ["maxClaimFee", getOptionEncoder2(getU64Encoder6())],
1514
- ["maxActionFee", getOptionEncoder2(getU64Encoder6())],
1515
- ["minAirdropDuration", getOptionEncoder2(getI64Encoder4())],
1516
- ["defaultAirdropDuration", getOptionEncoder2(getI64Encoder4())],
1517
- ["maxAirdropDuration", getOptionEncoder2(getI64Encoder4())],
1518
- ["updateGracePeriod", getOptionEncoder2(getI64Encoder4())],
1519
- ["protocolFee", getOptionEncoder2(getU64Encoder6())],
1520
- ["masterFeeBps", getOptionEncoder2(getU16Encoder6())]
1524
+ return (0, import_kit10.transformEncoder)(
1525
+ (0, import_kit10.getStructEncoder)([
1526
+ ["discriminator", (0, import_kit10.fixEncoderSize)((0, import_kit10.getBytesEncoder)(), 8)],
1527
+ ["wlRoot", (0, import_kit10.getOptionEncoder)((0, import_kit10.fixEncoderSize)((0, import_kit10.getBytesEncoder)(), 32))],
1528
+ ["airdropMasterCreateFee", (0, import_kit10.getOptionEncoder)((0, import_kit10.getU64Encoder)())],
1529
+ ["maxClaimFee", (0, import_kit10.getOptionEncoder)((0, import_kit10.getU64Encoder)())],
1530
+ ["maxActionFee", (0, import_kit10.getOptionEncoder)((0, import_kit10.getU64Encoder)())],
1531
+ ["minAirdropDuration", (0, import_kit10.getOptionEncoder)((0, import_kit10.getI64Encoder)())],
1532
+ ["defaultAirdropDuration", (0, import_kit10.getOptionEncoder)((0, import_kit10.getI64Encoder)())],
1533
+ ["maxAirdropDuration", (0, import_kit10.getOptionEncoder)((0, import_kit10.getI64Encoder)())],
1534
+ ["updateGracePeriod", (0, import_kit10.getOptionEncoder)((0, import_kit10.getI64Encoder)())],
1535
+ ["protocolFee", (0, import_kit10.getOptionEncoder)((0, import_kit10.getU64Encoder)())],
1536
+ ["masterFeeBps", (0, import_kit10.getOptionEncoder)((0, import_kit10.getU16Encoder)())]
1521
1537
  ]),
1522
1538
  (value) => ({
1523
1539
  ...value,
@@ -1526,22 +1542,22 @@ function getInitializeAirdropConfigInstructionDataEncoder() {
1526
1542
  );
1527
1543
  }
1528
1544
  function getInitializeAirdropConfigInstructionDataDecoder() {
1529
- return getStructDecoder9([
1530
- ["discriminator", fixDecoderSize9(getBytesDecoder9(), 8)],
1531
- ["wlRoot", getOptionDecoder2(fixDecoderSize9(getBytesDecoder9(), 32))],
1532
- ["airdropMasterCreateFee", getOptionDecoder2(getU64Decoder6())],
1533
- ["maxClaimFee", getOptionDecoder2(getU64Decoder6())],
1534
- ["maxActionFee", getOptionDecoder2(getU64Decoder6())],
1535
- ["minAirdropDuration", getOptionDecoder2(getI64Decoder4())],
1536
- ["defaultAirdropDuration", getOptionDecoder2(getI64Decoder4())],
1537
- ["maxAirdropDuration", getOptionDecoder2(getI64Decoder4())],
1538
- ["updateGracePeriod", getOptionDecoder2(getI64Decoder4())],
1539
- ["protocolFee", getOptionDecoder2(getU64Decoder6())],
1540
- ["masterFeeBps", getOptionDecoder2(getU16Decoder6())]
1545
+ return (0, import_kit10.getStructDecoder)([
1546
+ ["discriminator", (0, import_kit10.fixDecoderSize)((0, import_kit10.getBytesDecoder)(), 8)],
1547
+ ["wlRoot", (0, import_kit10.getOptionDecoder)((0, import_kit10.fixDecoderSize)((0, import_kit10.getBytesDecoder)(), 32))],
1548
+ ["airdropMasterCreateFee", (0, import_kit10.getOptionDecoder)((0, import_kit10.getU64Decoder)())],
1549
+ ["maxClaimFee", (0, import_kit10.getOptionDecoder)((0, import_kit10.getU64Decoder)())],
1550
+ ["maxActionFee", (0, import_kit10.getOptionDecoder)((0, import_kit10.getU64Decoder)())],
1551
+ ["minAirdropDuration", (0, import_kit10.getOptionDecoder)((0, import_kit10.getI64Decoder)())],
1552
+ ["defaultAirdropDuration", (0, import_kit10.getOptionDecoder)((0, import_kit10.getI64Decoder)())],
1553
+ ["maxAirdropDuration", (0, import_kit10.getOptionDecoder)((0, import_kit10.getI64Decoder)())],
1554
+ ["updateGracePeriod", (0, import_kit10.getOptionDecoder)((0, import_kit10.getI64Decoder)())],
1555
+ ["protocolFee", (0, import_kit10.getOptionDecoder)((0, import_kit10.getU64Decoder)())],
1556
+ ["masterFeeBps", (0, import_kit10.getOptionDecoder)((0, import_kit10.getU16Decoder)())]
1541
1557
  ]);
1542
1558
  }
1543
1559
  function getInitializeAirdropConfigInstructionDataCodec() {
1544
- return combineCodec9(
1560
+ return (0, import_kit10.combineCodec)(
1545
1561
  getInitializeAirdropConfigInstructionDataEncoder(),
1546
1562
  getInitializeAirdropConfigInstructionDataDecoder()
1547
1563
  );
@@ -1560,10 +1576,10 @@ async function getInitializeAirdropConfigInstructionAsync(input, config) {
1560
1576
  const accounts = originalAccounts;
1561
1577
  const args = { ...input };
1562
1578
  if (!accounts.config.value) {
1563
- accounts.config.value = await getProgramDerivedAddress5({
1579
+ accounts.config.value = await (0, import_kit10.getProgramDerivedAddress)({
1564
1580
  programAddress,
1565
1581
  seeds: [
1566
- getBytesEncoder9().encode(
1582
+ (0, import_kit10.getBytesEncoder)().encode(
1567
1583
  new Uint8Array([
1568
1584
  97,
1569
1585
  105,
@@ -1662,24 +1678,7 @@ function parseInitializeAirdropConfigInstruction(instruction) {
1662
1678
  }
1663
1679
 
1664
1680
  // src/instructions/initializeAirdropMaster.ts
1665
- import {
1666
- combineCodec as combineCodec10,
1667
- fixDecoderSize as fixDecoderSize10,
1668
- fixEncoderSize as fixEncoderSize10,
1669
- getAddressEncoder as getAddressEncoder9,
1670
- getArrayDecoder as getArrayDecoder2,
1671
- getArrayEncoder as getArrayEncoder2,
1672
- getBytesDecoder as getBytesDecoder10,
1673
- getBytesEncoder as getBytesEncoder10,
1674
- getOptionDecoder as getOptionDecoder3,
1675
- getOptionEncoder as getOptionEncoder3,
1676
- getProgramDerivedAddress as getProgramDerivedAddress6,
1677
- getStructDecoder as getStructDecoder10,
1678
- getStructEncoder as getStructEncoder10,
1679
- getU64Decoder as getU64Decoder7,
1680
- getU64Encoder as getU64Encoder7,
1681
- transformEncoder as transformEncoder10
1682
- } from "@solana/kit";
1681
+ var import_kit11 = require("@solana/kit");
1683
1682
  var INITIALIZE_AIRDROP_MASTER_DISCRIMINATOR = new Uint8Array([
1684
1683
  163,
1685
1684
  197,
@@ -1691,23 +1690,23 @@ var INITIALIZE_AIRDROP_MASTER_DISCRIMINATOR = new Uint8Array([
1691
1690
  65
1692
1691
  ]);
1693
1692
  function getInitializeAirdropMasterDiscriminatorBytes() {
1694
- return fixEncoderSize10(getBytesEncoder10(), 8).encode(
1693
+ return (0, import_kit11.fixEncoderSize)((0, import_kit11.getBytesEncoder)(), 8).encode(
1695
1694
  INITIALIZE_AIRDROP_MASTER_DISCRIMINATOR
1696
1695
  );
1697
1696
  }
1698
1697
  function getInitializeAirdropMasterInstructionDataEncoder() {
1699
- return transformEncoder10(
1700
- getStructEncoder10([
1701
- ["discriminator", fixEncoderSize10(getBytesEncoder10(), 8)],
1702
- ["airdropUpdateFee", getOptionEncoder3(getU64Encoder7())],
1703
- ["airdropCreationFee", getOptionEncoder3(getU64Encoder7())],
1704
- ["airdropClaimFee", getOptionEncoder3(getU64Encoder7())],
1705
- ["airdropDelegateFee", getOptionEncoder3(getU64Encoder7())],
1706
- ["bitmapCreationFee", getOptionEncoder3(getU64Encoder7())],
1698
+ return (0, import_kit11.transformEncoder)(
1699
+ (0, import_kit11.getStructEncoder)([
1700
+ ["discriminator", (0, import_kit11.fixEncoderSize)((0, import_kit11.getBytesEncoder)(), 8)],
1701
+ ["airdropUpdateFee", (0, import_kit11.getOptionEncoder)((0, import_kit11.getU64Encoder)())],
1702
+ ["airdropCreationFee", (0, import_kit11.getOptionEncoder)((0, import_kit11.getU64Encoder)())],
1703
+ ["airdropClaimFee", (0, import_kit11.getOptionEncoder)((0, import_kit11.getU64Encoder)())],
1704
+ ["airdropDelegateFee", (0, import_kit11.getOptionEncoder)((0, import_kit11.getU64Encoder)())],
1705
+ ["bitmapCreationFee", (0, import_kit11.getOptionEncoder)((0, import_kit11.getU64Encoder)())],
1707
1706
  [
1708
1707
  "discountProof",
1709
- getOptionEncoder3(
1710
- getArrayEncoder2(fixEncoderSize10(getBytesEncoder10(), 32))
1708
+ (0, import_kit11.getOptionEncoder)(
1709
+ (0, import_kit11.getArrayEncoder)((0, import_kit11.fixEncoderSize)((0, import_kit11.getBytesEncoder)(), 32))
1711
1710
  )
1712
1711
  ]
1713
1712
  ]),
@@ -1718,21 +1717,21 @@ function getInitializeAirdropMasterInstructionDataEncoder() {
1718
1717
  );
1719
1718
  }
1720
1719
  function getInitializeAirdropMasterInstructionDataDecoder() {
1721
- return getStructDecoder10([
1722
- ["discriminator", fixDecoderSize10(getBytesDecoder10(), 8)],
1723
- ["airdropUpdateFee", getOptionDecoder3(getU64Decoder7())],
1724
- ["airdropCreationFee", getOptionDecoder3(getU64Decoder7())],
1725
- ["airdropClaimFee", getOptionDecoder3(getU64Decoder7())],
1726
- ["airdropDelegateFee", getOptionDecoder3(getU64Decoder7())],
1727
- ["bitmapCreationFee", getOptionDecoder3(getU64Decoder7())],
1720
+ return (0, import_kit11.getStructDecoder)([
1721
+ ["discriminator", (0, import_kit11.fixDecoderSize)((0, import_kit11.getBytesDecoder)(), 8)],
1722
+ ["airdropUpdateFee", (0, import_kit11.getOptionDecoder)((0, import_kit11.getU64Decoder)())],
1723
+ ["airdropCreationFee", (0, import_kit11.getOptionDecoder)((0, import_kit11.getU64Decoder)())],
1724
+ ["airdropClaimFee", (0, import_kit11.getOptionDecoder)((0, import_kit11.getU64Decoder)())],
1725
+ ["airdropDelegateFee", (0, import_kit11.getOptionDecoder)((0, import_kit11.getU64Decoder)())],
1726
+ ["bitmapCreationFee", (0, import_kit11.getOptionDecoder)((0, import_kit11.getU64Decoder)())],
1728
1727
  [
1729
1728
  "discountProof",
1730
- getOptionDecoder3(getArrayDecoder2(fixDecoderSize10(getBytesDecoder10(), 32)))
1729
+ (0, import_kit11.getOptionDecoder)((0, import_kit11.getArrayDecoder)((0, import_kit11.fixDecoderSize)((0, import_kit11.getBytesDecoder)(), 32)))
1731
1730
  ]
1732
1731
  ]);
1733
1732
  }
1734
1733
  function getInitializeAirdropMasterInstructionDataCodec() {
1735
- return combineCodec10(
1734
+ return (0, import_kit11.combineCodec)(
1736
1735
  getInitializeAirdropMasterInstructionDataEncoder(),
1737
1736
  getInitializeAirdropMasterInstructionDataDecoder()
1738
1737
  );
@@ -1754,10 +1753,10 @@ async function getInitializeAirdropMasterInstructionAsync(input, config) {
1754
1753
  const accounts = originalAccounts;
1755
1754
  const args = { ...input };
1756
1755
  if (!accounts.config.value) {
1757
- accounts.config.value = await getProgramDerivedAddress6({
1756
+ accounts.config.value = await (0, import_kit11.getProgramDerivedAddress)({
1758
1757
  programAddress,
1759
1758
  seeds: [
1760
- getBytesEncoder10().encode(
1759
+ (0, import_kit11.getBytesEncoder)().encode(
1761
1760
  new Uint8Array([
1762
1761
  97,
1763
1762
  105,
@@ -1779,10 +1778,10 @@ async function getInitializeAirdropMasterInstructionAsync(input, config) {
1779
1778
  });
1780
1779
  }
1781
1780
  if (!accounts.airdropMaster.value) {
1782
- accounts.airdropMaster.value = await getProgramDerivedAddress6({
1781
+ accounts.airdropMaster.value = await (0, import_kit11.getProgramDerivedAddress)({
1783
1782
  programAddress,
1784
1783
  seeds: [
1785
- getBytesEncoder10().encode(
1784
+ (0, import_kit11.getBytesEncoder)().encode(
1786
1785
  new Uint8Array([
1787
1786
  97,
1788
1787
  105,
@@ -1800,7 +1799,7 @@ async function getInitializeAirdropMasterInstructionAsync(input, config) {
1800
1799
  114
1801
1800
  ])
1802
1801
  ),
1803
- getAddressEncoder9().encode(expectAddress(accounts.creator.value))
1802
+ (0, import_kit11.getAddressEncoder)().encode(expectAddress(accounts.creator.value))
1804
1803
  ]
1805
1804
  });
1806
1805
  }
@@ -1892,7 +1891,7 @@ function parseInitializeAirdropMasterInstruction(instruction) {
1892
1891
  }
1893
1892
 
1894
1893
  // src/programs/dropsyAirdrop.ts
1895
- var DROPSY_AIRDROP_PROGRAM_ADDRESS = "BWd3s27cPuinNkZYqZvRbdfvpGyP9ff5rJZk4WhuNwDw";
1894
+ var DROPSY_AIRDROP_PROGRAM_ADDRESS = "3b97gLF94DDpa7sJQ8orbE3Ab6JQWBsDQTdQ5azoZqcz";
1896
1895
  var DropsyAirdropAccount = /* @__PURE__ */ ((DropsyAirdropAccount2) => {
1897
1896
  DropsyAirdropAccount2[DropsyAirdropAccount2["Airdrop"] = 0] = "Airdrop";
1898
1897
  DropsyAirdropAccount2[DropsyAirdropAccount2["AirdropConfig"] = 1] = "AirdropConfig";
@@ -1902,36 +1901,36 @@ var DropsyAirdropAccount = /* @__PURE__ */ ((DropsyAirdropAccount2) => {
1902
1901
  })(DropsyAirdropAccount || {});
1903
1902
  function identifyDropsyAirdropAccount(account) {
1904
1903
  const data = "data" in account ? account.data : account;
1905
- if (containsBytes(
1904
+ if ((0, import_kit12.containsBytes)(
1906
1905
  data,
1907
- fixEncoderSize11(getBytesEncoder11(), 8).encode(
1906
+ (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
1908
1907
  new Uint8Array([31, 112, 159, 158, 124, 237, 9, 241])
1909
1908
  ),
1910
1909
  0
1911
1910
  )) {
1912
1911
  return 0 /* Airdrop */;
1913
1912
  }
1914
- if (containsBytes(
1913
+ if ((0, import_kit12.containsBytes)(
1915
1914
  data,
1916
- fixEncoderSize11(getBytesEncoder11(), 8).encode(
1915
+ (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
1917
1916
  new Uint8Array([194, 149, 223, 142, 42, 98, 128, 16])
1918
1917
  ),
1919
1918
  0
1920
1919
  )) {
1921
1920
  return 1 /* AirdropConfig */;
1922
1921
  }
1923
- if (containsBytes(
1922
+ if ((0, import_kit12.containsBytes)(
1924
1923
  data,
1925
- fixEncoderSize11(getBytesEncoder11(), 8).encode(
1924
+ (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
1926
1925
  new Uint8Array([31, 109, 100, 62, 106, 173, 5, 4])
1927
1926
  ),
1928
1927
  0
1929
1928
  )) {
1930
1929
  return 2 /* AirdropMaster */;
1931
1930
  }
1932
- if (containsBytes(
1931
+ if ((0, import_kit12.containsBytes)(
1933
1932
  data,
1934
- fixEncoderSize11(getBytesEncoder11(), 8).encode(
1933
+ (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
1935
1934
  new Uint8Array([152, 161, 147, 85, 213, 38, 59, 48])
1936
1935
  ),
1937
1936
  0
@@ -1953,54 +1952,54 @@ var DropsyAirdropInstruction = /* @__PURE__ */ ((DropsyAirdropInstruction2) => {
1953
1952
  })(DropsyAirdropInstruction || {});
1954
1953
  function identifyDropsyAirdropInstruction(instruction) {
1955
1954
  const data = "data" in instruction ? instruction.data : instruction;
1956
- if (containsBytes(
1955
+ if ((0, import_kit12.containsBytes)(
1957
1956
  data,
1958
- fixEncoderSize11(getBytesEncoder11(), 8).encode(
1957
+ (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
1959
1958
  new Uint8Array([137, 50, 122, 111, 89, 254, 8, 20])
1960
1959
  ),
1961
1960
  0
1962
1961
  )) {
1963
1962
  return 0 /* ClaimAirdrop */;
1964
1963
  }
1965
- if (containsBytes(
1964
+ if ((0, import_kit12.containsBytes)(
1966
1965
  data,
1967
- fixEncoderSize11(getBytesEncoder11(), 8).encode(
1966
+ (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
1968
1967
  new Uint8Array([227, 135, 208, 66, 137, 177, 80, 94])
1969
1968
  ),
1970
1969
  0
1971
1970
  )) {
1972
1971
  return 1 /* CreateAirdrop */;
1973
1972
  }
1974
- if (containsBytes(
1973
+ if ((0, import_kit12.containsBytes)(
1975
1974
  data,
1976
- fixEncoderSize11(getBytesEncoder11(), 8).encode(
1975
+ (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
1977
1976
  new Uint8Array([69, 92, 61, 190, 154, 237, 116, 247])
1978
1977
  ),
1979
1978
  0
1980
1979
  )) {
1981
1980
  return 2 /* CreateBitmap */;
1982
1981
  }
1983
- if (containsBytes(
1982
+ if ((0, import_kit12.containsBytes)(
1984
1983
  data,
1985
- fixEncoderSize11(getBytesEncoder11(), 8).encode(
1984
+ (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
1986
1985
  new Uint8Array([176, 83, 229, 18, 191, 143, 176, 150])
1987
1986
  ),
1988
1987
  0
1989
1988
  )) {
1990
1989
  return 3 /* DepositTokens */;
1991
1990
  }
1992
- if (containsBytes(
1991
+ if ((0, import_kit12.containsBytes)(
1993
1992
  data,
1994
- fixEncoderSize11(getBytesEncoder11(), 8).encode(
1993
+ (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
1995
1994
  new Uint8Array([160, 68, 127, 205, 130, 205, 156, 94])
1996
1995
  ),
1997
1996
  0
1998
1997
  )) {
1999
1998
  return 4 /* InitializeAirdropConfig */;
2000
1999
  }
2001
- if (containsBytes(
2000
+ if ((0, import_kit12.containsBytes)(
2002
2001
  data,
2003
- fixEncoderSize11(getBytesEncoder11(), 8).encode(
2002
+ (0, import_kit12.fixEncoderSize)((0, import_kit12.getBytesEncoder)(), 8).encode(
2004
2003
  new Uint8Array([163, 197, 170, 44, 57, 57, 90, 65])
2005
2004
  ),
2006
2005
  0
@@ -2015,42 +2014,42 @@ function parseDropsyAirdropInstruction(instruction) {
2015
2014
  const instructionType = identifyDropsyAirdropInstruction(instruction);
2016
2015
  switch (instructionType) {
2017
2016
  case 0 /* ClaimAirdrop */: {
2018
- assertIsInstructionWithAccounts(instruction);
2017
+ (0, import_kit12.assertIsInstructionWithAccounts)(instruction);
2019
2018
  return {
2020
2019
  instructionType: 0 /* ClaimAirdrop */,
2021
2020
  ...parseClaimAirdropInstruction(instruction)
2022
2021
  };
2023
2022
  }
2024
2023
  case 1 /* CreateAirdrop */: {
2025
- assertIsInstructionWithAccounts(instruction);
2024
+ (0, import_kit12.assertIsInstructionWithAccounts)(instruction);
2026
2025
  return {
2027
2026
  instructionType: 1 /* CreateAirdrop */,
2028
2027
  ...parseCreateAirdropInstruction(instruction)
2029
2028
  };
2030
2029
  }
2031
2030
  case 2 /* CreateBitmap */: {
2032
- assertIsInstructionWithAccounts(instruction);
2031
+ (0, import_kit12.assertIsInstructionWithAccounts)(instruction);
2033
2032
  return {
2034
2033
  instructionType: 2 /* CreateBitmap */,
2035
2034
  ...parseCreateBitmapInstruction(instruction)
2036
2035
  };
2037
2036
  }
2038
2037
  case 3 /* DepositTokens */: {
2039
- assertIsInstructionWithAccounts(instruction);
2038
+ (0, import_kit12.assertIsInstructionWithAccounts)(instruction);
2040
2039
  return {
2041
2040
  instructionType: 3 /* DepositTokens */,
2042
2041
  ...parseDepositTokensInstruction(instruction)
2043
2042
  };
2044
2043
  }
2045
2044
  case 4 /* InitializeAirdropConfig */: {
2046
- assertIsInstructionWithAccounts(instruction);
2045
+ (0, import_kit12.assertIsInstructionWithAccounts)(instruction);
2047
2046
  return {
2048
2047
  instructionType: 4 /* InitializeAirdropConfig */,
2049
2048
  ...parseInitializeAirdropConfigInstruction(instruction)
2050
2049
  };
2051
2050
  }
2052
2051
  case 5 /* InitializeAirdropMaster */: {
2053
- assertIsInstructionWithAccounts(instruction);
2052
+ (0, import_kit12.assertIsInstructionWithAccounts)(instruction);
2054
2053
  return {
2055
2054
  instructionType: 5 /* InitializeAirdropMaster */,
2056
2055
  ...parseInitializeAirdropMasterInstruction(instruction)
@@ -2222,7 +2221,7 @@ function getDropsyAirdropErrorMessage(code) {
2222
2221
  return "Error message not available in production bundles.";
2223
2222
  }
2224
2223
  function isDropsyAirdropError(error, transactionMessage, code) {
2225
- return isProgramError(
2224
+ return (0, import_kit13.isProgramError)(
2226
2225
  error,
2227
2226
  transactionMessage,
2228
2227
  DROPSY_AIRDROP_PROGRAM_ADDRESS,
@@ -2231,173 +2230,128 @@ function isDropsyAirdropError(error, transactionMessage, code) {
2231
2230
  }
2232
2231
 
2233
2232
  // src/types/airdropInitialized.ts
2234
- import {
2235
- combineCodec as combineCodec11,
2236
- fixDecoderSize as fixDecoderSize11,
2237
- fixEncoderSize as fixEncoderSize12,
2238
- getAddressDecoder as getAddressDecoder6,
2239
- getAddressEncoder as getAddressEncoder10,
2240
- getBytesDecoder as getBytesDecoder11,
2241
- getBytesEncoder as getBytesEncoder12,
2242
- getI64Decoder as getI64Decoder5,
2243
- getI64Encoder as getI64Encoder5,
2244
- getStructDecoder as getStructDecoder11,
2245
- getStructEncoder as getStructEncoder11
2246
- } from "@solana/kit";
2233
+ var import_kit14 = require("@solana/kit");
2247
2234
  function getAirdropInitializedEncoder() {
2248
- return getStructEncoder11([
2249
- ["airdrop", getAddressEncoder10()],
2250
- ["mint", getAddressEncoder10()],
2251
- ["authority", getAddressEncoder10()],
2252
- ["master", getAddressEncoder10()],
2253
- ["merkleRoot", fixEncoderSize12(getBytesEncoder12(), 32)],
2254
- ["startTime", getI64Encoder5()],
2255
- ["endTime", getI64Encoder5()],
2256
- ["timestamp", getI64Encoder5()]
2235
+ return (0, import_kit14.getStructEncoder)([
2236
+ ["airdrop", (0, import_kit14.getAddressEncoder)()],
2237
+ ["mint", (0, import_kit14.getAddressEncoder)()],
2238
+ ["authority", (0, import_kit14.getAddressEncoder)()],
2239
+ ["master", (0, import_kit14.getAddressEncoder)()],
2240
+ ["merkleRoot", (0, import_kit14.fixEncoderSize)((0, import_kit14.getBytesEncoder)(), 32)],
2241
+ ["startTime", (0, import_kit14.getI64Encoder)()],
2242
+ ["endTime", (0, import_kit14.getI64Encoder)()],
2243
+ ["timestamp", (0, import_kit14.getI64Encoder)()]
2257
2244
  ]);
2258
2245
  }
2259
2246
  function getAirdropInitializedDecoder() {
2260
- return getStructDecoder11([
2261
- ["airdrop", getAddressDecoder6()],
2262
- ["mint", getAddressDecoder6()],
2263
- ["authority", getAddressDecoder6()],
2264
- ["master", getAddressDecoder6()],
2265
- ["merkleRoot", fixDecoderSize11(getBytesDecoder11(), 32)],
2266
- ["startTime", getI64Decoder5()],
2267
- ["endTime", getI64Decoder5()],
2268
- ["timestamp", getI64Decoder5()]
2247
+ return (0, import_kit14.getStructDecoder)([
2248
+ ["airdrop", (0, import_kit14.getAddressDecoder)()],
2249
+ ["mint", (0, import_kit14.getAddressDecoder)()],
2250
+ ["authority", (0, import_kit14.getAddressDecoder)()],
2251
+ ["master", (0, import_kit14.getAddressDecoder)()],
2252
+ ["merkleRoot", (0, import_kit14.fixDecoderSize)((0, import_kit14.getBytesDecoder)(), 32)],
2253
+ ["startTime", (0, import_kit14.getI64Decoder)()],
2254
+ ["endTime", (0, import_kit14.getI64Decoder)()],
2255
+ ["timestamp", (0, import_kit14.getI64Decoder)()]
2269
2256
  ]);
2270
2257
  }
2271
2258
  function getAirdropInitializedCodec() {
2272
- return combineCodec11(
2259
+ return (0, import_kit14.combineCodec)(
2273
2260
  getAirdropInitializedEncoder(),
2274
2261
  getAirdropInitializedDecoder()
2275
2262
  );
2276
2263
  }
2277
2264
 
2278
2265
  // src/types/bitmapClosed.ts
2279
- import {
2280
- combineCodec as combineCodec12,
2281
- getAddressDecoder as getAddressDecoder7,
2282
- getAddressEncoder as getAddressEncoder11,
2283
- getStructDecoder as getStructDecoder12,
2284
- getStructEncoder as getStructEncoder12
2285
- } from "@solana/kit";
2266
+ var import_kit15 = require("@solana/kit");
2286
2267
  function getBitmapClosedEncoder() {
2287
- return getStructEncoder12([
2288
- ["airdrop", getAddressEncoder11()],
2289
- ["bitmap", getAddressEncoder11()],
2290
- ["authority", getAddressEncoder11()]
2268
+ return (0, import_kit15.getStructEncoder)([
2269
+ ["airdrop", (0, import_kit15.getAddressEncoder)()],
2270
+ ["bitmap", (0, import_kit15.getAddressEncoder)()],
2271
+ ["authority", (0, import_kit15.getAddressEncoder)()]
2291
2272
  ]);
2292
2273
  }
2293
2274
  function getBitmapClosedDecoder() {
2294
- return getStructDecoder12([
2295
- ["airdrop", getAddressDecoder7()],
2296
- ["bitmap", getAddressDecoder7()],
2297
- ["authority", getAddressDecoder7()]
2275
+ return (0, import_kit15.getStructDecoder)([
2276
+ ["airdrop", (0, import_kit15.getAddressDecoder)()],
2277
+ ["bitmap", (0, import_kit15.getAddressDecoder)()],
2278
+ ["authority", (0, import_kit15.getAddressDecoder)()]
2298
2279
  ]);
2299
2280
  }
2300
2281
  function getBitmapClosedCodec() {
2301
- return combineCodec12(getBitmapClosedEncoder(), getBitmapClosedDecoder());
2282
+ return (0, import_kit15.combineCodec)(getBitmapClosedEncoder(), getBitmapClosedDecoder());
2302
2283
  }
2303
2284
 
2304
2285
  // src/types/bitmapInitialized.ts
2305
- import {
2306
- combineCodec as combineCodec13,
2307
- getAddressDecoder as getAddressDecoder8,
2308
- getAddressEncoder as getAddressEncoder12,
2309
- getI64Decoder as getI64Decoder6,
2310
- getI64Encoder as getI64Encoder6,
2311
- getStructDecoder as getStructDecoder13,
2312
- getStructEncoder as getStructEncoder13,
2313
- getU16Decoder as getU16Decoder7,
2314
- getU16Encoder as getU16Encoder7
2315
- } from "@solana/kit";
2286
+ var import_kit16 = require("@solana/kit");
2316
2287
  function getBitmapInitializedEncoder() {
2317
- return getStructEncoder13([
2318
- ["airdrop", getAddressEncoder12()],
2319
- ["bitmap", getAddressEncoder12()],
2320
- ["bitmapId", getU16Encoder7()],
2321
- ["timestamp", getI64Encoder6()]
2288
+ return (0, import_kit16.getStructEncoder)([
2289
+ ["airdrop", (0, import_kit16.getAddressEncoder)()],
2290
+ ["bitmap", (0, import_kit16.getAddressEncoder)()],
2291
+ ["bitmapId", (0, import_kit16.getU16Encoder)()],
2292
+ ["timestamp", (0, import_kit16.getI64Encoder)()]
2322
2293
  ]);
2323
2294
  }
2324
2295
  function getBitmapInitializedDecoder() {
2325
- return getStructDecoder13([
2326
- ["airdrop", getAddressDecoder8()],
2327
- ["bitmap", getAddressDecoder8()],
2328
- ["bitmapId", getU16Decoder7()],
2329
- ["timestamp", getI64Decoder6()]
2296
+ return (0, import_kit16.getStructDecoder)([
2297
+ ["airdrop", (0, import_kit16.getAddressDecoder)()],
2298
+ ["bitmap", (0, import_kit16.getAddressDecoder)()],
2299
+ ["bitmapId", (0, import_kit16.getU16Decoder)()],
2300
+ ["timestamp", (0, import_kit16.getI64Decoder)()]
2330
2301
  ]);
2331
2302
  }
2332
2303
  function getBitmapInitializedCodec() {
2333
- return combineCodec13(
2304
+ return (0, import_kit16.combineCodec)(
2334
2305
  getBitmapInitializedEncoder(),
2335
2306
  getBitmapInitializedDecoder()
2336
2307
  );
2337
2308
  }
2338
2309
 
2339
2310
  // src/types/tokensDeposited.ts
2340
- import {
2341
- combineCodec as combineCodec14,
2342
- getAddressDecoder as getAddressDecoder9,
2343
- getAddressEncoder as getAddressEncoder13,
2344
- getI64Decoder as getI64Decoder7,
2345
- getI64Encoder as getI64Encoder7,
2346
- getStructDecoder as getStructDecoder14,
2347
- getStructEncoder as getStructEncoder14,
2348
- getU64Decoder as getU64Decoder8,
2349
- getU64Encoder as getU64Encoder8
2350
- } from "@solana/kit";
2311
+ var import_kit17 = require("@solana/kit");
2351
2312
  function getTokensDepositedEncoder() {
2352
- return getStructEncoder14([
2353
- ["airdrop", getAddressEncoder13()],
2354
- ["amount", getU64Encoder8()],
2355
- ["newSupply", getU64Encoder8()],
2356
- ["depositor", getAddressEncoder13()],
2357
- ["timestamp", getI64Encoder7()]
2313
+ return (0, import_kit17.getStructEncoder)([
2314
+ ["airdrop", (0, import_kit17.getAddressEncoder)()],
2315
+ ["amount", (0, import_kit17.getU64Encoder)()],
2316
+ ["newSupply", (0, import_kit17.getU64Encoder)()],
2317
+ ["depositor", (0, import_kit17.getAddressEncoder)()],
2318
+ ["timestamp", (0, import_kit17.getI64Encoder)()]
2358
2319
  ]);
2359
2320
  }
2360
2321
  function getTokensDepositedDecoder() {
2361
- return getStructDecoder14([
2362
- ["airdrop", getAddressDecoder9()],
2363
- ["amount", getU64Decoder8()],
2364
- ["newSupply", getU64Decoder8()],
2365
- ["depositor", getAddressDecoder9()],
2366
- ["timestamp", getI64Decoder7()]
2322
+ return (0, import_kit17.getStructDecoder)([
2323
+ ["airdrop", (0, import_kit17.getAddressDecoder)()],
2324
+ ["amount", (0, import_kit17.getU64Decoder)()],
2325
+ ["newSupply", (0, import_kit17.getU64Decoder)()],
2326
+ ["depositor", (0, import_kit17.getAddressDecoder)()],
2327
+ ["timestamp", (0, import_kit17.getI64Decoder)()]
2367
2328
  ]);
2368
2329
  }
2369
2330
  function getTokensDepositedCodec() {
2370
- return combineCodec14(getTokensDepositedEncoder(), getTokensDepositedDecoder());
2331
+ return (0, import_kit17.combineCodec)(getTokensDepositedEncoder(), getTokensDepositedDecoder());
2371
2332
  }
2372
2333
 
2373
2334
  // src/types/tokensRedeemed.ts
2374
- import {
2375
- combineCodec as combineCodec15,
2376
- getAddressDecoder as getAddressDecoder10,
2377
- getAddressEncoder as getAddressEncoder14,
2378
- getI64Decoder as getI64Decoder8,
2379
- getI64Encoder as getI64Encoder8,
2380
- getStructDecoder as getStructDecoder15,
2381
- getStructEncoder as getStructEncoder15
2382
- } from "@solana/kit";
2335
+ var import_kit18 = require("@solana/kit");
2383
2336
  function getTokensRedeemedEncoder() {
2384
- return getStructEncoder15([
2385
- ["airdrop", getAddressEncoder14()],
2386
- ["authority", getAddressEncoder14()],
2387
- ["timestamp", getI64Encoder8()]
2337
+ return (0, import_kit18.getStructEncoder)([
2338
+ ["airdrop", (0, import_kit18.getAddressEncoder)()],
2339
+ ["authority", (0, import_kit18.getAddressEncoder)()],
2340
+ ["timestamp", (0, import_kit18.getI64Encoder)()]
2388
2341
  ]);
2389
2342
  }
2390
2343
  function getTokensRedeemedDecoder() {
2391
- return getStructDecoder15([
2392
- ["airdrop", getAddressDecoder10()],
2393
- ["authority", getAddressDecoder10()],
2394
- ["timestamp", getI64Decoder8()]
2344
+ return (0, import_kit18.getStructDecoder)([
2345
+ ["airdrop", (0, import_kit18.getAddressDecoder)()],
2346
+ ["authority", (0, import_kit18.getAddressDecoder)()],
2347
+ ["timestamp", (0, import_kit18.getI64Decoder)()]
2395
2348
  ]);
2396
2349
  }
2397
2350
  function getTokensRedeemedCodec() {
2398
- return combineCodec15(getTokensRedeemedEncoder(), getTokensRedeemedDecoder());
2351
+ return (0, import_kit18.combineCodec)(getTokensRedeemedEncoder(), getTokensRedeemedDecoder());
2399
2352
  }
2400
- export {
2353
+ // Annotate the CommonJS export names for ESM import in node:
2354
+ 0 && (module.exports = {
2401
2355
  AIRDROP_CONFIG_DISCRIMINATOR,
2402
2356
  AIRDROP_DISCRIMINATOR,
2403
2357
  AIRDROP_MASTER_DISCRIMINATOR,
@@ -2586,5 +2540,5 @@ export {
2586
2540
  parseDropsyAirdropInstruction,
2587
2541
  parseInitializeAirdropConfigInstruction,
2588
2542
  parseInitializeAirdropMasterInstruction
2589
- };
2590
- //# sourceMappingURL=index.mjs.map
2543
+ });
2544
+ //# sourceMappingURL=index.cjs.map