@1upmonster/duel 0.1.8 → 0.2.2

package/dist/generated/duel/instructions/initializeQueue.js

@@ -0,0 +1,63 @@
+/**
+ * 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 } from '@solana/kit';
+import { getAccountMetaFactory, getAddressFromResolvedInstructionAccount } from '@solana/program-client-core';
+import { DUEL_PROGRAM_ADDRESS } from '../programs';
+export const INITIALIZE_QUEUE_DISCRIMINATOR = new Uint8Array([174, 102, 132, 232, 90, 202, 27, 20]);
+export function getInitializeQueueDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(INITIALIZE_QUEUE_DISCRIMINATOR); }
+export function getInitializeQueueInstructionDataEncoder() {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({ ...value, discriminator: INITIALIZE_QUEUE_DISCRIMINATOR }));
+}
+export function getInitializeQueueInstructionDataDecoder() {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);
+}
+export function getInitializeQueueInstructionDataCodec() {
+    return combineCodec(getInitializeQueueInstructionDataEncoder(), getInitializeQueueInstructionDataDecoder());
+}
+export async function getInitializeQueueInstructionAsync(input, config) {
+    // 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 }, authority: { value: input.authority ?? null, isWritable: true }, systemProgram: { value: input.systemProgram ?? null, isWritable: false } };
+    const accounts = originalAccounts;
+    // Resolve default values.
+    if (!accounts.queue.value) {
+        accounts.queue.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([113, 117, 101, 117, 101])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("authority", accounts.authority.value))] });
+    }
+    if (!accounts.systemProgram.value) {
+        accounts.systemProgram.value = '11111111111111111111111111111111';
+    }
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({ accounts: [getAccountMeta("queue", accounts.queue), getAccountMeta("tenant", accounts.tenant), getAccountMeta("authority", accounts.authority), getAccountMeta("systemProgram", accounts.systemProgram)], data: getInitializeQueueInstructionDataEncoder().encode({}), programAddress });
+}
+export function getInitializeQueueInstruction(input, config) {
+    // 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 }, authority: { value: input.authority ?? null, isWritable: true }, systemProgram: { value: input.systemProgram ?? null, isWritable: false } };
+    const accounts = originalAccounts;
+    // Resolve default values.
+    if (!accounts.systemProgram.value) {
+        accounts.systemProgram.value = '11111111111111111111111111111111';
+    }
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({ accounts: [getAccountMeta("queue", accounts.queue), getAccountMeta("tenant", accounts.tenant), getAccountMeta("authority", accounts.authority), getAccountMeta("systemProgram", accounts.systemProgram)], data: getInitializeQueueInstructionDataEncoder().encode({}), programAddress });
+}
+export function parseInitializeQueueInstruction(instruction) {
+    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[accountIndex];
+        accountIndex += 1;
+        return accountMeta;
+    };
+    return { programAddress: instruction.programAddress, accounts: { queue: getNextAccount(), tenant: getNextAccount(), authority: getNextAccount(), systemProgram: getNextAccount() }, data: getInitializeQueueInstructionDataDecoder().decode(instruction.data) };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"initializeQueue.js","sourceRoot":"","sources":["../../../../src/generated/duel/instructions/initializeQueue.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * This code was AUTOGENERATED using the Codama library.\n * Please DO NOT EDIT THIS FILE, instead use visitors\n * to add features, then rerun Codama to update it.\n *\n * @see https://github.com/codama-idl/codama\n */\n\nimport { 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 ReadonlyUint8Array, type TransactionSigner, type WritableAccount, type WritableSignerAccount } from '@solana/kit';\nimport { getAccountMetaFactory, getAddressFromResolvedInstructionAccount, type ResolvedInstructionAccount } from '@solana/program-client-core';\nimport { DUEL_PROGRAM_ADDRESS } from '../programs';\n\nexport const INITIALIZE_QUEUE_DISCRIMINATOR = new Uint8Array([174, 102, 132, 232, 90, 202, 27, 20]);\n\nexport function getInitializeQueueDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(INITIALIZE_QUEUE_DISCRIMINATOR); }\n\nexport type InitializeQueueInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountQueue extends string | AccountMeta<string> = string, TAccountTenant extends string | AccountMeta<string> = string, TAccountAuthority extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = \"11111111111111111111111111111111\", TRemainingAccounts extends readonly AccountMeta<string>[] = []> =\nInstruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountQueue extends string ? WritableAccount<TAccountQueue> : TAccountQueue, TAccountTenant extends string ? ReadonlyAccount<TAccountTenant> : TAccountTenant, TAccountAuthority extends string ? WritableSignerAccount<TAccountAuthority> & AccountSignerMeta<TAccountAuthority> : TAccountAuthority, TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram, ...TRemainingAccounts]>;\n\nexport type InitializeQueueInstructionData = { discriminator: ReadonlyUint8Array;  };\n\nexport type InitializeQueueInstructionDataArgs = {  };\n\nexport function getInitializeQueueInstructionDataEncoder(): FixedSizeEncoder<InitializeQueueInstructionDataArgs> {\n    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({ ...value, discriminator: INITIALIZE_QUEUE_DISCRIMINATOR }));\n}\n\nexport function getInitializeQueueInstructionDataDecoder(): FixedSizeDecoder<InitializeQueueInstructionData> {\n    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);\n}\n\nexport function getInitializeQueueInstructionDataCodec(): FixedSizeCodec<InitializeQueueInstructionDataArgs, InitializeQueueInstructionData> {\n    return combineCodec(getInitializeQueueInstructionDataEncoder(), getInitializeQueueInstructionDataDecoder());\n}\n\nexport type InitializeQueueAsyncInput<TAccountQueue extends string = string, TAccountTenant extends string = string, TAccountAuthority extends string = string, TAccountSystemProgram extends string = string> =  {\n  queue?: Address<TAccountQueue>;\ntenant: Address<TAccountTenant>;\nauthority: TransactionSigner<TAccountAuthority>;\nsystemProgram?: Address<TAccountSystemProgram>;\n}\n\nexport async function getInitializeQueueInstructionAsync<TAccountQueue extends string, TAccountTenant extends string, TAccountAuthority extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: InitializeQueueAsyncInput<TAccountQueue, TAccountTenant, TAccountAuthority, TAccountSystemProgram>, config?: { programAddress?: TProgramAddress } ): Promise<InitializeQueueInstruction<TProgramAddress, TAccountQueue, TAccountTenant, TAccountAuthority, TAccountSystemProgram>> {\n  // Program address.\nconst programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst originalAccounts = { queue: { value: input.queue ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, authority: { value: input.authority ?? null, isWritable: true }, systemProgram: { value: input.systemProgram ?? null, isWritable: false } }\nconst accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;\n\n\n// Resolve default values.\nif (!accounts.queue.value) {\naccounts.queue.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([113, 117, 101, 117, 101])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount(\"authority\", accounts.authority.value))] });\n}\nif (!accounts.systemProgram.value) {\naccounts.systemProgram.value = '11111111111111111111111111111111' as Address<'11111111111111111111111111111111'>;\n}\n\nconst getAccountMeta = getAccountMetaFactory(programAddress, 'programId');\nreturn Object.freeze({ accounts: [getAccountMeta(\"queue\", accounts.queue), getAccountMeta(\"tenant\", accounts.tenant), getAccountMeta(\"authority\", accounts.authority), getAccountMeta(\"systemProgram\", accounts.systemProgram)], data: getInitializeQueueInstructionDataEncoder().encode({}), programAddress } as InitializeQueueInstruction<TProgramAddress, TAccountQueue, TAccountTenant, TAccountAuthority, TAccountSystemProgram>);\n}\n\nexport type InitializeQueueInput<TAccountQueue extends string = string, TAccountTenant extends string = string, TAccountAuthority extends string = string, TAccountSystemProgram extends string = string> =  {\n  queue: Address<TAccountQueue>;\ntenant: Address<TAccountTenant>;\nauthority: TransactionSigner<TAccountAuthority>;\nsystemProgram?: Address<TAccountSystemProgram>;\n}\n\nexport function getInitializeQueueInstruction<TAccountQueue extends string, TAccountTenant extends string, TAccountAuthority extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: InitializeQueueInput<TAccountQueue, TAccountTenant, TAccountAuthority, TAccountSystemProgram>, config?: { programAddress?: TProgramAddress } ): InitializeQueueInstruction<TProgramAddress, TAccountQueue, TAccountTenant, TAccountAuthority, TAccountSystemProgram> {\n  // Program address.\nconst programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst originalAccounts = { queue: { value: input.queue ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, authority: { value: input.authority ?? null, isWritable: true }, systemProgram: { value: input.systemProgram ?? null, isWritable: false } }\nconst accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;\n\n\n// Resolve default values.\nif (!accounts.systemProgram.value) {\naccounts.systemProgram.value = '11111111111111111111111111111111' as Address<'11111111111111111111111111111111'>;\n}\n\nconst getAccountMeta = getAccountMetaFactory(programAddress, 'programId');\nreturn Object.freeze({ accounts: [getAccountMeta(\"queue\", accounts.queue), getAccountMeta(\"tenant\", accounts.tenant), getAccountMeta(\"authority\", accounts.authority), getAccountMeta(\"systemProgram\", accounts.systemProgram)], data: getInitializeQueueInstructionDataEncoder().encode({}), programAddress } as InitializeQueueInstruction<TProgramAddress, TAccountQueue, TAccountTenant, TAccountAuthority, TAccountSystemProgram>);\n}\n\nexport type ParsedInitializeQueueInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;\naccounts: {\nqueue: TAccountMetas[0];\ntenant: TAccountMetas[1];\nauthority: TAccountMetas[2];\nsystemProgram: TAccountMetas[3];\n};\ndata: InitializeQueueInstructionData; };\n\nexport function parseInitializeQueueInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedInitializeQueueInstruction<TProgram, TAccountMetas> {\n  if (instruction.accounts.length < 4) {\n  throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: 4 });\n}\nlet accountIndex = 0;\nconst getNextAccount = () => {\n  const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;\n  accountIndex += 1;\n  return accountMeta;\n}\n  return { programAddress: instruction.programAddress, accounts: { queue: getNextAccount(), tenant: getNextAccount(), authority: getNextAccount(), systemProgram: getNextAccount() }, data: getInitializeQueueInstructionDataDecoder().decode(instruction.data) };\n}"]}

