@gabox-labs/sdk 0.2.0 → 0.6.0

package/dist/generated/index.js

@@ -1,6 +1,2293 @@
 import { t as __exportAll } from "../rolldown-runtime-D7D4PA-g.js";
-import { $ as getFulfillDrawInstructionDataCodec, $n as getPrizeEncoder, $t as findPoolPda, A as getRetryDrawInstructionDataCodec, An as fetchMaybePool, At as getClaimPrizeInstructionAsync, B as getInitializePoolInstructionDataEncoder, Bn as fetchAllMaybeDraw, Bt as getBuyPackInstructionDataDecoder, C as getSellPrizeInstructionDataDecoder, Cn as getReferralDiscriminatorBytes, Ct as getClaimReferralInstructionDataCodec, D as getRetryDrawDiscriminatorBytes, Dn as decodePool, Dt as CLAIM_PRIZE_DISCRIMINATOR, E as RETRY_DRAW_DISCRIMINATOR, En as POOL_DISCRIMINATOR, Et as parseClaimReferralInstruction, F as getInitializePoolDiscriminatorBytes, Fn as getPoolEncoder, Ft as BUY_PACK_DISCRIMINATOR, G as getFundPrizesInstructionDataCodec, Gn as getDrawDiscriminatorBytes, Gt as getBindReferrerInstruction, H as FUND_PRIZES_DISCRIMINATOR, Hn as fetchMaybeDraw, Ht as parseBuyPackInstruction, I as getInitializePoolInstruction, In as getPoolSize, It as getBuyPackDiscriminatorBytes, J as parseFundPrizesInstruction, Jn as getTierCodec, Jt as getBindReferrerInstructionDataDecoder, K as getFundPrizesInstructionDataDecoder, Kn as getDrawEncoder, Kt as getBindReferrerInstructionAsync, L as getInitializePoolInstructionAsync, Ln as DRAW_DISCRIMINATOR, Lt as getBuyPackInstruction, M as getRetryDrawInstructionDataEncoder, Mn as getPoolCodec, Mt as getClaimPrizeInstructionDataDecoder, N as parseRetryDrawInstruction, Nn as getPoolDecoder, Nt as getClaimPrizeInstructionDataEncoder, O as getRetryDrawInstruction, On as fetchAllMaybePool, Ot as getClaimPrizeDiscriminatorBytes, P as INITIALIZE_POOL_DISCRIMINATOR, Pn as getPoolDiscriminatorBytes, Pt as parseClaimPrizeInstruction, Q as getFulfillDrawInstructionAsync, Qn as getPrizeDecoder, Qt as findReferralPda, R as getInitializePoolInstructionDataCodec, Rn as decodeDraw, Rt as getBuyPackInstructionAsync, S as getSellPrizeInstructionDataCodec, Sn as getReferralDecoder, St as getClaimReferralInstructionAsync, T as parseSellPrizeInstruction, Tn as getReferralSize, Tt as getClaimReferralInstructionDataEncoder, U as getFundPrizesDiscriminatorBytes, Un as getDrawCodec, Ut as BIND_REFERRER_DISCRIMINATOR, V as parseInitializePoolInstruction, Vn as fetchDraw, Vt as getBuyPackInstructionDataEncoder, W as getFundPrizesInstruction, Wn as getDrawDecoder, Wt as getBindReferrerDiscriminatorBytes, X as getFulfillDrawDiscriminatorBytes, Xn as getTierEncoder, Xt as parseBindReferrerInstruction, Y as FULFILL_DRAW_DISCRIMINATOR, Yn as getTierDecoder, Yt as getBindReferrerInstructionDataEncoder, Z as getFulfillDrawInstruction, Zn as getPrizeCodec, Zt as findReferralLinkPda, _ as parseSellTokensInstruction, _n as fetchAllMaybeReferral, _t as getDeliverDrawInstructionDataEncoder, a as gaboxV2Program, an as decodeReferralLink, at as getExpireDrawInstruction, b as getSellPrizeInstruction, bn as fetchReferral, bt as getClaimReferralDiscriminatorBytes, c as identifyGaboxV2Instruction, cn as fetchMaybeReferralLink, ct as getExpireDrawInstructionDataDecoder, d as getSellTokensDiscriminatorBytes, dn as getReferralLinkDecoder, dt as DELIVER_DRAW_DISCRIMINATOR, en as findLinkPda, er as DrawStatus, et as getFulfillDrawInstructionDataDecoder, f as getSellTokensInstruction, fn as getReferralLinkDiscriminatorBytes, ft as getDeliverDrawDiscriminatorBytes, g as getSellTokensInstructionDataEncoder, gn as decodeReferral, gt as getDeliverDrawInstructionDataDecoder, h as getSellTokensInstructionDataDecoder, hn as REFERRAL_DISCRIMINATOR, ht as getDeliverDrawInstructionDataCodec, i as GaboxV2Instruction, in as REFERRAL_LINK_DISCRIMINATOR, it as getExpireDrawDiscriminatorBytes, j as getRetryDrawInstructionDataDecoder, jn as fetchPool, jt as getClaimPrizeInstructionDataCodec, k as getRetryDrawInstructionAsync, kn as fetchAllPool, kt as getClaimPrizeInstruction, l as parseGaboxV2Instruction, ln as fetchReferralLink, lt as getExpireDrawInstructionDataEncoder, m as getSellTokensInstructionDataCodec, mn as getReferralLinkSize, mt as getDeliverDrawInstructionAsync, n as GaboxV2Account, nn as findDrawPda, nr as getDrawStatusDecoder, nt as parseFulfillDrawInstruction, o as identifyGaboxV2Account, on as fetchAllMaybeReferralLink, ot as getExpireDrawInstructionAsync, p as getSellTokensInstructionAsync, pn as getReferralLinkEncoder, pt as getDeliverDrawInstruction, q as getFundPrizesInstructionDataEncoder, qn as getDrawSize, qt as getBindReferrerInstructionDataCodec, r as GaboxV2Event, rn as findClaimReferralReferralPda, rr as getDrawStatusEncoder, rt as EXPIRE_DRAW_DISCRIMINATOR, s as identifyGaboxV2Event, sn as fetchAllReferralLink, st as getExpireDrawInstructionDataCodec, t as GABOX_V2_PROGRAM_ADDRESS, tn as findIdentityPda, tr as getDrawStatusCodec, tt as getFulfillDrawInstructionDataEncoder, u as SELL_TOKENS_DISCRIMINATOR, un as getReferralLinkCodec, ut as parseExpireDrawInstruction, v as SELL_PRIZE_DISCRIMINATOR, vn as fetchAllReferral, vt as parseDeliverDrawInstruction, w as getSellPrizeInstructionDataEncoder, wn as getReferralEncoder, wt as getClaimReferralInstructionDataDecoder, x as getSellPrizeInstructionAsync, xn as getReferralCodec, xt as getClaimReferralInstruction, y as getSellPrizeDiscriminatorBytes, yn as fetchMaybeReferral, yt as CLAIM_REFERRAL_DISCRIMINATOR, z as getInitializePoolInstructionDataDecoder, zn as fetchAllDraw, zt as getBuyPackInstructionDataCodec } from "../gaboxV2-CV2XltqC.js";
-import { combineCodec, containsBytes, fixDecoderSize, fixEncoderSize, getAddressDecoder, getAddressEncoder, getArrayDecoder, getArrayEncoder, getBooleanDecoder, getBooleanEncoder, getBytesDecoder, getBytesEncoder, getConstantDecoder, getConstantEncoder, getHiddenPrefixDecoder, getHiddenPrefixEncoder, getStructDecoder, getStructEncoder, getU16Decoder, getU16Encoder, getU64Decoder, getU64Encoder, getU8Decoder, getU8Encoder, isProgramError } from "@solana/kit";
+import { SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT, SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, SolanaError, assertAccountExists, assertAccountsExist, assertIsInstructionWithAccounts, combineCodec, containsBytes, decodeAccount, extendClient, fetchEncodedAccount, fetchEncodedAccounts, fixDecoderSize, fixEncoderSize, getAddressDecoder, getAddressEncoder, getArrayDecoder, getArrayEncoder, getBooleanDecoder, getBooleanEncoder, getBytesDecoder, getBytesEncoder, getConstantDecoder, getConstantEncoder, getHiddenPrefixDecoder, getHiddenPrefixEncoder, getProgramDerivedAddress, getStructDecoder, getStructEncoder, getU32Decoder, getU32Encoder, getU64Decoder, getU64Encoder, getU8Decoder, getU8Encoder, isProgramError, transformEncoder } from "@solana/kit";
+import { addSelfFetchFunctions, addSelfPlanAndSendFunctions, getAccountMetaFactory, getAddressFromResolvedInstructionAccount, getNonNullResolvedInstructionInput } from "@solana/program-client-core";
+//#region src/generated/types/prize.ts
+/**
+* This code was AUTOGENERATED using the Codama library.
+* Please DO NOT EDIT THIS FILE, instead use visitors
+* to add features, then rerun Codama to update it.
+*
+* @see https://github.com/codama-idl/codama
+*/
+function getPrizeEncoder() {
+	return getStructEncoder([["amount", getU64Encoder()], ["tickets", getU32Encoder()]]);
+}
+function getPrizeDecoder() {
+	return getStructDecoder([["amount", getU64Decoder()], ["tickets", getU32Decoder()]]);
+}
+function getPrizeCodec() {
+	return combineCodec(getPrizeEncoder(), getPrizeDecoder());
+}
+//#endregion
+//#region src/generated/types/tier.ts
+/**
+* This code was AUTOGENERATED using the Codama library.
+* Please DO NOT EDIT THIS FILE, instead use visitors
+* to add features, then rerun Codama to update it.
+*
+* @see https://github.com/codama-idl/codama
+*/
+function getTierEncoder() {
+	return getStructEncoder([["multiplierBps", getU32Encoder()], ["tickets", getU32Encoder()]]);
+}
+function getTierDecoder() {
+	return getStructDecoder([["multiplierBps", getU32Decoder()], ["tickets", getU32Decoder()]]);
+}
+function getTierCodec() {
+	return combineCodec(getTierEncoder(), getTierDecoder());
+}
+//#endregion
+//#region src/generated/accounts/draw.ts
+/**
+* This code was AUTOGENERATED using the Codama library.
+* Please DO NOT EDIT THIS FILE, instead use visitors
+* to add features, then rerun Codama to update it.
+*
+* @see https://github.com/codama-idl/codama
+*/
+const DRAW_DISCRIMINATOR = new Uint8Array([
+	101,
+	31,
+	52,
+	179,
+	121,
+	78,
+	252,
+	89
+]);
+function getDrawDiscriminatorBytes() {
+	return fixEncoderSize(getBytesEncoder(), 8).encode(DRAW_DISCRIMINATOR);
+}
+/** Gets the encoder for {@link DrawArgs} account data. */
+function getDrawEncoder() {
+	return transformEncoder(getStructEncoder([
+		["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+		["pool", getAddressEncoder()],
+		["purchaser", getAddressEncoder()],
+		["seq", getU64Encoder()],
+		["bump", getU8Encoder()],
+		["requestSlot", getU64Encoder()],
+		["lastAttemptSlot", getU64Encoder()],
+		["attempts", getU8Encoder()],
+		["maximum", getU64Encoder()],
+		["minimum", getU64Encoder()],
+		["prizes", getArrayEncoder(getPrizeEncoder(), { size: 8 })]
+	]), (value) => ({
+		...value,
+		discriminator: DRAW_DISCRIMINATOR
+	}));
+}
+/** Gets the decoder for {@link Draw} account data. */
+function getDrawDecoder() {
+	return getStructDecoder([
+		["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+		["pool", getAddressDecoder()],
+		["purchaser", getAddressDecoder()],
+		["seq", getU64Decoder()],
+		["bump", getU8Decoder()],
+		["requestSlot", getU64Decoder()],
+		["lastAttemptSlot", getU64Decoder()],
+		["attempts", getU8Decoder()],
+		["maximum", getU64Decoder()],
+		["minimum", getU64Decoder()],
+		["prizes", getArrayDecoder(getPrizeDecoder(), { size: 8 })]
+	]);
+}
+/** Gets the codec for {@link Draw} account data. */
+function getDrawCodec() {
+	return combineCodec(getDrawEncoder(), getDrawDecoder());
+}
+function decodeDraw(encodedAccount) {
+	return decodeAccount(encodedAccount, getDrawDecoder());
+}
+async function fetchDraw(rpc, address, config) {
+	const maybeAccount = await fetchMaybeDraw(rpc, address, config);
+	assertAccountExists(maybeAccount);
+	return maybeAccount;
+}
+async function fetchMaybeDraw(rpc, address, config) {
+	return decodeDraw(await fetchEncodedAccount(rpc, address, config));
+}
+async function fetchAllDraw(rpc, addresses, config) {
+	const maybeAccounts = await fetchAllMaybeDraw(rpc, addresses, config);
+	assertAccountsExist(maybeAccounts);
+	return maybeAccounts;
+}
+async function fetchAllMaybeDraw(rpc, addresses, config) {
+	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeDraw(maybeAccount));
+}
+function getDrawSize() {
+	return 210;
+}
+//#endregion
+//#region src/generated/accounts/pool.ts
+/**
+* This code was AUTOGENERATED using the Codama library.
+* Please DO NOT EDIT THIS FILE, instead use visitors
+* to add features, then rerun Codama to update it.
+*
+* @see https://github.com/codama-idl/codama
+*/
+const POOL_DISCRIMINATOR = new Uint8Array([
+	140,
+	230,
+	142,
+	167,
+	14,
+	202,
+	43,
+	254
+]);
+function getPoolDiscriminatorBytes() {
+	return fixEncoderSize(getBytesEncoder(), 8).encode(POOL_DISCRIMINATOR);
+}
+/** Gets the encoder for {@link PoolArgs} account data. */
+function getPoolEncoder() {
+	return transformEncoder(getStructEncoder([
+		["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+		["creator", getAddressEncoder()],
+		["mint", getAddressEncoder()],
+		["vault", getAddressEncoder()],
+		["quoteMint", getAddressEncoder()],
+		["bump", getU8Encoder()],
+		["packTokens", getU64Encoder()],
+		["seedQuoteAmount", getU64Encoder()],
+		["tiers", getArrayEncoder(getTierEncoder(), { size: 8 })],
+		["nextSeq", getU64Encoder()],
+		["reserved", getU64Encoder()]
+	]), (value) => ({
+		...value,
+		discriminator: POOL_DISCRIMINATOR
+	}));
+}
+/** Gets the decoder for {@link Pool} account data. */
+function getPoolDecoder() {
+	return getStructDecoder([
+		["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+		["creator", getAddressDecoder()],
+		["mint", getAddressDecoder()],
+		["vault", getAddressDecoder()],
+		["quoteMint", getAddressDecoder()],
+		["bump", getU8Decoder()],
+		["packTokens", getU64Decoder()],
+		["seedQuoteAmount", getU64Decoder()],
+		["tiers", getArrayDecoder(getTierDecoder(), { size: 8 })],
+		["nextSeq", getU64Decoder()],
+		["reserved", getU64Decoder()]
+	]);
+}
+/** Gets the codec for {@link Pool} account data. */
+function getPoolCodec() {
+	return combineCodec(getPoolEncoder(), getPoolDecoder());
+}
+function decodePool(encodedAccount) {
+	return decodeAccount(encodedAccount, getPoolDecoder());
+}
+async function fetchPool(rpc, address, config) {
+	const maybeAccount = await fetchMaybePool(rpc, address, config);
+	assertAccountExists(maybeAccount);
+	return maybeAccount;
+}
+async function fetchMaybePool(rpc, address, config) {
+	return decodePool(await fetchEncodedAccount(rpc, address, config));
+}
+async function fetchAllPool(rpc, addresses, config) {
+	const maybeAccounts = await fetchAllMaybePool(rpc, addresses, config);
+	assertAccountsExist(maybeAccounts);
+	return maybeAccounts;
+}
+async function fetchAllMaybePool(rpc, addresses, config) {
+	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodePool(maybeAccount));
+}
+function getPoolSize() {
+	return 233;
+}
+//#endregion
+//#region src/generated/accounts/walletActivity.ts
+/**
+* This code was AUTOGENERATED using the Codama library.
+* Please DO NOT EDIT THIS FILE, instead use visitors
+* to add features, then rerun Codama to update it.
+*
+* @see https://github.com/codama-idl/codama
+*/
+const WALLET_ACTIVITY_DISCRIMINATOR = new Uint8Array([
+	212,
+	80,
+	180,
+	131,
+	173,
+	1,
+	252,
+	141
+]);
+function getWalletActivityDiscriminatorBytes() {
+	return fixEncoderSize(getBytesEncoder(), 8).encode(WALLET_ACTIVITY_DISCRIMINATOR);
+}
+/** Gets the encoder for {@link WalletActivityArgs} account data. */
+function getWalletActivityEncoder() {
+	return transformEncoder(getStructEncoder([
+		["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+		["wallet", getAddressEncoder()],
+		["bump", getU8Encoder()],
+		["packsBought", getU64Encoder()],
+		["nativeSpent", getU64Encoder()],
+		["reserved", fixEncoderSize(getBytesEncoder(), 64)]
+	]), (value) => ({
+		...value,
+		discriminator: WALLET_ACTIVITY_DISCRIMINATOR
+	}));
+}
+/** Gets the decoder for {@link WalletActivity} account data. */
+function getWalletActivityDecoder() {
+	return getStructDecoder([
+		["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+		["wallet", getAddressDecoder()],
+		["bump", getU8Decoder()],
+		["packsBought", getU64Decoder()],
+		["nativeSpent", getU64Decoder()],
+		["reserved", fixDecoderSize(getBytesDecoder(), 64)]
+	]);
+}
+/** Gets the codec for {@link WalletActivity} account data. */
+function getWalletActivityCodec() {
+	return combineCodec(getWalletActivityEncoder(), getWalletActivityDecoder());
+}
+function decodeWalletActivity(encodedAccount) {
+	return decodeAccount(encodedAccount, getWalletActivityDecoder());
+}
+async function fetchWalletActivity(rpc, address, config) {
+	const maybeAccount = await fetchMaybeWalletActivity(rpc, address, config);
+	assertAccountExists(maybeAccount);
+	return maybeAccount;
+}
+async function fetchMaybeWalletActivity(rpc, address, config) {
+	return decodeWalletActivity(await fetchEncodedAccount(rpc, address, config));
+}
+async function fetchAllWalletActivity(rpc, addresses, config) {
+	const maybeAccounts = await fetchAllMaybeWalletActivity(rpc, addresses, config);
+	assertAccountsExist(maybeAccounts);
+	return maybeAccounts;
+}
+async function fetchAllMaybeWalletActivity(rpc, addresses, config) {
+	return (await fetchEncodedAccounts(rpc, addresses, config)).map((maybeAccount) => decodeWalletActivity(maybeAccount));
+}
+function getWalletActivitySize() {
+	return 121;
+}
+//#endregion
+//#region src/generated/pdas/activity.ts
+/**
+* This code was AUTOGENERATED using the Codama library.
+* Please DO NOT EDIT THIS FILE, instead use visitors
+* to add features, then rerun Codama to update it.
+*
+* @see https://github.com/codama-idl/codama
+*/
+async function findActivityPda(seeds, config = {}) {
+	const { programAddress = "GaBoxR9nYcK1zeu8EvSJVHV3SrYpCFmvbh2MLgobMcUA" } = config;
+	return await getProgramDerivedAddress({
+		programAddress,
+		seeds: [getBytesEncoder().encode(new Uint8Array([
+			97,
+			99,
+			116,
+			105,
+			118,
+			105,
+			116,
+			121
+		])), getAddressEncoder().encode(seeds.purchaser)]
+	});
+}
+//#endregion
+//#region src/generated/pdas/draw.ts
+/**
+* This code was AUTOGENERATED using the Codama library.
+* Please DO NOT EDIT THIS FILE, instead use visitors
+* to add features, then rerun Codama to update it.
+*
+* @see https://github.com/codama-idl/codama
+*/
+async function findDrawPda(seeds, config = {}) {
+	const { programAddress = "GaBoxR9nYcK1zeu8EvSJVHV3SrYpCFmvbh2MLgobMcUA" } = config;
+	return await getProgramDerivedAddress({
+		programAddress,
+		seeds: [
+			getBytesEncoder().encode(new Uint8Array([
+				100,
+				114,
+				97,
+				119
+			])),
+			getAddressEncoder().encode(seeds.pool),
+			getU64Encoder().encode(seeds.seq)
+		]
+	});
+}
+//#endregion
+//#region src/generated/pdas/identity.ts
+/**
+* This code was AUTOGENERATED using the Codama library.
+* Please DO NOT EDIT THIS FILE, instead use visitors
+* to add features, then rerun Codama to update it.
+*
+* @see https://github.com/codama-idl/codama
+*/
+async function findIdentityPda(config = {}) {
+	const { programAddress = "GaBoxR9nYcK1zeu8EvSJVHV3SrYpCFmvbh2MLgobMcUA" } = config;
+	return await getProgramDerivedAddress({
+		programAddress,
+		seeds: [getBytesEncoder().encode(new Uint8Array([
+			105,
+			100,
+			101,
+			110,
+			116,
+			105,
+			116,
+			121
+		]))]
+	});
+}
+//#endregion
+//#region src/generated/pdas/pool.ts
+/**
+* This code was AUTOGENERATED using the Codama library.
+* Please DO NOT EDIT THIS FILE, instead use visitors
+* to add features, then rerun Codama to update it.
+*
+* @see https://github.com/codama-idl/codama
+*/
+async function findPoolPda(seeds, config = {}) {
+	const { programAddress = "GaBoxR9nYcK1zeu8EvSJVHV3SrYpCFmvbh2MLgobMcUA" } = config;
+	return await getProgramDerivedAddress({
+		programAddress,
+		seeds: [getBytesEncoder().encode(new Uint8Array([
+			112,
+			111,
+			111,
+			108
+		])), getAddressEncoder().encode(seeds.mint)]
+	});
+}
+//#endregion
+//#region src/generated/instructions/buyPack.ts
+/**
+* This code was AUTOGENERATED using the Codama library.
+* Please DO NOT EDIT THIS FILE, instead use visitors
+* to add features, then rerun Codama to update it.
+*
+* @see https://github.com/codama-idl/codama
+*/
+const BUY_PACK_DISCRIMINATOR = new Uint8Array([
+	151,
+	46,
+	141,
+	93,
+	174,
+	5,
+	49,
+	173
+]);
+function getBuyPackDiscriminatorBytes() {
+	return fixEncoderSize(getBytesEncoder(), 8).encode(BUY_PACK_DISCRIMINATOR);
+}
+function getBuyPackInstructionDataEncoder() {
+	return transformEncoder(getStructEncoder([
+		["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+		["maxQuoteIn", getU64Encoder()],
+		["minMaximum", getU64Encoder()],
+		["maxNativeDebit", getU64Encoder()]
+	]), (value) => ({
+		...value,
+		discriminator: BUY_PACK_DISCRIMINATOR
+	}));
+}
+function getBuyPackInstructionDataDecoder() {
+	return getStructDecoder([
+		["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+		["maxQuoteIn", getU64Decoder()],
+		["minMaximum", getU64Decoder()],
+		["maxNativeDebit", getU64Decoder()]
+	]);
+}
+function getBuyPackInstructionDataCodec() {
+	return combineCodec(getBuyPackInstructionDataEncoder(), getBuyPackInstructionDataDecoder());
+}
+async function getBuyPackInstructionAsync(input, config) {
+	const programAddress = config?.programAddress ?? "GaBoxR9nYcK1zeu8EvSJVHV3SrYpCFmvbh2MLgobMcUA";
+	const accounts = {
+		purchaser: {
+			value: input.purchaser ?? null,
+			isWritable: true
+		},
+		pool: {
+			value: input.pool ?? null,
+			isWritable: true
+		},
+		draw: {
+			value: input.draw ?? null,
+			isWritable: true
+		},
+		activity: {
+			value: input.activity ?? null,
+			isWritable: true
+		},
+		mint: {
+			value: input.mint ?? null,
+			isWritable: false
+		},
+		quoteMint: {
+			value: input.quoteMint ?? null,
+			isWritable: false
+		},
+		vault: {
+			value: input.vault ?? null,
+			isWritable: true
+		},
+		userTokens: {
+			value: input.userTokens ?? null,
+			isWritable: true
+		},
+		venue: {
+			value: input.venue ?? null,
+			isWritable: false
+		},
+		identity: {
+			value: input.identity ?? null,
+			isWritable: false
+		},
+		queue: {
+			value: input.queue ?? null,
+			isWritable: true
+		},
+		program: {
+			value: input.program ?? null,
+			isWritable: false
+		},
+		slotHashes: {
+			value: input.slotHashes ?? null,
+			isWritable: false
+		},
+		tokenProgram: {
+			value: input.tokenProgram ?? null,
+			isWritable: false
+		},
+		associatedTokenProgram: {
+			value: input.associatedTokenProgram ?? null,
+			isWritable: false
+		},
+		systemProgram: {
+			value: input.systemProgram ?? null,
+			isWritable: false
+		}
+	};
+	const args = { ...input };
+	if (!accounts.pool.value) accounts.pool.value = await findPoolPda({ mint: getAddressFromResolvedInstructionAccount("mint", accounts.mint.value) }, { programAddress });
+	if (!accounts.activity.value) accounts.activity.value = await findActivityPda({ purchaser: getAddressFromResolvedInstructionAccount("purchaser", accounts.purchaser.value) }, { programAddress });
+	if (!accounts.userTokens.value) accounts.userTokens.value = await getProgramDerivedAddress({
+		programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
+		seeds: [
+			getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("purchaser", accounts.purchaser.value)),
+			getBytesEncoder().encode(new Uint8Array([
+				6,
+				221,
+				246,
+				225,
+				215,
+				101,
+				161,
+				147,
+				217,
+				203,
+				225,
+				70,
+				206,
+				235,
+				121,
+				172,
+				28,
+				180,
+				133,
+				237,
+				95,
+				91,
+				55,
+				145,
+				58,
+				140,
+				245,
+				133,
+				126,
+				255,
+				0,
+				169
+			])),
+			getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("mint", accounts.mint.value))
+		]
+	});
+	if (!accounts.identity.value) accounts.identity.value = await findIdentityPda({ programAddress });
+	if (!accounts.queue.value) accounts.queue.value = "Cuj97ggrhhidhbu39TijNVqE74xvKJ69gDervRUXAxGh";
+	if (!accounts.program.value) accounts.program.value = "Vrf1RNUjXmQGjmQrQLvJHs9SNkvDJEsRVFPkfSQUwGz";
+	if (!accounts.slotHashes.value) accounts.slotHashes.value = "SysvarS1otHashes111111111111111111111111111";
+	if (!accounts.tokenProgram.value) accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+	if (!accounts.associatedTokenProgram.value) accounts.associatedTokenProgram.value = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+	if (!accounts.systemProgram.value) accounts.systemProgram.value = "11111111111111111111111111111111";
+	const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+	return Object.freeze({
+		accounts: [
+			getAccountMeta("purchaser", accounts.purchaser),
+			getAccountMeta("pool", accounts.pool),
+			getAccountMeta("draw", accounts.draw),
+			getAccountMeta("activity", accounts.activity),
+			getAccountMeta("mint", accounts.mint),
+			getAccountMeta("quoteMint", accounts.quoteMint),
+			getAccountMeta("vault", accounts.vault),
+			getAccountMeta("userTokens", accounts.userTokens),
+			getAccountMeta("venue", accounts.venue),
+			getAccountMeta("identity", accounts.identity),
+			getAccountMeta("queue", accounts.queue),
+			getAccountMeta("program", accounts.program),
+			getAccountMeta("slotHashes", accounts.slotHashes),
+			getAccountMeta("tokenProgram", accounts.tokenProgram),
+			getAccountMeta("associatedTokenProgram", accounts.associatedTokenProgram),
+			getAccountMeta("systemProgram", accounts.systemProgram)
+		],
+		data: getBuyPackInstructionDataEncoder().encode(args),
+		programAddress
+	});
+}
+function getBuyPackInstruction(input, config) {
+	const programAddress = config?.programAddress ?? "GaBoxR9nYcK1zeu8EvSJVHV3SrYpCFmvbh2MLgobMcUA";
+	const accounts = {
+		purchaser: {
+			value: input.purchaser ?? null,
+			isWritable: true
+		},
+		pool: {
+			value: input.pool ?? null,
+			isWritable: true
+		},
+		draw: {
+			value: input.draw ?? null,
+			isWritable: true
+		},
+		activity: {
+			value: input.activity ?? null,
+			isWritable: true
+		},
+		mint: {
+			value: input.mint ?? null,
+			isWritable: false
+		},
+		quoteMint: {
+			value: input.quoteMint ?? null,
+			isWritable: false
+		},
+		vault: {
+			value: input.vault ?? null,
+			isWritable: true
+		},
+		userTokens: {
+			value: input.userTokens ?? null,
+			isWritable: true
+		},
+		venue: {
+			value: input.venue ?? null,
+			isWritable: false
+		},
+		identity: {
+			value: input.identity ?? null,
+			isWritable: false
+		},
+		queue: {
+			value: input.queue ?? null,
+			isWritable: true
+		},
+		program: {
+			value: input.program ?? null,
+			isWritable: false
+		},
+		slotHashes: {
+			value: input.slotHashes ?? null,
+			isWritable: false
+		},
+		tokenProgram: {
+			value: input.tokenProgram ?? null,
+			isWritable: false
+		},
+		associatedTokenProgram: {
+			value: input.associatedTokenProgram ?? null,
+			isWritable: false
+		},
+		systemProgram: {
+			value: input.systemProgram ?? null,
+			isWritable: false
+		}
+	};
+	const args = { ...input };
+	if (!accounts.queue.value) accounts.queue.value = "Cuj97ggrhhidhbu39TijNVqE74xvKJ69gDervRUXAxGh";
+	if (!accounts.program.value) accounts.program.value = "Vrf1RNUjXmQGjmQrQLvJHs9SNkvDJEsRVFPkfSQUwGz";
+	if (!accounts.slotHashes.value) accounts.slotHashes.value = "SysvarS1otHashes111111111111111111111111111";
+	if (!accounts.tokenProgram.value) accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+	if (!accounts.associatedTokenProgram.value) accounts.associatedTokenProgram.value = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+	if (!accounts.systemProgram.value) accounts.systemProgram.value = "11111111111111111111111111111111";
+	const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+	return Object.freeze({
+		accounts: [
+			getAccountMeta("purchaser", accounts.purchaser),
+			getAccountMeta("pool", accounts.pool),
+			getAccountMeta("draw", accounts.draw),
+			getAccountMeta("activity", accounts.activity),
+			getAccountMeta("mint", accounts.mint),
+			getAccountMeta("quoteMint", accounts.quoteMint),
+			getAccountMeta("vault", accounts.vault),
+			getAccountMeta("userTokens", accounts.userTokens),
+			getAccountMeta("venue", accounts.venue),
+			getAccountMeta("identity", accounts.identity),
+			getAccountMeta("queue", accounts.queue),
+			getAccountMeta("program", accounts.program),
+			getAccountMeta("slotHashes", accounts.slotHashes),
+			getAccountMeta("tokenProgram", accounts.tokenProgram),
+			getAccountMeta("associatedTokenProgram", accounts.associatedTokenProgram),
+			getAccountMeta("systemProgram", accounts.systemProgram)
+		],
+		data: getBuyPackInstructionDataEncoder().encode(args),
+		programAddress
+	});
+}
+function parseBuyPackInstruction(instruction) {
+	if (instruction.accounts.length < 16) throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+		actualAccountMetas: instruction.accounts.length,
+		expectedAccountMetas: 16
+	});
+	let accountIndex = 0;
+	const getNextAccount = () => {
+		const accountMeta = instruction.accounts[accountIndex];
+		accountIndex += 1;
+		return accountMeta;
+	};
+	return {
+		programAddress: instruction.programAddress,
+		accounts: {
+			purchaser: getNextAccount(),
+			pool: getNextAccount(),
+			draw: getNextAccount(),
+			activity: getNextAccount(),
+			mint: getNextAccount(),
+			quoteMint: getNextAccount(),
+			vault: getNextAccount(),
+			userTokens: getNextAccount(),
+			venue: getNextAccount(),
+			identity: getNextAccount(),
+			queue: getNextAccount(),
+			program: getNextAccount(),
+			slotHashes: getNextAccount(),
+			tokenProgram: getNextAccount(),
+			associatedTokenProgram: getNextAccount(),
+			systemProgram: getNextAccount()
+		},
+		data: getBuyPackInstructionDataDecoder().decode(instruction.data)
+	};
+}
+//#endregion
+//#region src/generated/instructions/deliverDraw.ts
+/**
+* This code was AUTOGENERATED using the Codama library.
+* Please DO NOT EDIT THIS FILE, instead use visitors
+* to add features, then rerun Codama to update it.
+*
+* @see https://github.com/codama-idl/codama
+*/
+const DELIVER_DRAW_DISCRIMINATOR = new Uint8Array([
+	113,
+	181,
+	226,
+	173,
+	237,
+	138,
+	199,
+	51
+]);
+function getDeliverDrawDiscriminatorBytes() {
+	return fixEncoderSize(getBytesEncoder(), 8).encode(DELIVER_DRAW_DISCRIMINATOR);
+}
+function getDeliverDrawInstructionDataEncoder() {
+	return transformEncoder(getStructEncoder([
+		["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+		["randomness", fixEncoderSize(getBytesEncoder(), 32)],
+		["seq", getU64Encoder()]
+	]), (value) => ({
+		...value,
+		discriminator: DELIVER_DRAW_DISCRIMINATOR
+	}));
+}
+function getDeliverDrawInstructionDataDecoder() {
+	return getStructDecoder([
+		["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+		["randomness", fixDecoderSize(getBytesDecoder(), 32)],
+		["seq", getU64Decoder()]
+	]);
+}
+function getDeliverDrawInstructionDataCodec() {
+	return combineCodec(getDeliverDrawInstructionDataEncoder(), getDeliverDrawInstructionDataDecoder());
+}
+async function getDeliverDrawInstructionAsync(input, config) {
+	const programAddress = config?.programAddress ?? "GaBoxR9nYcK1zeu8EvSJVHV3SrYpCFmvbh2MLgobMcUA";
+	const accounts = {
+		oracleIdentity: {
+			value: input.oracleIdentity ?? null,
+			isWritable: false
+		},
+		pool: {
+			value: input.pool ?? null,
+			isWritable: true
+		},
+		draw: {
+			value: input.draw ?? null,
+			isWritable: true
+		},
+		purchaser: {
+			value: input.purchaser ?? null,
+			isWritable: true
+		},
+		mint: {
+			value: input.mint ?? null,
+			isWritable: false
+		},
+		vault: {
+			value: input.vault ?? null,
+			isWritable: true
+		},
+		userTokens: {
+			value: input.userTokens ?? null,
+			isWritable: true
+		},
+		tokenProgram: {
+			value: input.tokenProgram ?? null,
+			isWritable: false
+		}
+	};
+	const args = { ...input };
+	if (!accounts.oracleIdentity.value) accounts.oracleIdentity.value = await getProgramDerivedAddress({
+		programAddress: "Vrf1RNUjXmQGjmQrQLvJHs9SNkvDJEsRVFPkfSQUwGz",
+		seeds: [getBytesEncoder().encode(new Uint8Array([
+			105,
+			100,
+			101,
+			110,
+			116,
+			105,
+			116,
+			121
+		])), getBytesEncoder().encode(new Uint8Array([
+			231,
+			95,
+			177,
+			105,
+			231,
+			174,
+			80,
+			36,
+			228,
+			6,
+			241,
+			195,
+			89,
+			243,
+			52,
+			57,
+			128,
+			219,
+			206,
+			84,
+			115,
+			45,
+			3,
+			217,
+			77,
+			35,
+			38,
+			40,
+			214,
+			248,
+			69,
+			83
+		]))]
+	});
+	if (!accounts.pool.value) accounts.pool.value = await findPoolPda({ mint: getAddressFromResolvedInstructionAccount("mint", accounts.mint.value) }, { programAddress });
+	if (!accounts.draw.value) accounts.draw.value = await findDrawPda({
+		pool: getAddressFromResolvedInstructionAccount("pool", accounts.pool.value),
+		seq: getNonNullResolvedInstructionInput("seq", args.seq)
+	}, { programAddress });
+	if (!accounts.userTokens.value) accounts.userTokens.value = await getProgramDerivedAddress({
+		programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
+		seeds: [
+			getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("purchaser", accounts.purchaser.value)),
+			getBytesEncoder().encode(new Uint8Array([
+				6,
+				221,
+				246,
+				225,
+				215,
+				101,
+				161,
+				147,
+				217,
+				203,
+				225,
+				70,
+				206,
+				235,
+				121,
+				172,
+				28,
+				180,
+				133,
+				237,
+				95,
+				91,
+				55,
+				145,
+				58,
+				140,
+				245,
+				133,
+				126,
+				255,
+				0,
+				169
+			])),
+			getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("mint", accounts.mint.value))
+		]
+	});
+	if (!accounts.tokenProgram.value) accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+	const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+	return Object.freeze({
+		accounts: [
+			getAccountMeta("oracleIdentity", accounts.oracleIdentity),
+			getAccountMeta("pool", accounts.pool),
+			getAccountMeta("draw", accounts.draw),
+			getAccountMeta("purchaser", accounts.purchaser),
+			getAccountMeta("mint", accounts.mint),
+			getAccountMeta("vault", accounts.vault),
+			getAccountMeta("userTokens", accounts.userTokens),
+			getAccountMeta("tokenProgram", accounts.tokenProgram)
+		],
+		data: getDeliverDrawInstructionDataEncoder().encode(args),
+		programAddress
+	});
+}
+function getDeliverDrawInstruction(input, config) {
+	const programAddress = config?.programAddress ?? "GaBoxR9nYcK1zeu8EvSJVHV3SrYpCFmvbh2MLgobMcUA";
+	const accounts = {
+		oracleIdentity: {
+			value: input.oracleIdentity ?? null,
+			isWritable: false
+		},
+		pool: {
+			value: input.pool ?? null,
+			isWritable: true
+		},
+		draw: {
+			value: input.draw ?? null,
+			isWritable: true
+		},
+		purchaser: {
+			value: input.purchaser ?? null,
+			isWritable: true
+		},
+		mint: {
+			value: input.mint ?? null,
+			isWritable: false
+		},
+		vault: {
+			value: input.vault ?? null,
+			isWritable: true
+		},
+		userTokens: {
+			value: input.userTokens ?? null,
+			isWritable: true
+		},
+		tokenProgram: {
+			value: input.tokenProgram ?? null,
+			isWritable: false
+		}
+	};
+	const args = { ...input };
+	if (!accounts.tokenProgram.value) accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+	const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+	return Object.freeze({
+		accounts: [
+			getAccountMeta("oracleIdentity", accounts.oracleIdentity),
+			getAccountMeta("pool", accounts.pool),
+			getAccountMeta("draw", accounts.draw),
+			getAccountMeta("purchaser", accounts.purchaser),
+			getAccountMeta("mint", accounts.mint),
+			getAccountMeta("vault", accounts.vault),
+			getAccountMeta("userTokens", accounts.userTokens),
+			getAccountMeta("tokenProgram", accounts.tokenProgram)
+		],
+		data: getDeliverDrawInstructionDataEncoder().encode(args),
+		programAddress
+	});
+}
+function parseDeliverDrawInstruction(instruction) {
+	if (instruction.accounts.length < 8) throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+		actualAccountMetas: instruction.accounts.length,
+		expectedAccountMetas: 8
+	});
+	let accountIndex = 0;
+	const getNextAccount = () => {
+		const accountMeta = instruction.accounts[accountIndex];
+		accountIndex += 1;
+		return accountMeta;
+	};
+	return {
+		programAddress: instruction.programAddress,
+		accounts: {
+			oracleIdentity: getNextAccount(),
+			pool: getNextAccount(),
+			draw: getNextAccount(),
+			purchaser: getNextAccount(),
+			mint: getNextAccount(),
+			vault: getNextAccount(),
+			userTokens: getNextAccount(),
+			tokenProgram: getNextAccount()
+		},
+		data: getDeliverDrawInstructionDataDecoder().decode(instruction.data)
+	};
+}
+//#endregion
+//#region src/generated/instructions/expireDraw.ts
+/**
+* This code was AUTOGENERATED using the Codama library.
+* Please DO NOT EDIT THIS FILE, instead use visitors
+* to add features, then rerun Codama to update it.
+*
+* @see https://github.com/codama-idl/codama
+*/
+const EXPIRE_DRAW_DISCRIMINATOR = new Uint8Array([
+	100,
+	119,
+	235,
+	75,
+	8,
+	25,
+	252,
+	255
+]);
+function getExpireDrawDiscriminatorBytes() {
+	return fixEncoderSize(getBytesEncoder(), 8).encode(EXPIRE_DRAW_DISCRIMINATOR);
+}
+function getExpireDrawInstructionDataEncoder() {
+	return transformEncoder(getStructEncoder([["discriminator", fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({
+		...value,
+		discriminator: EXPIRE_DRAW_DISCRIMINATOR
+	}));
+}
+function getExpireDrawInstructionDataDecoder() {
+	return getStructDecoder([["discriminator", fixDecoderSize(getBytesDecoder(), 8)]]);
+}
+function getExpireDrawInstructionDataCodec() {
+	return combineCodec(getExpireDrawInstructionDataEncoder(), getExpireDrawInstructionDataDecoder());
+}
+async function getExpireDrawInstructionAsync(input, config) {
+	const programAddress = config?.programAddress ?? "GaBoxR9nYcK1zeu8EvSJVHV3SrYpCFmvbh2MLgobMcUA";
+	const accounts = {
+		pool: {
+			value: input.pool ?? null,
+			isWritable: true
+		},
+		draw: {
+			value: input.draw ?? null,
+			isWritable: true
+		},
+		purchaser: {
+			value: input.purchaser ?? null,
+			isWritable: true
+		},
+		mint: {
+			value: input.mint ?? null,
+			isWritable: false
+		},
+		vault: {
+			value: input.vault ?? null,
+			isWritable: true
+		},
+		userTokens: {
+			value: input.userTokens ?? null,
+			isWritable: true
+		},
+		tokenProgram: {
+			value: input.tokenProgram ?? null,
+			isWritable: false
+		}
+	};
+	if (!accounts.pool.value) accounts.pool.value = await findPoolPda({ mint: getAddressFromResolvedInstructionAccount("mint", accounts.mint.value) }, { programAddress });
+	if (!accounts.userTokens.value) accounts.userTokens.value = await getProgramDerivedAddress({
+		programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
+		seeds: [
+			getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("purchaser", accounts.purchaser.value)),
+			getBytesEncoder().encode(new Uint8Array([
+				6,
+				221,
+				246,
+				225,
+				215,
+				101,
+				161,
+				147,
+				217,
+				203,
+				225,
+				70,
+				206,
+				235,
+				121,
+				172,
+				28,
+				180,
+				133,
+				237,
+				95,
+				91,
+				55,
+				145,
+				58,
+				140,
+				245,
+				133,
+				126,
+				255,
+				0,
+				169
+			])),
+			getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("mint", accounts.mint.value))
+		]
+	});
+	if (!accounts.tokenProgram.value) accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+	const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+	return Object.freeze({
+		accounts: [
+			getAccountMeta("pool", accounts.pool),
+			getAccountMeta("draw", accounts.draw),
+			getAccountMeta("purchaser", accounts.purchaser),
+			getAccountMeta("mint", accounts.mint),
+			getAccountMeta("vault", accounts.vault),
+			getAccountMeta("userTokens", accounts.userTokens),
+			getAccountMeta("tokenProgram", accounts.tokenProgram)
+		],
+		data: getExpireDrawInstructionDataEncoder().encode({}),
+		programAddress
+	});
+}
+function getExpireDrawInstruction(input, config) {
+	const programAddress = config?.programAddress ?? "GaBoxR9nYcK1zeu8EvSJVHV3SrYpCFmvbh2MLgobMcUA";
+	const accounts = {
+		pool: {
+			value: input.pool ?? null,
+			isWritable: true
+		},
+		draw: {
+			value: input.draw ?? null,
+			isWritable: true
+		},
+		purchaser: {
+			value: input.purchaser ?? null,
+			isWritable: true
+		},
+		mint: {
+			value: input.mint ?? null,
+			isWritable: false
+		},
+		vault: {
+			value: input.vault ?? null,
+			isWritable: true
+		},
+		userTokens: {
+			value: input.userTokens ?? null,
+			isWritable: true
+		},
+		tokenProgram: {
+			value: input.tokenProgram ?? null,
+			isWritable: false
+		}
+	};
+	if (!accounts.tokenProgram.value) accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+	const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+	return Object.freeze({
+		accounts: [
+			getAccountMeta("pool", accounts.pool),
+			getAccountMeta("draw", accounts.draw),
+			getAccountMeta("purchaser", accounts.purchaser),
+			getAccountMeta("mint", accounts.mint),
+			getAccountMeta("vault", accounts.vault),
+			getAccountMeta("userTokens", accounts.userTokens),
+			getAccountMeta("tokenProgram", accounts.tokenProgram)
+		],
+		data: getExpireDrawInstructionDataEncoder().encode({}),
+		programAddress
+	});
+}
+function parseExpireDrawInstruction(instruction) {
+	if (instruction.accounts.length < 7) throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+		actualAccountMetas: instruction.accounts.length,
+		expectedAccountMetas: 7
+	});
+	let accountIndex = 0;
+	const getNextAccount = () => {
+		const accountMeta = instruction.accounts[accountIndex];
+		accountIndex += 1;
+		return accountMeta;
+	};
+	return {
+		programAddress: instruction.programAddress,
+		accounts: {
+			pool: getNextAccount(),
+			draw: getNextAccount(),
+			purchaser: getNextAccount(),
+			mint: getNextAccount(),
+			vault: getNextAccount(),
+			userTokens: getNextAccount(),
+			tokenProgram: getNextAccount()
+		},
+		data: getExpireDrawInstructionDataDecoder().decode(instruction.data)
+	};
+}
+//#endregion
+//#region src/generated/instructions/fundPrizes.ts
+/**
+* This code was AUTOGENERATED using the Codama library.
+* Please DO NOT EDIT THIS FILE, instead use visitors
+* to add features, then rerun Codama to update it.
+*
+* @see https://github.com/codama-idl/codama
+*/
+const FUND_PRIZES_DISCRIMINATOR = new Uint8Array([
+	163,
+	225,
+	193,
+	125,
+	144,
+	171,
+	29,
+	241
+]);
+function getFundPrizesDiscriminatorBytes() {
+	return fixEncoderSize(getBytesEncoder(), 8).encode(FUND_PRIZES_DISCRIMINATOR);
+}
+function getFundPrizesInstructionDataEncoder() {
+	return transformEncoder(getStructEncoder([["discriminator", fixEncoderSize(getBytesEncoder(), 8)], ["amount", getU64Encoder()]]), (value) => ({
+		...value,
+		discriminator: FUND_PRIZES_DISCRIMINATOR
+	}));
+}
+function getFundPrizesInstructionDataDecoder() {
+	return getStructDecoder([["discriminator", fixDecoderSize(getBytesDecoder(), 8)], ["amount", getU64Decoder()]]);
+}
+function getFundPrizesInstructionDataCodec() {
+	return combineCodec(getFundPrizesInstructionDataEncoder(), getFundPrizesInstructionDataDecoder());
+}
+async function getFundPrizesInstructionAsync(input, config) {
+	const programAddress = config?.programAddress ?? "GaBoxR9nYcK1zeu8EvSJVHV3SrYpCFmvbh2MLgobMcUA";
+	const accounts = {
+		funder: {
+			value: input.funder ?? null,
+			isWritable: false
+		},
+		pool: {
+			value: input.pool ?? null,
+			isWritable: false
+		},
+		mint: {
+			value: input.mint ?? null,
+			isWritable: false
+		},
+		source: {
+			value: input.source ?? null,
+			isWritable: true
+		},
+		vault: {
+			value: input.vault ?? null,
+			isWritable: true
+		},
+		tokenProgram: {
+			value: input.tokenProgram ?? null,
+			isWritable: false
+		}
+	};
+	const args = { ...input };
+	if (!accounts.pool.value) accounts.pool.value = await findPoolPda({ mint: getAddressFromResolvedInstructionAccount("mint", accounts.mint.value) }, { programAddress });
+	if (!accounts.tokenProgram.value) accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+	const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+	return Object.freeze({
+		accounts: [
+			getAccountMeta("funder", accounts.funder),
+			getAccountMeta("pool", accounts.pool),
+			getAccountMeta("mint", accounts.mint),
+			getAccountMeta("source", accounts.source),
+			getAccountMeta("vault", accounts.vault),
+			getAccountMeta("tokenProgram", accounts.tokenProgram)
+		],
+		data: getFundPrizesInstructionDataEncoder().encode(args),
+		programAddress
+	});
+}
+function getFundPrizesInstruction(input, config) {
+	const programAddress = config?.programAddress ?? "GaBoxR9nYcK1zeu8EvSJVHV3SrYpCFmvbh2MLgobMcUA";
+	const accounts = {
+		funder: {
+			value: input.funder ?? null,
+			isWritable: false
+		},
+		pool: {
+			value: input.pool ?? null,
+			isWritable: false
+		},
+		mint: {
+			value: input.mint ?? null,
+			isWritable: false
+		},
+		source: {
+			value: input.source ?? null,
+			isWritable: true
+		},
+		vault: {
+			value: input.vault ?? null,
+			isWritable: true
+		},
+		tokenProgram: {
+			value: input.tokenProgram ?? null,
+			isWritable: false
+		}
+	};
+	const args = { ...input };
+	if (!accounts.tokenProgram.value) accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+	const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+	return Object.freeze({
+		accounts: [
+			getAccountMeta("funder", accounts.funder),
+			getAccountMeta("pool", accounts.pool),
+			getAccountMeta("mint", accounts.mint),
+			getAccountMeta("source", accounts.source),
+			getAccountMeta("vault", accounts.vault),
+			getAccountMeta("tokenProgram", accounts.tokenProgram)
+		],
+		data: getFundPrizesInstructionDataEncoder().encode(args),
+		programAddress
+	});
+}
+function parseFundPrizesInstruction(instruction) {
+	if (instruction.accounts.length < 6) throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+		actualAccountMetas: instruction.accounts.length,
+		expectedAccountMetas: 6
+	});
+	let accountIndex = 0;
+	const getNextAccount = () => {
+		const accountMeta = instruction.accounts[accountIndex];
+		accountIndex += 1;
+		return accountMeta;
+	};
+	return {
+		programAddress: instruction.programAddress,
+		accounts: {
+			funder: getNextAccount(),
+			pool: getNextAccount(),
+			mint: getNextAccount(),
+			source: getNextAccount(),
+			vault: getNextAccount(),
+			tokenProgram: getNextAccount()
+		},
+		data: getFundPrizesInstructionDataDecoder().decode(instruction.data)
+	};
+}
+//#endregion
+//#region src/generated/instructions/initializePool.ts
+/**
+* This code was AUTOGENERATED using the Codama library.
+* Please DO NOT EDIT THIS FILE, instead use visitors
+* to add features, then rerun Codama to update it.
+*
+* @see https://github.com/codama-idl/codama
+*/
+const INITIALIZE_POOL_DISCRIMINATOR = new Uint8Array([
+	95,
+	180,
+	10,
+	172,
+	84,
+	174,
+	232,
+	40
+]);
+function getInitializePoolDiscriminatorBytes() {
+	return fixEncoderSize(getBytesEncoder(), 8).encode(INITIALIZE_POOL_DISCRIMINATOR);
+}
+function getInitializePoolInstructionDataEncoder() {
+	return transformEncoder(getStructEncoder([
+		["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+		["tiers", getArrayEncoder(getTierEncoder(), { size: 8 })],
+		["maxSeedQuoteIn", getU64Encoder()],
+		["maxSeedNativeDebit", getU64Encoder()],
+		["extraSeedTokens", getU64Encoder()]
+	]), (value) => ({
+		...value,
+		discriminator: INITIALIZE_POOL_DISCRIMINATOR
+	}));
+}
+function getInitializePoolInstructionDataDecoder() {
+	return getStructDecoder([
+		["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+		["tiers", getArrayDecoder(getTierDecoder(), { size: 8 })],
+		["maxSeedQuoteIn", getU64Decoder()],
+		["maxSeedNativeDebit", getU64Decoder()],
+		["extraSeedTokens", getU64Decoder()]
+	]);
+}
+function getInitializePoolInstructionDataCodec() {
+	return combineCodec(getInitializePoolInstructionDataEncoder(), getInitializePoolInstructionDataDecoder());
+}
+async function getInitializePoolInstructionAsync(input, config) {
+	const programAddress = config?.programAddress ?? "GaBoxR9nYcK1zeu8EvSJVHV3SrYpCFmvbh2MLgobMcUA";
+	const accounts = {
+		creator: {
+			value: input.creator ?? null,
+			isWritable: true
+		},
+		pool: {
+			value: input.pool ?? null,
+			isWritable: true
+		},
+		mint: {
+			value: input.mint ?? null,
+			isWritable: false
+		},
+		quoteMint: {
+			value: input.quoteMint ?? null,
+			isWritable: false
+		},
+		creatorTokens: {
+			value: input.creatorTokens ?? null,
+			isWritable: true
+		},
+		vault: {
+			value: input.vault ?? null,
+			isWritable: true
+		},
+		venue: {
+			value: input.venue ?? null,
+			isWritable: false
+		},
+		instructions: {
+			value: input.instructions ?? null,
+			isWritable: false
+		},
+		tokenProgram: {
+			value: input.tokenProgram ?? null,
+			isWritable: false
+		},
+		associatedTokenProgram: {
+			value: input.associatedTokenProgram ?? null,
+			isWritable: false
+		},
+		systemProgram: {
+			value: input.systemProgram ?? null,
+			isWritable: false
+		}
+	};
+	const args = { ...input };
+	if (!accounts.pool.value) accounts.pool.value = await findPoolPda({ mint: getAddressFromResolvedInstructionAccount("mint", accounts.mint.value) }, { programAddress });
+	if (!accounts.creatorTokens.value) accounts.creatorTokens.value = await getProgramDerivedAddress({
+		programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
+		seeds: [
+			getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("creator", accounts.creator.value)),
+			getBytesEncoder().encode(new Uint8Array([
+				6,
+				221,
+				246,
+				225,
+				215,
+				101,
+				161,
+				147,
+				217,
+				203,
+				225,
+				70,
+				206,
+				235,
+				121,
+				172,
+				28,
+				180,
+				133,
+				237,
+				95,
+				91,
+				55,
+				145,
+				58,
+				140,
+				245,
+				133,
+				126,
+				255,
+				0,
+				169
+			])),
+			getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("mint", accounts.mint.value))
+		]
+	});
+	if (!accounts.vault.value) accounts.vault.value = await getProgramDerivedAddress({
+		programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
+		seeds: [
+			getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("pool", accounts.pool.value)),
+			getBytesEncoder().encode(new Uint8Array([
+				6,
+				221,
+				246,
+				225,
+				215,
+				101,
+				161,
+				147,
+				217,
+				203,
+				225,
+				70,
+				206,
+				235,
+				121,
+				172,
+				28,
+				180,
+				133,
+				237,
+				95,
+				91,
+				55,
+				145,
+				58,
+				140,
+				245,
+				133,
+				126,
+				255,
+				0,
+				169
+			])),
+			getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("mint", accounts.mint.value))
+		]
+	});
+	if (!accounts.venue.value) accounts.venue.value = "DRay6fNdQ5J82H7xV6uq2aV3mNrUZ1J4PgSKsWgptcm6";
+	if (!accounts.instructions.value) accounts.instructions.value = "Sysvar1nstructions1111111111111111111111111";
+	if (!accounts.tokenProgram.value) accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+	if (!accounts.associatedTokenProgram.value) accounts.associatedTokenProgram.value = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+	if (!accounts.systemProgram.value) accounts.systemProgram.value = "11111111111111111111111111111111";
+	const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+	return Object.freeze({
+		accounts: [
+			getAccountMeta("creator", accounts.creator),
+			getAccountMeta("pool", accounts.pool),
+			getAccountMeta("mint", accounts.mint),
+			getAccountMeta("quoteMint", accounts.quoteMint),
+			getAccountMeta("creatorTokens", accounts.creatorTokens),
+			getAccountMeta("vault", accounts.vault),
+			getAccountMeta("venue", accounts.venue),
+			getAccountMeta("instructions", accounts.instructions),
+			getAccountMeta("tokenProgram", accounts.tokenProgram),
+			getAccountMeta("associatedTokenProgram", accounts.associatedTokenProgram),
+			getAccountMeta("systemProgram", accounts.systemProgram)
+		],
+		data: getInitializePoolInstructionDataEncoder().encode(args),
+		programAddress
+	});
+}
+function getInitializePoolInstruction(input, config) {
+	const programAddress = config?.programAddress ?? "GaBoxR9nYcK1zeu8EvSJVHV3SrYpCFmvbh2MLgobMcUA";
+	const accounts = {
+		creator: {
+			value: input.creator ?? null,
+			isWritable: true
+		},
+		pool: {
+			value: input.pool ?? null,
+			isWritable: true
+		},
+		mint: {
+			value: input.mint ?? null,
+			isWritable: false
+		},
+		quoteMint: {
+			value: input.quoteMint ?? null,
+			isWritable: false
+		},
+		creatorTokens: {
+			value: input.creatorTokens ?? null,
+			isWritable: true
+		},
+		vault: {
+			value: input.vault ?? null,
+			isWritable: true
+		},
+		venue: {
+			value: input.venue ?? null,
+			isWritable: false
+		},
+		instructions: {
+			value: input.instructions ?? null,
+			isWritable: false
+		},
+		tokenProgram: {
+			value: input.tokenProgram ?? null,
+			isWritable: false
+		},
+		associatedTokenProgram: {
+			value: input.associatedTokenProgram ?? null,
+			isWritable: false
+		},
+		systemProgram: {
+			value: input.systemProgram ?? null,
+			isWritable: false
+		}
+	};
+	const args = { ...input };
+	if (!accounts.venue.value) accounts.venue.value = "DRay6fNdQ5J82H7xV6uq2aV3mNrUZ1J4PgSKsWgptcm6";
+	if (!accounts.instructions.value) accounts.instructions.value = "Sysvar1nstructions1111111111111111111111111";
+	if (!accounts.tokenProgram.value) accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+	if (!accounts.associatedTokenProgram.value) accounts.associatedTokenProgram.value = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+	if (!accounts.systemProgram.value) accounts.systemProgram.value = "11111111111111111111111111111111";
+	const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+	return Object.freeze({
+		accounts: [
+			getAccountMeta("creator", accounts.creator),
+			getAccountMeta("pool", accounts.pool),
+			getAccountMeta("mint", accounts.mint),
+			getAccountMeta("quoteMint", accounts.quoteMint),
+			getAccountMeta("creatorTokens", accounts.creatorTokens),
+			getAccountMeta("vault", accounts.vault),
+			getAccountMeta("venue", accounts.venue),
+			getAccountMeta("instructions", accounts.instructions),
+			getAccountMeta("tokenProgram", accounts.tokenProgram),
+			getAccountMeta("associatedTokenProgram", accounts.associatedTokenProgram),
+			getAccountMeta("systemProgram", accounts.systemProgram)
+		],
+		data: getInitializePoolInstructionDataEncoder().encode(args),
+		programAddress
+	});
+}
+function parseInitializePoolInstruction(instruction) {
+	if (instruction.accounts.length < 11) throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+		actualAccountMetas: instruction.accounts.length,
+		expectedAccountMetas: 11
+	});
+	let accountIndex = 0;
+	const getNextAccount = () => {
+		const accountMeta = instruction.accounts[accountIndex];
+		accountIndex += 1;
+		return accountMeta;
+	};
+	return {
+		programAddress: instruction.programAddress,
+		accounts: {
+			creator: getNextAccount(),
+			pool: getNextAccount(),
+			mint: getNextAccount(),
+			quoteMint: getNextAccount(),
+			creatorTokens: getNextAccount(),
+			vault: getNextAccount(),
+			venue: getNextAccount(),
+			instructions: getNextAccount(),
+			tokenProgram: getNextAccount(),
+			associatedTokenProgram: getNextAccount(),
+			systemProgram: getNextAccount()
+		},
+		data: getInitializePoolInstructionDataDecoder().decode(instruction.data)
+	};
+}
+//#endregion
+//#region src/generated/instructions/retryDraw.ts
+/**
+* This code was AUTOGENERATED using the Codama library.
+* Please DO NOT EDIT THIS FILE, instead use visitors
+* to add features, then rerun Codama to update it.
+*
+* @see https://github.com/codama-idl/codama
+*/
+const RETRY_DRAW_DISCRIMINATOR = new Uint8Array([
+	112,
+	118,
+	137,
+	120,
+	211,
+	39,
+	196,
+	96
+]);
+function getRetryDrawDiscriminatorBytes() {
+	return fixEncoderSize(getBytesEncoder(), 8).encode(RETRY_DRAW_DISCRIMINATOR);
+}
+function getRetryDrawInstructionDataEncoder() {
+	return transformEncoder(getStructEncoder([["discriminator", fixEncoderSize(getBytesEncoder(), 8)], ["maxVrfDebit", getU64Encoder()]]), (value) => ({
+		...value,
+		discriminator: RETRY_DRAW_DISCRIMINATOR
+	}));
+}
+function getRetryDrawInstructionDataDecoder() {
+	return getStructDecoder([["discriminator", fixDecoderSize(getBytesDecoder(), 8)], ["maxVrfDebit", getU64Decoder()]]);
+}
+function getRetryDrawInstructionDataCodec() {
+	return combineCodec(getRetryDrawInstructionDataEncoder(), getRetryDrawInstructionDataDecoder());
+}
+async function getRetryDrawInstructionAsync(input, config) {
+	const programAddress = config?.programAddress ?? "GaBoxR9nYcK1zeu8EvSJVHV3SrYpCFmvbh2MLgobMcUA";
+	const accounts = {
+		payer: {
+			value: input.payer ?? null,
+			isWritable: true
+		},
+		pool: {
+			value: input.pool ?? null,
+			isWritable: false
+		},
+		draw: {
+			value: input.draw ?? null,
+			isWritable: true
+		},
+		identity: {
+			value: input.identity ?? null,
+			isWritable: false
+		},
+		queue: {
+			value: input.queue ?? null,
+			isWritable: true
+		},
+		program: {
+			value: input.program ?? null,
+			isWritable: false
+		},
+		slotHashes: {
+			value: input.slotHashes ?? null,
+			isWritable: false
+		},
+		systemProgram: {
+			value: input.systemProgram ?? null,
+			isWritable: false
+		}
+	};
+	const args = { ...input };
+	if (!accounts.identity.value) accounts.identity.value = await findIdentityPda({ programAddress });
+	if (!accounts.queue.value) accounts.queue.value = "Cuj97ggrhhidhbu39TijNVqE74xvKJ69gDervRUXAxGh";
+	if (!accounts.program.value) accounts.program.value = "Vrf1RNUjXmQGjmQrQLvJHs9SNkvDJEsRVFPkfSQUwGz";
+	if (!accounts.slotHashes.value) accounts.slotHashes.value = "SysvarS1otHashes111111111111111111111111111";
+	if (!accounts.systemProgram.value) accounts.systemProgram.value = "11111111111111111111111111111111";
+	const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+	return Object.freeze({
+		accounts: [
+			getAccountMeta("payer", accounts.payer),
+			getAccountMeta("pool", accounts.pool),
+			getAccountMeta("draw", accounts.draw),
+			getAccountMeta("identity", accounts.identity),
+			getAccountMeta("queue", accounts.queue),
+			getAccountMeta("program", accounts.program),
+			getAccountMeta("slotHashes", accounts.slotHashes),
+			getAccountMeta("systemProgram", accounts.systemProgram)
+		],
+		data: getRetryDrawInstructionDataEncoder().encode(args),
+		programAddress
+	});
+}
+function getRetryDrawInstruction(input, config) {
+	const programAddress = config?.programAddress ?? "GaBoxR9nYcK1zeu8EvSJVHV3SrYpCFmvbh2MLgobMcUA";
+	const accounts = {
+		payer: {
+			value: input.payer ?? null,
+			isWritable: true
+		},
+		pool: {
+			value: input.pool ?? null,
+			isWritable: false
+		},
+		draw: {
+			value: input.draw ?? null,
+			isWritable: true
+		},
+		identity: {
+			value: input.identity ?? null,
+			isWritable: false
+		},
+		queue: {
+			value: input.queue ?? null,
+			isWritable: true
+		},
+		program: {
+			value: input.program ?? null,
+			isWritable: false
+		},
+		slotHashes: {
+			value: input.slotHashes ?? null,
+			isWritable: false
+		},
+		systemProgram: {
+			value: input.systemProgram ?? null,
+			isWritable: false
+		}
+	};
+	const args = { ...input };
+	if (!accounts.queue.value) accounts.queue.value = "Cuj97ggrhhidhbu39TijNVqE74xvKJ69gDervRUXAxGh";
+	if (!accounts.program.value) accounts.program.value = "Vrf1RNUjXmQGjmQrQLvJHs9SNkvDJEsRVFPkfSQUwGz";
+	if (!accounts.slotHashes.value) accounts.slotHashes.value = "SysvarS1otHashes111111111111111111111111111";
+	if (!accounts.systemProgram.value) accounts.systemProgram.value = "11111111111111111111111111111111";
+	const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+	return Object.freeze({
+		accounts: [
+			getAccountMeta("payer", accounts.payer),
+			getAccountMeta("pool", accounts.pool),
+			getAccountMeta("draw", accounts.draw),
+			getAccountMeta("identity", accounts.identity),
+			getAccountMeta("queue", accounts.queue),
+			getAccountMeta("program", accounts.program),
+			getAccountMeta("slotHashes", accounts.slotHashes),
+			getAccountMeta("systemProgram", accounts.systemProgram)
+		],
+		data: getRetryDrawInstructionDataEncoder().encode(args),
+		programAddress
+	});
+}
+function parseRetryDrawInstruction(instruction) {
+	if (instruction.accounts.length < 8) throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+		actualAccountMetas: instruction.accounts.length,
+		expectedAccountMetas: 8
+	});
+	let accountIndex = 0;
+	const getNextAccount = () => {
+		const accountMeta = instruction.accounts[accountIndex];
+		accountIndex += 1;
+		return accountMeta;
+	};
+	return {
+		programAddress: instruction.programAddress,
+		accounts: {
+			payer: getNextAccount(),
+			pool: getNextAccount(),
+			draw: getNextAccount(),
+			identity: getNextAccount(),
+			queue: getNextAccount(),
+			program: getNextAccount(),
+			slotHashes: getNextAccount(),
+			systemProgram: getNextAccount()
+		},
+		data: getRetryDrawInstructionDataDecoder().decode(instruction.data)
+	};
+}
+//#endregion
+//#region src/generated/instructions/sellTokens.ts
+/**
+* This code was AUTOGENERATED using the Codama library.
+* Please DO NOT EDIT THIS FILE, instead use visitors
+* to add features, then rerun Codama to update it.
+*
+* @see https://github.com/codama-idl/codama
+*/
+const SELL_TOKENS_DISCRIMINATOR = new Uint8Array([
+	114,
+	242,
+	25,
+	12,
+	62,
+	126,
+	92,
+	2
+]);
+function getSellTokensDiscriminatorBytes() {
+	return fixEncoderSize(getBytesEncoder(), 8).encode(SELL_TOKENS_DISCRIMINATOR);
+}
+function getSellTokensInstructionDataEncoder() {
+	return transformEncoder(getStructEncoder([
+		["discriminator", fixEncoderSize(getBytesEncoder(), 8)],
+		["amount", getU64Encoder()],
+		["minQuoteOutput", getU64Encoder()],
+		["maxNativeDebit", getU64Encoder()]
+	]), (value) => ({
+		...value,
+		discriminator: SELL_TOKENS_DISCRIMINATOR
+	}));
+}
+function getSellTokensInstructionDataDecoder() {
+	return getStructDecoder([
+		["discriminator", fixDecoderSize(getBytesDecoder(), 8)],
+		["amount", getU64Decoder()],
+		["minQuoteOutput", getU64Decoder()],
+		["maxNativeDebit", getU64Decoder()]
+	]);
+}
+function getSellTokensInstructionDataCodec() {
+	return combineCodec(getSellTokensInstructionDataEncoder(), getSellTokensInstructionDataDecoder());
+}
+async function getSellTokensInstructionAsync(input, config) {
+	const programAddress = config?.programAddress ?? "GaBoxR9nYcK1zeu8EvSJVHV3SrYpCFmvbh2MLgobMcUA";
+	const accounts = {
+		seller: {
+			value: input.seller ?? null,
+			isWritable: true
+		},
+		pool: {
+			value: input.pool ?? null,
+			isWritable: false
+		},
+		mint: {
+			value: input.mint ?? null,
+			isWritable: false
+		},
+		quoteMint: {
+			value: input.quoteMint ?? null,
+			isWritable: false
+		},
+		userTokens: {
+			value: input.userTokens ?? null,
+			isWritable: true
+		},
+		venue: {
+			value: input.venue ?? null,
+			isWritable: false
+		},
+		tokenProgram: {
+			value: input.tokenProgram ?? null,
+			isWritable: false
+		}
+	};
+	const args = { ...input };
+	if (!accounts.pool.value) accounts.pool.value = await findPoolPda({ mint: getAddressFromResolvedInstructionAccount("mint", accounts.mint.value) }, { programAddress });
+	if (!accounts.userTokens.value) accounts.userTokens.value = await getProgramDerivedAddress({
+		programAddress: "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL",
+		seeds: [
+			getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("seller", accounts.seller.value)),
+			getBytesEncoder().encode(new Uint8Array([
+				6,
+				221,
+				246,
+				225,
+				215,
+				101,
+				161,
+				147,
+				217,
+				203,
+				225,
+				70,
+				206,
+				235,
+				121,
+				172,
+				28,
+				180,
+				133,
+				237,
+				95,
+				91,
+				55,
+				145,
+				58,
+				140,
+				245,
+				133,
+				126,
+				255,
+				0,
+				169
+			])),
+			getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("mint", accounts.mint.value))
+		]
+	});
+	if (!accounts.tokenProgram.value) accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+	const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+	return Object.freeze({
+		accounts: [
+			getAccountMeta("seller", accounts.seller),
+			getAccountMeta("pool", accounts.pool),
+			getAccountMeta("mint", accounts.mint),
+			getAccountMeta("quoteMint", accounts.quoteMint),
+			getAccountMeta("userTokens", accounts.userTokens),
+			getAccountMeta("venue", accounts.venue),
+			getAccountMeta("tokenProgram", accounts.tokenProgram)
+		],
+		data: getSellTokensInstructionDataEncoder().encode(args),
+		programAddress
+	});
+}
+function getSellTokensInstruction(input, config) {
+	const programAddress = config?.programAddress ?? "GaBoxR9nYcK1zeu8EvSJVHV3SrYpCFmvbh2MLgobMcUA";
+	const accounts = {
+		seller: {
+			value: input.seller ?? null,
+			isWritable: true
+		},
+		pool: {
+			value: input.pool ?? null,
+			isWritable: false
+		},
+		mint: {
+			value: input.mint ?? null,
+			isWritable: false
+		},
+		quoteMint: {
+			value: input.quoteMint ?? null,
+			isWritable: false
+		},
+		userTokens: {
+			value: input.userTokens ?? null,
+			isWritable: true
+		},
+		venue: {
+			value: input.venue ?? null,
+			isWritable: false
+		},
+		tokenProgram: {
+			value: input.tokenProgram ?? null,
+			isWritable: false
+		}
+	};
+	const args = { ...input };
+	if (!accounts.tokenProgram.value) accounts.tokenProgram.value = "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA";
+	const getAccountMeta = getAccountMetaFactory(programAddress, "programId");
+	return Object.freeze({
+		accounts: [
+			getAccountMeta("seller", accounts.seller),
+			getAccountMeta("pool", accounts.pool),
+			getAccountMeta("mint", accounts.mint),
+			getAccountMeta("quoteMint", accounts.quoteMint),
+			getAccountMeta("userTokens", accounts.userTokens),
+			getAccountMeta("venue", accounts.venue),
+			getAccountMeta("tokenProgram", accounts.tokenProgram)
+		],
+		data: getSellTokensInstructionDataEncoder().encode(args),
+		programAddress
+	});
+}
+function parseSellTokensInstruction(instruction) {
+	if (instruction.accounts.length < 7) throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, {
+		actualAccountMetas: instruction.accounts.length,
+		expectedAccountMetas: 7
+	});
+	let accountIndex = 0;
+	const getNextAccount = () => {
+		const accountMeta = instruction.accounts[accountIndex];
+		accountIndex += 1;
+		return accountMeta;
+	};
+	return {
+		programAddress: instruction.programAddress,
+		accounts: {
+			seller: getNextAccount(),
+			pool: getNextAccount(),
+			mint: getNextAccount(),
+			quoteMint: getNextAccount(),
+			userTokens: getNextAccount(),
+			venue: getNextAccount(),
+			tokenProgram: getNextAccount()
+		},
+		data: getSellTokensInstructionDataDecoder().decode(instruction.data)
+	};
+}
+//#endregion
+//#region src/generated/programs/gabox.ts
+/**
+* This code was AUTOGENERATED using the Codama library.
+* Please DO NOT EDIT THIS FILE, instead use visitors
+* to add features, then rerun Codama to update it.
+*
+* @see https://github.com/codama-idl/codama
+*/
+const GABOX_PROGRAM_ADDRESS = "GaBoxR9nYcK1zeu8EvSJVHV3SrYpCFmvbh2MLgobMcUA";
+let GaboxAccount = /* @__PURE__ */ function(GaboxAccount) {
+	GaboxAccount[GaboxAccount["Draw"] = 0] = "Draw";
+	GaboxAccount[GaboxAccount["Pool"] = 1] = "Pool";
+	GaboxAccount[GaboxAccount["WalletActivity"] = 2] = "WalletActivity";
+	return GaboxAccount;
+}({});
+function identifyGaboxAccount(account) {
+	const data = "data" in account ? account.data : account;
+	if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([
+		101,
+		31,
+		52,
+		179,
+		121,
+		78,
+		252,
+		89
+	])), 0)) return 0;
+	if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([
+		140,
+		230,
+		142,
+		167,
+		14,
+		202,
+		43,
+		254
+	])), 0)) return 1;
+	if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([
+		212,
+		80,
+		180,
+		131,
+		173,
+		1,
+		252,
+		141
+	])), 0)) return 2;
+	throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT, {
+		accountData: data,
+		programName: "gabox"
+	});
+}
+let GaboxEvent = /* @__PURE__ */ function(GaboxEvent) {
+	GaboxEvent[GaboxEvent["DrawResolved"] = 0] = "DrawResolved";
+	GaboxEvent[GaboxEvent["PackBought"] = 1] = "PackBought";
+	GaboxEvent[GaboxEvent["PoolCreated"] = 2] = "PoolCreated";
+	GaboxEvent[GaboxEvent["PrizesFunded"] = 3] = "PrizesFunded";
+	GaboxEvent[GaboxEvent["RandomnessRetried"] = 4] = "RandomnessRetried";
+	GaboxEvent[GaboxEvent["TokensSold"] = 5] = "TokensSold";
+	return GaboxEvent;
+}({});
+function identifyGaboxEvent(event) {
+	const data = "data" in event ? event.data : event;
+	if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([
+		127,
+		177,
+		62,
+		146,
+		164,
+		90,
+		185,
+		218
+	])), 0)) return 0;
+	if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([
+		220,
+		208,
+		74,
+		75,
+		42,
+		144,
+		231,
+		69
+	])), 0)) return 1;
+	if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([
+		202,
+		44,
+		41,
+		88,
+		104,
+		220,
+		157,
+		82
+	])), 0)) return 2;
+	if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([
+		188,
+		129,
+		185,
+		44,
+		234,
+		71,
+		53,
+		60
+	])), 0)) return 3;
+	if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([
+		243,
+		30,
+		148,
+		22,
+		14,
+		127,
+		52,
+		140
+	])), 0)) return 4;
+	if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([
+		217,
+		83,
+		68,
+		137,
+		134,
+		225,
+		94,
+		45
+	])), 0)) return 5;
+	throw new Error("The provided event could not be identified as a gabox event.");
+}
+let GaboxInstruction = /* @__PURE__ */ function(GaboxInstruction) {
+	GaboxInstruction[GaboxInstruction["BuyPack"] = 0] = "BuyPack";
+	GaboxInstruction[GaboxInstruction["DeliverDraw"] = 1] = "DeliverDraw";
+	GaboxInstruction[GaboxInstruction["ExpireDraw"] = 2] = "ExpireDraw";
+	GaboxInstruction[GaboxInstruction["FundPrizes"] = 3] = "FundPrizes";
+	GaboxInstruction[GaboxInstruction["InitializePool"] = 4] = "InitializePool";
+	GaboxInstruction[GaboxInstruction["RetryDraw"] = 5] = "RetryDraw";
+	GaboxInstruction[GaboxInstruction["SellTokens"] = 6] = "SellTokens";
+	return GaboxInstruction;
+}({});
+function identifyGaboxInstruction(instruction) {
+	const data = "data" in instruction ? instruction.data : instruction;
+	if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([
+		151,
+		46,
+		141,
+		93,
+		174,
+		5,
+		49,
+		173
+	])), 0)) return 0;
+	if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([
+		113,
+		181,
+		226,
+		173,
+		237,
+		138,
+		199,
+		51
+	])), 0)) return 1;
+	if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([
+		100,
+		119,
+		235,
+		75,
+		8,
+		25,
+		252,
+		255
+	])), 0)) return 2;
+	if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([
+		163,
+		225,
+		193,
+		125,
+		144,
+		171,
+		29,
+		241
+	])), 0)) return 3;
+	if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([
+		95,
+		180,
+		10,
+		172,
+		84,
+		174,
+		232,
+		40
+	])), 0)) return 4;
+	if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([
+		112,
+		118,
+		137,
+		120,
+		211,
+		39,
+		196,
+		96
+	])), 0)) return 5;
+	if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([
+		114,
+		242,
+		25,
+		12,
+		62,
+		126,
+		92,
+		2
+	])), 0)) return 6;
+	throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, {
+		instructionData: data,
+		programName: "gabox"
+	});
+}
+function parseGaboxInstruction(instruction) {
+	const instructionType = identifyGaboxInstruction(instruction);
+	switch (instructionType) {
+		case 0:
+			assertIsInstructionWithAccounts(instruction);
+			return {
+				instructionType: 0,
+				...parseBuyPackInstruction(instruction)
+			};
+		case 1:
+			assertIsInstructionWithAccounts(instruction);
+			return {
+				instructionType: 1,
+				...parseDeliverDrawInstruction(instruction)
+			};
+		case 2:
+			assertIsInstructionWithAccounts(instruction);
+			return {
+				instructionType: 2,
+				...parseExpireDrawInstruction(instruction)
+			};
+		case 3:
+			assertIsInstructionWithAccounts(instruction);
+			return {
+				instructionType: 3,
+				...parseFundPrizesInstruction(instruction)
+			};
+		case 4:
+			assertIsInstructionWithAccounts(instruction);
+			return {
+				instructionType: 4,
+				...parseInitializePoolInstruction(instruction)
+			};
+		case 5:
+			assertIsInstructionWithAccounts(instruction);
+			return {
+				instructionType: 5,
+				...parseRetryDrawInstruction(instruction)
+			};
+		case 6:
+			assertIsInstructionWithAccounts(instruction);
+			return {
+				instructionType: 6,
+				...parseSellTokensInstruction(instruction)
+			};
+		default: throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, {
+			instructionType,
+			programName: "gabox"
+		});
+	}
+}
+function gaboxProgram() {
+	return (client) => {
+		return extendClient(client, { gabox: {
+			accounts: {
+				draw: addSelfFetchFunctions(client, getDrawCodec()),
+				pool: addSelfFetchFunctions(client, getPoolCodec()),
+				walletActivity: addSelfFetchFunctions(client, getWalletActivityCodec())
+			},
+			instructions: {
+				buyPack: (input) => addSelfPlanAndSendFunctions(client, getBuyPackInstructionAsync(input)),
+				deliverDraw: (input) => addSelfPlanAndSendFunctions(client, getDeliverDrawInstructionAsync(input)),
+				expireDraw: (input) => addSelfPlanAndSendFunctions(client, getExpireDrawInstructionAsync(input)),
+				fundPrizes: (input) => addSelfPlanAndSendFunctions(client, getFundPrizesInstructionAsync(input)),
+				initializePool: (input) => addSelfPlanAndSendFunctions(client, getInitializePoolInstructionAsync(input)),
+				retryDraw: (input) => addSelfPlanAndSendFunctions(client, getRetryDrawInstructionAsync({
+					...input,
+					payer: input.payer ?? client.payer
+				})),
+				sellTokens: (input) => addSelfPlanAndSendFunctions(client, getSellTokensInstructionAsync(input))
+			},
+			pdas: {
+				pool: findPoolPda,
+				activity: findActivityPda,
+				identity: findIdentityPda,
+				draw: findDrawPda
+			},
+			identifyAccount: identifyGaboxAccount,
+			identifyInstruction: identifyGaboxInstruction,
+			parseInstruction: parseGaboxInstruction
+		} });
+	};
+}
+//#endregion
 //#region src/generated/events/drawResolved.ts
 /**
 * This code was AUTOGENERATED using the Codama library.
@@ -82,12 +2369,12 @@ function getPackBoughtEventEncoder() {
 		["seq", getU64Encoder()],
 		["purchaser", getAddressEncoder()],
 		["venue", getAddressEncoder()],
+		["quoteMint", getAddressEncoder()],
 		["tokensBought", getU64Encoder()],
-		["venueDebit", getU64Encoder()],
-		["feeLamports", getU64Encoder()],
-		["referralLamports", getU64Encoder()],
-		["protocolLamports", getU64Encoder()],
-		["vrfDebit", getU64Encoder()],
+		["quoteDebit", getU64Encoder()],
+		["nativeDebit", getU64Encoder()],
+		["vrfNativeDebit", getU64Encoder()],
+		["totalNativeDebit", getU64Encoder()],
 		["prizes", getArrayEncoder(getPrizeEncoder(), { size: 8 })]
 	]), [getConstantEncoder(PACK_BOUGHT_EVENT_DISCRIMINATOR)]);
 }
@@ -98,12 +2385,12 @@ function getPackBoughtEventDecoder() {
 		["seq", getU64Decoder()],
 		["purchaser", getAddressDecoder()],
 		["venue", getAddressDecoder()],
+		["quoteMint", getAddressDecoder()],
 		["tokensBought", getU64Decoder()],
-		["venueDebit", getU64Decoder()],
-		["feeLamports", getU64Decoder()],
-		["referralLamports", getU64Decoder()],
-		["protocolLamports", getU64Decoder()],
-		["vrfDebit", getU64Decoder()],
+		["quoteDebit", getU64Decoder()],
+		["nativeDebit", getU64Decoder()],
+		["vrfNativeDebit", getU64Decoder()],
+		["totalNativeDebit", getU64Decoder()],
 		["prizes", getArrayDecoder(getPrizeDecoder(), { size: 8 })]
 	]), [getConstantDecoder(PACK_BOUGHT_EVENT_DISCRIMINATOR)]);
 }
@@ -145,10 +2432,12 @@ function getPoolCreatedEventEncoder() {
 		["mint", getAddressEncoder()],
 		["creator", getAddressEncoder()],
 		["packTokens", getU64Encoder()],
-		["feeBps", getU16Encoder()],
 		["tiers", getArrayEncoder(getTierEncoder(), { size: 8 })],
 		["seedTokens", getU64Encoder()],
-		["seedLamports", getU64Encoder()]
+		["extraSeedTokens", getU64Encoder()],
+		["quoteMint", getAddressEncoder()],
+		["seedQuoteAmount", getU64Encoder()],
+		["seedNativeDebit", getU64Encoder()]
 	]), [getConstantEncoder(POOL_CREATED_EVENT_DISCRIMINATOR)]);
 }
 /** Gets the decoder for {@link PoolCreatedEvent} event data. */
