@1upmonster/duel 0.1.7 → 0.2.1

package/src/generated/duel/instructions/initializeTenant.ts

@@ -0,0 +1,126 @@
+/**
+ * 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
+ */
+
+import { combineCodec, fixDecoderSize, fixEncoderSize, getAddressDecoder, getAddressEncoder, getBytesDecoder, getBytesEncoder, getOptionDecoder, getOptionEncoder, getProgramDerivedAddress, getStructDecoder, getStructEncoder, getU32Decoder, getU32Encoder, getU64Decoder, getU64Encoder, getU8Decoder, getU8Encoder, SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, SolanaError, transformEncoder, type AccountMeta, type AccountSignerMeta, type Address, type Codec, type Decoder, type Encoder, type Instruction, type InstructionWithAccounts, type InstructionWithData, type Option, type OptionOrNullable, type ReadonlyAccount, type ReadonlyUint8Array, type TransactionSigner, type WritableAccount, type WritableSignerAccount } from '@solana/kit';
+import { getAccountMetaFactory, getAddressFromResolvedInstructionAccount, type ResolvedInstructionAccount } from '@solana/program-client-core';
+import { DUEL_PROGRAM_ADDRESS } from '../programs';
+
+export const INITIALIZE_TENANT_DISCRIMINATOR = new Uint8Array([94, 120, 34, 186, 57, 167, 241, 206]);
+
+export function getInitializeTenantDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(INITIALIZE_TENANT_DISCRIMINATOR); }
+
+export type InitializeTenantInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountTenant extends string | AccountMeta<string> = string, TAccountAuthority extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = "11111111111111111111111111111111", TRemainingAccounts extends readonly AccountMeta<string>[] = []> =
+Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountTenant extends string ? WritableAccount<TAccountTenant> : TAccountTenant, TAccountAuthority extends string ? WritableSignerAccount<TAccountAuthority> & AccountSignerMeta<TAccountAuthority> : TAccountAuthority, TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram, ...TRemainingAccounts]>;
+
+export type InitializeTenantInstructionData = { discriminator: ReadonlyUint8Array; tenantProgramId: Address; eloOffset: number; eloSize: number; eloWindow: bigint; callbackProgramId: Option<Address>; callbackDiscriminator: Option<ReadonlyUint8Array>;  };
+
+export type InitializeTenantInstructionDataArgs = { tenantProgramId: Address; eloOffset: number; eloSize: number; eloWindow: number | bigint; callbackProgramId: OptionOrNullable<Address>; callbackDiscriminator: OptionOrNullable<ReadonlyUint8Array>;  };
+
+export function getInitializeTenantInstructionDataEncoder(): Encoder<InitializeTenantInstructionDataArgs> {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['tenantProgramId', getAddressEncoder()], ['eloOffset', getU32Encoder()], ['eloSize', getU8Encoder()], ['eloWindow', getU64Encoder()], ['callbackProgramId', getOptionEncoder(getAddressEncoder())], ['callbackDiscriminator', getOptionEncoder(fixEncoderSize(getBytesEncoder(), 8))]]), (value) => ({ ...value, discriminator: INITIALIZE_TENANT_DISCRIMINATOR }));
+}
+
+export function getInitializeTenantInstructionDataDecoder(): Decoder<InitializeTenantInstructionData> {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['tenantProgramId', getAddressDecoder()], ['eloOffset', getU32Decoder()], ['eloSize', getU8Decoder()], ['eloWindow', getU64Decoder()], ['callbackProgramId', getOptionDecoder(getAddressDecoder())], ['callbackDiscriminator', getOptionDecoder(fixDecoderSize(getBytesDecoder(), 8))]]);
+}
+
+export function getInitializeTenantInstructionDataCodec(): Codec<InitializeTenantInstructionDataArgs, InitializeTenantInstructionData> {
+    return combineCodec(getInitializeTenantInstructionDataEncoder(), getInitializeTenantInstructionDataDecoder());
+}
+
+export type InitializeTenantAsyncInput<TAccountTenant extends string = string, TAccountAuthority extends string = string, TAccountSystemProgram extends string = string> =  {
+  tenant?: Address<TAccountTenant>;
+authority: TransactionSigner<TAccountAuthority>;
+systemProgram?: Address<TAccountSystemProgram>;
+tenantProgramId: InitializeTenantInstructionDataArgs["tenantProgramId"];
+eloOffset: InitializeTenantInstructionDataArgs["eloOffset"];
+eloSize: InitializeTenantInstructionDataArgs["eloSize"];
+eloWindow: InitializeTenantInstructionDataArgs["eloWindow"];
+callbackProgramId: InitializeTenantInstructionDataArgs["callbackProgramId"];
+callbackDiscriminator: InitializeTenantInstructionDataArgs["callbackDiscriminator"];
+}
+
+export async function getInitializeTenantInstructionAsync<TAccountTenant extends string, TAccountAuthority extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: InitializeTenantAsyncInput<TAccountTenant, TAccountAuthority, TAccountSystemProgram>, config?: { programAddress?: TProgramAddress } ): Promise<InitializeTenantInstruction<TProgramAddress, TAccountTenant, TAccountAuthority, TAccountSystemProgram>> {
+  // Program address.
+const programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;
+
+ // Original accounts.
+const originalAccounts = { tenant: { value: input.tenant ?? null, isWritable: true }, authority: { value: input.authority ?? null, isWritable: true }, systemProgram: { value: input.systemProgram ?? null, isWritable: false } }
+const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+
+// Original args.
+const args = { ...input,  };
+
+
+// Resolve default values.
+if (!accounts.tenant.value) {
+accounts.tenant.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([116, 101, 110, 97, 110, 116])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("authority", accounts.authority.value))] });
+}
+if (!accounts.systemProgram.value) {
+accounts.systemProgram.value = '11111111111111111111111111111111' as Address<'11111111111111111111111111111111'>;
+}
+
+const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+return Object.freeze({ accounts: [getAccountMeta("tenant", accounts.tenant), getAccountMeta("authority", accounts.authority), getAccountMeta("systemProgram", accounts.systemProgram)], data: getInitializeTenantInstructionDataEncoder().encode(args as InitializeTenantInstructionDataArgs), programAddress } as InitializeTenantInstruction<TProgramAddress, TAccountTenant, TAccountAuthority, TAccountSystemProgram>);
+}
+
+export type InitializeTenantInput<TAccountTenant extends string = string, TAccountAuthority extends string = string, TAccountSystemProgram extends string = string> =  {
+  tenant: Address<TAccountTenant>;
+authority: TransactionSigner<TAccountAuthority>;
+systemProgram?: Address<TAccountSystemProgram>;
+tenantProgramId: InitializeTenantInstructionDataArgs["tenantProgramId"];
+eloOffset: InitializeTenantInstructionDataArgs["eloOffset"];
+eloSize: InitializeTenantInstructionDataArgs["eloSize"];
+eloWindow: InitializeTenantInstructionDataArgs["eloWindow"];
+callbackProgramId: InitializeTenantInstructionDataArgs["callbackProgramId"];
+callbackDiscriminator: InitializeTenantInstructionDataArgs["callbackDiscriminator"];
+}
+
+export function getInitializeTenantInstruction<TAccountTenant extends string, TAccountAuthority extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: InitializeTenantInput<TAccountTenant, TAccountAuthority, TAccountSystemProgram>, config?: { programAddress?: TProgramAddress } ): InitializeTenantInstruction<TProgramAddress, TAccountTenant, TAccountAuthority, TAccountSystemProgram> {
+  // Program address.
+const programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;
+
+ // Original accounts.
+const originalAccounts = { tenant: { value: input.tenant ?? null, isWritable: true }, authority: { value: input.authority ?? null, isWritable: true }, systemProgram: { value: input.systemProgram ?? null, isWritable: false } }
+const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+
+// Original args.
+const args = { ...input,  };
+
+
+// Resolve default values.
+if (!accounts.systemProgram.value) {
+accounts.systemProgram.value = '11111111111111111111111111111111' as Address<'11111111111111111111111111111111'>;
+}
+
+const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+return Object.freeze({ accounts: [getAccountMeta("tenant", accounts.tenant), getAccountMeta("authority", accounts.authority), getAccountMeta("systemProgram", accounts.systemProgram)], data: getInitializeTenantInstructionDataEncoder().encode(args as InitializeTenantInstructionDataArgs), programAddress } as InitializeTenantInstruction<TProgramAddress, TAccountTenant, TAccountAuthority, TAccountSystemProgram>);
+}
+
+export type ParsedInitializeTenantInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;
+accounts: {
+tenant: TAccountMetas[0];
+authority: TAccountMetas[1];
+systemProgram: TAccountMetas[2];
+};
+data: InitializeTenantInstructionData; };
+
+export function parseInitializeTenantInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedInitializeTenantInstruction<TProgram, TAccountMetas> {
+  if (instruction.accounts.length < 3) {
+  throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: 3 });
+}
+let accountIndex = 0;
+const getNextAccount = () => {
+  const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;
+  accountIndex += 1;
+  return accountMeta;
+}
+  return { programAddress: instruction.programAddress, accounts: { tenant: getNextAccount(), authority: getNextAccount(), systemProgram: getNextAccount() }, data: getInitializeTenantInstructionDataDecoder().decode(instruction.data) };
+}

