@1upmonster/duel 0.1.8 → 0.2.2

package/dist/generated/rps-game/instructions/startGame.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, getProgramDerivedAddress, getStructDecoder, getStructEncoder, getU64Decoder, getU64Encoder, SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, SolanaError, transformEncoder } from '@solana/kit';
+import { getAccountMetaFactory, getAddressFromResolvedInstructionAccount, getNonNullResolvedInstructionInput } from '@solana/program-client-core';
+import { RPS_GAME_PROGRAM_ADDRESS } from '../programs';
+export const START_GAME_DISCRIMINATOR = new Uint8Array([249, 47, 252, 172, 184, 162, 245, 14]);
+export function getStartGameDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(START_GAME_DISCRIMINATOR); }
+export function getStartGameInstructionDataEncoder() {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['gameId', getU64Encoder()], ['opponent', getAddressEncoder()]]), (value) => ({ ...value, discriminator: START_GAME_DISCRIMINATOR }));
+}
+export function getStartGameInstructionDataDecoder() {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['gameId', getU64Decoder()], ['opponent', getAddressDecoder()]]);
+}
+export function getStartGameInstructionDataCodec() {
+    return combineCodec(getStartGameInstructionDataEncoder(), getStartGameInstructionDataDecoder());
+}
+export async function getStartGameInstructionAsync(input, config) {
+    // Program address.
+    const programAddress = config?.programAddress ?? RPS_GAME_PROGRAM_ADDRESS;
+    // Original accounts.
+    const originalAccounts = { gameSession: { value: input.gameSession ?? null, isWritable: true }, player: { value: input.player ?? null, isWritable: true }, systemProgram: { value: input.systemProgram ?? null, isWritable: false } };
+    const accounts = originalAccounts;
+    // Original args.
+    const args = { ...input, };
+    // Resolve default values.
+    if (!accounts.gameSession.value) {
+        accounts.gameSession.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([103, 97, 109, 101, 95, 115, 101, 115, 115, 105, 111, 110, 95, 118, 49])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("player", accounts.player.value)), getAddressEncoder().encode(getNonNullResolvedInstructionInput("opponent", args.opponent)), getU64Encoder().encode(getNonNullResolvedInstructionInput("gameId", args.gameId))] });
+    }
+    if (!accounts.systemProgram.value) {
+        accounts.systemProgram.value = '11111111111111111111111111111111';
+    }
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({ accounts: [getAccountMeta("gameSession", accounts.gameSession), getAccountMeta("player", accounts.player), getAccountMeta("systemProgram", accounts.systemProgram)], data: getStartGameInstructionDataEncoder().encode(args), programAddress });
+}
+export function getStartGameInstruction(input, config) {
+    // Program address.
+    const programAddress = config?.programAddress ?? RPS_GAME_PROGRAM_ADDRESS;
+    // Original accounts.
+    const originalAccounts = { gameSession: { value: input.gameSession ?? null, isWritable: true }, player: { value: input.player ?? 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("gameSession", accounts.gameSession), getAccountMeta("player", accounts.player), getAccountMeta("systemProgram", accounts.systemProgram)], data: getStartGameInstructionDataEncoder().encode(args), programAddress });
+}
+export function parseStartGameInstruction(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: { gameSession: getNextAccount(), player: getNextAccount(), systemProgram: getNextAccount() }, data: getStartGameInstructionDataDecoder().decode(instruction.data) };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"startGame.js","sourceRoot":"","sources":["../../../../src/generated/rps-game/instructions/startGame.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, getProgramDerivedAddress, getStructDecoder, getStructEncoder, getU64Decoder, getU64Encoder, 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, getNonNullResolvedInstructionInput, type ResolvedInstructionAccount } from '@solana/program-client-core';\nimport { RPS_GAME_PROGRAM_ADDRESS } from '../programs';\n\nexport const START_GAME_DISCRIMINATOR = new Uint8Array([249, 47, 252, 172, 184, 162, 245, 14]);\n\nexport function getStartGameDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(START_GAME_DISCRIMINATOR); }\n\nexport type StartGameInstruction<TProgram extends string = typeof RPS_GAME_PROGRAM_ADDRESS, TAccountGameSession 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<[TAccountGameSession extends string ? WritableAccount<TAccountGameSession> : TAccountGameSession, TAccountPlayer extends string ? WritableSignerAccount<TAccountPlayer> & AccountSignerMeta<TAccountPlayer> : TAccountPlayer, TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram, ...TRemainingAccounts]>;\n\nexport type StartGameInstructionData = { discriminator: ReadonlyUint8Array; gameId: bigint; opponent: Address;  };\n\nexport type StartGameInstructionDataArgs = { gameId: number | bigint; opponent: Address;  };\n\nexport function getStartGameInstructionDataEncoder(): FixedSizeEncoder<StartGameInstructionDataArgs> {\n    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['gameId', getU64Encoder()], ['opponent', getAddressEncoder()]]), (value) => ({ ...value, discriminator: START_GAME_DISCRIMINATOR }));\n}\n\nexport function getStartGameInstructionDataDecoder(): FixedSizeDecoder<StartGameInstructionData> {\n    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['gameId', getU64Decoder()], ['opponent', getAddressDecoder()]]);\n}\n\nexport function getStartGameInstructionDataCodec(): FixedSizeCodec<StartGameInstructionDataArgs, StartGameInstructionData> {\n    return combineCodec(getStartGameInstructionDataEncoder(), getStartGameInstructionDataDecoder());\n}\n\nexport type StartGameAsyncInput<TAccountGameSession extends string = string, TAccountPlayer extends string = string, TAccountSystemProgram extends string = string> =  {\n  gameSession?: Address<TAccountGameSession>;\nplayer: TransactionSigner<TAccountPlayer>;\nsystemProgram?: Address<TAccountSystemProgram>;\ngameId: StartGameInstructionDataArgs[\"gameId\"];\nopponent: StartGameInstructionDataArgs[\"opponent\"];\n}\n\nexport async function getStartGameInstructionAsync<TAccountGameSession extends string, TAccountPlayer extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof RPS_GAME_PROGRAM_ADDRESS>(input: StartGameAsyncInput<TAccountGameSession, TAccountPlayer, TAccountSystemProgram>, config?: { programAddress?: TProgramAddress } ): Promise<StartGameInstruction<TProgramAddress, TAccountGameSession, TAccountPlayer, TAccountSystemProgram>> {\n  // Program address.\nconst programAddress = config?.programAddress ?? RPS_GAME_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst originalAccounts = { gameSession: { value: input.gameSession ?? null, isWritable: true }, 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// Original args.\nconst args = { ...input,  };\n\n\n// Resolve default values.\nif (!accounts.gameSession.value) {\naccounts.gameSession.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([103, 97, 109, 101, 95, 115, 101, 115, 115, 105, 111, 110, 95, 118, 49])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount(\"player\", accounts.player.value)), getAddressEncoder().encode(getNonNullResolvedInstructionInput(\"opponent\", args.opponent)), getU64Encoder().encode(getNonNullResolvedInstructionInput(\"gameId\", args.gameId))] });\n}\nif (!accounts.systemProgram.value) {\naccounts.systemProgram.value = '11111111111111111111111111111111' as Address<'11111111111111111111111111111111'>;\n}\n\nconst getAccountMeta = getAccountMetaFactory(programAddress, 'programId');\nreturn Object.freeze({ accounts: [getAccountMeta(\"gameSession\", accounts.gameSession), getAccountMeta(\"player\", accounts.player), getAccountMeta(\"systemProgram\", accounts.systemProgram)], data: getStartGameInstructionDataEncoder().encode(args as StartGameInstructionDataArgs), programAddress } as StartGameInstruction<TProgramAddress, TAccountGameSession, TAccountPlayer, TAccountSystemProgram>);\n}\n\nexport type StartGameInput<TAccountGameSession extends string = string, TAccountPlayer extends string = string, TAccountSystemProgram extends string = string> =  {\n  gameSession: Address<TAccountGameSession>;\nplayer: TransactionSigner<TAccountPlayer>;\nsystemProgram?: Address<TAccountSystemProgram>;\ngameId: StartGameInstructionDataArgs[\"gameId\"];\nopponent: StartGameInstructionDataArgs[\"opponent\"];\n}\n\nexport function getStartGameInstruction<TAccountGameSession extends string, TAccountPlayer extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof RPS_GAME_PROGRAM_ADDRESS>(input: StartGameInput<TAccountGameSession, TAccountPlayer, TAccountSystemProgram>, config?: { programAddress?: TProgramAddress } ): StartGameInstruction<TProgramAddress, TAccountGameSession, TAccountPlayer, TAccountSystemProgram> {\n  // Program address.\nconst programAddress = config?.programAddress ?? RPS_GAME_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst originalAccounts = { gameSession: { value: input.gameSession ?? null, isWritable: true }, 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// 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(\"gameSession\", accounts.gameSession), getAccountMeta(\"player\", accounts.player), getAccountMeta(\"systemProgram\", accounts.systemProgram)], data: getStartGameInstructionDataEncoder().encode(args as StartGameInstructionDataArgs), programAddress } as StartGameInstruction<TProgramAddress, TAccountGameSession, TAccountPlayer, TAccountSystemProgram>);\n}\n\nexport type ParsedStartGameInstruction<TProgram extends string = typeof RPS_GAME_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;\naccounts: {\ngameSession: TAccountMetas[0];\nplayer: TAccountMetas[1];\nsystemProgram: TAccountMetas[2];\n};\ndata: StartGameInstructionData; };\n\nexport function parseStartGameInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedStartGameInstruction<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: { gameSession: getNextAccount(), player: getNextAccount(), systemProgram: getNextAccount() }, data: getStartGameInstructionDataDecoder().decode(instruction.data) };\n}"]}