@@ -158,10 +2447,12 @@ function getPoolCreatedEventDecoder() {
 		["mint", getAddressDecoder()],
 		["creator", getAddressDecoder()],
 		["packTokens", getU64Decoder()],
-		["feeBps", getU16Decoder()],
 		["tiers", getArrayDecoder(getTierDecoder(), { size: 8 })],
 		["seedTokens", getU64Decoder()],
-		["seedLamports", getU64Decoder()]
+		["extraSeedTokens", getU64Decoder()],
+		["quoteMint", getAddressDecoder()],
+		["seedQuoteAmount", getU64Decoder()],
+		["seedNativeDebit", getU64Decoder()]
 	]), [getConstantDecoder(POOL_CREATED_EVENT_DISCRIMINATOR)]);
 }
 /** Gets the codec for {@link PoolCreatedEvent} event data. */
@@ -174,57 +2465,6 @@ function parsePoolCreatedEvent(data) {
 	throw new Error("The provided data does not match the \"PoolCreatedEvent\" event discriminators.");
 }
 //#endregion
-//#region src/generated/events/prizeRedeemed.ts
-/**
-* This code was AUTOGENERATED using the Codama library.
-* Please DO NOT EDIT THIS FILE, instead use visitors
-* to add features, then rerun Codama to update it.
-*
-* @see https://github.com/codama-idl/codama
-*/
-const PRIZE_REDEEMED_EVENT_DISCRIMINATOR = new Uint8Array([
-	243,
-	193,
-	245,
-	166,
-	160,
-	101,
-	182,
-	207
-]);
-function getPrizeRedeemedEventDiscriminatorBytes() {
-	return fixEncoderSize(getBytesEncoder(), 8).encode(PRIZE_REDEEMED_EVENT_DISCRIMINATOR);
-}
-/** Gets the encoder for {@link PrizeRedeemedEventArgs} event data. */
-function getPrizeRedeemedEventEncoder() {
-	return getHiddenPrefixEncoder(getStructEncoder([
-		["pool", getAddressEncoder()],
-		["seq", getU64Encoder()],
-		["purchaser", getAddressEncoder()],
-		["amount", getU64Encoder()],
-		["sold", getBooleanEncoder()]
-	]), [getConstantEncoder(PRIZE_REDEEMED_EVENT_DISCRIMINATOR)]);
-}
-/** Gets the decoder for {@link PrizeRedeemedEvent} event data. */
-function getPrizeRedeemedEventDecoder() {
-	return getHiddenPrefixDecoder(getStructDecoder([
-		["pool", getAddressDecoder()],
-		["seq", getU64Decoder()],
-		["purchaser", getAddressDecoder()],
-		["amount", getU64Decoder()],
-		["sold", getBooleanDecoder()]
-	]), [getConstantDecoder(PRIZE_REDEEMED_EVENT_DISCRIMINATOR)]);
-}
-/** Gets the codec for {@link PrizeRedeemedEvent} event data. */
-function getPrizeRedeemedEventCodec() {
-	return combineCodec(getPrizeRedeemedEventEncoder(), getPrizeRedeemedEventDecoder());
-}
-/** Parses the provided bytes into {@link PrizeRedeemedEvent} event data. */
-function parsePrizeRedeemedEvent(data) {
-	if (containsBytes(data, PRIZE_REDEEMED_EVENT_DISCRIMINATOR, 0)) return getPrizeRedeemedEventDecoder().decode(data);
-	throw new Error("The provided data does not match the \"PrizeRedeemedEvent\" event discriminators.");
-}
-//#endregion
 //#region src/generated/events/prizesFunded.ts
 /**
 * This code was AUTOGENERATED using the Codama library.
@@ -346,9 +2586,10 @@ function getTokensSoldEventEncoder() {
 		["pool", getAddressEncoder()],
 		["seller", getAddressEncoder()],
 		["venue", getAddressEncoder()],
+		["quoteMint", getAddressEncoder()],
 		["amount", getU64Encoder()],
-		["proceeds", getU64Encoder()],
-		["protocolFee", getU64Encoder()]
+		["quoteProceeds", getU64Encoder()],
+		["nativeDebit", getU64Encoder()]
 	]), [getConstantEncoder(TOKENS_SOLD_EVENT_DISCRIMINATOR)]);
 }
 /** Gets the decoder for {@link TokensSoldEvent} event data. */