package/src/generated/duel/instructions/joinQueue.ts

@@ -0,0 +1,106 @@
+/**
+ * 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
+ */
+
+import { combineCodec, fixDecoderSize, fixEncoderSize, getAddressEncoder, getBytesDecoder, getBytesEncoder, getProgramDerivedAddress, getStructDecoder, getStructEncoder, SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, SolanaError, transformEncoder, type AccountMeta, type AccountSignerMeta, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type Instruction, type InstructionWithAccounts, type InstructionWithData, type ReadonlyAccount, type ReadonlySignerAccount, type ReadonlyUint8Array, type TransactionSigner, type WritableAccount } from '@solana/kit';
+import { getAccountMetaFactory, getAddressFromResolvedInstructionAccount, type ResolvedInstructionAccount } from '@solana/program-client-core';
+import { DUEL_PROGRAM_ADDRESS } from '../programs';
+
+export const JOIN_QUEUE_DISCRIMINATOR = new Uint8Array([157, 115, 48, 109, 65, 86, 203, 238]);
+
+export function getJoinQueueDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(JOIN_QUEUE_DISCRIMINATOR); }
+
+export type JoinQueueInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountQueue extends string | AccountMeta<string> = string, TAccountTenant extends string | AccountMeta<string> = string, TAccountPlayerData extends string | AccountMeta<string> = string, TAccountPlayerTicket extends string | AccountMeta<string> = string, TAccountSigner extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> =
+Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountQueue extends string ? WritableAccount<TAccountQueue> : TAccountQueue, TAccountTenant extends string ? ReadonlyAccount<TAccountTenant> : TAccountTenant, TAccountPlayerData extends string ? WritableAccount<TAccountPlayerData> : TAccountPlayerData, TAccountPlayerTicket extends string ? WritableAccount<TAccountPlayerTicket> : TAccountPlayerTicket, TAccountSigner extends string ? ReadonlySignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner, ...TRemainingAccounts]>;
+
+export type JoinQueueInstructionData = { discriminator: ReadonlyUint8Array;  };
+
+export type JoinQueueInstructionDataArgs = {  };
+
+export function getJoinQueueInstructionDataEncoder(): FixedSizeEncoder<JoinQueueInstructionDataArgs> {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({ ...value, discriminator: JOIN_QUEUE_DISCRIMINATOR }));
+}
+
+export function getJoinQueueInstructionDataDecoder(): FixedSizeDecoder<JoinQueueInstructionData> {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);
+}
+
+export function getJoinQueueInstructionDataCodec(): FixedSizeCodec<JoinQueueInstructionDataArgs, JoinQueueInstructionData> {
+    return combineCodec(getJoinQueueInstructionDataEncoder(), getJoinQueueInstructionDataDecoder());
+}
+
+export type JoinQueueAsyncInput<TAccountQueue extends string = string, TAccountTenant extends string = string, TAccountPlayerData extends string = string, TAccountPlayerTicket extends string = string, TAccountSigner extends string = string> =  {
+  queue: Address<TAccountQueue>;
+tenant: Address<TAccountTenant>;
+playerData: Address<TAccountPlayerData>;
+playerTicket?: Address<TAccountPlayerTicket>;
+signer: TransactionSigner<TAccountSigner>;
+}
+
+export async function getJoinQueueInstructionAsync<TAccountQueue extends string, TAccountTenant extends string, TAccountPlayerData extends string, TAccountPlayerTicket extends string, TAccountSigner extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: JoinQueueAsyncInput<TAccountQueue, TAccountTenant, TAccountPlayerData, TAccountPlayerTicket, TAccountSigner>, config?: { programAddress?: TProgramAddress } ): Promise<JoinQueueInstruction<TProgramAddress, TAccountQueue, TAccountTenant, TAccountPlayerData, TAccountPlayerTicket, TAccountSigner>> {
+  // Program address.
+const programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;
+
+ // Original accounts.
+const originalAccounts = { queue: { value: input.queue ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, playerData: { value: input.playerData ?? null, isWritable: true }, playerTicket: { value: input.playerTicket ?? null, isWritable: true }, signer: { value: input.signer ?? null, isWritable: false } }
+const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+
+// Resolve default values.
+if (!accounts.playerTicket.value) {
+accounts.playerTicket.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([116, 105, 99, 107, 101, 116])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("signer", accounts.signer.value)), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("tenant", accounts.tenant.value))] });
+}
+
+const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+return Object.freeze({ accounts: [getAccountMeta("queue", accounts.queue), getAccountMeta("tenant", accounts.tenant), getAccountMeta("playerData", accounts.playerData), getAccountMeta("playerTicket", accounts.playerTicket), getAccountMeta("signer", accounts.signer)], data: getJoinQueueInstructionDataEncoder().encode({}), programAddress } as JoinQueueInstruction<TProgramAddress, TAccountQueue, TAccountTenant, TAccountPlayerData, TAccountPlayerTicket, TAccountSigner>);
+}
+
+export type JoinQueueInput<TAccountQueue extends string = string, TAccountTenant extends string = string, TAccountPlayerData extends string = string, TAccountPlayerTicket extends string = string, TAccountSigner extends string = string> =  {
+  queue: Address<TAccountQueue>;
+tenant: Address<TAccountTenant>;
+playerData: Address<TAccountPlayerData>;
+playerTicket: Address<TAccountPlayerTicket>;
+signer: TransactionSigner<TAccountSigner>;
+}
+
+export function getJoinQueueInstruction<TAccountQueue extends string, TAccountTenant extends string, TAccountPlayerData extends string, TAccountPlayerTicket extends string, TAccountSigner extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: JoinQueueInput<TAccountQueue, TAccountTenant, TAccountPlayerData, TAccountPlayerTicket, TAccountSigner>, config?: { programAddress?: TProgramAddress } ): JoinQueueInstruction<TProgramAddress, TAccountQueue, TAccountTenant, TAccountPlayerData, TAccountPlayerTicket, TAccountSigner> {
+  // Program address.
+const programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;
+
+ // Original accounts.
+const originalAccounts = { queue: { value: input.queue ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, playerData: { value: input.playerData ?? null, isWritable: true }, playerTicket: { value: input.playerTicket ?? null, isWritable: true }, signer: { value: input.signer ?? null, isWritable: false } }
+const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+
+
+
+const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+return Object.freeze({ accounts: [getAccountMeta("queue", accounts.queue), getAccountMeta("tenant", accounts.tenant), getAccountMeta("playerData", accounts.playerData), getAccountMeta("playerTicket", accounts.playerTicket), getAccountMeta("signer", accounts.signer)], data: getJoinQueueInstructionDataEncoder().encode({}), programAddress } as JoinQueueInstruction<TProgramAddress, TAccountQueue, TAccountTenant, TAccountPlayerData, TAccountPlayerTicket, TAccountSigner>);
+}
+
+export type ParsedJoinQueueInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;
+accounts: {
+queue: TAccountMetas[0];
+tenant: TAccountMetas[1];
+playerData: TAccountMetas[2];
+playerTicket: TAccountMetas[3];
+signer: TAccountMetas[4];
+};
+data: JoinQueueInstructionData; };
+
+export function parseJoinQueueInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedJoinQueueInstruction<TProgram, TAccountMetas> {
+  if (instruction.accounts.length < 5) {
+  throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: 5 });
+}
+let accountIndex = 0;
+const getNextAccount = () => {
+  const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;
+  accountIndex += 1;
+  return accountMeta;
+}
+  return { programAddress: instruction.programAddress, accounts: { queue: getNextAccount(), tenant: getNextAccount(), playerData: getNextAccount(), playerTicket: getNextAccount(), signer: getNextAccount() }, data: getJoinQueueInstructionDataDecoder().decode(instruction.data) };
+}