package/dist/generated/rps-game/instructions/startGameWithTicket.d.ts

@@ -0,0 +1,57 @@
+/**
+ * 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 { RPS_GAME_PROGRAM_ADDRESS } from '../programs';
+export declare const START_GAME_WITH_TICKET_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getStartGameWithTicketDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+export type StartGameWithTicketInstruction<TProgram extends string = typeof RPS_GAME_PROGRAM_ADDRESS, TAccountGameSession extends string | AccountMeta<string> = string, TAccountPlayer extends string | AccountMeta<string> = string, TAccountMatchTicket extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = "11111111111111111111111111111111", TRemainingAccounts extends readonly AccountMeta<string>[] = []> = Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountGameSession extends string ? WritableAccount<TAccountGameSession> : TAccountGameSession, TAccountPlayer extends string ? WritableSignerAccount<TAccountPlayer> & AccountSignerMeta<TAccountPlayer> : TAccountPlayer, TAccountMatchTicket extends string ? ReadonlyAccount<TAccountMatchTicket> : TAccountMatchTicket, TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram, ...TRemainingAccounts]>;
+export type StartGameWithTicketInstructionData = {
+    discriminator: ReadonlyUint8Array;
+    gameId: bigint;
+    opponent: Address;
+};
+export type StartGameWithTicketInstructionDataArgs = {
+    gameId: number | bigint;
+    opponent: Address;
+};
+export declare function getStartGameWithTicketInstructionDataEncoder(): FixedSizeEncoder<StartGameWithTicketInstructionDataArgs>;
+export declare function getStartGameWithTicketInstructionDataDecoder(): FixedSizeDecoder<StartGameWithTicketInstructionData>;
+export declare function getStartGameWithTicketInstructionDataCodec(): FixedSizeCodec<StartGameWithTicketInstructionDataArgs, StartGameWithTicketInstructionData>;
+export type StartGameWithTicketAsyncInput<TAccountGameSession extends string = string, TAccountPlayer extends string = string, TAccountMatchTicket extends string = string, TAccountSystemProgram extends string = string> = {
+    gameSession?: Address<TAccountGameSession>;
+    player: TransactionSigner<TAccountPlayer>;
+    matchTicket: Address<TAccountMatchTicket>;
+    systemProgram?: Address<TAccountSystemProgram>;
+    gameId: StartGameWithTicketInstructionDataArgs["gameId"];
+    opponent: StartGameWithTicketInstructionDataArgs["opponent"];
+};
+export declare function getStartGameWithTicketInstructionAsync<TAccountGameSession extends string, TAccountPlayer extends string, TAccountMatchTicket extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof RPS_GAME_PROGRAM_ADDRESS>(input: StartGameWithTicketAsyncInput<TAccountGameSession, TAccountPlayer, TAccountMatchTicket, TAccountSystemProgram>, config?: {
+    programAddress?: TProgramAddress;
+}): Promise<StartGameWithTicketInstruction<TProgramAddress, TAccountGameSession, TAccountPlayer, TAccountMatchTicket, TAccountSystemProgram>>;
+export type StartGameWithTicketInput<TAccountGameSession extends string = string, TAccountPlayer extends string = string, TAccountMatchTicket extends string = string, TAccountSystemProgram extends string = string> = {
+    gameSession: Address<TAccountGameSession>;
+    player: TransactionSigner<TAccountPlayer>;
+    matchTicket: Address<TAccountMatchTicket>;
+    systemProgram?: Address<TAccountSystemProgram>;
+    gameId: StartGameWithTicketInstructionDataArgs["gameId"];
+    opponent: StartGameWithTicketInstructionDataArgs["opponent"];
+};
+export declare function getStartGameWithTicketInstruction<TAccountGameSession extends string, TAccountPlayer extends string, TAccountMatchTicket extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof RPS_GAME_PROGRAM_ADDRESS>(input: StartGameWithTicketInput<TAccountGameSession, TAccountPlayer, TAccountMatchTicket, TAccountSystemProgram>, config?: {
+    programAddress?: TProgramAddress;
+}): StartGameWithTicketInstruction<TProgramAddress, TAccountGameSession, TAccountPlayer, TAccountMatchTicket, TAccountSystemProgram>;
+export type ParsedStartGameWithTicketInstruction<TProgram extends string = typeof RPS_GAME_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = {
+    programAddress: Address<TProgram>;
+    accounts: {
+        gameSession: TAccountMetas[0];
+        player: TAccountMetas[1];
+        matchTicket: TAccountMetas[2];
+        systemProgram: TAccountMetas[3];
+    };
+    data: StartGameWithTicketInstructionData;
+};
+export declare function parseStartGameWithTicketInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedStartGameWithTicketInstruction<TProgram, TAccountMetas>;

package/dist/generated/rps-game/instructions/startGameWithTicket.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, getProgramDerivedAddress, getStructDecoder, getStructEncoder, getU64Decoder, getU64Encoder, SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, SolanaError, transformEncoder } from '@solana/kit';
+import { getAccountMetaFactory, getAddressFromResolvedInstructionAccount, getNonNullResolvedInstructionInput } from '@solana/program-client-core';
+import { RPS_GAME_PROGRAM_ADDRESS } from '../programs';
+export const START_GAME_WITH_TICKET_DISCRIMINATOR = new Uint8Array([2, 250, 253, 202, 51, 138, 80, 20]);
+export function getStartGameWithTicketDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(START_GAME_WITH_TICKET_DISCRIMINATOR); }
+export function getStartGameWithTicketInstructionDataEncoder() {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['gameId', getU64Encoder()], ['opponent', getAddressEncoder()]]), (value) => ({ ...value, discriminator: START_GAME_WITH_TICKET_DISCRIMINATOR }));
+}
+export function getStartGameWithTicketInstructionDataDecoder() {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['gameId', getU64Decoder()], ['opponent', getAddressDecoder()]]);
+}
+export function getStartGameWithTicketInstructionDataCodec() {
+    return combineCodec(getStartGameWithTicketInstructionDataEncoder(), getStartGameWithTicketInstructionDataDecoder());
+}
+export async function getStartGameWithTicketInstructionAsync(input, config) {
+    // Program address.
+    const programAddress = config?.programAddress ?? RPS_GAME_PROGRAM_ADDRESS;
+    // Original accounts.
+    const originalAccounts = { gameSession: { value: input.gameSession ?? null, isWritable: true }, player: { value: input.player ?? null, isWritable: true }, matchTicket: { value: input.matchTicket ?? null, isWritable: false }, systemProgram: { value: input.systemProgram ?? null, isWritable: false } };
+    const accounts = originalAccounts;
+    // Original args.
+    const args = { ...input, };
+    // Resolve default values.
+    if (!accounts.gameSession.value) {
+        accounts.gameSession.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([103, 97, 109, 101, 95, 115, 101, 115, 115, 105, 111, 110, 95, 118, 49])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("player", accounts.player.value)), getAddressEncoder().encode(getNonNullResolvedInstructionInput("opponent", args.opponent)), getU64Encoder().encode(getNonNullResolvedInstructionInput("gameId", args.gameId))] });
+    }
+    if (!accounts.systemProgram.value) {
+        accounts.systemProgram.value = '11111111111111111111111111111111';
+    }
+    const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+    return Object.freeze({ accounts: [getAccountMeta("gameSession", accounts.gameSession), getAccountMeta("player", accounts.player), getAccountMeta("matchTicket", accounts.matchTicket), getAccountMeta("systemProgram", accounts.systemProgram)], data: getStartGameWithTicketInstructionDataEncoder().encode(args), programAddress });
+}
+export function getStartGameWithTicketInstruction(input, config) {
+    // Program address.
+    const programAddress = config?.programAddress ?? RPS_GAME_PROGRAM_ADDRESS;
+    // Original accounts.
+    const originalAccounts = { gameSession: { value: input.gameSession ?? null, isWritable: true }, player: { value: input.player ?? null, isWritable: true }, matchTicket: { value: input.matchTicket ?? null, isWritable: false }, 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("gameSession", accounts.gameSession), getAccountMeta("player", accounts.player), getAccountMeta("matchTicket", accounts.matchTicket), getAccountMeta("systemProgram", accounts.systemProgram)], data: getStartGameWithTicketInstructionDataEncoder().encode(args), programAddress });
+}
+export function parseStartGameWithTicketInstruction(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: { gameSession: getNextAccount(), player: getNextAccount(), matchTicket: getNextAccount(), systemProgram: getNextAccount() }, data: getStartGameWithTicketInstructionDataDecoder().decode(instruction.data) };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"startGameWithTicket.js","sourceRoot":"","sources":["../../../../src/generated/rps-game/instructions/startGameWithTicket.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, getProgramDerivedAddress, getStructDecoder, getStructEncoder, getU64Decoder, getU64Encoder, 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, getNonNullResolvedInstructionInput, type ResolvedInstructionAccount } from '@solana/program-client-core';\nimport { RPS_GAME_PROGRAM_ADDRESS } from '../programs';\n\nexport const START_GAME_WITH_TICKET_DISCRIMINATOR = new Uint8Array([2, 250, 253, 202, 51, 138, 80, 20]);\n\nexport function getStartGameWithTicketDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(START_GAME_WITH_TICKET_DISCRIMINATOR); }\n\nexport type StartGameWithTicketInstruction<TProgram extends string = typeof RPS_GAME_PROGRAM_ADDRESS, TAccountGameSession extends string | AccountMeta<string> = string, TAccountPlayer extends string | AccountMeta<string> = string, TAccountMatchTicket extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = \"11111111111111111111111111111111\", TRemainingAccounts extends readonly AccountMeta<string>[] = []> =\nInstruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountGameSession extends string ? WritableAccount<TAccountGameSession> : TAccountGameSession, TAccountPlayer extends string ? WritableSignerAccount<TAccountPlayer> & AccountSignerMeta<TAccountPlayer> : TAccountPlayer, TAccountMatchTicket extends string ? ReadonlyAccount<TAccountMatchTicket> : TAccountMatchTicket, TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram, ...TRemainingAccounts]>;\n\nexport type StartGameWithTicketInstructionData = { discriminator: ReadonlyUint8Array; gameId: bigint; opponent: Address;  };\n\nexport type StartGameWithTicketInstructionDataArgs = { gameId: number | bigint; opponent: Address;  };\n\nexport function getStartGameWithTicketInstructionDataEncoder(): FixedSizeEncoder<StartGameWithTicketInstructionDataArgs> {\n    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['gameId', getU64Encoder()], ['opponent', getAddressEncoder()]]), (value) => ({ ...value, discriminator: START_GAME_WITH_TICKET_DISCRIMINATOR }));\n}\n\nexport function getStartGameWithTicketInstructionDataDecoder(): FixedSizeDecoder<StartGameWithTicketInstructionData> {\n    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['gameId', getU64Decoder()], ['opponent', getAddressDecoder()]]);\n}\n\nexport function getStartGameWithTicketInstructionDataCodec(): FixedSizeCodec<StartGameWithTicketInstructionDataArgs, StartGameWithTicketInstructionData> {\n    return combineCodec(getStartGameWithTicketInstructionDataEncoder(), getStartGameWithTicketInstructionDataDecoder());\n}\n\nexport type StartGameWithTicketAsyncInput<TAccountGameSession extends string = string, TAccountPlayer extends string = string, TAccountMatchTicket extends string = string, TAccountSystemProgram extends string = string> =  {\n  gameSession?: Address<TAccountGameSession>;\nplayer: TransactionSigner<TAccountPlayer>;\nmatchTicket: Address<TAccountMatchTicket>;\nsystemProgram?: Address<TAccountSystemProgram>;\ngameId: StartGameWithTicketInstructionDataArgs[\"gameId\"];\nopponent: StartGameWithTicketInstructionDataArgs[\"opponent\"];\n}\n\nexport async function getStartGameWithTicketInstructionAsync<TAccountGameSession extends string, TAccountPlayer extends string, TAccountMatchTicket extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof RPS_GAME_PROGRAM_ADDRESS>(input: StartGameWithTicketAsyncInput<TAccountGameSession, TAccountPlayer, TAccountMatchTicket, TAccountSystemProgram>, config?: { programAddress?: TProgramAddress } ): Promise<StartGameWithTicketInstruction<TProgramAddress, TAccountGameSession, TAccountPlayer, TAccountMatchTicket, TAccountSystemProgram>> {\n  // Program address.\nconst programAddress = config?.programAddress ?? RPS_GAME_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst originalAccounts = { gameSession: { value: input.gameSession ?? null, isWritable: true }, player: { value: input.player ?? null, isWritable: true }, matchTicket: { value: input.matchTicket ?? null, isWritable: false }, 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.gameSession.value) {\naccounts.gameSession.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([103, 97, 109, 101, 95, 115, 101, 115, 115, 105, 111, 110, 95, 118, 49])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount(\"player\", accounts.player.value)), getAddressEncoder().encode(getNonNullResolvedInstructionInput(\"opponent\", args.opponent)), getU64Encoder().encode(getNonNullResolvedInstructionInput(\"gameId\", args.gameId))] });\n}\nif (!accounts.systemProgram.value) {\naccounts.systemProgram.value = '11111111111111111111111111111111' as Address<'11111111111111111111111111111111'>;\n}\n\nconst getAccountMeta = getAccountMetaFactory(programAddress, 'programId');\nreturn Object.freeze({ accounts: [getAccountMeta(\"gameSession\", accounts.gameSession), getAccountMeta(\"player\", accounts.player), getAccountMeta(\"matchTicket\", accounts.matchTicket), getAccountMeta(\"systemProgram\", accounts.systemProgram)], data: getStartGameWithTicketInstructionDataEncoder().encode(args as StartGameWithTicketInstructionDataArgs), programAddress } as StartGameWithTicketInstruction<TProgramAddress, TAccountGameSession, TAccountPlayer, TAccountMatchTicket, TAccountSystemProgram>);\n}\n\nexport type StartGameWithTicketInput<TAccountGameSession extends string = string, TAccountPlayer extends string = string, TAccountMatchTicket extends string = string, TAccountSystemProgram extends string = string> =  {\n  gameSession: Address<TAccountGameSession>;\nplayer: TransactionSigner<TAccountPlayer>;\nmatchTicket: Address<TAccountMatchTicket>;\nsystemProgram?: Address<TAccountSystemProgram>;\ngameId: StartGameWithTicketInstructionDataArgs[\"gameId\"];\nopponent: StartGameWithTicketInstructionDataArgs[\"opponent\"];\n}\n\nexport function getStartGameWithTicketInstruction<TAccountGameSession extends string, TAccountPlayer extends string, TAccountMatchTicket extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof RPS_GAME_PROGRAM_ADDRESS>(input: StartGameWithTicketInput<TAccountGameSession, TAccountPlayer, TAccountMatchTicket, TAccountSystemProgram>, config?: { programAddress?: TProgramAddress } ): StartGameWithTicketInstruction<TProgramAddress, TAccountGameSession, TAccountPlayer, TAccountMatchTicket, TAccountSystemProgram> {\n  // Program address.\nconst programAddress = config?.programAddress ?? RPS_GAME_PROGRAM_ADDRESS;\n\n // Original accounts.\nconst originalAccounts = { gameSession: { value: input.gameSession ?? null, isWritable: true }, player: { value: input.player ?? null, isWritable: true }, matchTicket: { value: input.matchTicket ?? null, isWritable: false }, 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(\"gameSession\", accounts.gameSession), getAccountMeta(\"player\", accounts.player), getAccountMeta(\"matchTicket\", accounts.matchTicket), getAccountMeta(\"systemProgram\", accounts.systemProgram)], data: getStartGameWithTicketInstructionDataEncoder().encode(args as StartGameWithTicketInstructionDataArgs), programAddress } as StartGameWithTicketInstruction<TProgramAddress, TAccountGameSession, TAccountPlayer, TAccountMatchTicket, TAccountSystemProgram>);\n}\n\nexport type ParsedStartGameWithTicketInstruction<TProgram extends string = typeof RPS_GAME_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;\naccounts: {\ngameSession: TAccountMetas[0];\nplayer: TAccountMetas[1];\nmatchTicket: TAccountMetas[2];\nsystemProgram: TAccountMetas[3];\n};\ndata: StartGameWithTicketInstructionData; };\n\nexport function parseStartGameWithTicketInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedStartGameWithTicketInstruction<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: { gameSession: getNextAccount(), player: getNextAccount(), matchTicket: getNextAccount(), systemProgram: getNextAccount() }, data: getStartGameWithTicketInstructionDataDecoder().decode(instruction.data) };\n}"]}

package/dist/generated/rps-game/programs/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+export * from './rpsGame';

package/dist/generated/rps-game/programs/index.js

@@ -0,0 +1,9 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+export * from './rpsGame';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZ2VuZXJhdGVkL3Jwcy1nYW1lL3Byb2dyYW1zL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7R0FNRztBQUVILGNBQWMsV0FBVyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBUaGlzIGNvZGUgd2FzIEFVVE9HRU5FUkFURUQgdXNpbmcgdGhlIENvZGFtYSBsaWJyYXJ5LlxuICogUGxlYXNlIERPIE5PVCBFRElUIFRISVMgRklMRSwgaW5zdGVhZCB1c2UgdmlzaXRvcnNcbiAqIHRvIGFkZCBmZWF0dXJlcywgdGhlbiByZXJ1biBDb2RhbWEgdG8gdXBkYXRlIGl0LlxuICpcbiAqIEBzZWUgaHR0cHM6Ly9naXRodWIuY29tL2NvZGFtYS1pZGwvY29kYW1hXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9ycHNHYW1lJzsiXX0=

package/dist/generated/rps-game/programs/rpsGame.d.ts

@@ -0,0 +1,78 @@
+/**
+ * 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 Address, type ClientWithPayer, type ClientWithRpc, type ClientWithTransactionPlanning, type ClientWithTransactionSending, type GetAccountInfoApi, type GetMultipleAccountsApi, type Instruction, type InstructionWithData, type ReadonlyUint8Array } from '@solana/kit';
+import { type SelfFetchFunctions, type SelfPlanAndSendFunctions } from '@solana/program-client-core';
+import { getGameSessionCodec, getPlayerProfileCodec, type GameSession, type GameSessionArgs, type PlayerProfile, type PlayerProfileArgs } from '../accounts';
+import { getClosePlayerInstructionAsync, getDelegatePdaInstructionAsync, getInitializePlayerInstructionAsync, getMakeChoiceInstruction, getOnMatchFoundInstruction, getPersistResultsInstruction, getProcessUndelegationInstruction, getStartGameInstructionAsync, getStartGameWithTicketInstructionAsync, type ClosePlayerAsyncInput, type DelegatePdaAsyncInput, type InitializePlayerAsyncInput, type MakeChoiceInput, type OnMatchFoundInput, type ParsedClosePlayerInstruction, type ParsedDelegatePdaInstruction, type ParsedInitializePlayerInstruction, type ParsedMakeChoiceInstruction, type ParsedOnMatchFoundInstruction, type ParsedPersistResultsInstruction, type ParsedProcessUndelegationInstruction, type ParsedStartGameInstruction, type ParsedStartGameWithTicketInstruction, type PersistResultsInput, type ProcessUndelegationInput, type StartGameAsyncInput, type StartGameWithTicketAsyncInput } from '../instructions';
+export declare const RPS_GAME_PROGRAM_ADDRESS: Address<"8ohu3RobXyZ2DebyJjbs2co9YCG275FUsVckEcmDbCos">;
+export declare enum RpsGameAccount {
+    GameSession = 0,
+    PlayerProfile = 1
+}
+export declare function identifyRpsGameAccount(account: {
+    data: ReadonlyUint8Array;
+} | ReadonlyUint8Array): RpsGameAccount;
+export declare enum RpsGameInstruction {
+    ClosePlayer = 0,
+    DelegatePda = 1,
+    InitializePlayer = 2,
+    MakeChoice = 3,
+    OnMatchFound = 4,
+    PersistResults = 5,
+    ProcessUndelegation = 6,
+    StartGame = 7,
+    StartGameWithTicket = 8
+}
+export declare function identifyRpsGameInstruction(instruction: {
+    data: ReadonlyUint8Array;
+} | ReadonlyUint8Array): RpsGameInstruction;
+export type ParsedRpsGameInstruction<TProgram extends string = '8ohu3RobXyZ2DebyJjbs2co9YCG275FUsVckEcmDbCos'> = {
+    instructionType: RpsGameInstruction.ClosePlayer;
+} & ParsedClosePlayerInstruction<TProgram> | {
+    instructionType: RpsGameInstruction.DelegatePda;
+} & ParsedDelegatePdaInstruction<TProgram> | {
+    instructionType: RpsGameInstruction.InitializePlayer;
+} & ParsedInitializePlayerInstruction<TProgram> | {
+    instructionType: RpsGameInstruction.MakeChoice;
+} & ParsedMakeChoiceInstruction<TProgram> | {
+    instructionType: RpsGameInstruction.OnMatchFound;
+} & ParsedOnMatchFoundInstruction<TProgram> | {
+    instructionType: RpsGameInstruction.PersistResults;
+} & ParsedPersistResultsInstruction<TProgram> | {
+    instructionType: RpsGameInstruction.ProcessUndelegation;
+} & ParsedProcessUndelegationInstruction<TProgram> | {
+    instructionType: RpsGameInstruction.StartGame;
+} & ParsedStartGameInstruction<TProgram> | {
+    instructionType: RpsGameInstruction.StartGameWithTicket;
+} & ParsedStartGameWithTicketInstruction<TProgram>;
+export declare function parseRpsGameInstruction<TProgram extends string>(instruction: Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array>): ParsedRpsGameInstruction<TProgram>;
+export type RpsGamePlugin = {
+    accounts: RpsGamePluginAccounts;
+    instructions: RpsGamePluginInstructions;
+};
+export type RpsGamePluginAccounts = {
+    gameSession: ReturnType<typeof getGameSessionCodec> & SelfFetchFunctions<GameSessionArgs, GameSession>;
+    playerProfile: ReturnType<typeof getPlayerProfileCodec> & SelfFetchFunctions<PlayerProfileArgs, PlayerProfile>;
+};
+export type RpsGamePluginInstructions = {
+    closePlayer: (input: MakeOptional<ClosePlayerAsyncInput, "payer">) => ReturnType<typeof getClosePlayerInstructionAsync> & SelfPlanAndSendFunctions;
+    delegatePda: (input: MakeOptional<DelegatePdaAsyncInput, "payer">) => ReturnType<typeof getDelegatePdaInstructionAsync> & SelfPlanAndSendFunctions;
+    initializePlayer: (input: MakeOptional<InitializePlayerAsyncInput, "payer">) => ReturnType<typeof getInitializePlayerInstructionAsync> & SelfPlanAndSendFunctions;
+    makeChoice: (input: MakeChoiceInput) => ReturnType<typeof getMakeChoiceInstruction> & SelfPlanAndSendFunctions;
+    onMatchFound: (input: OnMatchFoundInput) => ReturnType<typeof getOnMatchFoundInstruction> & SelfPlanAndSendFunctions;
+    persistResults: (input: MakeOptional<PersistResultsInput, "payer">) => ReturnType<typeof getPersistResultsInstruction> & SelfPlanAndSendFunctions;
+    processUndelegation: (input: MakeOptional<ProcessUndelegationInput, "payer">) => ReturnType<typeof getProcessUndelegationInstruction> & SelfPlanAndSendFunctions;
+    startGame: (input: StartGameAsyncInput) => ReturnType<typeof getStartGameInstructionAsync> & SelfPlanAndSendFunctions;
+    startGameWithTicket: (input: StartGameWithTicketAsyncInput) => ReturnType<typeof getStartGameWithTicketInstructionAsync> & SelfPlanAndSendFunctions;
+};
+export type RpsGamePluginRequirements = ClientWithRpc<GetAccountInfoApi & GetMultipleAccountsApi> & ClientWithPayer & ClientWithTransactionPlanning & ClientWithTransactionSending;
+export declare function rpsGameProgram(): <T extends RpsGamePluginRequirements>(client: T) => T & {
+    rpsGame: RpsGamePlugin;
+};
+type MakeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+export {};

package/dist/generated/rps-game/programs/rpsGame.js

@@ -0,0 +1,118 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+import { assertIsInstructionWithAccounts, containsBytes, fixEncoderSize, getBytesEncoder, SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT, SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, SolanaError } from '@solana/kit';
+import { addSelfFetchFunctions, addSelfPlanAndSendFunctions } from '@solana/program-client-core';
+import { getGameSessionCodec, getPlayerProfileCodec } from '../accounts';
+import { getClosePlayerInstructionAsync, getDelegatePdaInstructionAsync, getInitializePlayerInstructionAsync, getMakeChoiceInstruction, getOnMatchFoundInstruction, getPersistResultsInstruction, getProcessUndelegationInstruction, getStartGameInstructionAsync, getStartGameWithTicketInstructionAsync, parseClosePlayerInstruction, parseDelegatePdaInstruction, parseInitializePlayerInstruction, parseMakeChoiceInstruction, parseOnMatchFoundInstruction, parsePersistResultsInstruction, parseProcessUndelegationInstruction, parseStartGameInstruction, parseStartGameWithTicketInstruction } from '../instructions';
+export const RPS_GAME_PROGRAM_ADDRESS = '8ohu3RobXyZ2DebyJjbs2co9YCG275FUsVckEcmDbCos';
+export var RpsGameAccount;
+(function (RpsGameAccount) {
+    RpsGameAccount[RpsGameAccount["GameSession"] = 0] = "GameSession";
+    RpsGameAccount[RpsGameAccount["PlayerProfile"] = 1] = "PlayerProfile";
+})(RpsGameAccount || (RpsGameAccount = {}));
+export function identifyRpsGameAccount(account) {
+    const data = 'data' in account ? account.data : account;
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([150, 116, 20, 197, 205, 121, 220, 240])), 0)) {
+        return RpsGameAccount.GameSession;
+    }
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([82, 226, 99, 87, 164, 130, 181, 80])), 0)) {
+        return RpsGameAccount.PlayerProfile;
+    }
+    throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT, { accountData: data, programName: "rpsGame" });
+}
+export var RpsGameInstruction;
+(function (RpsGameInstruction) {
+    RpsGameInstruction[RpsGameInstruction["ClosePlayer"] = 0] = "ClosePlayer";
+    RpsGameInstruction[RpsGameInstruction["DelegatePda"] = 1] = "DelegatePda";
+    RpsGameInstruction[RpsGameInstruction["InitializePlayer"] = 2] = "InitializePlayer";
+    RpsGameInstruction[RpsGameInstruction["MakeChoice"] = 3] = "MakeChoice";
+    RpsGameInstruction[RpsGameInstruction["OnMatchFound"] = 4] = "OnMatchFound";
+    RpsGameInstruction[RpsGameInstruction["PersistResults"] = 5] = "PersistResults";
+    RpsGameInstruction[RpsGameInstruction["ProcessUndelegation"] = 6] = "ProcessUndelegation";
+    RpsGameInstruction[RpsGameInstruction["StartGame"] = 7] = "StartGame";
+    RpsGameInstruction[RpsGameInstruction["StartGameWithTicket"] = 8] = "StartGameWithTicket";
+})(RpsGameInstruction || (RpsGameInstruction = {}));
+export function identifyRpsGameInstruction(instruction) {
+    const data = 'data' in instruction ? instruction.data : instruction;
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([225, 227, 204, 63, 32, 122, 58, 227])), 0)) {
+        return RpsGameInstruction.ClosePlayer;
+    }
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([248, 217, 193, 46, 124, 191, 64, 135])), 0)) {
+        return RpsGameInstruction.DelegatePda;
+    }
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([79, 249, 88, 177, 220, 62, 56, 128])), 0)) {
+        return RpsGameInstruction.InitializePlayer;
+    }
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([207, 18, 251, 32, 135, 122, 160, 77])), 0)) {
+        return RpsGameInstruction.MakeChoice;
+    }
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([66, 209, 170, 159, 10, 195, 34, 214])), 0)) {
+        return RpsGameInstruction.OnMatchFound;
+    }
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([9, 175, 42, 217, 2, 48, 80, 81])), 0)) {
+        return RpsGameInstruction.PersistResults;
+    }
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([196, 28, 41, 206, 48, 37, 51, 167])), 0)) {
+        return RpsGameInstruction.ProcessUndelegation;
+    }
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([249, 47, 252, 172, 184, 162, 245, 14])), 0)) {
+        return RpsGameInstruction.StartGame;
+    }
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([2, 250, 253, 202, 51, 138, 80, 20])), 0)) {
+        return RpsGameInstruction.StartGameWithTicket;
+    }
+    throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, { instructionData: data, programName: "rpsGame" });
+}
+export function parseRpsGameInstruction(instruction) {
+    const instructionType = identifyRpsGameInstruction(instruction);
+    switch (instructionType) {
+        case RpsGameInstruction.ClosePlayer: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: RpsGameInstruction.ClosePlayer, ...parseClosePlayerInstruction(instruction) };
+        }
+        case RpsGameInstruction.DelegatePda: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: RpsGameInstruction.DelegatePda, ...parseDelegatePdaInstruction(instruction) };
+        }
+        case RpsGameInstruction.InitializePlayer: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: RpsGameInstruction.InitializePlayer, ...parseInitializePlayerInstruction(instruction) };
+        }
+        case RpsGameInstruction.MakeChoice: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: RpsGameInstruction.MakeChoice, ...parseMakeChoiceInstruction(instruction) };
+        }
+        case RpsGameInstruction.OnMatchFound: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: RpsGameInstruction.OnMatchFound, ...parseOnMatchFoundInstruction(instruction) };
+        }
+        case RpsGameInstruction.PersistResults: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: RpsGameInstruction.PersistResults, ...parsePersistResultsInstruction(instruction) };
+        }
+        case RpsGameInstruction.ProcessUndelegation: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: RpsGameInstruction.ProcessUndelegation, ...parseProcessUndelegationInstruction(instruction) };
+        }
+        case RpsGameInstruction.StartGame: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: RpsGameInstruction.StartGame, ...parseStartGameInstruction(instruction) };
+        }
+        case RpsGameInstruction.StartGameWithTicket: {
+            assertIsInstructionWithAccounts(instruction);
+            return { instructionType: RpsGameInstruction.StartGameWithTicket, ...parseStartGameWithTicketInstruction(instruction) };
+        }
+        default: throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, { instructionType: instructionType, programName: "rpsGame" });
+    }
+}
+export function rpsGameProgram() {
+    return (client) => {
+        return { ...client, rpsGame: { accounts: { gameSession: addSelfFetchFunctions(client, getGameSessionCodec()), playerProfile: addSelfFetchFunctions(client, getPlayerProfileCodec()) }, instructions: { closePlayer: input => addSelfPlanAndSendFunctions(client, getClosePlayerInstructionAsync({ ...input, payer: input.payer ?? client.payer.address })), delegatePda: input => addSelfPlanAndSendFunctions(client, getDelegatePdaInstructionAsync({ ...input, payer: input.payer ?? client.payer })), initializePlayer: input => addSelfPlanAndSendFunctions(client, getInitializePlayerInstructionAsync({ ...input, payer: input.payer ?? client.payer })), makeChoice: input => addSelfPlanAndSendFunctions(client, getMakeChoiceInstruction(input)), onMatchFound: input => addSelfPlanAndSendFunctions(client, getOnMatchFoundInstruction(input)), persistResults: input => addSelfPlanAndSendFunctions(client, getPersistResultsInstruction({ ...input, payer: input.payer ?? client.payer })), processUndelegation: input => addSelfPlanAndSendFunctions(client, getProcessUndelegationInstruction({ ...input, payer: input.payer ?? client.payer.address })), startGame: input => addSelfPlanAndSendFunctions(client, getStartGameInstructionAsync(input)), startGameWithTicket: input => addSelfPlanAndSendFunctions(client, getStartGameWithTicketInstructionAsync(input)) } } };
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rpsGame.js","sourceRoot":"","sources":["../../../../src/generated/rps-game/programs/rpsGame.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 { assertIsInstructionWithAccounts, containsBytes, fixEncoderSize, getBytesEncoder, SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT, SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, SolanaError, type Address, type ClientWithPayer, type ClientWithRpc, type ClientWithTransactionPlanning, type ClientWithTransactionSending, type GetAccountInfoApi, type GetMultipleAccountsApi, type Instruction, type InstructionWithData, type ReadonlyUint8Array } from '@solana/kit';\nimport { addSelfFetchFunctions, addSelfPlanAndSendFunctions, type SelfFetchFunctions, type SelfPlanAndSendFunctions } from '@solana/program-client-core';\nimport { getGameSessionCodec, getPlayerProfileCodec, type GameSession, type GameSessionArgs, type PlayerProfile, type PlayerProfileArgs } from '../accounts';\nimport { getClosePlayerInstructionAsync, getDelegatePdaInstructionAsync, getInitializePlayerInstructionAsync, getMakeChoiceInstruction, getOnMatchFoundInstruction, getPersistResultsInstruction, getProcessUndelegationInstruction, getStartGameInstructionAsync, getStartGameWithTicketInstructionAsync, parseClosePlayerInstruction, parseDelegatePdaInstruction, parseInitializePlayerInstruction, parseMakeChoiceInstruction, parseOnMatchFoundInstruction, parsePersistResultsInstruction, parseProcessUndelegationInstruction, parseStartGameInstruction, parseStartGameWithTicketInstruction, type ClosePlayerAsyncInput, type DelegatePdaAsyncInput, type InitializePlayerAsyncInput, type MakeChoiceInput, type OnMatchFoundInput, type ParsedClosePlayerInstruction, type ParsedDelegatePdaInstruction, type ParsedInitializePlayerInstruction, type ParsedMakeChoiceInstruction, type ParsedOnMatchFoundInstruction, type ParsedPersistResultsInstruction, type ParsedProcessUndelegationInstruction, type ParsedStartGameInstruction, type ParsedStartGameWithTicketInstruction, type PersistResultsInput, type ProcessUndelegationInput, type StartGameAsyncInput, type StartGameWithTicketAsyncInput } from '../instructions';\n\nexport const RPS_GAME_PROGRAM_ADDRESS = '8ohu3RobXyZ2DebyJjbs2co9YCG275FUsVckEcmDbCos' as Address<'8ohu3RobXyZ2DebyJjbs2co9YCG275FUsVckEcmDbCos'>;\n\nexport enum RpsGameAccount { GameSession, PlayerProfile }\n\nexport function identifyRpsGameAccount(account: { data: ReadonlyUint8Array } | ReadonlyUint8Array): RpsGameAccount {\n    const data = 'data' in account ? account.data : account;\n    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([150, 116, 20, 197, 205, 121, 220, 240])), 0)) { return RpsGameAccount.GameSession; }\nif (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([82, 226, 99, 87, 164, 130, 181, 80])), 0)) { return RpsGameAccount.PlayerProfile; }\n    throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT, { accountData: data, programName: \"rpsGame\" });\n}\n\nexport enum RpsGameInstruction { ClosePlayer, DelegatePda, InitializePlayer, MakeChoice, OnMatchFound, PersistResults, ProcessUndelegation, StartGame, StartGameWithTicket }\n\nexport function identifyRpsGameInstruction(instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array): RpsGameInstruction {\n    const data = 'data' in instruction ? instruction.data : instruction;\n    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([225, 227, 204, 63, 32, 122, 58, 227])), 0)) { return RpsGameInstruction.ClosePlayer; }\nif (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([248, 217, 193, 46, 124, 191, 64, 135])), 0)) { return RpsGameInstruction.DelegatePda; }\nif (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([79, 249, 88, 177, 220, 62, 56, 128])), 0)) { return RpsGameInstruction.InitializePlayer; }\nif (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([207, 18, 251, 32, 135, 122, 160, 77])), 0)) { return RpsGameInstruction.MakeChoice; }\nif (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([66, 209, 170, 159, 10, 195, 34, 214])), 0)) { return RpsGameInstruction.OnMatchFound; }\nif (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([9, 175, 42, 217, 2, 48, 80, 81])), 0)) { return RpsGameInstruction.PersistResults; }\nif (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([196, 28, 41, 206, 48, 37, 51, 167])), 0)) { return RpsGameInstruction.ProcessUndelegation; }\nif (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([249, 47, 252, 172, 184, 162, 245, 14])), 0)) { return RpsGameInstruction.StartGame; }\nif (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([2, 250, 253, 202, 51, 138, 80, 20])), 0)) { return RpsGameInstruction.StartGameWithTicket; }\n    throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, { instructionData: data, programName: \"rpsGame\" });\n}\n\nexport type ParsedRpsGameInstruction<TProgram extends string = '8ohu3RobXyZ2DebyJjbs2co9YCG275FUsVckEcmDbCos'> =\n| { instructionType: RpsGameInstruction.ClosePlayer } & ParsedClosePlayerInstruction<TProgram>\n| { instructionType: RpsGameInstruction.DelegatePda } & ParsedDelegatePdaInstruction<TProgram>\n| { instructionType: RpsGameInstruction.InitializePlayer } & ParsedInitializePlayerInstruction<TProgram>\n| { instructionType: RpsGameInstruction.MakeChoice } & ParsedMakeChoiceInstruction<TProgram>\n| { instructionType: RpsGameInstruction.OnMatchFound } & ParsedOnMatchFoundInstruction<TProgram>\n| { instructionType: RpsGameInstruction.PersistResults } & ParsedPersistResultsInstruction<TProgram>\n| { instructionType: RpsGameInstruction.ProcessUndelegation } & ParsedProcessUndelegationInstruction<TProgram>\n| { instructionType: RpsGameInstruction.StartGame } & ParsedStartGameInstruction<TProgram>\n| { instructionType: RpsGameInstruction.StartGameWithTicket } & ParsedStartGameWithTicketInstruction<TProgram>\n\n\n        export function parseRpsGameInstruction<TProgram extends string>(\n            instruction: Instruction<TProgram> \n                & InstructionWithData<ReadonlyUint8Array>\n        ): ParsedRpsGameInstruction<TProgram> {\n            const instructionType = identifyRpsGameInstruction(instruction);\n            switch (instructionType) {\n                case RpsGameInstruction.ClosePlayer: { assertIsInstructionWithAccounts(instruction);\nreturn { instructionType: RpsGameInstruction.ClosePlayer, ...parseClosePlayerInstruction(instruction) }; }\ncase RpsGameInstruction.DelegatePda: { assertIsInstructionWithAccounts(instruction);\nreturn { instructionType: RpsGameInstruction.DelegatePda, ...parseDelegatePdaInstruction(instruction) }; }\ncase RpsGameInstruction.InitializePlayer: { assertIsInstructionWithAccounts(instruction);\nreturn { instructionType: RpsGameInstruction.InitializePlayer, ...parseInitializePlayerInstruction(instruction) }; }\ncase RpsGameInstruction.MakeChoice: { assertIsInstructionWithAccounts(instruction);\nreturn { instructionType: RpsGameInstruction.MakeChoice, ...parseMakeChoiceInstruction(instruction) }; }\ncase RpsGameInstruction.OnMatchFound: { assertIsInstructionWithAccounts(instruction);\nreturn { instructionType: RpsGameInstruction.OnMatchFound, ...parseOnMatchFoundInstruction(instruction) }; }\ncase RpsGameInstruction.PersistResults: { assertIsInstructionWithAccounts(instruction);\nreturn { instructionType: RpsGameInstruction.PersistResults, ...parsePersistResultsInstruction(instruction) }; }\ncase RpsGameInstruction.ProcessUndelegation: { assertIsInstructionWithAccounts(instruction);\nreturn { instructionType: RpsGameInstruction.ProcessUndelegation, ...parseProcessUndelegationInstruction(instruction) }; }\ncase RpsGameInstruction.StartGame: { assertIsInstructionWithAccounts(instruction);\nreturn { instructionType: RpsGameInstruction.StartGame, ...parseStartGameInstruction(instruction) }; }\ncase RpsGameInstruction.StartGameWithTicket: { assertIsInstructionWithAccounts(instruction);\nreturn { instructionType: RpsGameInstruction.StartGameWithTicket, ...parseStartGameWithTicketInstruction(instruction) }; }\n                default: throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, { instructionType: instructionType as string, programName: \"rpsGame\" });\n            }\n        }\n\nexport type RpsGamePlugin = { accounts: RpsGamePluginAccounts; instructions: RpsGamePluginInstructions; }\n\nexport type RpsGamePluginAccounts = { gameSession: ReturnType<typeof getGameSessionCodec> & SelfFetchFunctions<GameSessionArgs, GameSession>; playerProfile: ReturnType<typeof getPlayerProfileCodec> & SelfFetchFunctions<PlayerProfileArgs, PlayerProfile>; }\n\nexport type RpsGamePluginInstructions = { closePlayer: (input: MakeOptional<ClosePlayerAsyncInput, \"payer\">) => ReturnType<typeof getClosePlayerInstructionAsync> & SelfPlanAndSendFunctions; delegatePda: (input: MakeOptional<DelegatePdaAsyncInput, \"payer\">) => ReturnType<typeof getDelegatePdaInstructionAsync> & SelfPlanAndSendFunctions; initializePlayer: (input: MakeOptional<InitializePlayerAsyncInput, \"payer\">) => ReturnType<typeof getInitializePlayerInstructionAsync> & SelfPlanAndSendFunctions; makeChoice: (input: MakeChoiceInput) => ReturnType<typeof getMakeChoiceInstruction> & SelfPlanAndSendFunctions; onMatchFound: (input: OnMatchFoundInput) => ReturnType<typeof getOnMatchFoundInstruction> & SelfPlanAndSendFunctions; persistResults: (input: MakeOptional<PersistResultsInput, \"payer\">) => ReturnType<typeof getPersistResultsInstruction> & SelfPlanAndSendFunctions; processUndelegation: (input: MakeOptional<ProcessUndelegationInput, \"payer\">) => ReturnType<typeof getProcessUndelegationInstruction> & SelfPlanAndSendFunctions; startGame: (input: StartGameAsyncInput) => ReturnType<typeof getStartGameInstructionAsync> & SelfPlanAndSendFunctions; startGameWithTicket: (input: StartGameWithTicketAsyncInput) => ReturnType<typeof getStartGameWithTicketInstructionAsync> & SelfPlanAndSendFunctions; }\n\nexport type RpsGamePluginRequirements = ClientWithRpc<GetAccountInfoApi & GetMultipleAccountsApi> & ClientWithPayer & ClientWithTransactionPlanning & ClientWithTransactionSending\n\nexport function rpsGameProgram() {\n    return <T extends RpsGamePluginRequirements>(client: T) => {\n        return { ...client, rpsGame: <RpsGamePlugin>{ accounts: { gameSession: addSelfFetchFunctions(client, getGameSessionCodec()), playerProfile: addSelfFetchFunctions(client, getPlayerProfileCodec()) }, instructions: { closePlayer: input => addSelfPlanAndSendFunctions(client, getClosePlayerInstructionAsync({ ...input, payer: input.payer ?? client.payer.address })), delegatePda: input => addSelfPlanAndSendFunctions(client, getDelegatePdaInstructionAsync({ ...input, payer: input.payer ?? client.payer })), initializePlayer: input => addSelfPlanAndSendFunctions(client, getInitializePlayerInstructionAsync({ ...input, payer: input.payer ?? client.payer })), makeChoice: input => addSelfPlanAndSendFunctions(client, getMakeChoiceInstruction(input)), onMatchFound: input => addSelfPlanAndSendFunctions(client, getOnMatchFoundInstruction(input)), persistResults: input => addSelfPlanAndSendFunctions(client, getPersistResultsInstruction({ ...input, payer: input.payer ?? client.payer })), processUndelegation: input => addSelfPlanAndSendFunctions(client, getProcessUndelegationInstruction({ ...input, payer: input.payer ?? client.payer.address })), startGame: input => addSelfPlanAndSendFunctions(client, getStartGameInstructionAsync(input)), startGameWithTicket: input => addSelfPlanAndSendFunctions(client, getStartGameWithTicketInstructionAsync(input)) } } };\n    };\n}\n\ntype MakeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;"]}

package/dist/generated/rps-game/types/accountType.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 Address, type Codec, type Decoder, type Encoder, type GetDiscriminatedUnionVariant, type GetDiscriminatedUnionVariantContent } from '@solana/kit';
+export type AccountType = {
+    __kind: "PlayerProfile";
+    player: Address;
+} | {
+    __kind: "GameSession";
+    p1: Address;
+    p2: Address;
+    id: bigint;
+};
+export type AccountTypeArgs = {
+    __kind: "PlayerProfile";
+    player: Address;
+} | {
+    __kind: "GameSession";
+    p1: Address;
+    p2: Address;
+    id: number | bigint;
+};
+export declare function getAccountTypeEncoder(): Encoder<AccountTypeArgs>;
+export declare function getAccountTypeDecoder(): Decoder<AccountType>;
+export declare function getAccountTypeCodec(): Codec<AccountTypeArgs, AccountType>;
+export declare function accountType(kind: 'PlayerProfile', data: GetDiscriminatedUnionVariantContent<AccountTypeArgs, '__kind', 'PlayerProfile'>): GetDiscriminatedUnionVariant<AccountTypeArgs, '__kind', 'PlayerProfile'>;
+export declare function accountType(kind: 'GameSession', data: GetDiscriminatedUnionVariantContent<AccountTypeArgs, '__kind', 'GameSession'>): GetDiscriminatedUnionVariant<AccountTypeArgs, '__kind', 'GameSession'>;
+export declare function isAccountType<K extends AccountType['__kind']>(kind: K, value: AccountType): value is AccountType & {
+    __kind: K;
+};