@@ -357,9 +2598,10 @@ function getTokensSoldEventDecoder() {
 		["pool", getAddressDecoder()],
 		["seller", getAddressDecoder()],
 		["venue", getAddressDecoder()],
+		["quoteMint", getAddressDecoder()],
 		["amount", getU64Decoder()],
-		["proceeds", getU64Decoder()],
-		["protocolFee", getU64Decoder()]
+		["quoteProceeds", getU64Decoder()],
+		["nativeDebit", getU64Decoder()]
 	]), [getConstantDecoder(TOKENS_SOLD_EVENT_DISCRIMINATOR)]);
 }
 /** Gets the codec for {@link TokensSoldEvent} event data. */
@@ -372,7 +2614,7 @@ function parseTokensSoldEvent(data) {
 	throw new Error("The provided data does not match the \"TokensSoldEvent\" event discriminators.");
 }
 //#endregion
-//#region src/generated/errors/gaboxV2.ts
+//#region src/generated/errors/gabox.ts
 /**
 * This code was AUTOGENERATED using the Codama library.
 * Please DO NOT EDIT THIS FILE, instead use visitors
@@ -381,274 +2623,136 @@ function parseTokensSoldEvent(data) {
 * @see https://github.com/codama-idl/codama
 */
 /** Arithmetic: Arithmetic overflow or inconsistent accounting */