package/src/generated/duel/instructions/processUndelegation.ts

@@ -0,0 +1,86 @@
+/**
+ * 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
+ */
+
+import { addDecoderSizePrefix, addEncoderSizePrefix, combineCodec, fixDecoderSize, fixEncoderSize, getArrayDecoder, getArrayEncoder, getBytesDecoder, getBytesEncoder, getStructDecoder, getStructEncoder, getU32Decoder, getU32Encoder, SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, SolanaError, transformEncoder, type AccountMeta, type Address, type Codec, type Decoder, type Encoder, type Instruction, type InstructionWithAccounts, type InstructionWithData, type ReadonlyAccount, type ReadonlyUint8Array, type WritableAccount } from '@solana/kit';
+import { getAccountMetaFactory, type ResolvedInstructionAccount } from '@solana/program-client-core';
+import { DUEL_PROGRAM_ADDRESS } from '../programs';
+
+export const PROCESS_UNDELEGATION_DISCRIMINATOR = new Uint8Array([196, 28, 41, 206, 48, 37, 51, 167]);
+
+export function getProcessUndelegationDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(PROCESS_UNDELEGATION_DISCRIMINATOR); }
+
+export type ProcessUndelegationInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountBaseAccount extends string | AccountMeta<string> = string, TAccountBuffer extends string | AccountMeta<string> = string, TAccountPayer extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = "11111111111111111111111111111111", TRemainingAccounts extends readonly AccountMeta<string>[] = []> =
+Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountBaseAccount extends string ? WritableAccount<TAccountBaseAccount> : TAccountBaseAccount, TAccountBuffer extends string ? ReadonlyAccount<TAccountBuffer> : TAccountBuffer, TAccountPayer extends string ? WritableAccount<TAccountPayer> : TAccountPayer, TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram, ...TRemainingAccounts]>;
+
+export type ProcessUndelegationInstructionData = { discriminator: ReadonlyUint8Array; accountSeeds: Array<ReadonlyUint8Array>;  };
+
+export type ProcessUndelegationInstructionDataArgs = { accountSeeds: Array<ReadonlyUint8Array>;  };
+
+export function getProcessUndelegationInstructionDataEncoder(): Encoder<ProcessUndelegationInstructionDataArgs> {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['accountSeeds', getArrayEncoder(addEncoderSizePrefix(getBytesEncoder(), getU32Encoder()))]]), (value) => ({ ...value, discriminator: PROCESS_UNDELEGATION_DISCRIMINATOR }));
+}
+
+export function getProcessUndelegationInstructionDataDecoder(): Decoder<ProcessUndelegationInstructionData> {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['accountSeeds', getArrayDecoder(addDecoderSizePrefix(getBytesDecoder(), getU32Decoder()))]]);
+}
+
+export function getProcessUndelegationInstructionDataCodec(): Codec<ProcessUndelegationInstructionDataArgs, ProcessUndelegationInstructionData> {
+    return combineCodec(getProcessUndelegationInstructionDataEncoder(), getProcessUndelegationInstructionDataDecoder());
+}
+
+export type ProcessUndelegationInput<TAccountBaseAccount extends string = string, TAccountBuffer extends string = string, TAccountPayer extends string = string, TAccountSystemProgram extends string = string> =  {
+  baseAccount: Address<TAccountBaseAccount>;
+buffer: Address<TAccountBuffer>;
+payer: Address<TAccountPayer>;
+systemProgram?: Address<TAccountSystemProgram>;
+accountSeeds: ProcessUndelegationInstructionDataArgs["accountSeeds"];
+}
+
+export function getProcessUndelegationInstruction<TAccountBaseAccount extends string, TAccountBuffer extends string, TAccountPayer extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: ProcessUndelegationInput<TAccountBaseAccount, TAccountBuffer, TAccountPayer, TAccountSystemProgram>, config?: { programAddress?: TProgramAddress } ): ProcessUndelegationInstruction<TProgramAddress, TAccountBaseAccount, TAccountBuffer, TAccountPayer, TAccountSystemProgram> {
+  // Program address.
+const programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;
+
+ // Original accounts.
+const originalAccounts = { baseAccount: { value: input.baseAccount ?? null, isWritable: true }, buffer: { value: input.buffer ?? null, isWritable: false }, payer: { value: input.payer ?? null, isWritable: true }, systemProgram: { value: input.systemProgram ?? null, isWritable: false } }
+const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+
+// Original args.
+const args = { ...input,  };
+
+
+// Resolve default values.
+if (!accounts.systemProgram.value) {
+accounts.systemProgram.value = '11111111111111111111111111111111' as Address<'11111111111111111111111111111111'>;
+}
+
+const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+return Object.freeze({ accounts: [getAccountMeta("baseAccount", accounts.baseAccount), getAccountMeta("buffer", accounts.buffer), getAccountMeta("payer", accounts.payer), getAccountMeta("systemProgram", accounts.systemProgram)], data: getProcessUndelegationInstructionDataEncoder().encode(args as ProcessUndelegationInstructionDataArgs), programAddress } as ProcessUndelegationInstruction<TProgramAddress, TAccountBaseAccount, TAccountBuffer, TAccountPayer, TAccountSystemProgram>);
+}
+
+export type ParsedProcessUndelegationInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;
+accounts: {
+baseAccount: TAccountMetas[0];
+buffer: TAccountMetas[1];
+payer: TAccountMetas[2];
+systemProgram: TAccountMetas[3];
+};
+data: ProcessUndelegationInstructionData; };
+
+export function parseProcessUndelegationInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedProcessUndelegationInstruction<TProgram, TAccountMetas> {
+  if (instruction.accounts.length < 4) {
+  throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: 4 });
+}
+let accountIndex = 0;
+const getNextAccount = () => {
+  const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;
+  accountIndex += 1;
+  return accountMeta;
+}
+  return { programAddress: instruction.programAddress, accounts: { baseAccount: getNextAccount(), buffer: getNextAccount(), payer: getNextAccount(), systemProgram: getNextAccount() }, data: getProcessUndelegationInstructionDataDecoder().decode(instruction.data) };
+}