package/dist/generated/duel/instructions/initializeTenant.d.ts

@@ -0,0 +1,70 @@
+/**
+ * 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 { 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 { DUEL_PROGRAM_ADDRESS } from '../programs';
+export declare const INITIALIZE_TENANT_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getInitializeTenantDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+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 declare function getInitializeTenantInstructionDataEncoder(): Encoder<InitializeTenantInstructionDataArgs>;
+export declare function getInitializeTenantInstructionDataDecoder(): Decoder<InitializeTenantInstructionData>;
+export declare function getInitializeTenantInstructionDataCodec(): Codec<InitializeTenantInstructionDataArgs, InitializeTenantInstructionData>;
+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 declare 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>>;
+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 declare 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>;
+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 declare function parseInitializeTenantInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedInitializeTenantInstruction<TProgram, TAccountMetas>;

package/dist/generated/duel/instructions/initializeTenant.js

@@ -0,0 +1,67 @@
+/**
+ * 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 } from '@solana/kit';
+import { getAccountMetaFactory, getAddressFromResolvedInstructionAccount } 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 function getInitializeTenantInstructionDataEncoder() {
+    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() {
+    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() {
+    return combineCodec(getInitializeTenantInstructionDataEncoder(), getInitializeTenantInstructionDataDecoder());
+}
+export async function getInitializeTenantInstructionAsync(input, config) {
+    // 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;
+    // 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';
+    }
+    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), programAddress });
+}
+export function getInitializeTenantInstruction(input, config) {
+    // 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;
+    // Original args.
+    const args = { ...input, };
+    // Resolve default values.
+    if (!accounts.systemProgram.value) {
+        accounts.systemProgram.value = '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), programAddress });
+}
+export function parseInitializeTenantInstruction(instruction) {
+    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[accountIndex];
+        accountIndex += 1;
+        return accountMeta;
+    };
+    return { programAddress: instruction.programAddress, accounts: { tenant: getNextAccount(), authority: getNextAccount(), systemProgram: getNextAccount() }, data: getInitializeTenantInstructionDataDecoder().decode(instruction.data) };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"initializeTenant.js","sourceRoot":"","sources":["../../../../src/generated/duel/instructions/initializeTenant.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * This code was AUTOGENERATED using the Codama library.\n * Please DO NOT EDIT THIS FILE, instead use visitors\n * to add features, then rerun Codama to update it.\n *\n * @see https://github.com/codama-idl/codama\n */\n\nimport { 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';\nimport { getAccountMetaFactory, getAddressFromResolvedInstructionAccount, type ResolvedInstructionAccount } from '@solana/program-client-core';\nimport { DUEL_PROGRAM_ADDRESS } from '../programs';\n\nexport const INITIALIZE_TENANT_DISCRIMINATOR = new Uint8Array([94, 120, 34, 186, 57, 167, 241, 206]);\n\nexport function getInitializeTenantDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(INITIALIZE_TENANT_DISCRIMINATOR); }\n\nexport 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>[] = []> =\nInstruction<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]>;\n\nexport type InitializeTenantInstructionData = { discriminator: ReadonlyUint8Array; tenantProgramId: Address; eloOffset: number; eloSize: number; eloWindow: bigint; callbackProgramId: Option<Address>; callbackDiscriminator: Option<ReadonlyUint8Array>;  };\n\nexport type InitializeTenantInstructionDataArgs = { tenantProgramId: Address; eloOffset: number; eloSize: number; eloWindow: number | bigint; callbackProgramId: OptionOrNullable<Address>; callbackDiscriminator: OptionOrNullable<ReadonlyUint8Array>;  };\n\nexport function getInitializeTenantInstructionDataEncoder(): Encoder<InitializeTenantInstructionDataArgs> {\n    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 }));\n}\n\nexport function getInitializeTenantInstructionDataDecoder(): Decoder<InitializeTenantInstructionData> {\n    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['tenantProgramId', getAddressDecoder()], ['eloOffset', getU32Decoder()], ['eloSize', getU8Decoder()], ['eloWindow', getU64Decoder()], ['callbackProgramId', getOptionDecoder(getAddressDecoder())], ['callbackDiscriminator', getOptionDecoder(fixDecoderSize(getBytesDecoder(), 8))]]);\n}\n\nexport function getInitializeTenantInstructionDataCodec(): Codec<InitializeTenantInstructionDataArgs, InitializeTenantInstructionData> {\n    return combineCodec(getInitializeTenantInstructionDataEncoder(), getInitializeTenantInstructionDataDecoder());\n}\n\nexport type InitializeTenantAsyncInput<TAccountTenant extends string = string, TAccountAuthority extends string = string, TAccountSystemProgram extends string = string> =  {\n  tenant?: Address<TAccountTenant>;\nauthority: TransactionSigner<TAccountAuthority>;\nsystemProgram?: Address<TAccountSystemProgram>;\ntenantProgramId: InitializeTenantInstructionDataArgs[\"tenantProgramId\"];\neloOffset: InitializeTenantInstructionDataArgs[\"eloOffset\"];\neloSize: InitializeTenantInstructionDataArgs[\"eloSize\"];\neloWindow: InitializeTenantInstructionDataArgs[\"eloWindow\"];\ncallbackProgramId: InitializeTenantInstructionDataArgs[\"callbackProgramId\"];\ncallbackDiscriminator: InitializeTenantInstructionDataArgs[\"callbackDiscriminator\"];\n}\n\nexport 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>> {\n  // Program address.\nconst programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst originalAccounts = { tenant: { value: input.tenant ?? null, isWritable: true }, authority: { value: input.authority ?? null, isWritable: true }, systemProgram: { value: input.systemProgram ?? null, isWritable: false } }\nconst accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;\n\n\n// Original args.\nconst args = { ...input,  };\n\n\n// Resolve default values.\nif (!accounts.tenant.value) {\naccounts.tenant.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([116, 101, 110, 97, 110, 116])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount(\"authority\", accounts.authority.value))] });\n}\nif (!accounts.systemProgram.value) {\naccounts.systemProgram.value = '11111111111111111111111111111111' as Address<'11111111111111111111111111111111'>;\n}\n\nconst getAccountMeta = getAccountMetaFactory(programAddress, 'programId');\nreturn 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>);\n}\n\nexport type InitializeTenantInput<TAccountTenant extends string = string, TAccountAuthority extends string = string, TAccountSystemProgram extends string = string> =  {\n  tenant: Address<TAccountTenant>;\nauthority: TransactionSigner<TAccountAuthority>;\nsystemProgram?: Address<TAccountSystemProgram>;\ntenantProgramId: InitializeTenantInstructionDataArgs[\"tenantProgramId\"];\neloOffset: InitializeTenantInstructionDataArgs[\"eloOffset\"];\neloSize: InitializeTenantInstructionDataArgs[\"eloSize\"];\neloWindow: InitializeTenantInstructionDataArgs[\"eloWindow\"];\ncallbackProgramId: InitializeTenantInstructionDataArgs[\"callbackProgramId\"];\ncallbackDiscriminator: InitializeTenantInstructionDataArgs[\"callbackDiscriminator\"];\n}\n\nexport 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> {\n  // Program address.\nconst programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst originalAccounts = { tenant: { value: input.tenant ?? null, isWritable: true }, authority: { value: input.authority ?? null, isWritable: true }, systemProgram: { value: input.systemProgram ?? null, isWritable: false } }\nconst accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;\n\n\n// Original args.\nconst args = { ...input,  };\n\n\n// Resolve default values.\nif (!accounts.systemProgram.value) {\naccounts.systemProgram.value = '11111111111111111111111111111111' as Address<'11111111111111111111111111111111'>;\n}\n\nconst getAccountMeta = getAccountMetaFactory(programAddress, 'programId');\nreturn 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>);\n}\n\nexport type ParsedInitializeTenantInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;\naccounts: {\ntenant: TAccountMetas[0];\nauthority: TAccountMetas[1];\nsystemProgram: TAccountMetas[2];\n};\ndata: InitializeTenantInstructionData; };\n\nexport function parseInitializeTenantInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedInitializeTenantInstruction<TProgram, TAccountMetas> {\n  if (instruction.accounts.length < 3) {\n  throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: 3 });\n}\nlet accountIndex = 0;\nconst getNextAccount = () => {\n  const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;\n  accountIndex += 1;\n  return accountMeta;\n}\n  return { programAddress: instruction.programAddress, accounts: { tenant: getNextAccount(), authority: getNextAccount(), systemProgram: getNextAccount() }, data: getInitializeTenantInstructionDataDecoder().decode(instruction.data) };\n}"]}

package/dist/generated/duel/instructions/joinQueue.d.ts

@@ -0,0 +1,51 @@
+/**
+ * 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 { 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 { DUEL_PROGRAM_ADDRESS } from '../programs';
+export declare const JOIN_QUEUE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getJoinQueueDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+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 ? ReadonlyAccount<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 declare function getJoinQueueInstructionDataEncoder(): FixedSizeEncoder<JoinQueueInstructionDataArgs>;
+export declare function getJoinQueueInstructionDataDecoder(): FixedSizeDecoder<JoinQueueInstructionData>;
+export declare function getJoinQueueInstructionDataCodec(): FixedSizeCodec<JoinQueueInstructionDataArgs, JoinQueueInstructionData>;
+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 declare 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>>;
+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 declare 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>;
+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 declare function parseJoinQueueInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedJoinQueueInstruction<TProgram, TAccountMetas>;

package/dist/generated/duel/instructions/joinQueue.js

@@ -0,0 +1,56 @@
+/**
+ * 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 } from '@solana/kit';
+import { getAccountMetaFactory, getAddressFromResolvedInstructionAccount } 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 function getJoinQueueInstructionDataEncoder() {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({ ...value, discriminator: JOIN_QUEUE_DISCRIMINATOR }));
+}
+export function getJoinQueueInstructionDataDecoder() {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);
+}
+export function getJoinQueueInstructionDataCodec() {
+    return combineCodec(getJoinQueueInstructionDataEncoder(), getJoinQueueInstructionDataDecoder());
+}
+export async function getJoinQueueInstructionAsync(input, config) {
+    // 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: false }, playerTicket: { value: input.playerTicket ?? null, isWritable: true }, signer: { value: input.signer ?? null, isWritable: false } };
+    const accounts = originalAccounts;
+    // 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 });
+}
+export function getJoinQueueInstruction(input, config) {
+    // 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: false }, playerTicket: { value: input.playerTicket ?? null, isWritable: true }, signer: { value: input.signer ?? null, isWritable: false } };
+    const accounts = originalAccounts;
+    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 });
+}
+export function parseJoinQueueInstruction(instruction) {
+    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[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) };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"joinQueue.js","sourceRoot":"","sources":["../../../../src/generated/duel/instructions/joinQueue.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * This code was AUTOGENERATED using the Codama library.\n * Please DO NOT EDIT THIS FILE, instead use visitors\n * to add features, then rerun Codama to update it.\n *\n * @see https://github.com/codama-idl/codama\n */\n\nimport { 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';\nimport { getAccountMetaFactory, getAddressFromResolvedInstructionAccount, type ResolvedInstructionAccount } from '@solana/program-client-core';\nimport { DUEL_PROGRAM_ADDRESS } from '../programs';\n\nexport const JOIN_QUEUE_DISCRIMINATOR = new Uint8Array([157, 115, 48, 109, 65, 86, 203, 238]);\n\nexport function getJoinQueueDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(JOIN_QUEUE_DISCRIMINATOR); }\n\nexport 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>[] = []> =\nInstruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountQueue extends string ? WritableAccount<TAccountQueue> : TAccountQueue, TAccountTenant extends string ? ReadonlyAccount<TAccountTenant> : TAccountTenant, TAccountPlayerData extends string ? ReadonlyAccount<TAccountPlayerData> : TAccountPlayerData, TAccountPlayerTicket extends string ? WritableAccount<TAccountPlayerTicket> : TAccountPlayerTicket, TAccountSigner extends string ? ReadonlySignerAccount<TAccountSigner> & AccountSignerMeta<TAccountSigner> : TAccountSigner, ...TRemainingAccounts]>;\n\nexport type JoinQueueInstructionData = { discriminator: ReadonlyUint8Array;  };\n\nexport type JoinQueueInstructionDataArgs = {  };\n\nexport function getJoinQueueInstructionDataEncoder(): FixedSizeEncoder<JoinQueueInstructionDataArgs> {\n    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({ ...value, discriminator: JOIN_QUEUE_DISCRIMINATOR }));\n}\n\nexport function getJoinQueueInstructionDataDecoder(): FixedSizeDecoder<JoinQueueInstructionData> {\n    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);\n}\n\nexport function getJoinQueueInstructionDataCodec(): FixedSizeCodec<JoinQueueInstructionDataArgs, JoinQueueInstructionData> {\n    return combineCodec(getJoinQueueInstructionDataEncoder(), getJoinQueueInstructionDataDecoder());\n}\n\nexport type JoinQueueAsyncInput<TAccountQueue extends string = string, TAccountTenant extends string = string, TAccountPlayerData extends string = string, TAccountPlayerTicket extends string = string, TAccountSigner extends string = string> =  {\n  queue: Address<TAccountQueue>;\ntenant: Address<TAccountTenant>;\nplayerData: Address<TAccountPlayerData>;\nplayerTicket?: Address<TAccountPlayerTicket>;\nsigner: TransactionSigner<TAccountSigner>;\n}\n\nexport 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>> {\n  // Program address.\nconst programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst originalAccounts = { queue: { value: input.queue ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, playerData: { value: input.playerData ?? null, isWritable: false }, playerTicket: { value: input.playerTicket ?? null, isWritable: true }, signer: { value: input.signer ?? null, isWritable: false } }\nconst accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;\n\n\n// Resolve default values.\nif (!accounts.playerTicket.value) {\naccounts.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))] });\n}\n\nconst getAccountMeta = getAccountMetaFactory(programAddress, 'programId');\nreturn 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>);\n}\n\nexport type JoinQueueInput<TAccountQueue extends string = string, TAccountTenant extends string = string, TAccountPlayerData extends string = string, TAccountPlayerTicket extends string = string, TAccountSigner extends string = string> =  {\n  queue: Address<TAccountQueue>;\ntenant: Address<TAccountTenant>;\nplayerData: Address<TAccountPlayerData>;\nplayerTicket: Address<TAccountPlayerTicket>;\nsigner: TransactionSigner<TAccountSigner>;\n}\n\nexport 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> {\n  // Program address.\nconst programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst originalAccounts = { queue: { value: input.queue ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, playerData: { value: input.playerData ?? null, isWritable: false }, playerTicket: { value: input.playerTicket ?? null, isWritable: true }, signer: { value: input.signer ?? null, isWritable: false } }\nconst accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;\n\n\n\n\nconst getAccountMeta = getAccountMetaFactory(programAddress, 'programId');\nreturn 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>);\n}\n\nexport type ParsedJoinQueueInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;\naccounts: {\nqueue: TAccountMetas[0];\ntenant: TAccountMetas[1];\nplayerData: TAccountMetas[2];\nplayerTicket: TAccountMetas[3];\nsigner: TAccountMetas[4];\n};\ndata: JoinQueueInstructionData; };\n\nexport function parseJoinQueueInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedJoinQueueInstruction<TProgram, TAccountMetas> {\n  if (instruction.accounts.length < 5) {\n  throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: 5 });\n}\nlet accountIndex = 0;\nconst getNextAccount = () => {\n  const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;\n  accountIndex += 1;\n  return accountMeta;\n}\n  return { programAddress: instruction.programAddress, accounts: { queue: getNextAccount(), tenant: getNextAccount(), playerData: getNextAccount(), playerTicket: getNextAccount(), signer: getNextAccount() }, data: getJoinQueueInstructionDataDecoder().decode(instruction.data) };\n}"]}

package/dist/generated/duel/instructions/processUndelegation.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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 { 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 { DUEL_PROGRAM_ADDRESS } from '../programs';
+export declare const PROCESS_UNDELEGATION_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getProcessUndelegationDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+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 declare function getProcessUndelegationInstructionDataEncoder(): Encoder<ProcessUndelegationInstructionDataArgs>;
+export declare function getProcessUndelegationInstructionDataDecoder(): Decoder<ProcessUndelegationInstructionData>;
+export declare function getProcessUndelegationInstructionDataCodec(): Codec<ProcessUndelegationInstructionDataArgs, ProcessUndelegationInstructionData>;
+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 declare 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>;
+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 declare function parseProcessUndelegationInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedProcessUndelegationInstruction<TProgram, TAccountMetas>;

package/dist/generated/duel/instructions/processUndelegation.js

@@ -0,0 +1,49 @@
+/**
+ * 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 } from '@solana/kit';
+import { getAccountMetaFactory } 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 function getProcessUndelegationInstructionDataEncoder() {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['accountSeeds', getArrayEncoder(addEncoderSizePrefix(getBytesEncoder(), getU32Encoder()))]]), (value) => ({ ...value, discriminator: PROCESS_UNDELEGATION_DISCRIMINATOR }));
+}
+export function getProcessUndelegationInstructionDataDecoder() {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['accountSeeds', getArrayDecoder(addDecoderSizePrefix(getBytesDecoder(), getU32Decoder()))]]);
+}
+export function getProcessUndelegationInstructionDataCodec() {
+    return combineCodec(getProcessUndelegationInstructionDataEncoder(), getProcessUndelegationInstructionDataDecoder());
+}
+export function getProcessUndelegationInstruction(input, config) {
+    // 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;
+    // Original args.
+    const args = { ...input, };
+    // Resolve default values.
+    if (!accounts.systemProgram.value) {
+        accounts.systemProgram.value = '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), programAddress });
+}
+export function parseProcessUndelegationInstruction(instruction) {
+    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[accountIndex];
+        accountIndex += 1;
+        return accountMeta;
+    };
+    return { programAddress: instruction.programAddress, accounts: { baseAccount: getNextAccount(), buffer: getNextAccount(), payer: getNextAccount(), systemProgram: getNextAccount() }, data: getProcessUndelegationInstructionDataDecoder().decode(instruction.data) };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"processUndelegation.js","sourceRoot":"","sources":["../../../../src/generated/duel/instructions/processUndelegation.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * This code was AUTOGENERATED using the Codama library.\n * Please DO NOT EDIT THIS FILE, instead use visitors\n * to add features, then rerun Codama to update it.\n *\n * @see https://github.com/codama-idl/codama\n */\n\nimport { 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';\nimport { getAccountMetaFactory, type ResolvedInstructionAccount } from '@solana/program-client-core';\nimport { DUEL_PROGRAM_ADDRESS } from '../programs';\n\nexport const PROCESS_UNDELEGATION_DISCRIMINATOR = new Uint8Array([196, 28, 41, 206, 48, 37, 51, 167]);\n\nexport function getProcessUndelegationDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(PROCESS_UNDELEGATION_DISCRIMINATOR); }\n\nexport 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>[] = []> =\nInstruction<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]>;\n\nexport type ProcessUndelegationInstructionData = { discriminator: ReadonlyUint8Array; accountSeeds: Array<ReadonlyUint8Array>;  };\n\nexport type ProcessUndelegationInstructionDataArgs = { accountSeeds: Array<ReadonlyUint8Array>;  };\n\nexport function getProcessUndelegationInstructionDataEncoder(): Encoder<ProcessUndelegationInstructionDataArgs> {\n    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['accountSeeds', getArrayEncoder(addEncoderSizePrefix(getBytesEncoder(), getU32Encoder()))]]), (value) => ({ ...value, discriminator: PROCESS_UNDELEGATION_DISCRIMINATOR }));\n}\n\nexport function getProcessUndelegationInstructionDataDecoder(): Decoder<ProcessUndelegationInstructionData> {\n    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['accountSeeds', getArrayDecoder(addDecoderSizePrefix(getBytesDecoder(), getU32Decoder()))]]);\n}\n\nexport function getProcessUndelegationInstructionDataCodec(): Codec<ProcessUndelegationInstructionDataArgs, ProcessUndelegationInstructionData> {\n    return combineCodec(getProcessUndelegationInstructionDataEncoder(), getProcessUndelegationInstructionDataDecoder());\n}\n\nexport type ProcessUndelegationInput<TAccountBaseAccount extends string = string, TAccountBuffer extends string = string, TAccountPayer extends string = string, TAccountSystemProgram extends string = string> =  {\n  baseAccount: Address<TAccountBaseAccount>;\nbuffer: Address<TAccountBuffer>;\npayer: Address<TAccountPayer>;\nsystemProgram?: Address<TAccountSystemProgram>;\naccountSeeds: ProcessUndelegationInstructionDataArgs[\"accountSeeds\"];\n}\n\nexport 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> {\n  // Program address.\nconst programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst 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 } }\nconst accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;\n\n\n// Original args.\nconst args = { ...input,  };\n\n\n// Resolve default values.\nif (!accounts.systemProgram.value) {\naccounts.systemProgram.value = '11111111111111111111111111111111' as Address<'11111111111111111111111111111111'>;\n}\n\nconst getAccountMeta = getAccountMetaFactory(programAddress, 'programId');\nreturn 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>);\n}\n\nexport type ParsedProcessUndelegationInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;\naccounts: {\nbaseAccount: TAccountMetas[0];\nbuffer: TAccountMetas[1];\npayer: TAccountMetas[2];\nsystemProgram: TAccountMetas[3];\n};\ndata: ProcessUndelegationInstructionData; };\n\nexport function parseProcessUndelegationInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedProcessUndelegationInstruction<TProgram, TAccountMetas> {\n  if (instruction.accounts.length < 4) {\n  throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: 4 });\n}\nlet accountIndex = 0;\nconst getNextAccount = () => {\n  const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;\n  accountIndex += 1;\n  return accountMeta;\n}\n  return { programAddress: instruction.programAddress, accounts: { baseAccount: getNextAccount(), buffer: getNextAccount(), payer: getNextAccount(), systemProgram: getNextAccount() }, data: getProcessUndelegationInstructionDataDecoder().decode(instruction.data) };\n}"]}