-const GABOX_V2_ERROR__ARITHMETIC = 6e3;
+const GABOX_ERROR__ARITHMETIC = 6e3;
 /** InvalidDistribution: Invalid prize distribution */
-const GABOX_V2_ERROR__INVALID_DISTRIBUTION = 6001;
+const GABOX_ERROR__INVALID_DISTRIBUTION = 6001;
 /** UnfundedExpectation: Expected token award exceeds tokens purchased */
-const GABOX_V2_ERROR__UNFUNDED_EXPECTATION = 6002;
-/** UnsupportedMint: Mint must have no mint/freeze authority and only supported extensions */
-const GABOX_V2_ERROR__UNSUPPORTED_MINT = 6003;
+const GABOX_ERROR__UNFUNDED_EXPECTATION = 6002;
+/** UnsupportedMint: Mint must have 6 decimals and no mint or freeze authority */
+const GABOX_ERROR__UNSUPPORTED_MINT = 6003;
 /** InsolventInventory: Prize inventory does not cover reservations */
-const GABOX_V2_ERROR__INSOLVENT_INVENTORY = 6004;
+const GABOX_ERROR__INSOLVENT_INVENTORY = 6004;
 /** PrizeCapChanged: Top prize is below the signed minimum; refresh the offer */
-const GABOX_V2_ERROR__PRIZE_CAP_CHANGED = 6005;
+const GABOX_ERROR__PRIZE_CAP_CHANGED = 6005;
 /** PackTooSmall: A pack pays zero tokens on some tier */