package/src/generated/duel/programs/duel.ts

@@ -0,0 +1,104 @@
+/**
+ * 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
+ */
+
+import { assertIsInstructionWithAccounts, containsBytes, fixEncoderSize, getBytesEncoder, SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT, SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, SolanaError, type Address, type ClientWithPayer, type ClientWithRpc, type ClientWithTransactionPlanning, type ClientWithTransactionSending, type GetAccountInfoApi, type GetMultipleAccountsApi, type Instruction, type InstructionWithData, type ReadonlyUint8Array } from '@solana/kit';
+import { addSelfFetchFunctions, addSelfPlanAndSendFunctions, type SelfFetchFunctions, type SelfPlanAndSendFunctions } from '@solana/program-client-core';
+import { getMatchTicketCodec, getQueueCodec, getTenantCodec, type MatchTicket, type MatchTicketArgs, type Queue, type QueueArgs, type Tenant, type TenantArgs } from '../accounts';
+import { getCancelTicketInstructionAsync, getCloseTicketInstructionAsync, getCommitTicketsInstruction, getCreateTicketInstructionAsync, getDelegateQueueInstructionAsync, getDelegateTicketInstructionAsync, getFlushMatchesInstruction, getInitializeQueueInstructionAsync, getInitializeTenantInstructionAsync, getJoinQueueInstructionAsync, getProcessUndelegationInstruction, parseCancelTicketInstruction, parseCloseTicketInstruction, parseCommitTicketsInstruction, parseCreateTicketInstruction, parseDelegateQueueInstruction, parseDelegateTicketInstruction, parseFlushMatchesInstruction, parseInitializeQueueInstruction, parseInitializeTenantInstruction, parseJoinQueueInstruction, parseProcessUndelegationInstruction, type CancelTicketAsyncInput, type CloseTicketAsyncInput, type CommitTicketsInput, type CreateTicketAsyncInput, type DelegateQueueAsyncInput, type DelegateTicketAsyncInput, type FlushMatchesInput, type InitializeQueueAsyncInput, type InitializeTenantAsyncInput, type JoinQueueAsyncInput, type ParsedCancelTicketInstruction, type ParsedCloseTicketInstruction, type ParsedCommitTicketsInstruction, type ParsedCreateTicketInstruction, type ParsedDelegateQueueInstruction, type ParsedDelegateTicketInstruction, type ParsedFlushMatchesInstruction, type ParsedInitializeQueueInstruction, type ParsedInitializeTenantInstruction, type ParsedJoinQueueInstruction, type ParsedProcessUndelegationInstruction, type ProcessUndelegationInput } from '../instructions';
+
+export const DUEL_PROGRAM_ADDRESS = 'EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X' as Address<'EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X'>;
+
+export enum DuelAccount { MatchTicket, Queue, Tenant }
+
+export function identifyDuelAccount(account: { data: ReadonlyUint8Array } | ReadonlyUint8Array): DuelAccount {
+    const data = 'data' in account ? account.data : account;
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([11, 131, 4, 157, 207, 79, 126, 5])), 0)) { return DuelAccount.MatchTicket; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([204, 167, 6, 247, 20, 33, 2, 188])), 0)) { return DuelAccount.Queue; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([61, 43, 215, 51, 232, 242, 209, 170])), 0)) { return DuelAccount.Tenant; }
+    throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT, { accountData: data, programName: "duel" });
+}
+
+export enum DuelInstruction { CancelTicket, CloseTicket, CommitTickets, CreateTicket, DelegateQueue, DelegateTicket, FlushMatches, InitializeQueue, InitializeTenant, JoinQueue, ProcessUndelegation }
+
+export function identifyDuelInstruction(instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array): DuelInstruction {
+    const data = 'data' in instruction ? instruction.data : instruction;
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([216, 28, 247, 206, 195, 171, 100, 143])), 0)) { return DuelInstruction.CancelTicket; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([66, 209, 114, 197, 75, 27, 182, 117])), 0)) { return DuelInstruction.CloseTicket; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([245, 199, 81, 0, 62, 133, 18, 22])), 0)) { return DuelInstruction.CommitTickets; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([16, 178, 122, 25, 213, 85, 96, 129])), 0)) { return DuelInstruction.CreateTicket; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([31, 200, 139, 125, 93, 239, 83, 87])), 0)) { return DuelInstruction.DelegateQueue; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([195, 3, 78, 64, 128, 235, 209, 171])), 0)) { return DuelInstruction.DelegateTicket; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([49, 148, 163, 71, 77, 63, 197, 76])), 0)) { return DuelInstruction.FlushMatches; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([174, 102, 132, 232, 90, 202, 27, 20])), 0)) { return DuelInstruction.InitializeQueue; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([94, 120, 34, 186, 57, 167, 241, 206])), 0)) { return DuelInstruction.InitializeTenant; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([157, 115, 48, 109, 65, 86, 203, 238])), 0)) { return DuelInstruction.JoinQueue; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([196, 28, 41, 206, 48, 37, 51, 167])), 0)) { return DuelInstruction.ProcessUndelegation; }
+    throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, { instructionData: data, programName: "duel" });
+}
+
+export type ParsedDuelInstruction<TProgram extends string = 'EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X'> =
+| { instructionType: DuelInstruction.CancelTicket } & ParsedCancelTicketInstruction<TProgram>
+| { instructionType: DuelInstruction.CloseTicket } & ParsedCloseTicketInstruction<TProgram>
+| { instructionType: DuelInstruction.CommitTickets } & ParsedCommitTicketsInstruction<TProgram>
+| { instructionType: DuelInstruction.CreateTicket } & ParsedCreateTicketInstruction<TProgram>
+| { instructionType: DuelInstruction.DelegateQueue } & ParsedDelegateQueueInstruction<TProgram>
+| { instructionType: DuelInstruction.DelegateTicket } & ParsedDelegateTicketInstruction<TProgram>
+| { instructionType: DuelInstruction.FlushMatches } & ParsedFlushMatchesInstruction<TProgram>
+| { instructionType: DuelInstruction.InitializeQueue } & ParsedInitializeQueueInstruction<TProgram>
+| { instructionType: DuelInstruction.InitializeTenant } & ParsedInitializeTenantInstruction<TProgram>
+| { instructionType: DuelInstruction.JoinQueue } & ParsedJoinQueueInstruction<TProgram>
+| { instructionType: DuelInstruction.ProcessUndelegation } & ParsedProcessUndelegationInstruction<TProgram>
+
+
+        export function parseDuelInstruction<TProgram extends string>(
+            instruction: Instruction<TProgram> 
+                & InstructionWithData<ReadonlyUint8Array>
+        ): ParsedDuelInstruction<TProgram> {
+            const instructionType = identifyDuelInstruction(instruction);
+            switch (instructionType) {
+                case DuelInstruction.CancelTicket: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: DuelInstruction.CancelTicket, ...parseCancelTicketInstruction(instruction) }; }
+case DuelInstruction.CloseTicket: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: DuelInstruction.CloseTicket, ...parseCloseTicketInstruction(instruction) }; }
+case DuelInstruction.CommitTickets: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: DuelInstruction.CommitTickets, ...parseCommitTicketsInstruction(instruction) }; }
+case DuelInstruction.CreateTicket: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: DuelInstruction.CreateTicket, ...parseCreateTicketInstruction(instruction) }; }
+case DuelInstruction.DelegateQueue: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: DuelInstruction.DelegateQueue, ...parseDelegateQueueInstruction(instruction) }; }
+case DuelInstruction.DelegateTicket: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: DuelInstruction.DelegateTicket, ...parseDelegateTicketInstruction(instruction) }; }
+case DuelInstruction.FlushMatches: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: DuelInstruction.FlushMatches, ...parseFlushMatchesInstruction(instruction) }; }
+case DuelInstruction.InitializeQueue: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: DuelInstruction.InitializeQueue, ...parseInitializeQueueInstruction(instruction) }; }
+case DuelInstruction.InitializeTenant: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: DuelInstruction.InitializeTenant, ...parseInitializeTenantInstruction(instruction) }; }
+case DuelInstruction.JoinQueue: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: DuelInstruction.JoinQueue, ...parseJoinQueueInstruction(instruction) }; }
+case DuelInstruction.ProcessUndelegation: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: DuelInstruction.ProcessUndelegation, ...parseProcessUndelegationInstruction(instruction) }; }
+                default: throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, { instructionType: instructionType as string, programName: "duel" });
+            }
+        }
+
+export type DuelPlugin = { accounts: DuelPluginAccounts; instructions: DuelPluginInstructions; }
+
+export type DuelPluginAccounts = { matchTicket: ReturnType<typeof getMatchTicketCodec> & SelfFetchFunctions<MatchTicketArgs, MatchTicket>; queue: ReturnType<typeof getQueueCodec> & SelfFetchFunctions<QueueArgs, Queue>; tenant: ReturnType<typeof getTenantCodec> & SelfFetchFunctions<TenantArgs, Tenant>; }
+
+export type DuelPluginInstructions = { cancelTicket: (input: CancelTicketAsyncInput) => ReturnType<typeof getCancelTicketInstructionAsync> & SelfPlanAndSendFunctions; closeTicket: (input: CloseTicketAsyncInput) => ReturnType<typeof getCloseTicketInstructionAsync> & SelfPlanAndSendFunctions; commitTickets: (input: MakeOptional<CommitTicketsInput, "payer">) => ReturnType<typeof getCommitTicketsInstruction> & SelfPlanAndSendFunctions; createTicket: (input: CreateTicketAsyncInput) => ReturnType<typeof getCreateTicketInstructionAsync> & SelfPlanAndSendFunctions; delegateQueue: (input: MakeOptional<DelegateQueueAsyncInput, "payer">) => ReturnType<typeof getDelegateQueueInstructionAsync> & SelfPlanAndSendFunctions; delegateTicket: (input: MakeOptional<DelegateTicketAsyncInput, "payer">) => ReturnType<typeof getDelegateTicketInstructionAsync> & SelfPlanAndSendFunctions; flushMatches: (input: FlushMatchesInput) => ReturnType<typeof getFlushMatchesInstruction> & SelfPlanAndSendFunctions; initializeQueue: (input: InitializeQueueAsyncInput) => ReturnType<typeof getInitializeQueueInstructionAsync> & SelfPlanAndSendFunctions; initializeTenant: (input: InitializeTenantAsyncInput) => ReturnType<typeof getInitializeTenantInstructionAsync> & SelfPlanAndSendFunctions; joinQueue: (input: JoinQueueAsyncInput) => ReturnType<typeof getJoinQueueInstructionAsync> & SelfPlanAndSendFunctions; processUndelegation: (input: MakeOptional<ProcessUndelegationInput, "payer">) => ReturnType<typeof getProcessUndelegationInstruction> & SelfPlanAndSendFunctions; }
+
+export type DuelPluginRequirements = ClientWithRpc<GetAccountInfoApi & GetMultipleAccountsApi> & ClientWithPayer & ClientWithTransactionPlanning & ClientWithTransactionSending
+
+export function duelProgram() {
+    return <T extends DuelPluginRequirements>(client: T) => {
+        return { ...client, duel: <DuelPlugin>{ accounts: { matchTicket: addSelfFetchFunctions(client, getMatchTicketCodec()), queue: addSelfFetchFunctions(client, getQueueCodec()), tenant: addSelfFetchFunctions(client, getTenantCodec()) }, instructions: { cancelTicket: input => addSelfPlanAndSendFunctions(client, getCancelTicketInstructionAsync(input)), closeTicket: input => addSelfPlanAndSendFunctions(client, getCloseTicketInstructionAsync(input)), commitTickets: input => addSelfPlanAndSendFunctions(client, getCommitTicketsInstruction({ ...input, payer: input.payer ?? client.payer })), createTicket: input => addSelfPlanAndSendFunctions(client, getCreateTicketInstructionAsync(input)), delegateQueue: input => addSelfPlanAndSendFunctions(client, getDelegateQueueInstructionAsync({ ...input, payer: input.payer ?? client.payer })), delegateTicket: input => addSelfPlanAndSendFunctions(client, getDelegateTicketInstructionAsync({ ...input, payer: input.payer ?? client.payer })), flushMatches: input => addSelfPlanAndSendFunctions(client, getFlushMatchesInstruction(input)), initializeQueue: input => addSelfPlanAndSendFunctions(client, getInitializeQueueInstructionAsync(input)), initializeTenant: input => addSelfPlanAndSendFunctions(client, getInitializeTenantInstructionAsync(input)), joinQueue: input => addSelfPlanAndSendFunctions(client, getJoinQueueInstructionAsync(input)), processUndelegation: input => addSelfPlanAndSendFunctions(client, getProcessUndelegationInstruction({ ...input, payer: input.payer ?? client.payer.address })) } } };
+    };
+}
+
+type MakeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

