@1upmonster/duel 0.1.8 → 0.2.2

package/dist/generated/duel/instructions/cancelTicket.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 CANCEL_TICKET_DISCRIMINATOR = new Uint8Array([216, 28, 247, 206, 195, 171, 100, 143]);
+export function getCancelTicketDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(CANCEL_TICKET_DISCRIMINATOR); }
+export function getCancelTicketInstructionDataEncoder() {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({ ...value, discriminator: CANCEL_TICKET_DISCRIMINATOR }));
+}
+export function getCancelTicketInstructionDataDecoder() {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);
+}
+export function getCancelTicketInstructionDataCodec() {
+    return combineCodec(getCancelTicketInstructionDataEncoder(), getCancelTicketInstructionDataDecoder());
+}
+export async function getCancelTicketInstructionAsync(input, config) {
+    // Program address.
+    const programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;
+    // Original accounts.
+    const originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? null, isWritable: false } };
+    const accounts = originalAccounts;
+    // Resolve default values.
+    if (!accounts.ticket.value) {
+        accounts.ticket.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([116, 105, 99, 107, 101, 116])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("player", accounts.player.value)), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("tenant", accounts.tenant.value))] });
+    }
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({ accounts: [getAccountMeta("ticket", accounts.ticket), getAccountMeta("tenant", accounts.tenant), getAccountMeta("player", accounts.player)], data: getCancelTicketInstructionDataEncoder().encode({}), programAddress });
+}
+export function getCancelTicketInstruction(input, config) {
+    // Program address.
+    const programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;
+    // Original accounts.
+    const originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? null, isWritable: false } };
+    const accounts = originalAccounts;
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({ accounts: [getAccountMeta("ticket", accounts.ticket), getAccountMeta("tenant", accounts.tenant), getAccountMeta("player", accounts.player)], data: getCancelTicketInstructionDataEncoder().encode({}), programAddress });
+}
+export function parseCancelTicketInstruction(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: { ticket: getNextAccount(), tenant: getNextAccount(), player: getNextAccount() }, data: getCancelTicketInstructionDataDecoder().decode(instruction.data) };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cancelTicket.js","sourceRoot":"","sources":["../../../../src/generated/duel/instructions/cancelTicket.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 CANCEL_TICKET_DISCRIMINATOR = new Uint8Array([216, 28, 247, 206, 195, 171, 100, 143]);\n\nexport function getCancelTicketDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(CANCEL_TICKET_DISCRIMINATOR); }\n\nexport type CancelTicketInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountTicket extends string | AccountMeta<string> = string, TAccountTenant extends string | AccountMeta<string> = string, TAccountPlayer extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> =\nInstruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountTicket extends string ? WritableAccount<TAccountTicket> : TAccountTicket, TAccountTenant extends string ? ReadonlyAccount<TAccountTenant> : TAccountTenant, TAccountPlayer extends string ? ReadonlySignerAccount<TAccountPlayer> & AccountSignerMeta<TAccountPlayer> : TAccountPlayer, ...TRemainingAccounts]>;\n\nexport type CancelTicketInstructionData = { discriminator: ReadonlyUint8Array;  };\n\nexport type CancelTicketInstructionDataArgs = {  };\n\nexport function getCancelTicketInstructionDataEncoder(): FixedSizeEncoder<CancelTicketInstructionDataArgs> {\n    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({ ...value, discriminator: CANCEL_TICKET_DISCRIMINATOR }));\n}\n\nexport function getCancelTicketInstructionDataDecoder(): FixedSizeDecoder<CancelTicketInstructionData> {\n    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);\n}\n\nexport function getCancelTicketInstructionDataCodec(): FixedSizeCodec<CancelTicketInstructionDataArgs, CancelTicketInstructionData> {\n    return combineCodec(getCancelTicketInstructionDataEncoder(), getCancelTicketInstructionDataDecoder());\n}\n\nexport type CancelTicketAsyncInput<TAccountTicket extends string = string, TAccountTenant extends string = string, TAccountPlayer extends string = string> =  {\n  ticket?: Address<TAccountTicket>;\ntenant: Address<TAccountTenant>;\nplayer: TransactionSigner<TAccountPlayer>;\n}\n\nexport async function getCancelTicketInstructionAsync<TAccountTicket extends string, TAccountTenant extends string, TAccountPlayer extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: CancelTicketAsyncInput<TAccountTicket, TAccountTenant, TAccountPlayer>, config?: { programAddress?: TProgramAddress } ): Promise<CancelTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer>> {\n  // Program address.\nconst programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? null, isWritable: false } }\nconst accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;\n\n\n// Resolve default values.\nif (!accounts.ticket.value) {\naccounts.ticket.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([116, 105, 99, 107, 101, 116])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount(\"player\", accounts.player.value)), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount(\"tenant\", accounts.tenant.value))] });\n}\n\nconst getAccountMeta = getAccountMetaFactory(programAddress, 'programId');\nreturn Object.freeze({ accounts: [getAccountMeta(\"ticket\", accounts.ticket), getAccountMeta(\"tenant\", accounts.tenant), getAccountMeta(\"player\", accounts.player)], data: getCancelTicketInstructionDataEncoder().encode({}), programAddress } as CancelTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer>);\n}\n\nexport type CancelTicketInput<TAccountTicket extends string = string, TAccountTenant extends string = string, TAccountPlayer extends string = string> =  {\n  ticket: Address<TAccountTicket>;\ntenant: Address<TAccountTenant>;\nplayer: TransactionSigner<TAccountPlayer>;\n}\n\nexport function getCancelTicketInstruction<TAccountTicket extends string, TAccountTenant extends string, TAccountPlayer extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: CancelTicketInput<TAccountTicket, TAccountTenant, TAccountPlayer>, config?: { programAddress?: TProgramAddress } ): CancelTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer> {\n  // Program address.\nconst programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? 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(\"ticket\", accounts.ticket), getAccountMeta(\"tenant\", accounts.tenant), getAccountMeta(\"player\", accounts.player)], data: getCancelTicketInstructionDataEncoder().encode({}), programAddress } as CancelTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer>);\n}\n\nexport type ParsedCancelTicketInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;\naccounts: {\nticket: TAccountMetas[0];\ntenant: TAccountMetas[1];\nplayer: TAccountMetas[2];\n};\ndata: CancelTicketInstructionData; };\n\nexport function parseCancelTicketInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedCancelTicketInstruction<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: { ticket: getNextAccount(), tenant: getNextAccount(), player: getNextAccount() }, data: getCancelTicketInstructionDataDecoder().decode(instruction.data) };\n}"]}

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

@@ -0,0 +1,45 @@
+/**
+ * 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 ReadonlyUint8Array, type TransactionSigner, type WritableAccount, type WritableSignerAccount } from '@solana/kit';
+import { DUEL_PROGRAM_ADDRESS } from '../programs';
+export declare const CLOSE_TICKET_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getCloseTicketDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type CloseTicketInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountTicket extends string | AccountMeta<string> = string, TAccountTenant extends string | AccountMeta<string> = string, TAccountPlayer extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountTicket extends string ? WritableAccount<TAccountTicket> : TAccountTicket, TAccountTenant extends string ? ReadonlyAccount<TAccountTenant> : TAccountTenant, TAccountPlayer extends string ? WritableSignerAccount<TAccountPlayer> & AccountSignerMeta<TAccountPlayer> : TAccountPlayer, ...TRemainingAccounts]>;
+export type CloseTicketInstructionData = {
+    discriminator: ReadonlyUint8Array;
+};
+export type CloseTicketInstructionDataArgs = {};
+export declare function getCloseTicketInstructionDataEncoder(): FixedSizeEncoder<CloseTicketInstructionDataArgs>;
+export declare function getCloseTicketInstructionDataDecoder(): FixedSizeDecoder<CloseTicketInstructionData>;
+export declare function getCloseTicketInstructionDataCodec(): FixedSizeCodec<CloseTicketInstructionDataArgs, CloseTicketInstructionData>;
+export type CloseTicketAsyncInput<TAccountTicket extends string = string, TAccountTenant extends string = string, TAccountPlayer extends string = string> = {
+    ticket?: Address<TAccountTicket>;
+    tenant: Address<TAccountTenant>;
+    player: TransactionSigner<TAccountPlayer>;
+};
+export declare function getCloseTicketInstructionAsync<TAccountTicket extends string, TAccountTenant extends string, TAccountPlayer extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: CloseTicketAsyncInput<TAccountTicket, TAccountTenant, TAccountPlayer>, config?: {
+    programAddress?: TProgramAddress;
+}): Promise<CloseTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer>>;
+export type CloseTicketInput<TAccountTicket extends string = string, TAccountTenant extends string = string, TAccountPlayer extends string = string> = {
+    ticket: Address<TAccountTicket>;
+    tenant: Address<TAccountTenant>;
+    player: TransactionSigner<TAccountPlayer>;
+};
+export declare function getCloseTicketInstruction<TAccountTicket extends string, TAccountTenant extends string, TAccountPlayer extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: CloseTicketInput<TAccountTicket, TAccountTenant, TAccountPlayer>, config?: {
+    programAddress?: TProgramAddress;
+}): CloseTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer>;
+export type ParsedCloseTicketInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        ticket: TAccountMetas[0];
+        tenant: TAccountMetas[1];
+        player: TAccountMetas[2];
+    };
+    data: CloseTicketInstructionData;
+};
+export declare function parseCloseTicketInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedCloseTicketInstruction<TProgram, TAccountMetas>;

package/dist/generated/duel/instructions/closeTicket.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 CLOSE_TICKET_DISCRIMINATOR = new Uint8Array([66, 209, 114, 197, 75, 27, 182, 117]);
+export function getCloseTicketDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(CLOSE_TICKET_DISCRIMINATOR); }
+export function getCloseTicketInstructionDataEncoder() {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({ ...value, discriminator: CLOSE_TICKET_DISCRIMINATOR }));
+}
+export function getCloseTicketInstructionDataDecoder() {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);
+}
+export function getCloseTicketInstructionDataCodec() {
+    return combineCodec(getCloseTicketInstructionDataEncoder(), getCloseTicketInstructionDataDecoder());
+}
+export async function getCloseTicketInstructionAsync(input, config) {
+    // Program address.
+    const programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;
+    // Original accounts.
+    const originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? null, isWritable: true } };
+    const accounts = originalAccounts;
+    // Resolve default values.
+    if (!accounts.ticket.value) {
+        accounts.ticket.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([116, 105, 99, 107, 101, 116])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("player", accounts.player.value)), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("tenant", accounts.tenant.value))] });
+    }
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({ accounts: [getAccountMeta("ticket", accounts.ticket), getAccountMeta("tenant", accounts.tenant), getAccountMeta("player", accounts.player)], data: getCloseTicketInstructionDataEncoder().encode({}), programAddress });
+}
+export function getCloseTicketInstruction(input, config) {
+    // Program address.
+    const programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;
+    // Original accounts.
+    const originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? null, isWritable: true } };
+    const accounts = originalAccounts;
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({ accounts: [getAccountMeta("ticket", accounts.ticket), getAccountMeta("tenant", accounts.tenant), getAccountMeta("player", accounts.player)], data: getCloseTicketInstructionDataEncoder().encode({}), programAddress });
+}
+export function parseCloseTicketInstruction(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: { ticket: getNextAccount(), tenant: getNextAccount(), player: getNextAccount() }, data: getCloseTicketInstructionDataDecoder().decode(instruction.data) };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"closeTicket.js","sourceRoot":"","sources":["../../../../src/generated/duel/instructions/closeTicket.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 CLOSE_TICKET_DISCRIMINATOR = new Uint8Array([66, 209, 114, 197, 75, 27, 182, 117]);\n\nexport function getCloseTicketDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(CLOSE_TICKET_DISCRIMINATOR); }\n\nexport type CloseTicketInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountTicket extends string | AccountMeta<string> = string, TAccountTenant extends string | AccountMeta<string> = string, TAccountPlayer extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> =\nInstruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountTicket extends string ? WritableAccount<TAccountTicket> : TAccountTicket, TAccountTenant extends string ? ReadonlyAccount<TAccountTenant> : TAccountTenant, TAccountPlayer extends string ? WritableSignerAccount<TAccountPlayer> & AccountSignerMeta<TAccountPlayer> : TAccountPlayer, ...TRemainingAccounts]>;\n\nexport type CloseTicketInstructionData = { discriminator: ReadonlyUint8Array;  };\n\nexport type CloseTicketInstructionDataArgs = {  };\n\nexport function getCloseTicketInstructionDataEncoder(): FixedSizeEncoder<CloseTicketInstructionDataArgs> {\n    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({ ...value, discriminator: CLOSE_TICKET_DISCRIMINATOR }));\n}\n\nexport function getCloseTicketInstructionDataDecoder(): FixedSizeDecoder<CloseTicketInstructionData> {\n    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);\n}\n\nexport function getCloseTicketInstructionDataCodec(): FixedSizeCodec<CloseTicketInstructionDataArgs, CloseTicketInstructionData> {\n    return combineCodec(getCloseTicketInstructionDataEncoder(), getCloseTicketInstructionDataDecoder());\n}\n\nexport type CloseTicketAsyncInput<TAccountTicket extends string = string, TAccountTenant extends string = string, TAccountPlayer extends string = string> =  {\n  ticket?: Address<TAccountTicket>;\ntenant: Address<TAccountTenant>;\nplayer: TransactionSigner<TAccountPlayer>;\n}\n\nexport async function getCloseTicketInstructionAsync<TAccountTicket extends string, TAccountTenant extends string, TAccountPlayer extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: CloseTicketAsyncInput<TAccountTicket, TAccountTenant, TAccountPlayer>, config?: { programAddress?: TProgramAddress } ): Promise<CloseTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer>> {\n  // Program address.\nconst programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? null, isWritable: true } }\nconst accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;\n\n\n// Resolve default values.\nif (!accounts.ticket.value) {\naccounts.ticket.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([116, 105, 99, 107, 101, 116])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount(\"player\", accounts.player.value)), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount(\"tenant\", accounts.tenant.value))] });\n}\n\nconst getAccountMeta = getAccountMetaFactory(programAddress, 'programId');\nreturn Object.freeze({ accounts: [getAccountMeta(\"ticket\", accounts.ticket), getAccountMeta(\"tenant\", accounts.tenant), getAccountMeta(\"player\", accounts.player)], data: getCloseTicketInstructionDataEncoder().encode({}), programAddress } as CloseTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer>);\n}\n\nexport type CloseTicketInput<TAccountTicket extends string = string, TAccountTenant extends string = string, TAccountPlayer extends string = string> =  {\n  ticket: Address<TAccountTicket>;\ntenant: Address<TAccountTenant>;\nplayer: TransactionSigner<TAccountPlayer>;\n}\n\nexport function getCloseTicketInstruction<TAccountTicket extends string, TAccountTenant extends string, TAccountPlayer extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: CloseTicketInput<TAccountTicket, TAccountTenant, TAccountPlayer>, config?: { programAddress?: TProgramAddress } ): CloseTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer> {\n  // Program address.\nconst programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? null, isWritable: true } }\nconst accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;\n\n\n\n\nconst getAccountMeta = getAccountMetaFactory(programAddress, 'programId');\nreturn Object.freeze({ accounts: [getAccountMeta(\"ticket\", accounts.ticket), getAccountMeta(\"tenant\", accounts.tenant), getAccountMeta(\"player\", accounts.player)], data: getCloseTicketInstructionDataEncoder().encode({}), programAddress } as CloseTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer>);\n}\n\nexport type ParsedCloseTicketInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;\naccounts: {\nticket: TAccountMetas[0];\ntenant: TAccountMetas[1];\nplayer: TAccountMetas[2];\n};\ndata: CloseTicketInstructionData; };\n\nexport function parseCloseTicketInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedCloseTicketInstruction<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: { ticket: getNextAccount(), tenant: getNextAccount(), player: getNextAccount() }, data: getCloseTicketInstructionDataDecoder().decode(instruction.data) };\n}"]}

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

@@ -0,0 +1,39 @@
+/**
+ * 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 ReadonlyUint8Array, type TransactionSigner, type WritableAccount, type WritableSignerAccount } from '@solana/kit';
+import { DUEL_PROGRAM_ADDRESS } from '../programs';
+export declare const COMMIT_TICKETS_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getCommitTicketsDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type CommitTicketsInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountTenant extends string | AccountMeta<string> = string, TAccountPayer extends string | AccountMeta<string> = string, TAccountMagicProgram extends string | AccountMeta<string> = "Magic11111111111111111111111111111111111111", TAccountMagicContext extends string | AccountMeta<string> = "MagicContext1111111111111111111111111111111", TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountTenant extends string ? ReadonlyAccount<TAccountTenant> : TAccountTenant, TAccountPayer extends string ? WritableSignerAccount<TAccountPayer> & AccountSignerMeta<TAccountPayer> : TAccountPayer, TAccountMagicProgram extends string ? ReadonlyAccount<TAccountMagicProgram> : TAccountMagicProgram, TAccountMagicContext extends string ? WritableAccount<TAccountMagicContext> : TAccountMagicContext, ...TRemainingAccounts]>;
+export type CommitTicketsInstructionData = {
+    discriminator: ReadonlyUint8Array;
+};
+export type CommitTicketsInstructionDataArgs = {};
+export declare function getCommitTicketsInstructionDataEncoder(): FixedSizeEncoder<CommitTicketsInstructionDataArgs>;
+export declare function getCommitTicketsInstructionDataDecoder(): FixedSizeDecoder<CommitTicketsInstructionData>;
+export declare function getCommitTicketsInstructionDataCodec(): FixedSizeCodec<CommitTicketsInstructionDataArgs, CommitTicketsInstructionData>;
+export type CommitTicketsInput<TAccountTenant extends string = string, TAccountPayer extends string = string, TAccountMagicProgram extends string = string, TAccountMagicContext extends string = string> = {
+    tenant: Address<TAccountTenant>;
+    payer: TransactionSigner<TAccountPayer>;
+    magicProgram?: Address<TAccountMagicProgram>;
+    magicContext?: Address<TAccountMagicContext>;
+};
+export declare function getCommitTicketsInstruction<TAccountTenant extends string, TAccountPayer extends string, TAccountMagicProgram extends string, TAccountMagicContext extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: CommitTicketsInput<TAccountTenant, TAccountPayer, TAccountMagicProgram, TAccountMagicContext>, config?: {
+    programAddress?: TProgramAddress;
+}): CommitTicketsInstruction<TProgramAddress, TAccountTenant, TAccountPayer, TAccountMagicProgram, TAccountMagicContext>;
+export type ParsedCommitTicketsInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        tenant: TAccountMetas[0];
+        payer: TAccountMetas[1];
+        magicProgram: TAccountMetas[2];
+        magicContext: TAccountMetas[3];
+    };
+    data: CommitTicketsInstructionData;
+};
+export declare function parseCommitTicketsInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedCommitTicketsInstruction<TProgram, TAccountMetas>;

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

@@ -0,0 +1,50 @@
+/**
+ * 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, getBytesDecoder, getBytesEncoder, getStructDecoder, getStructEncoder, 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 COMMIT_TICKETS_DISCRIMINATOR = new Uint8Array([245, 199, 81, 0, 62, 133, 18, 22]);
+export function getCommitTicketsDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(COMMIT_TICKETS_DISCRIMINATOR); }
+export function getCommitTicketsInstructionDataEncoder() {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({ ...value, discriminator: COMMIT_TICKETS_DISCRIMINATOR }));
+}
+export function getCommitTicketsInstructionDataDecoder() {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);
+}
+export function getCommitTicketsInstructionDataCodec() {
+    return combineCodec(getCommitTicketsInstructionDataEncoder(), getCommitTicketsInstructionDataDecoder());
+}
+export function getCommitTicketsInstruction(input, config) {
+    // Program address.
+    const programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;
+    // Original accounts.
+    const originalAccounts = { tenant: { value: input.tenant ?? null, isWritable: false }, payer: { value: input.payer ?? null, isWritable: true }, magicProgram: { value: input.magicProgram ?? null, isWritable: false }, magicContext: { value: input.magicContext ?? null, isWritable: true } };
+    const accounts = originalAccounts;
+    // Resolve default values.
+    if (!accounts.magicProgram.value) {
+        accounts.magicProgram.value = 'Magic11111111111111111111111111111111111111';
+    }
+    if (!accounts.magicContext.value) {
+        accounts.magicContext.value = 'MagicContext1111111111111111111111111111111';
+    }
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({ accounts: [getAccountMeta("tenant", accounts.tenant), getAccountMeta("payer", accounts.payer), getAccountMeta("magicProgram", accounts.magicProgram), getAccountMeta("magicContext", accounts.magicContext)], data: getCommitTicketsInstructionDataEncoder().encode({}), programAddress });
+}
+export function parseCommitTicketsInstruction(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: { tenant: getNextAccount(), payer: getNextAccount(), magicProgram: getNextAccount(), magicContext: getNextAccount() }, data: getCommitTicketsInstructionDataDecoder().decode(instruction.data) };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"commitTickets.js","sourceRoot":"","sources":["../../../../src/generated/duel/instructions/commitTickets.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, getBytesDecoder, getBytesEncoder, 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, type ResolvedInstructionAccount } from '@solana/program-client-core';\nimport { DUEL_PROGRAM_ADDRESS } from '../programs';\n\nexport const COMMIT_TICKETS_DISCRIMINATOR = new Uint8Array([245, 199, 81, 0, 62, 133, 18, 22]);\n\nexport function getCommitTicketsDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(COMMIT_TICKETS_DISCRIMINATOR); }\n\nexport type CommitTicketsInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountTenant extends string | AccountMeta<string> = string, TAccountPayer extends string | AccountMeta<string> = string, TAccountMagicProgram extends string | AccountMeta<string> = \"Magic11111111111111111111111111111111111111\", TAccountMagicContext extends string | AccountMeta<string> = \"MagicContext1111111111111111111111111111111\", TRemainingAccounts extends readonly AccountMeta<string>[] = []> =\nInstruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountTenant extends string ? ReadonlyAccount<TAccountTenant> : TAccountTenant, TAccountPayer extends string ? WritableSignerAccount<TAccountPayer> & AccountSignerMeta<TAccountPayer> : TAccountPayer, TAccountMagicProgram extends string ? ReadonlyAccount<TAccountMagicProgram> : TAccountMagicProgram, TAccountMagicContext extends string ? WritableAccount<TAccountMagicContext> : TAccountMagicContext, ...TRemainingAccounts]>;\n\nexport type CommitTicketsInstructionData = { discriminator: ReadonlyUint8Array;  };\n\nexport type CommitTicketsInstructionDataArgs = {  };\n\nexport function getCommitTicketsInstructionDataEncoder(): FixedSizeEncoder<CommitTicketsInstructionDataArgs> {\n    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({ ...value, discriminator: COMMIT_TICKETS_DISCRIMINATOR }));\n}\n\nexport function getCommitTicketsInstructionDataDecoder(): FixedSizeDecoder<CommitTicketsInstructionData> {\n    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);\n}\n\nexport function getCommitTicketsInstructionDataCodec(): FixedSizeCodec<CommitTicketsInstructionDataArgs, CommitTicketsInstructionData> {\n    return combineCodec(getCommitTicketsInstructionDataEncoder(), getCommitTicketsInstructionDataDecoder());\n}\n\nexport type CommitTicketsInput<TAccountTenant extends string = string, TAccountPayer extends string = string, TAccountMagicProgram extends string = string, TAccountMagicContext extends string = string> =  {\n  tenant: Address<TAccountTenant>;\npayer: TransactionSigner<TAccountPayer>;\nmagicProgram?: Address<TAccountMagicProgram>;\nmagicContext?: Address<TAccountMagicContext>;\n}\n\nexport function getCommitTicketsInstruction<TAccountTenant extends string, TAccountPayer extends string, TAccountMagicProgram extends string, TAccountMagicContext extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: CommitTicketsInput<TAccountTenant, TAccountPayer, TAccountMagicProgram, TAccountMagicContext>, config?: { programAddress?: TProgramAddress } ): CommitTicketsInstruction<TProgramAddress, TAccountTenant, TAccountPayer, TAccountMagicProgram, TAccountMagicContext> {\n  // Program address.\nconst programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst originalAccounts = { tenant: { value: input.tenant ?? null, isWritable: false }, payer: { value: input.payer ?? null, isWritable: true }, magicProgram: { value: input.magicProgram ?? null, isWritable: false }, magicContext: { value: input.magicContext ?? null, isWritable: true } }\nconst accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;\n\n\n// Resolve default values.\nif (!accounts.magicProgram.value) {\naccounts.magicProgram.value = 'Magic11111111111111111111111111111111111111' as Address<'Magic11111111111111111111111111111111111111'>;\n}\nif (!accounts.magicContext.value) {\naccounts.magicContext.value = 'MagicContext1111111111111111111111111111111' as Address<'MagicContext1111111111111111111111111111111'>;\n}\n\nconst getAccountMeta = getAccountMetaFactory(programAddress, 'programId');\nreturn Object.freeze({ accounts: [getAccountMeta(\"tenant\", accounts.tenant), getAccountMeta(\"payer\", accounts.payer), getAccountMeta(\"magicProgram\", accounts.magicProgram), getAccountMeta(\"magicContext\", accounts.magicContext)], data: getCommitTicketsInstructionDataEncoder().encode({}), programAddress } as CommitTicketsInstruction<TProgramAddress, TAccountTenant, TAccountPayer, TAccountMagicProgram, TAccountMagicContext>);\n}\n\nexport type ParsedCommitTicketsInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;\naccounts: {\ntenant: TAccountMetas[0];\npayer: TAccountMetas[1];\nmagicProgram: TAccountMetas[2];\nmagicContext: TAccountMetas[3];\n};\ndata: CommitTicketsInstructionData; };\n\nexport function parseCommitTicketsInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedCommitTicketsInstruction<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: { tenant: getNextAccount(), payer: getNextAccount(), magicProgram: getNextAccount(), magicContext: getNextAccount() }, data: getCommitTicketsInstructionDataDecoder().decode(instruction.data) };\n}"]}

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

@@ -0,0 +1,48 @@
+/**
+ * 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 ReadonlyUint8Array, type TransactionSigner, type WritableAccount, type WritableSignerAccount } from '@solana/kit';
+import { DUEL_PROGRAM_ADDRESS } from '../programs';
+export declare const CREATE_TICKET_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getCreateTicketDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type CreateTicketInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountTicket extends string | AccountMeta<string> = string, TAccountTenant extends string | AccountMeta<string> = string, TAccountPlayer extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = "11111111111111111111111111111111", TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountTicket extends string ? WritableAccount<TAccountTicket> : TAccountTicket, TAccountTenant extends string ? ReadonlyAccount<TAccountTenant> : TAccountTenant, TAccountPlayer extends string ? WritableSignerAccount<TAccountPlayer> & AccountSignerMeta<TAccountPlayer> : TAccountPlayer, TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram, ...TRemainingAccounts]>;
+export type CreateTicketInstructionData = {
+    discriminator: ReadonlyUint8Array;
+};
+export type CreateTicketInstructionDataArgs = {};
+export declare function getCreateTicketInstructionDataEncoder(): FixedSizeEncoder<CreateTicketInstructionDataArgs>;
+export declare function getCreateTicketInstructionDataDecoder(): FixedSizeDecoder<CreateTicketInstructionData>;
+export declare function getCreateTicketInstructionDataCodec(): FixedSizeCodec<CreateTicketInstructionDataArgs, CreateTicketInstructionData>;
+export type CreateTicketAsyncInput<TAccountTicket extends string = string, TAccountTenant extends string = string, TAccountPlayer extends string = string, TAccountSystemProgram extends string = string> = {
+    ticket?: Address<TAccountTicket>;
+    tenant: Address<TAccountTenant>;
+    player: TransactionSigner<TAccountPlayer>;
+    systemProgram?: Address<TAccountSystemProgram>;
+};
+export declare function getCreateTicketInstructionAsync<TAccountTicket extends string, TAccountTenant extends string, TAccountPlayer extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: CreateTicketAsyncInput<TAccountTicket, TAccountTenant, TAccountPlayer, TAccountSystemProgram>, config?: {
+    programAddress?: TProgramAddress;
+}): Promise<CreateTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer, TAccountSystemProgram>>;
+export type CreateTicketInput<TAccountTicket extends string = string, TAccountTenant extends string = string, TAccountPlayer extends string = string, TAccountSystemProgram extends string = string> = {
+    ticket: Address<TAccountTicket>;
+    tenant: Address<TAccountTenant>;
+    player: TransactionSigner<TAccountPlayer>;
+    systemProgram?: Address<TAccountSystemProgram>;
+};
+export declare function getCreateTicketInstruction<TAccountTicket extends string, TAccountTenant extends string, TAccountPlayer extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: CreateTicketInput<TAccountTicket, TAccountTenant, TAccountPlayer, TAccountSystemProgram>, config?: {
+    programAddress?: TProgramAddress;
+}): CreateTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer, TAccountSystemProgram>;
+export type ParsedCreateTicketInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        ticket: TAccountMetas[0];
+        tenant: TAccountMetas[1];
+        player: TAccountMetas[2];
+        systemProgram: TAccountMetas[3];
+    };
+    data: CreateTicketInstructionData;
+};
+export declare function parseCreateTicketInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedCreateTicketInstruction<TProgram, TAccountMetas>;

package/dist/generated/duel/instructions/createTicket.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 CREATE_TICKET_DISCRIMINATOR = new Uint8Array([16, 178, 122, 25, 213, 85, 96, 129]);
+export function getCreateTicketDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(CREATE_TICKET_DISCRIMINATOR); }
+export function getCreateTicketInstructionDataEncoder() {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({ ...value, discriminator: CREATE_TICKET_DISCRIMINATOR }));
+}
+export function getCreateTicketInstructionDataDecoder() {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);
+}
+export function getCreateTicketInstructionDataCodec() {
+    return combineCodec(getCreateTicketInstructionDataEncoder(), getCreateTicketInstructionDataDecoder());
+}
+export async function getCreateTicketInstructionAsync(input, config) {
+    // Program address.
+    const programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;
+    // Original accounts.
+    const originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? null, isWritable: true }, systemProgram: { value: input.systemProgram ?? null, isWritable: false } };
+    const accounts = originalAccounts;
+    // Resolve default values.
+    if (!accounts.ticket.value) {
+        accounts.ticket.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([116, 105, 99, 107, 101, 116])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("player", accounts.player.value)), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("tenant", accounts.tenant.value))] });
+    }
+    if (!accounts.systemProgram.value) {
+        accounts.systemProgram.value = '11111111111111111111111111111111';
+    }
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({ accounts: [getAccountMeta("ticket", accounts.ticket), getAccountMeta("tenant", accounts.tenant), getAccountMeta("player", accounts.player), getAccountMeta("systemProgram", accounts.systemProgram)], data: getCreateTicketInstructionDataEncoder().encode({}), programAddress });
+}
+export function getCreateTicketInstruction(input, config) {
+    // Program address.
+    const programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;
+    // Original accounts.
+    const originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? 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("ticket", accounts.ticket), getAccountMeta("tenant", accounts.tenant), getAccountMeta("player", accounts.player), getAccountMeta("systemProgram", accounts.systemProgram)], data: getCreateTicketInstructionDataEncoder().encode({}), programAddress });
+}
+export function parseCreateTicketInstruction(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: { ticket: getNextAccount(), tenant: getNextAccount(), player: getNextAccount(), systemProgram: getNextAccount() }, data: getCreateTicketInstructionDataDecoder().decode(instruction.data) };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"createTicket.js","sourceRoot":"","sources":["../../../../src/generated/duel/instructions/createTicket.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 CREATE_TICKET_DISCRIMINATOR = new Uint8Array([16, 178, 122, 25, 213, 85, 96, 129]);\n\nexport function getCreateTicketDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(CREATE_TICKET_DISCRIMINATOR); }\n\nexport type CreateTicketInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountTicket extends string | AccountMeta<string> = string, TAccountTenant extends string | AccountMeta<string> = string, TAccountPlayer extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = \"11111111111111111111111111111111\", TRemainingAccounts extends readonly AccountMeta<string>[] = []> =\nInstruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountTicket extends string ? WritableAccount<TAccountTicket> : TAccountTicket, TAccountTenant extends string ? ReadonlyAccount<TAccountTenant> : TAccountTenant, TAccountPlayer extends string ? WritableSignerAccount<TAccountPlayer> & AccountSignerMeta<TAccountPlayer> : TAccountPlayer, TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram, ...TRemainingAccounts]>;\n\nexport type CreateTicketInstructionData = { discriminator: ReadonlyUint8Array;  };\n\nexport type CreateTicketInstructionDataArgs = {  };\n\nexport function getCreateTicketInstructionDataEncoder(): FixedSizeEncoder<CreateTicketInstructionDataArgs> {\n    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({ ...value, discriminator: CREATE_TICKET_DISCRIMINATOR }));\n}\n\nexport function getCreateTicketInstructionDataDecoder(): FixedSizeDecoder<CreateTicketInstructionData> {\n    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);\n}\n\nexport function getCreateTicketInstructionDataCodec(): FixedSizeCodec<CreateTicketInstructionDataArgs, CreateTicketInstructionData> {\n    return combineCodec(getCreateTicketInstructionDataEncoder(), getCreateTicketInstructionDataDecoder());\n}\n\nexport type CreateTicketAsyncInput<TAccountTicket extends string = string, TAccountTenant extends string = string, TAccountPlayer extends string = string, TAccountSystemProgram extends string = string> =  {\n  ticket?: Address<TAccountTicket>;\ntenant: Address<TAccountTenant>;\nplayer: TransactionSigner<TAccountPlayer>;\nsystemProgram?: Address<TAccountSystemProgram>;\n}\n\nexport async function getCreateTicketInstructionAsync<TAccountTicket extends string, TAccountTenant extends string, TAccountPlayer extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: CreateTicketAsyncInput<TAccountTicket, TAccountTenant, TAccountPlayer, TAccountSystemProgram>, config?: { programAddress?: TProgramAddress } ): Promise<CreateTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer, TAccountSystemProgram>> {\n  // Program address.\nconst programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? 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.ticket.value) {\naccounts.ticket.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([116, 105, 99, 107, 101, 116])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount(\"player\", accounts.player.value)), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount(\"tenant\", accounts.tenant.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(\"ticket\", accounts.ticket), getAccountMeta(\"tenant\", accounts.tenant), getAccountMeta(\"player\", accounts.player), getAccountMeta(\"systemProgram\", accounts.systemProgram)], data: getCreateTicketInstructionDataEncoder().encode({}), programAddress } as CreateTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer, TAccountSystemProgram>);\n}\n\nexport type CreateTicketInput<TAccountTicket extends string = string, TAccountTenant extends string = string, TAccountPlayer extends string = string, TAccountSystemProgram extends string = string> =  {\n  ticket: Address<TAccountTicket>;\ntenant: Address<TAccountTenant>;\nplayer: TransactionSigner<TAccountPlayer>;\nsystemProgram?: Address<TAccountSystemProgram>;\n}\n\nexport function getCreateTicketInstruction<TAccountTicket extends string, TAccountTenant extends string, TAccountPlayer extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: CreateTicketInput<TAccountTicket, TAccountTenant, TAccountPlayer, TAccountSystemProgram>, config?: { programAddress?: TProgramAddress } ): CreateTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer, TAccountSystemProgram> {\n  // Program address.\nconst programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? 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(\"ticket\", accounts.ticket), getAccountMeta(\"tenant\", accounts.tenant), getAccountMeta(\"player\", accounts.player), getAccountMeta(\"systemProgram\", accounts.systemProgram)], data: getCreateTicketInstructionDataEncoder().encode({}), programAddress } as CreateTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer, TAccountSystemProgram>);\n}\n\nexport type ParsedCreateTicketInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;\naccounts: {\nticket: TAccountMetas[0];\ntenant: TAccountMetas[1];\nplayer: TAccountMetas[2];\nsystemProgram: TAccountMetas[3];\n};\ndata: CreateTicketInstructionData; };\n\nexport function parseCreateTicketInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedCreateTicketInstruction<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: { ticket: getNextAccount(), tenant: getNextAccount(), player: getNextAccount(), systemProgram: getNextAccount() }, data: getCreateTicketInstructionDataDecoder().decode(instruction.data) };\n}"]}

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

@@ -0,0 +1,69 @@
+/**
+ * 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 ReadonlyAccount, type ReadonlyUint8Array, type TransactionSigner, type WritableAccount, type WritableSignerAccount } from '@solana/kit';
+import { DUEL_PROGRAM_ADDRESS } from '../programs';
+import { type AccountType, type AccountTypeArgs } from '../types';
+export declare const DELEGATE_QUEUE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getDelegateQueueDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type DelegateQueueInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountBufferPda extends string | AccountMeta<string> = string, TAccountDelegationRecordPda extends string | AccountMeta<string> = string, TAccountDelegationMetadataPda extends string | AccountMeta<string> = string, TAccountPda extends string | AccountMeta<string> = string, TAccountPayer extends string | AccountMeta<string> = string, TAccountValidator extends string | AccountMeta<string> = string, TAccountOwnerProgram extends string | AccountMeta<string> = "EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X", TAccountDelegationProgram extends string | AccountMeta<string> = "DELeGGvXpWV2fqJUhqcF5ZSYMS4JTLjteaAMARRSaeSh", TAccountSystemProgram extends string | AccountMeta<string> = "11111111111111111111111111111111", TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountBufferPda extends string ? WritableAccount<TAccountBufferPda> : TAccountBufferPda, TAccountDelegationRecordPda extends string ? WritableAccount<TAccountDelegationRecordPda> : TAccountDelegationRecordPda, TAccountDelegationMetadataPda extends string ? WritableAccount<TAccountDelegationMetadataPda> : TAccountDelegationMetadataPda, TAccountPda extends string ? WritableAccount<TAccountPda> : TAccountPda, TAccountPayer extends string ? WritableSignerAccount<TAccountPayer> & AccountSignerMeta<TAccountPayer> : TAccountPayer, TAccountValidator extends string ? ReadonlyAccount<TAccountValidator> : TAccountValidator, TAccountOwnerProgram extends string ? ReadonlyAccount<TAccountOwnerProgram> : TAccountOwnerProgram, TAccountDelegationProgram extends string ? ReadonlyAccount<TAccountDelegationProgram> : TAccountDelegationProgram, TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram, ...TRemainingAccounts]>;
+export type DelegateQueueInstructionData = {
+    discriminator: ReadonlyUint8Array;
+    accountType: AccountType;
+};
+export type DelegateQueueInstructionDataArgs = {
+    accountType: AccountTypeArgs;
+};
+export declare function getDelegateQueueInstructionDataEncoder(): Encoder<DelegateQueueInstructionDataArgs>;
+export declare function getDelegateQueueInstructionDataDecoder(): Decoder<DelegateQueueInstructionData>;
+export declare function getDelegateQueueInstructionDataCodec(): Codec<DelegateQueueInstructionDataArgs, DelegateQueueInstructionData>;
+export type DelegateQueueAsyncInput<TAccountBufferPda extends string = string, TAccountDelegationRecordPda extends string = string, TAccountDelegationMetadataPda extends string = string, TAccountPda extends string = string, TAccountPayer extends string = string, TAccountValidator extends string = string, TAccountOwnerProgram extends string = string, TAccountDelegationProgram extends string = string, TAccountSystemProgram extends string = string> = {
+    bufferPda?: Address<TAccountBufferPda>;
+    delegationRecordPda?: Address<TAccountDelegationRecordPda>;
+    delegationMetadataPda?: Address<TAccountDelegationMetadataPda>;
+    pda: Address<TAccountPda>;
+    payer: TransactionSigner<TAccountPayer>;
+    validator?: Address<TAccountValidator>;
+    ownerProgram?: Address<TAccountOwnerProgram>;
+    delegationProgram?: Address<TAccountDelegationProgram>;
+    systemProgram?: Address<TAccountSystemProgram>;
+    accountType: DelegateQueueInstructionDataArgs["accountType"];
+};
+export declare function getDelegateQueueInstructionAsync<TAccountBufferPda extends string, TAccountDelegationRecordPda extends string, TAccountDelegationMetadataPda extends string, TAccountPda extends string, TAccountPayer extends string, TAccountValidator extends string, TAccountOwnerProgram extends string, TAccountDelegationProgram extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: DelegateQueueAsyncInput<TAccountBufferPda, TAccountDelegationRecordPda, TAccountDelegationMetadataPda, TAccountPda, TAccountPayer, TAccountValidator, TAccountOwnerProgram, TAccountDelegationProgram, TAccountSystemProgram>, config?: {
+    programAddress?: TProgramAddress;
+}): Promise<DelegateQueueInstruction<TProgramAddress, TAccountBufferPda, TAccountDelegationRecordPda, TAccountDelegationMetadataPda, TAccountPda, TAccountPayer, TAccountValidator, TAccountOwnerProgram, TAccountDelegationProgram, TAccountSystemProgram>>;
+export type DelegateQueueInput<TAccountBufferPda extends string = string, TAccountDelegationRecordPda extends string = string, TAccountDelegationMetadataPda extends string = string, TAccountPda extends string = string, TAccountPayer extends string = string, TAccountValidator extends string = string, TAccountOwnerProgram extends string = string, TAccountDelegationProgram extends string = string, TAccountSystemProgram extends string = string> = {
+    bufferPda: Address<TAccountBufferPda>;
+    delegationRecordPda: Address<TAccountDelegationRecordPda>;
+    delegationMetadataPda: Address<TAccountDelegationMetadataPda>;
+    pda: Address<TAccountPda>;
+    payer: TransactionSigner<TAccountPayer>;
+    validator?: Address<TAccountValidator>;
+    ownerProgram?: Address<TAccountOwnerProgram>;
+    delegationProgram?: Address<TAccountDelegationProgram>;
+    systemProgram?: Address<TAccountSystemProgram>;
+    accountType: DelegateQueueInstructionDataArgs["accountType"];
+};
+export declare function getDelegateQueueInstruction<TAccountBufferPda extends string, TAccountDelegationRecordPda extends string, TAccountDelegationMetadataPda extends string, TAccountPda extends string, TAccountPayer extends string, TAccountValidator extends string, TAccountOwnerProgram extends string, TAccountDelegationProgram extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: DelegateQueueInput<TAccountBufferPda, TAccountDelegationRecordPda, TAccountDelegationMetadataPda, TAccountPda, TAccountPayer, TAccountValidator, TAccountOwnerProgram, TAccountDelegationProgram, TAccountSystemProgram>, config?: {
+    programAddress?: TProgramAddress;
+}): DelegateQueueInstruction<TProgramAddress, TAccountBufferPda, TAccountDelegationRecordPda, TAccountDelegationMetadataPda, TAccountPda, TAccountPayer, TAccountValidator, TAccountOwnerProgram, TAccountDelegationProgram, TAccountSystemProgram>;
+export type ParsedDelegateQueueInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        bufferPda: TAccountMetas[0];
+        delegationRecordPda: TAccountMetas[1];
+        delegationMetadataPda: TAccountMetas[2];
+        pda: TAccountMetas[3];
+        payer: TAccountMetas[4];
+        validator?: TAccountMetas[5] | undefined;
+        ownerProgram: TAccountMetas[6];
+        delegationProgram: TAccountMetas[7];
+        systemProgram: TAccountMetas[8];
+    };
+    data: DelegateQueueInstructionData;
+};
+export declare function parseDelegateQueueInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedDelegateQueueInstruction<TProgram, TAccountMetas>;