-const GABOX_V2_ERROR__PACK_TOO_SMALL = 6006;
+const GABOX_ERROR__PACK_TOO_SMALL = 6006;
 /** JackpotBelowOnePack: The largest tier must pay at least one pack */
-const GABOX_V2_ERROR__JACKPOT_BELOW_ONE_PACK = 6007;
+const GABOX_ERROR__JACKPOT_BELOW_ONE_PACK = 6007;
 /** InvalidVenue: Incorrect trade program, account order, or token binding */
-const GABOX_V2_ERROR__INVALID_VENUE = 6008;
+const GABOX_ERROR__INVALID_VENUE = 6008;
 /** IncorrectTokenDelta: Trade did not move the exact token amount */
-const GABOX_V2_ERROR__INCORRECT_TOKEN_DELTA = 6009;
+const GABOX_ERROR__INCORRECT_TOKEN_DELTA = 6009;
 /** SlippageExceeded: Spend exceeds the signed limit */
-const GABOX_V2_ERROR__SLIPPAGE_EXCEEDED = 6010;
-/** NotPending: Draw is not awaiting randomness */
-const GABOX_V2_ERROR__NOT_PENDING = 6011;
-/** NotReady: Draw has not resolved */
-const GABOX_V2_ERROR__NOT_READY = 6012;
+const GABOX_ERROR__SLIPPAGE_EXCEEDED = 6010;
 /** RetryTooSoon: Retry interval has not elapsed */