package/src/generated/duel/programs/index.ts

@@ -0,0 +1,9 @@
+/**
+ * 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
+ */
+
+export * from './duel';

package/src/generated/duel/types/accountType.ts

@@ -0,0 +1,36 @@
+/**
+ * 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
+ */
+
+import { combineCodec, getAddressDecoder, getAddressEncoder, getDiscriminatedUnionDecoder, getDiscriminatedUnionEncoder, getStructDecoder, getStructEncoder, type Address, type Codec, type Decoder, type Encoder, type GetDiscriminatedUnionVariant, type GetDiscriminatedUnionVariantContent } from '@solana/kit';
+
+export type AccountType = { __kind: "Queue", authority: Address;  } | { __kind: "Ticket", player: Address; tenant: Address;  };
+
+export type AccountTypeArgs = AccountType;
+
+export function getAccountTypeEncoder(): Encoder<AccountTypeArgs> {
+    return getDiscriminatedUnionEncoder([['Queue', getStructEncoder([['authority', getAddressEncoder()]])], ['Ticket', getStructEncoder([['player', getAddressEncoder()], ['tenant', getAddressEncoder()]])]]);
+}
+
+export function getAccountTypeDecoder(): Decoder<AccountType> {
+    return getDiscriminatedUnionDecoder([['Queue', getStructDecoder([['authority', getAddressDecoder()]])], ['Ticket', getStructDecoder([['player', getAddressDecoder()], ['tenant', getAddressDecoder()]])]]);
+}
+
+export function getAccountTypeCodec(): Codec<AccountTypeArgs, AccountType> {
+    return combineCodec(getAccountTypeEncoder(), getAccountTypeDecoder());
+}
+
+// Data Enum Helpers.
+export function accountType(kind: 'Queue', data: GetDiscriminatedUnionVariantContent<AccountTypeArgs, '__kind', 'Queue'>): GetDiscriminatedUnionVariant<AccountTypeArgs, '__kind', 'Queue'>;
+export function accountType(kind: 'Ticket', data: GetDiscriminatedUnionVariantContent<AccountTypeArgs, '__kind', 'Ticket'>): GetDiscriminatedUnionVariant<AccountTypeArgs, '__kind', 'Ticket'>;
+export function accountType<K extends AccountTypeArgs['__kind'], Data>(kind: K, data?: Data) {
+  return Array.isArray(data) ? { __kind: kind, fields: data } : { __kind: kind, ...(data ?? {}) };
+}
+
+export function isAccountType<K extends AccountType['__kind']>(kind: K, value: AccountType): value is AccountType & { __kind: K } {
+  return value.__kind === kind;
+};