-const GABOX_V2_ERROR__RETRY_TOO_SOON = 6013;
+const GABOX_ERROR__RETRY_TOO_SOON = 6011;
 /** RetryUnavailable: Retry limit reached or draw expired */
-const GABOX_V2_ERROR__RETRY_UNAVAILABLE = 6014;
+const GABOX_ERROR__RETRY_UNAVAILABLE = 6012;
 /** NotExpired: Oracle timeout has not elapsed */
-const GABOX_V2_ERROR__NOT_EXPIRED = 6015;
+const GABOX_ERROR__NOT_EXPIRED = 6013;
 /** ZeroAmount: Amount must be positive */
-const GABOX_V2_ERROR__ZERO_AMOUNT = 6016;
-/** InvalidFee: Creator fee exceeds the limit */
-const GABOX_V2_ERROR__INVALID_FEE = 6017;
-/** CoinNotCreatedHere: A pool must be created in the same transaction that creates the coin */
-const GABOX_V2_ERROR__COIN_NOT_CREATED_HERE = 6018;
-/** InvalidReferral: Referral account is missing or inconsistent */
-const GABOX_V2_ERROR__INVALID_REFERRAL = 6019;
-/** NothingOwedToReferrer: No referral revenue is owed */
-const GABOX_V2_ERROR__NOTHING_OWED_TO_REFERRER = 6020;
-/** InvalidFeeCollector: Fee account is not the protocol fee collector's */
-const GABOX_V2_ERROR__INVALID_FEE_COLLECTOR = 6021;
-let gaboxV2ErrorMessages;
-if (process.env["NODE_ENV"] !== "production") gaboxV2ErrorMessages = {
-	[GABOX_V2_ERROR__ARITHMETIC]: `Arithmetic overflow or inconsistent accounting`,
-	[GABOX_V2_ERROR__COIN_NOT_CREATED_HERE]: `A pool must be created in the same transaction that creates the coin`,
-	[GABOX_V2_ERROR__INCORRECT_TOKEN_DELTA]: `Trade did not move the exact token amount`,
-	[GABOX_V2_ERROR__INSOLVENT_INVENTORY]: `Prize inventory does not cover reservations`,
-	[GABOX_V2_ERROR__INVALID_DISTRIBUTION]: `Invalid prize distribution`,
-	[GABOX_V2_ERROR__INVALID_FEE]: `Creator fee exceeds the limit`,
-	[GABOX_V2_ERROR__INVALID_FEE_COLLECTOR]: `Fee account is not the protocol fee collector's`,
-	[GABOX_V2_ERROR__INVALID_REFERRAL]: `Referral account is missing or inconsistent`,
-	[GABOX_V2_ERROR__INVALID_VENUE]: `Incorrect trade program, account order, or token binding`,
-	[GABOX_V2_ERROR__JACKPOT_BELOW_ONE_PACK]: `The largest tier must pay at least one pack`,
-	[GABOX_V2_ERROR__NOT_EXPIRED]: `Oracle timeout has not elapsed`,
-	[GABOX_V2_ERROR__NOTHING_OWED_TO_REFERRER]: `No referral revenue is owed`,
-	[GABOX_V2_ERROR__NOT_PENDING]: `Draw is not awaiting randomness`,
-	[GABOX_V2_ERROR__NOT_READY]: `Draw has not resolved`,
-	[GABOX_V2_ERROR__PACK_TOO_SMALL]: `A pack pays zero tokens on some tier`,
-	[GABOX_V2_ERROR__PRIZE_CAP_CHANGED]: `Top prize is below the signed minimum; refresh the offer`,
-	[GABOX_V2_ERROR__RETRY_TOO_SOON]: `Retry interval has not elapsed`,
-	[GABOX_V2_ERROR__RETRY_UNAVAILABLE]: `Retry limit reached or draw expired`,
-	[GABOX_V2_ERROR__SLIPPAGE_EXCEEDED]: `Spend exceeds the signed limit`,
-	[GABOX_V2_ERROR__UNFUNDED_EXPECTATION]: `Expected token award exceeds tokens purchased`,
-	[GABOX_V2_ERROR__UNSUPPORTED_MINT]: `Mint must have no mint/freeze authority and only supported extensions`,
-	[GABOX_V2_ERROR__ZERO_AMOUNT]: `Amount must be positive`
+const GABOX_ERROR__ZERO_AMOUNT = 6014;
+/** InvalidLaunch: LaunchLab create instruction is malformed or missing before this instruction */
+const GABOX_ERROR__INVALID_LAUNCH = 6015;
+/** InvalidQuote: Quote mint or quote token program is unsupported */
+const GABOX_ERROR__INVALID_QUOTE = 6016;
+/** WalletActivityMismatch: Wallet activity account belongs to a different wallet */
+const GABOX_ERROR__WALLET_ACTIVITY_MISMATCH = 6017;
+let gaboxErrorMessages;
+if (process.env["NODE_ENV"] !== "production") gaboxErrorMessages = {
+	[GABOX_ERROR__ARITHMETIC]: `Arithmetic overflow or inconsistent accounting`,
+	[GABOX_ERROR__INCORRECT_TOKEN_DELTA]: `Trade did not move the exact token amount`,
+	[GABOX_ERROR__INSOLVENT_INVENTORY]: `Prize inventory does not cover reservations`,
+	[GABOX_ERROR__INVALID_DISTRIBUTION]: `Invalid prize distribution`,
+	[GABOX_ERROR__INVALID_LAUNCH]: `LaunchLab create instruction is malformed or missing before this instruction`,
+	[GABOX_ERROR__INVALID_QUOTE]: `Quote mint or quote token program is unsupported`,
+	[GABOX_ERROR__INVALID_VENUE]: `Incorrect trade program, account order, or token binding`,
+	[GABOX_ERROR__JACKPOT_BELOW_ONE_PACK]: `The largest tier must pay at least one pack`,
+	[GABOX_ERROR__NOT_EXPIRED]: `Oracle timeout has not elapsed`,
+	[GABOX_ERROR__PACK_TOO_SMALL]: `A pack pays zero tokens on some tier`,
+	[GABOX_ERROR__PRIZE_CAP_CHANGED]: `Top prize is below the signed minimum; refresh the offer`,
+	[GABOX_ERROR__RETRY_TOO_SOON]: `Retry interval has not elapsed`,
+	[GABOX_ERROR__RETRY_UNAVAILABLE]: `Retry limit reached or draw expired`,
+	[GABOX_ERROR__SLIPPAGE_EXCEEDED]: `Spend exceeds the signed limit`,
+	[GABOX_ERROR__UNFUNDED_EXPECTATION]: `Expected token award exceeds tokens purchased`,
+	[GABOX_ERROR__UNSUPPORTED_MINT]: `Mint must have 6 decimals and no mint or freeze authority`,
+	[GABOX_ERROR__WALLET_ACTIVITY_MISMATCH]: `Wallet activity account belongs to a different wallet`,
+	[GABOX_ERROR__ZERO_AMOUNT]: `Amount must be positive`
 };
-function getGaboxV2ErrorMessage(code) {
-	if (process.env["NODE_ENV"] !== "production") return gaboxV2ErrorMessages[code];
+function getGaboxErrorMessage(code) {
+	if (process.env["NODE_ENV"] !== "production") return gaboxErrorMessages[code];
 	return "Error message not available in production bundles.";
 }
-function isGaboxV2Error(error, transactionMessage, code) {
-	return isProgramError(error, transactionMessage, GABOX_V2_PROGRAM_ADDRESS, code);
-}
-//#endregion
-//#region src/generated/events/referralBound.ts
-/**
-* This code was AUTOGENERATED using the Codama library.
-* Please DO NOT EDIT THIS FILE, instead use visitors
-* to add features, then rerun Codama to update it.
-*
-* @see https://github.com/codama-idl/codama
-*/
-const REFERRAL_BOUND_EVENT_DISCRIMINATOR = new Uint8Array([
-	12,
-	28,
-	152,
-	148,
-	55,
-	210,
-	102,
-	190
-]);
-function getReferralBoundEventDiscriminatorBytes() {
-	return fixEncoderSize(getBytesEncoder(), 8).encode(REFERRAL_BOUND_EVENT_DISCRIMINATOR);
-}
-/** Gets the encoder for {@link ReferralBoundEventArgs} event data. */
-function getReferralBoundEventEncoder() {
-	return getHiddenPrefixEncoder(getStructEncoder([["referee", getAddressEncoder()], ["referrer", getAddressEncoder()]]), [getConstantEncoder(REFERRAL_BOUND_EVENT_DISCRIMINATOR)]);
-}
-/** Gets the decoder for {@link ReferralBoundEvent} event data. */
-function getReferralBoundEventDecoder() {
-	return getHiddenPrefixDecoder(getStructDecoder([["referee", getAddressDecoder()], ["referrer", getAddressDecoder()]]), [getConstantDecoder(REFERRAL_BOUND_EVENT_DISCRIMINATOR)]);
-}
-/** Gets the codec for {@link ReferralBoundEvent} event data. */
-function getReferralBoundEventCodec() {
-	return combineCodec(getReferralBoundEventEncoder(), getReferralBoundEventDecoder());
-}
-/** Parses the provided bytes into {@link ReferralBoundEvent} event data. */
-function parseReferralBoundEvent(data) {
-	if (containsBytes(data, REFERRAL_BOUND_EVENT_DISCRIMINATOR, 0)) return getReferralBoundEventDecoder().decode(data);
-	throw new Error("The provided data does not match the \"ReferralBoundEvent\" event discriminators.");
-}
-//#endregion
-//#region src/generated/events/referralClaimed.ts
-/**
-* This code was AUTOGENERATED using the Codama library.
-* Please DO NOT EDIT THIS FILE, instead use visitors
-* to add features, then rerun Codama to update it.
-*
-* @see https://github.com/codama-idl/codama
-*/
-const REFERRAL_CLAIMED_EVENT_DISCRIMINATOR = new Uint8Array([
-	195,
-	109,
-	77,
-	196,
-	134,
-	226,
-	78,
-	108
-]);
-function getReferralClaimedEventDiscriminatorBytes() {
-	return fixEncoderSize(getBytesEncoder(), 8).encode(REFERRAL_CLAIMED_EVENT_DISCRIMINATOR);
-}
-/** Gets the encoder for {@link ReferralClaimedEventArgs} event data. */
-function getReferralClaimedEventEncoder() {
-	return getHiddenPrefixEncoder(getStructEncoder([
-		["pool", getAddressEncoder()],
-		["referrer", getAddressEncoder()],
-		["amount", getU64Encoder()]
-	]), [getConstantEncoder(REFERRAL_CLAIMED_EVENT_DISCRIMINATOR)]);
-}
-/** Gets the decoder for {@link ReferralClaimedEvent} event data. */
-function getReferralClaimedEventDecoder() {
-	return getHiddenPrefixDecoder(getStructDecoder([
-		["pool", getAddressDecoder()],
-		["referrer", getAddressDecoder()],
-		["amount", getU64Decoder()]
-	]), [getConstantDecoder(REFERRAL_CLAIMED_EVENT_DISCRIMINATOR)]);
-}
-/** Gets the codec for {@link ReferralClaimedEvent} event data. */
-function getReferralClaimedEventCodec() {
-	return combineCodec(getReferralClaimedEventEncoder(), getReferralClaimedEventDecoder());
-}
-/** Parses the provided bytes into {@link ReferralClaimedEvent} event data. */
-function parseReferralClaimedEvent(data) {
-	if (containsBytes(data, REFERRAL_CLAIMED_EVENT_DISCRIMINATOR, 0)) return getReferralClaimedEventDecoder().decode(data);
-	throw new Error("The provided data does not match the \"ReferralClaimedEvent\" event discriminators.");
+function isGaboxError(error, transactionMessage, code) {
+	return isProgramError(error, transactionMessage, GABOX_PROGRAM_ADDRESS, code);
 }
 //#endregion
 //#region src/generated/index.ts
 var generated_exports = /* @__PURE__ */ __exportAll({
-	BIND_REFERRER_DISCRIMINATOR: () => BIND_REFERRER_DISCRIMINATOR,
 	BUY_PACK_DISCRIMINATOR: () => BUY_PACK_DISCRIMINATOR,
-	CLAIM_PRIZE_DISCRIMINATOR: () => CLAIM_PRIZE_DISCRIMINATOR,
-	CLAIM_REFERRAL_DISCRIMINATOR: () => CLAIM_REFERRAL_DISCRIMINATOR,
 	DELIVER_DRAW_DISCRIMINATOR: () => DELIVER_DRAW_DISCRIMINATOR,
 	DRAW_DISCRIMINATOR: () => DRAW_DISCRIMINATOR,
 	DRAW_RESOLVED_EVENT_DISCRIMINATOR: () => DRAW_RESOLVED_EVENT_DISCRIMINATOR,
-	DrawStatus: () => DrawStatus,
 	EXPIRE_DRAW_DISCRIMINATOR: () => EXPIRE_DRAW_DISCRIMINATOR,
-	FULFILL_DRAW_DISCRIMINATOR: () => FULFILL_DRAW_DISCRIMINATOR,
 	FUND_PRIZES_DISCRIMINATOR: () => FUND_PRIZES_DISCRIMINATOR,
-	GABOX_V2_ERROR__ARITHMETIC: () => GABOX_V2_ERROR__ARITHMETIC,
-	GABOX_V2_ERROR__COIN_NOT_CREATED_HERE: () => GABOX_V2_ERROR__COIN_NOT_CREATED_HERE,
-	GABOX_V2_ERROR__INCORRECT_TOKEN_DELTA: () => GABOX_V2_ERROR__INCORRECT_TOKEN_DELTA,
-	GABOX_V2_ERROR__INSOLVENT_INVENTORY: () => GABOX_V2_ERROR__INSOLVENT_INVENTORY,
-	GABOX_V2_ERROR__INVALID_DISTRIBUTION: () => GABOX_V2_ERROR__INVALID_DISTRIBUTION,
-	GABOX_V2_ERROR__INVALID_FEE: () => GABOX_V2_ERROR__INVALID_FEE,
-	GABOX_V2_ERROR__INVALID_FEE_COLLECTOR: () => GABOX_V2_ERROR__INVALID_FEE_COLLECTOR,
-	GABOX_V2_ERROR__INVALID_REFERRAL: () => GABOX_V2_ERROR__INVALID_REFERRAL,
-	GABOX_V2_ERROR__INVALID_VENUE: () => GABOX_V2_ERROR__INVALID_VENUE,
-	GABOX_V2_ERROR__JACKPOT_BELOW_ONE_PACK: () => GABOX_V2_ERROR__JACKPOT_BELOW_ONE_PACK,
-	GABOX_V2_ERROR__NOTHING_OWED_TO_REFERRER: () => GABOX_V2_ERROR__NOTHING_OWED_TO_REFERRER,
-	GABOX_V2_ERROR__NOT_EXPIRED: () => GABOX_V2_ERROR__NOT_EXPIRED,
-	GABOX_V2_ERROR__NOT_PENDING: () => GABOX_V2_ERROR__NOT_PENDING,
-	GABOX_V2_ERROR__NOT_READY: () => GABOX_V2_ERROR__NOT_READY,
-	GABOX_V2_ERROR__PACK_TOO_SMALL: () => GABOX_V2_ERROR__PACK_TOO_SMALL,
-	GABOX_V2_ERROR__PRIZE_CAP_CHANGED: () => GABOX_V2_ERROR__PRIZE_CAP_CHANGED,
-	GABOX_V2_ERROR__RETRY_TOO_SOON: () => GABOX_V2_ERROR__RETRY_TOO_SOON,
-	GABOX_V2_ERROR__RETRY_UNAVAILABLE: () => GABOX_V2_ERROR__RETRY_UNAVAILABLE,
-	GABOX_V2_ERROR__SLIPPAGE_EXCEEDED: () => GABOX_V2_ERROR__SLIPPAGE_EXCEEDED,
-	GABOX_V2_ERROR__UNFUNDED_EXPECTATION: () => GABOX_V2_ERROR__UNFUNDED_EXPECTATION,
-	GABOX_V2_ERROR__UNSUPPORTED_MINT: () => GABOX_V2_ERROR__UNSUPPORTED_MINT,
-	GABOX_V2_ERROR__ZERO_AMOUNT: () => GABOX_V2_ERROR__ZERO_AMOUNT,
-	GABOX_V2_PROGRAM_ADDRESS: () => GABOX_V2_PROGRAM_ADDRESS,
-	GaboxV2Account: () => GaboxV2Account,
-	GaboxV2Event: () => GaboxV2Event,
-	GaboxV2Instruction: () => GaboxV2Instruction,
+	GABOX_ERROR__ARITHMETIC: () => GABOX_ERROR__ARITHMETIC,
+	GABOX_ERROR__INCORRECT_TOKEN_DELTA: () => GABOX_ERROR__INCORRECT_TOKEN_DELTA,
+	GABOX_ERROR__INSOLVENT_INVENTORY: () => GABOX_ERROR__INSOLVENT_INVENTORY,
+	GABOX_ERROR__INVALID_DISTRIBUTION: () => GABOX_ERROR__INVALID_DISTRIBUTION,
+	GABOX_ERROR__INVALID_LAUNCH: () => GABOX_ERROR__INVALID_LAUNCH,
+	GABOX_ERROR__INVALID_QUOTE: () => GABOX_ERROR__INVALID_QUOTE,
+	GABOX_ERROR__INVALID_VENUE: () => GABOX_ERROR__INVALID_VENUE,
+	GABOX_ERROR__JACKPOT_BELOW_ONE_PACK: () => GABOX_ERROR__JACKPOT_BELOW_ONE_PACK,
+	GABOX_ERROR__NOT_EXPIRED: () => GABOX_ERROR__NOT_EXPIRED,
+	GABOX_ERROR__PACK_TOO_SMALL: () => GABOX_ERROR__PACK_TOO_SMALL,
+	GABOX_ERROR__PRIZE_CAP_CHANGED: () => GABOX_ERROR__PRIZE_CAP_CHANGED,
+	GABOX_ERROR__RETRY_TOO_SOON: () => GABOX_ERROR__RETRY_TOO_SOON,
+	GABOX_ERROR__RETRY_UNAVAILABLE: () => GABOX_ERROR__RETRY_UNAVAILABLE,
+	GABOX_ERROR__SLIPPAGE_EXCEEDED: () => GABOX_ERROR__SLIPPAGE_EXCEEDED,
+	GABOX_ERROR__UNFUNDED_EXPECTATION: () => GABOX_ERROR__UNFUNDED_EXPECTATION,
+	GABOX_ERROR__UNSUPPORTED_MINT: () => GABOX_ERROR__UNSUPPORTED_MINT,
+	GABOX_ERROR__WALLET_ACTIVITY_MISMATCH: () => GABOX_ERROR__WALLET_ACTIVITY_MISMATCH,
+	GABOX_ERROR__ZERO_AMOUNT: () => GABOX_ERROR__ZERO_AMOUNT,
+	GABOX_PROGRAM_ADDRESS: () => GABOX_PROGRAM_ADDRESS,
+	GaboxAccount: () => GaboxAccount,
+	GaboxEvent: () => GaboxEvent,
+	GaboxInstruction: () => GaboxInstruction,
 	INITIALIZE_POOL_DISCRIMINATOR: () => INITIALIZE_POOL_DISCRIMINATOR,
 	PACK_BOUGHT_EVENT_DISCRIMINATOR: () => PACK_BOUGHT_EVENT_DISCRIMINATOR,
 	POOL_CREATED_EVENT_DISCRIMINATOR: () => POOL_CREATED_EVENT_DISCRIMINATOR,
 	POOL_DISCRIMINATOR: () => POOL_DISCRIMINATOR,
 	PRIZES_FUNDED_EVENT_DISCRIMINATOR: () => PRIZES_FUNDED_EVENT_DISCRIMINATOR,
-	PRIZE_REDEEMED_EVENT_DISCRIMINATOR: () => PRIZE_REDEEMED_EVENT_DISCRIMINATOR,
 	RANDOMNESS_RETRIED_EVENT_DISCRIMINATOR: () => RANDOMNESS_RETRIED_EVENT_DISCRIMINATOR,
-	REFERRAL_BOUND_EVENT_DISCRIMINATOR: () => REFERRAL_BOUND_EVENT_DISCRIMINATOR,
-	REFERRAL_CLAIMED_EVENT_DISCRIMINATOR: () => REFERRAL_CLAIMED_EVENT_DISCRIMINATOR,
-	REFERRAL_DISCRIMINATOR: () => REFERRAL_DISCRIMINATOR,
-	REFERRAL_LINK_DISCRIMINATOR: () => REFERRAL_LINK_DISCRIMINATOR,
 	RETRY_DRAW_DISCRIMINATOR: () => RETRY_DRAW_DISCRIMINATOR,
-	SELL_PRIZE_DISCRIMINATOR: () => SELL_PRIZE_DISCRIMINATOR,
 	SELL_TOKENS_DISCRIMINATOR: () => SELL_TOKENS_DISCRIMINATOR,
 	TOKENS_SOLD_EVENT_DISCRIMINATOR: () => TOKENS_SOLD_EVENT_DISCRIMINATOR,
+	WALLET_ACTIVITY_DISCRIMINATOR: () => WALLET_ACTIVITY_DISCRIMINATOR,
 	decodeDraw: () => decodeDraw,
 	decodePool: () => decodePool,
-	decodeReferral: () => decodeReferral,
-	decodeReferralLink: () => decodeReferralLink,
+	decodeWalletActivity: () => decodeWalletActivity,
 	fetchAllDraw: () => fetchAllDraw,
 	fetchAllMaybeDraw: () => fetchAllMaybeDraw,
 	fetchAllMaybePool: () => fetchAllMaybePool,
-	fetchAllMaybeReferral: () => fetchAllMaybeReferral,
-	fetchAllMaybeReferralLink: () => fetchAllMaybeReferralLink,
+	fetchAllMaybeWalletActivity: () => fetchAllMaybeWalletActivity,
 	fetchAllPool: () => fetchAllPool,
-	fetchAllReferral: () => fetchAllReferral,
-	fetchAllReferralLink: () => fetchAllReferralLink,
+	fetchAllWalletActivity: () => fetchAllWalletActivity,
 	fetchDraw: () => fetchDraw,
 	fetchMaybeDraw: () => fetchMaybeDraw,
 	fetchMaybePool: () => fetchMaybePool,
-	fetchMaybeReferral: () => fetchMaybeReferral,
-	fetchMaybeReferralLink: () => fetchMaybeReferralLink,
+	fetchMaybeWalletActivity: () => fetchMaybeWalletActivity,
 	fetchPool: () => fetchPool,
-	fetchReferral: () => fetchReferral,
-	fetchReferralLink: () => fetchReferralLink,
-	findClaimReferralReferralPda: () => findClaimReferralReferralPda,
+	fetchWalletActivity: () => fetchWalletActivity,
+	findActivityPda: () => findActivityPda,
 	findDrawPda: () => findDrawPda,
 	findIdentityPda: () => findIdentityPda,
-	findLinkPda: () => findLinkPda,
 	findPoolPda: () => findPoolPda,
-	findReferralLinkPda: () => findReferralLinkPda,
-	findReferralPda: () => findReferralPda,
-	gaboxV2Program: () => gaboxV2Program,
-	getBindReferrerDiscriminatorBytes: () => getBindReferrerDiscriminatorBytes,
-	getBindReferrerInstruction: () => getBindReferrerInstruction,
-	getBindReferrerInstructionAsync: () => getBindReferrerInstructionAsync,
-	getBindReferrerInstructionDataCodec: () => getBindReferrerInstructionDataCodec,
-	getBindReferrerInstructionDataDecoder: () => getBindReferrerInstructionDataDecoder,
-	getBindReferrerInstructionDataEncoder: () => getBindReferrerInstructionDataEncoder,
+	gaboxProgram: () => gaboxProgram,
 	getBuyPackDiscriminatorBytes: () => getBuyPackDiscriminatorBytes,
 	getBuyPackInstruction: () => getBuyPackInstruction,
 	getBuyPackInstructionAsync: () => getBuyPackInstructionAsync,
 	getBuyPackInstructionDataCodec: () => getBuyPackInstructionDataCodec,
 	getBuyPackInstructionDataDecoder: () => getBuyPackInstructionDataDecoder,
 	getBuyPackInstructionDataEncoder: () => getBuyPackInstructionDataEncoder,
-	getClaimPrizeDiscriminatorBytes: () => getClaimPrizeDiscriminatorBytes,
-	getClaimPrizeInstruction: () => getClaimPrizeInstruction,
-	getClaimPrizeInstructionAsync: () => getClaimPrizeInstructionAsync,
-	getClaimPrizeInstructionDataCodec: () => getClaimPrizeInstructionDataCodec,
-	getClaimPrizeInstructionDataDecoder: () => getClaimPrizeInstructionDataDecoder,
-	getClaimPrizeInstructionDataEncoder: () => getClaimPrizeInstructionDataEncoder,
-	getClaimReferralDiscriminatorBytes: () => getClaimReferralDiscriminatorBytes,
-	getClaimReferralInstruction: () => getClaimReferralInstruction,
-	getClaimReferralInstructionAsync: () => getClaimReferralInstructionAsync,
-	getClaimReferralInstructionDataCodec: () => getClaimReferralInstructionDataCodec,
-	getClaimReferralInstructionDataDecoder: () => getClaimReferralInstructionDataDecoder,
-	getClaimReferralInstructionDataEncoder: () => getClaimReferralInstructionDataEncoder,
 	getDeliverDrawDiscriminatorBytes: () => getDeliverDrawDiscriminatorBytes,
 	getDeliverDrawInstruction: () => getDeliverDrawInstruction,
 	getDeliverDrawInstructionAsync: () => getDeliverDrawInstructionAsync,
@@ -664,27 +2768,19 @@ var generated_exports = /* @__PURE__ */ __exportAll({
 	getDrawResolvedEventDiscriminatorBytes: () => getDrawResolvedEventDiscriminatorBytes,
 	getDrawResolvedEventEncoder: () => getDrawResolvedEventEncoder,
 	getDrawSize: () => getDrawSize,
-	getDrawStatusCodec: () => getDrawStatusCodec,
-	getDrawStatusDecoder: () => getDrawStatusDecoder,
-	getDrawStatusEncoder: () => getDrawStatusEncoder,
 	getExpireDrawDiscriminatorBytes: () => getExpireDrawDiscriminatorBytes,
 	getExpireDrawInstruction: () => getExpireDrawInstruction,
 	getExpireDrawInstructionAsync: () => getExpireDrawInstructionAsync,
 	getExpireDrawInstructionDataCodec: () => getExpireDrawInstructionDataCodec,
 	getExpireDrawInstructionDataDecoder: () => getExpireDrawInstructionDataDecoder,
 	getExpireDrawInstructionDataEncoder: () => getExpireDrawInstructionDataEncoder,
-	getFulfillDrawDiscriminatorBytes: () => getFulfillDrawDiscriminatorBytes,
-	getFulfillDrawInstruction: () => getFulfillDrawInstruction,
-	getFulfillDrawInstructionAsync: () => getFulfillDrawInstructionAsync,
-	getFulfillDrawInstructionDataCodec: () => getFulfillDrawInstructionDataCodec,
-	getFulfillDrawInstructionDataDecoder: () => getFulfillDrawInstructionDataDecoder,
-	getFulfillDrawInstructionDataEncoder: () => getFulfillDrawInstructionDataEncoder,
 	getFundPrizesDiscriminatorBytes: () => getFundPrizesDiscriminatorBytes,
 	getFundPrizesInstruction: () => getFundPrizesInstruction,
+	getFundPrizesInstructionAsync: () => getFundPrizesInstructionAsync,
 	getFundPrizesInstructionDataCodec: () => getFundPrizesInstructionDataCodec,
 	getFundPrizesInstructionDataDecoder: () => getFundPrizesInstructionDataDecoder,
 	getFundPrizesInstructionDataEncoder: () => getFundPrizesInstructionDataEncoder,
-	getGaboxV2ErrorMessage: () => getGaboxV2ErrorMessage,
+	getGaboxErrorMessage: () => getGaboxErrorMessage,
 	getInitializePoolDiscriminatorBytes: () => getInitializePoolDiscriminatorBytes,
 	getInitializePoolInstruction: () => getInitializePoolInstruction,
 	getInitializePoolInstructionAsync: () => getInitializePoolInstructionAsync,
@@ -707,10 +2803,6 @@ var generated_exports = /* @__PURE__ */ __exportAll({
 	getPrizeCodec: () => getPrizeCodec,
 	getPrizeDecoder: () => getPrizeDecoder,
 	getPrizeEncoder: () => getPrizeEncoder,
-	getPrizeRedeemedEventCodec: () => getPrizeRedeemedEventCodec,
-	getPrizeRedeemedEventDecoder: () => getPrizeRedeemedEventDecoder,
-	getPrizeRedeemedEventDiscriminatorBytes: () => getPrizeRedeemedEventDiscriminatorBytes,
-	getPrizeRedeemedEventEncoder: () => getPrizeRedeemedEventEncoder,
 	getPrizesFundedEventCodec: () => getPrizesFundedEventCodec,
 	getPrizesFundedEventDecoder: () => getPrizesFundedEventDecoder,
 	getPrizesFundedEventDiscriminatorBytes: () => getPrizesFundedEventDiscriminatorBytes,
@@ -719,36 +2811,12 @@ var generated_exports = /* @__PURE__ */ __exportAll({
 	getRandomnessRetriedEventDecoder: () => getRandomnessRetriedEventDecoder,
 	getRandomnessRetriedEventDiscriminatorBytes: () => getRandomnessRetriedEventDiscriminatorBytes,
 	getRandomnessRetriedEventEncoder: () => getRandomnessRetriedEventEncoder,
-	getReferralBoundEventCodec: () => getReferralBoundEventCodec,
-	getReferralBoundEventDecoder: () => getReferralBoundEventDecoder,
-	getReferralBoundEventDiscriminatorBytes: () => getReferralBoundEventDiscriminatorBytes,
-	getReferralBoundEventEncoder: () => getReferralBoundEventEncoder,
-	getReferralClaimedEventCodec: () => getReferralClaimedEventCodec,
-	getReferralClaimedEventDecoder: () => getReferralClaimedEventDecoder,
-	getReferralClaimedEventDiscriminatorBytes: () => getReferralClaimedEventDiscriminatorBytes,
-	getReferralClaimedEventEncoder: () => getReferralClaimedEventEncoder,
-	getReferralCodec: () => getReferralCodec,
-	getReferralDecoder: () => getReferralDecoder,
-	getReferralDiscriminatorBytes: () => getReferralDiscriminatorBytes,
-	getReferralEncoder: () => getReferralEncoder,
-	getReferralLinkCodec: () => getReferralLinkCodec,
-	getReferralLinkDecoder: () => getReferralLinkDecoder,
-	getReferralLinkDiscriminatorBytes: () => getReferralLinkDiscriminatorBytes,
-	getReferralLinkEncoder: () => getReferralLinkEncoder,
-	getReferralLinkSize: () => getReferralLinkSize,
-	getReferralSize: () => getReferralSize,
 	getRetryDrawDiscriminatorBytes: () => getRetryDrawDiscriminatorBytes,
 	getRetryDrawInstruction: () => getRetryDrawInstruction,
 	getRetryDrawInstructionAsync: () => getRetryDrawInstructionAsync,
 	getRetryDrawInstructionDataCodec: () => getRetryDrawInstructionDataCodec,
 	getRetryDrawInstructionDataDecoder: () => getRetryDrawInstructionDataDecoder,
 	getRetryDrawInstructionDataEncoder: () => getRetryDrawInstructionDataEncoder,
-	getSellPrizeDiscriminatorBytes: () => getSellPrizeDiscriminatorBytes,
-	getSellPrizeInstruction: () => getSellPrizeInstruction,
-	getSellPrizeInstructionAsync: () => getSellPrizeInstructionAsync,
-	getSellPrizeInstructionDataCodec: () => getSellPrizeInstructionDataCodec,
-	getSellPrizeInstructionDataDecoder: () => getSellPrizeInstructionDataDecoder,
-	getSellPrizeInstructionDataEncoder: () => getSellPrizeInstructionDataEncoder,
 	getSellTokensDiscriminatorBytes: () => getSellTokensDiscriminatorBytes,
 	getSellTokensInstruction: () => getSellTokensInstruction,
 	getSellTokensInstructionAsync: () => getSellTokensInstructionAsync,
@@ -762,34 +2830,31 @@ var generated_exports = /* @__PURE__ */ __exportAll({
 	getTokensSoldEventDecoder: () => getTokensSoldEventDecoder,
 	getTokensSoldEventDiscriminatorBytes: () => getTokensSoldEventDiscriminatorBytes,
 	getTokensSoldEventEncoder: () => getTokensSoldEventEncoder,
-	identifyGaboxV2Account: () => identifyGaboxV2Account,
-	identifyGaboxV2Event: () => identifyGaboxV2Event,
-	identifyGaboxV2Instruction: () => identifyGaboxV2Instruction,
-	isGaboxV2Error: () => isGaboxV2Error,
-	parseBindReferrerInstruction: () => parseBindReferrerInstruction,
+	getWalletActivityCodec: () => getWalletActivityCodec,
+	getWalletActivityDecoder: () => getWalletActivityDecoder,
+	getWalletActivityDiscriminatorBytes: () => getWalletActivityDiscriminatorBytes,
+	getWalletActivityEncoder: () => getWalletActivityEncoder,
+	getWalletActivitySize: () => getWalletActivitySize,
+	identifyGaboxAccount: () => identifyGaboxAccount,
+	identifyGaboxEvent: () => identifyGaboxEvent,
+	identifyGaboxInstruction: () => identifyGaboxInstruction,
+	isGaboxError: () => isGaboxError,
 	parseBuyPackInstruction: () => parseBuyPackInstruction,
-	parseClaimPrizeInstruction: () => parseClaimPrizeInstruction,
-	parseClaimReferralInstruction: () => parseClaimReferralInstruction,
 	parseDeliverDrawInstruction: () => parseDeliverDrawInstruction,
 	parseDrawResolvedEvent: () => parseDrawResolvedEvent,
 	parseExpireDrawInstruction: () => parseExpireDrawInstruction,
-	parseFulfillDrawInstruction: () => parseFulfillDrawInstruction,
 	parseFundPrizesInstruction: () => parseFundPrizesInstruction,
-	parseGaboxV2Instruction: () => parseGaboxV2Instruction,
+	parseGaboxInstruction: () => parseGaboxInstruction,
 	parseInitializePoolInstruction: () => parseInitializePoolInstruction,
 	parsePackBoughtEvent: () => parsePackBoughtEvent,
 	parsePoolCreatedEvent: () => parsePoolCreatedEvent,
-	parsePrizeRedeemedEvent: () => parsePrizeRedeemedEvent,
 	parsePrizesFundedEvent: () => parsePrizesFundedEvent,
 	parseRandomnessRetriedEvent: () => parseRandomnessRetriedEvent,
-	parseReferralBoundEvent: () => parseReferralBoundEvent,
-	parseReferralClaimedEvent: () => parseReferralClaimedEvent,
 	parseRetryDrawInstruction: () => parseRetryDrawInstruction,
-	parseSellPrizeInstruction: () => parseSellPrizeInstruction,
 	parseSellTokensInstruction: () => parseSellTokensInstruction,
 	parseTokensSoldEvent: () => parseTokensSoldEvent
 });
 //#endregion
-export { BIND_REFERRER_DISCRIMINATOR, BUY_PACK_DISCRIMINATOR, CLAIM_PRIZE_DISCRIMINATOR, CLAIM_REFERRAL_DISCRIMINATOR, DELIVER_DRAW_DISCRIMINATOR, DRAW_DISCRIMINATOR, DRAW_RESOLVED_EVENT_DISCRIMINATOR, DrawStatus, EXPIRE_DRAW_DISCRIMINATOR, FULFILL_DRAW_DISCRIMINATOR, FUND_PRIZES_DISCRIMINATOR, GABOX_V2_ERROR__ARITHMETIC, GABOX_V2_ERROR__COIN_NOT_CREATED_HERE, GABOX_V2_ERROR__INCORRECT_TOKEN_DELTA, GABOX_V2_ERROR__INSOLVENT_INVENTORY, GABOX_V2_ERROR__INVALID_DISTRIBUTION, GABOX_V2_ERROR__INVALID_FEE, GABOX_V2_ERROR__INVALID_FEE_COLLECTOR, GABOX_V2_ERROR__INVALID_REFERRAL, GABOX_V2_ERROR__INVALID_VENUE, GABOX_V2_ERROR__JACKPOT_BELOW_ONE_PACK, GABOX_V2_ERROR__NOTHING_OWED_TO_REFERRER, GABOX_V2_ERROR__NOT_EXPIRED, GABOX_V2_ERROR__NOT_PENDING, GABOX_V2_ERROR__NOT_READY, GABOX_V2_ERROR__PACK_TOO_SMALL, GABOX_V2_ERROR__PRIZE_CAP_CHANGED, GABOX_V2_ERROR__RETRY_TOO_SOON, GABOX_V2_ERROR__RETRY_UNAVAILABLE, GABOX_V2_ERROR__SLIPPAGE_EXCEEDED, GABOX_V2_ERROR__UNFUNDED_EXPECTATION, GABOX_V2_ERROR__UNSUPPORTED_MINT, GABOX_V2_ERROR__ZERO_AMOUNT, GABOX_V2_PROGRAM_ADDRESS, GaboxV2Account, GaboxV2Event, GaboxV2Instruction, INITIALIZE_POOL_DISCRIMINATOR, PACK_BOUGHT_EVENT_DISCRIMINATOR, POOL_CREATED_EVENT_DISCRIMINATOR, POOL_DISCRIMINATOR, PRIZES_FUNDED_EVENT_DISCRIMINATOR, PRIZE_REDEEMED_EVENT_DISCRIMINATOR, RANDOMNESS_RETRIED_EVENT_DISCRIMINATOR, REFERRAL_BOUND_EVENT_DISCRIMINATOR, REFERRAL_CLAIMED_EVENT_DISCRIMINATOR, REFERRAL_DISCRIMINATOR, REFERRAL_LINK_DISCRIMINATOR, RETRY_DRAW_DISCRIMINATOR, SELL_PRIZE_DISCRIMINATOR, SELL_TOKENS_DISCRIMINATOR, TOKENS_SOLD_EVENT_DISCRIMINATOR, decodeDraw, decodePool, decodeReferral, decodeReferralLink, fetchAllDraw, fetchAllMaybeDraw, fetchAllMaybePool, fetchAllMaybeReferral, fetchAllMaybeReferralLink, fetchAllPool, fetchAllReferral, fetchAllReferralLink, fetchDraw, fetchMaybeDraw, fetchMaybePool, fetchMaybeReferral, fetchMaybeReferralLink, fetchPool, fetchReferral, fetchReferralLink, findClaimReferralReferralPda, findDrawPda, findIdentityPda, findLinkPda, findPoolPda, findReferralLinkPda, findReferralPda, gaboxV2Program, getBindReferrerDiscriminatorBytes, getBindReferrerInstruction, getBindReferrerInstructionAsync, getBindReferrerInstructionDataCodec, getBindReferrerInstructionDataDecoder, getBindReferrerInstructionDataEncoder, getBuyPackDiscriminatorBytes, getBuyPackInstruction, getBuyPackInstructionAsync, getBuyPackInstructionDataCodec, getBuyPackInstructionDataDecoder, getBuyPackInstructionDataEncoder, getClaimPrizeDiscriminatorBytes, getClaimPrizeInstruction, getClaimPrizeInstructionAsync, getClaimPrizeInstructionDataCodec, getClaimPrizeInstructionDataDecoder, getClaimPrizeInstructionDataEncoder, getClaimReferralDiscriminatorBytes, getClaimReferralInstruction, getClaimReferralInstructionAsync, getClaimReferralInstructionDataCodec, getClaimReferralInstructionDataDecoder, getClaimReferralInstructionDataEncoder, getDeliverDrawDiscriminatorBytes, getDeliverDrawInstruction, getDeliverDrawInstructionAsync, getDeliverDrawInstructionDataCodec, getDeliverDrawInstructionDataDecoder, getDeliverDrawInstructionDataEncoder, getDrawCodec, getDrawDecoder, getDrawDiscriminatorBytes, getDrawEncoder, getDrawResolvedEventCodec, getDrawResolvedEventDecoder, getDrawResolvedEventDiscriminatorBytes, getDrawResolvedEventEncoder, getDrawSize, getDrawStatusCodec, getDrawStatusDecoder, getDrawStatusEncoder, getExpireDrawDiscriminatorBytes, getExpireDrawInstruction, getExpireDrawInstructionAsync, getExpireDrawInstructionDataCodec, getExpireDrawInstructionDataDecoder, getExpireDrawInstructionDataEncoder, getFulfillDrawDiscriminatorBytes, getFulfillDrawInstruction, getFulfillDrawInstructionAsync, getFulfillDrawInstructionDataCodec, getFulfillDrawInstructionDataDecoder, getFulfillDrawInstructionDataEncoder, getFundPrizesDiscriminatorBytes, getFundPrizesInstruction, getFundPrizesInstructionDataCodec, getFundPrizesInstructionDataDecoder, getFundPrizesInstructionDataEncoder, getGaboxV2ErrorMessage, getInitializePoolDiscriminatorBytes, getInitializePoolInstruction, getInitializePoolInstructionAsync, getInitializePoolInstructionDataCodec, getInitializePoolInstructionDataDecoder, getInitializePoolInstructionDataEncoder, getPackBoughtEventCodec, getPackBoughtEventDecoder, getPackBoughtEventDiscriminatorBytes, getPackBoughtEventEncoder, getPoolCodec, getPoolCreatedEventCodec, getPoolCreatedEventDecoder, getPoolCreatedEventDiscriminatorBytes, getPoolCreatedEventEncoder, getPoolDecoder, getPoolDiscriminatorBytes, getPoolEncoder, getPoolSize, getPrizeCodec, getPrizeDecoder, getPrizeEncoder, getPrizeRedeemedEventCodec, getPrizeRedeemedEventDecoder, getPrizeRedeemedEventDiscriminatorBytes, getPrizeRedeemedEventEncoder, getPrizesFundedEventCodec, getPrizesFundedEventDecoder, getPrizesFundedEventDiscriminatorBytes, getPrizesFundedEventEncoder, getRandomnessRetriedEventCodec, getRandomnessRetriedEventDecoder, getRandomnessRetriedEventDiscriminatorBytes, getRandomnessRetriedEventEncoder, getReferralBoundEventCodec, getReferralBoundEventDecoder, getReferralBoundEventDiscriminatorBytes, getReferralBoundEventEncoder, getReferralClaimedEventCodec, getReferralClaimedEventDecoder, getReferralClaimedEventDiscriminatorBytes, getReferralClaimedEventEncoder, getReferralCodec, getReferralDecoder, getReferralDiscriminatorBytes, getReferralEncoder, getReferralLinkCodec, getReferralLinkDecoder, getReferralLinkDiscriminatorBytes, getReferralLinkEncoder, getReferralLinkSize, getReferralSize, getRetryDrawDiscriminatorBytes, getRetryDrawInstruction, getRetryDrawInstructionAsync, getRetryDrawInstructionDataCodec, getRetryDrawInstructionDataDecoder, getRetryDrawInstructionDataEncoder, getSellPrizeDiscriminatorBytes, getSellPrizeInstruction, getSellPrizeInstructionAsync, getSellPrizeInstructionDataCodec, getSellPrizeInstructionDataDecoder, getSellPrizeInstructionDataEncoder, getSellTokensDiscriminatorBytes, getSellTokensInstruction, getSellTokensInstructionAsync, getSellTokensInstructionDataCodec, getSellTokensInstructionDataDecoder, getSellTokensInstructionDataEncoder, getTierCodec, getTierDecoder, getTierEncoder, getTokensSoldEventCodec, getTokensSoldEventDecoder, getTokensSoldEventDiscriminatorBytes, getTokensSoldEventEncoder, identifyGaboxV2Account, identifyGaboxV2Event, identifyGaboxV2Instruction, isGaboxV2Error, parseBindReferrerInstruction, parseBuyPackInstruction, parseClaimPrizeInstruction, parseClaimReferralInstruction, parseDeliverDrawInstruction, parseDrawResolvedEvent, parseExpireDrawInstruction, parseFulfillDrawInstruction, parseFundPrizesInstruction, parseGaboxV2Instruction, parseInitializePoolInstruction, parsePackBoughtEvent, parsePoolCreatedEvent, parsePrizeRedeemedEvent, parsePrizesFundedEvent, parseRandomnessRetriedEvent, parseReferralBoundEvent, parseReferralClaimedEvent, parseRetryDrawInstruction, parseSellPrizeInstruction, parseSellTokensInstruction, parseTokensSoldEvent, generated_exports as t };
+export { BUY_PACK_DISCRIMINATOR, DELIVER_DRAW_DISCRIMINATOR, DRAW_DISCRIMINATOR, DRAW_RESOLVED_EVENT_DISCRIMINATOR, EXPIRE_DRAW_DISCRIMINATOR, FUND_PRIZES_DISCRIMINATOR, GABOX_ERROR__ARITHMETIC, GABOX_ERROR__INCORRECT_TOKEN_DELTA, GABOX_ERROR__INSOLVENT_INVENTORY, GABOX_ERROR__INVALID_DISTRIBUTION, GABOX_ERROR__INVALID_LAUNCH, GABOX_ERROR__INVALID_QUOTE, GABOX_ERROR__INVALID_VENUE, GABOX_ERROR__JACKPOT_BELOW_ONE_PACK, GABOX_ERROR__NOT_EXPIRED, GABOX_ERROR__PACK_TOO_SMALL, GABOX_ERROR__PRIZE_CAP_CHANGED, GABOX_ERROR__RETRY_TOO_SOON, GABOX_ERROR__RETRY_UNAVAILABLE, GABOX_ERROR__SLIPPAGE_EXCEEDED, GABOX_ERROR__UNFUNDED_EXPECTATION, GABOX_ERROR__UNSUPPORTED_MINT, GABOX_ERROR__WALLET_ACTIVITY_MISMATCH, GABOX_ERROR__ZERO_AMOUNT, GABOX_PROGRAM_ADDRESS, GaboxAccount, GaboxEvent, GaboxInstruction, INITIALIZE_POOL_DISCRIMINATOR, PACK_BOUGHT_EVENT_DISCRIMINATOR, POOL_CREATED_EVENT_DISCRIMINATOR, POOL_DISCRIMINATOR, PRIZES_FUNDED_EVENT_DISCRIMINATOR, RANDOMNESS_RETRIED_EVENT_DISCRIMINATOR, RETRY_DRAW_DISCRIMINATOR, SELL_TOKENS_DISCRIMINATOR, TOKENS_SOLD_EVENT_DISCRIMINATOR, WALLET_ACTIVITY_DISCRIMINATOR, decodeDraw, decodePool, decodeWalletActivity, fetchAllDraw, fetchAllMaybeDraw, fetchAllMaybePool, fetchAllMaybeWalletActivity, fetchAllPool, fetchAllWalletActivity, fetchDraw, fetchMaybeDraw, fetchMaybePool, fetchMaybeWalletActivity, fetchPool, fetchWalletActivity, findActivityPda, findDrawPda, findIdentityPda, findPoolPda, gaboxProgram, getBuyPackDiscriminatorBytes, getBuyPackInstruction, getBuyPackInstructionAsync, getBuyPackInstructionDataCodec, getBuyPackInstructionDataDecoder, getBuyPackInstructionDataEncoder, getDeliverDrawDiscriminatorBytes, getDeliverDrawInstruction, getDeliverDrawInstructionAsync, getDeliverDrawInstructionDataCodec, getDeliverDrawInstructionDataDecoder, getDeliverDrawInstructionDataEncoder, getDrawCodec, getDrawDecoder, getDrawDiscriminatorBytes, getDrawEncoder, getDrawResolvedEventCodec, getDrawResolvedEventDecoder, getDrawResolvedEventDiscriminatorBytes, getDrawResolvedEventEncoder, getDrawSize, getExpireDrawDiscriminatorBytes, getExpireDrawInstruction, getExpireDrawInstructionAsync, getExpireDrawInstructionDataCodec, getExpireDrawInstructionDataDecoder, getExpireDrawInstructionDataEncoder, getFundPrizesDiscriminatorBytes, getFundPrizesInstruction, getFundPrizesInstructionAsync, getFundPrizesInstructionDataCodec, getFundPrizesInstructionDataDecoder, getFundPrizesInstructionDataEncoder, getGaboxErrorMessage, getInitializePoolDiscriminatorBytes, getInitializePoolInstruction, getInitializePoolInstructionAsync, getInitializePoolInstructionDataCodec, getInitializePoolInstructionDataDecoder, getInitializePoolInstructionDataEncoder, getPackBoughtEventCodec, getPackBoughtEventDecoder, getPackBoughtEventDiscriminatorBytes, getPackBoughtEventEncoder, getPoolCodec, getPoolCreatedEventCodec, getPoolCreatedEventDecoder, getPoolCreatedEventDiscriminatorBytes, getPoolCreatedEventEncoder, getPoolDecoder, getPoolDiscriminatorBytes, getPoolEncoder, getPoolSize, getPrizeCodec, getPrizeDecoder, getPrizeEncoder, getPrizesFundedEventCodec, getPrizesFundedEventDecoder, getPrizesFundedEventDiscriminatorBytes, getPrizesFundedEventEncoder, getRandomnessRetriedEventCodec, getRandomnessRetriedEventDecoder, getRandomnessRetriedEventDiscriminatorBytes, getRandomnessRetriedEventEncoder, getRetryDrawDiscriminatorBytes, getRetryDrawInstruction, getRetryDrawInstructionAsync, getRetryDrawInstructionDataCodec, getRetryDrawInstructionDataDecoder, getRetryDrawInstructionDataEncoder, getSellTokensDiscriminatorBytes, getSellTokensInstruction, getSellTokensInstructionAsync, getSellTokensInstructionDataCodec, getSellTokensInstructionDataDecoder, getSellTokensInstructionDataEncoder, getTierCodec, getTierDecoder, getTierEncoder, getTokensSoldEventCodec, getTokensSoldEventDecoder, getTokensSoldEventDiscriminatorBytes, getTokensSoldEventEncoder, getWalletActivityCodec, getWalletActivityDecoder, getWalletActivityDiscriminatorBytes, getWalletActivityEncoder, getWalletActivitySize, identifyGaboxAccount, identifyGaboxEvent, identifyGaboxInstruction, isGaboxError, parseBuyPackInstruction, parseDeliverDrawInstruction, parseDrawResolvedEvent, parseExpireDrawInstruction, parseFundPrizesInstruction, parseGaboxInstruction, parseInitializePoolInstruction, parsePackBoughtEvent, parsePoolCreatedEvent, parsePrizesFundedEvent, parseRandomnessRetriedEvent, parseRetryDrawInstruction, parseSellTokensInstruction, parseTokensSoldEvent, generated_exports as t };
 
 //# sourceMappingURL=index.js.map