package/src/generated/duel/types/index.ts

@@ -0,0 +1,14 @@
+/**
+ * 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
+ */
+
+export * from './accountType';
+export * from './matchEntry';
+export * from './matchFound';
+export * from './pendingMatch';
+export * from './queueEntry';
+export * from './ticketStatus';

package/src/generated/duel/types/matchEntry.ts

@@ -0,0 +1,25 @@
+/**
+ * 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
+ */
+
+import { combineCodec, getAddressDecoder, getAddressEncoder, getI64Decoder, getI64Encoder, getStructDecoder, getStructEncoder, getU64Decoder, getU64Encoder, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder } from '@solana/kit';
+
+export type MatchEntry = { player1: Address; player2: Address; matchId: bigint; timestamp: bigint;  };
+
+export type MatchEntryArgs = { player1: Address; player2: Address; matchId: number | bigint; timestamp: number | bigint;  };
+
+export function getMatchEntryEncoder(): FixedSizeEncoder<MatchEntryArgs> {
+    return getStructEncoder([['player1', getAddressEncoder()], ['player2', getAddressEncoder()], ['matchId', getU64Encoder()], ['timestamp', getI64Encoder()]]);
+}
+
+export function getMatchEntryDecoder(): FixedSizeDecoder<MatchEntry> {
+    return getStructDecoder([['player1', getAddressDecoder()], ['player2', getAddressDecoder()], ['matchId', getU64Decoder()], ['timestamp', getI64Decoder()]]);
+}
+
+export function getMatchEntryCodec(): FixedSizeCodec<MatchEntryArgs, MatchEntry> {
+    return combineCodec(getMatchEntryEncoder(), getMatchEntryDecoder());
+}

package/src/generated/duel/types/matchFound.ts

@@ -0,0 +1,25 @@
+/**
+ * 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
+ */
+
+import { combineCodec, getAddressDecoder, getAddressEncoder, getI64Decoder, getI64Encoder, getStructDecoder, getStructEncoder, getU64Decoder, getU64Encoder, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder } from '@solana/kit';
+
+export type MatchFound = { player1: Address; player2: Address; matchId: bigint; timestamp: bigint;  };
+
+export type MatchFoundArgs = { player1: Address; player2: Address; matchId: number | bigint; timestamp: number | bigint;  };
+
+export function getMatchFoundEncoder(): FixedSizeEncoder<MatchFoundArgs> {
+    return getStructEncoder([['player1', getAddressEncoder()], ['player2', getAddressEncoder()], ['matchId', getU64Encoder()], ['timestamp', getI64Encoder()]]);
+}
+
+export function getMatchFoundDecoder(): FixedSizeDecoder<MatchFound> {
+    return getStructDecoder([['player1', getAddressDecoder()], ['player2', getAddressDecoder()], ['matchId', getU64Decoder()], ['timestamp', getI64Decoder()]]);
+}
+
+export function getMatchFoundCodec(): FixedSizeCodec<MatchFoundArgs, MatchFound> {
+    return combineCodec(getMatchFoundEncoder(), getMatchFoundDecoder());
+}

package/src/generated/duel/types/pendingMatch.ts

@@ -0,0 +1,25 @@
+/**
+ * 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
+ */
+
+import { combineCodec, getAddressDecoder, getAddressEncoder, getStructDecoder, getStructEncoder, getU64Decoder, getU64Encoder, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder } from '@solana/kit';
+
+export type PendingMatch = { player: Address; opponent: Address; matchId: bigint;  };
+
+export type PendingMatchArgs = { player: Address; opponent: Address; matchId: number | bigint;  };
+
+export function getPendingMatchEncoder(): FixedSizeEncoder<PendingMatchArgs> {
+    return getStructEncoder([['player', getAddressEncoder()], ['opponent', getAddressEncoder()], ['matchId', getU64Encoder()]]);
+}
+
+export function getPendingMatchDecoder(): FixedSizeDecoder<PendingMatch> {
+    return getStructDecoder([['player', getAddressDecoder()], ['opponent', getAddressDecoder()], ['matchId', getU64Decoder()]]);
+}
+
+export function getPendingMatchCodec(): FixedSizeCodec<PendingMatchArgs, PendingMatch> {
+    return combineCodec(getPendingMatchEncoder(), getPendingMatchDecoder());
+}

package/src/generated/duel/types/queueEntry.ts

@@ -0,0 +1,25 @@
+/**
+ * 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
+ */
+
+import { combineCodec, getAddressDecoder, getAddressEncoder, getStructDecoder, getStructEncoder, getU64Decoder, getU64Encoder, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder } from '@solana/kit';
+
+export type QueueEntry = { player: Address; elo: bigint;  };
+
+export type QueueEntryArgs = { player: Address; elo: number | bigint;  };
+
+export function getQueueEntryEncoder(): FixedSizeEncoder<QueueEntryArgs> {
+    return getStructEncoder([['player', getAddressEncoder()], ['elo', getU64Encoder()]]);
+}
+
+export function getQueueEntryDecoder(): FixedSizeDecoder<QueueEntry> {
+    return getStructDecoder([['player', getAddressDecoder()], ['elo', getU64Decoder()]]);
+}
+
+export function getQueueEntryCodec(): FixedSizeCodec<QueueEntryArgs, QueueEntry> {
+    return combineCodec(getQueueEntryEncoder(), getQueueEntryDecoder());
+}