@1upmonster/duel 0.1.8 → 0.2.2

package/src/generated/rps-game/instructions/persistResults.ts

@@ -0,0 +1,88 @@
+/**
+ * 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, 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 { getAccountMetaFactory, type ResolvedInstructionAccount } from '@solana/program-client-core';
+import { RPS_GAME_PROGRAM_ADDRESS } from '../programs';
+
+export const PERSIST_RESULTS_DISCRIMINATOR = new Uint8Array([9, 175, 42, 217, 2, 48, 80, 81]);
+
+export function getPersistResultsDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(PERSIST_RESULTS_DISCRIMINATOR); }
+
+export type PersistResultsInstruction<TProgram extends string = typeof RPS_GAME_PROGRAM_ADDRESS, TAccountGameSession extends string | AccountMeta<string> = string, TAccountPlayer1Profile extends string | AccountMeta<string> = string, TAccountPlayer2Profile 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<[TAccountGameSession extends string ? WritableAccount<TAccountGameSession> : TAccountGameSession, TAccountPlayer1Profile extends string ? WritableAccount<TAccountPlayer1Profile> : TAccountPlayer1Profile, TAccountPlayer2Profile extends string ? WritableAccount<TAccountPlayer2Profile> : TAccountPlayer2Profile, TAccountPayer extends string ? WritableSignerAccount<TAccountPayer> & AccountSignerMeta<TAccountPayer> : TAccountPayer, TAccountMagicProgram extends string ? ReadonlyAccount<TAccountMagicProgram> : TAccountMagicProgram, TAccountMagicContext extends string ? WritableAccount<TAccountMagicContext> : TAccountMagicContext, ...TRemainingAccounts]>;
+
+export type PersistResultsInstructionData = { discriminator: ReadonlyUint8Array;  };
+
+export type PersistResultsInstructionDataArgs = {  };
+
+export function getPersistResultsInstructionDataEncoder(): FixedSizeEncoder<PersistResultsInstructionDataArgs> {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({ ...value, discriminator: PERSIST_RESULTS_DISCRIMINATOR }));
+}
+
+export function getPersistResultsInstructionDataDecoder(): FixedSizeDecoder<PersistResultsInstructionData> {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);
+}
+
+export function getPersistResultsInstructionDataCodec(): FixedSizeCodec<PersistResultsInstructionDataArgs, PersistResultsInstructionData> {
+    return combineCodec(getPersistResultsInstructionDataEncoder(), getPersistResultsInstructionDataDecoder());
+}
+
+export type PersistResultsInput<TAccountGameSession extends string = string, TAccountPlayer1Profile extends string = string, TAccountPlayer2Profile extends string = string, TAccountPayer extends string = string, TAccountMagicProgram extends string = string, TAccountMagicContext extends string = string> =  {
+  gameSession: Address<TAccountGameSession>;
+player1Profile: Address<TAccountPlayer1Profile>;
+player2Profile: Address<TAccountPlayer2Profile>;
+payer: TransactionSigner<TAccountPayer>;
+magicProgram?: Address<TAccountMagicProgram>;
+magicContext?: Address<TAccountMagicContext>;
+}
+
+export function getPersistResultsInstruction<TAccountGameSession extends string, TAccountPlayer1Profile extends string, TAccountPlayer2Profile extends string, TAccountPayer extends string, TAccountMagicProgram extends string, TAccountMagicContext extends string, TProgramAddress extends Address = typeof RPS_GAME_PROGRAM_ADDRESS>(input: PersistResultsInput<TAccountGameSession, TAccountPlayer1Profile, TAccountPlayer2Profile, TAccountPayer, TAccountMagicProgram, TAccountMagicContext>, config?: { programAddress?: TProgramAddress } ): PersistResultsInstruction<TProgramAddress, TAccountGameSession, TAccountPlayer1Profile, TAccountPlayer2Profile, TAccountPayer, TAccountMagicProgram, TAccountMagicContext> {
+  // Program address.
+const programAddress = config?.programAddress ?? RPS_GAME_PROGRAM_ADDRESS;
+
+ // Original accounts.
+const originalAccounts = { gameSession: { value: input.gameSession ?? null, isWritable: true }, player1Profile: { value: input.player1Profile ?? null, isWritable: true }, player2Profile: { value: input.player2Profile ?? null, isWritable: true }, payer: { value: input.payer ?? null, isWritable: true }, magicProgram: { value: input.magicProgram ?? null, isWritable: false }, magicContext: { value: input.magicContext ?? null, isWritable: true } }
+const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+
+// Resolve default values.
+if (!accounts.magicProgram.value) {
+accounts.magicProgram.value = 'Magic11111111111111111111111111111111111111' as Address<'Magic11111111111111111111111111111111111111'>;
+}
+if (!accounts.magicContext.value) {
+accounts.magicContext.value = 'MagicContext1111111111111111111111111111111' as Address<'MagicContext1111111111111111111111111111111'>;
+}
+
+const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+return Object.freeze({ accounts: [getAccountMeta("gameSession", accounts.gameSession), getAccountMeta("player1Profile", accounts.player1Profile), getAccountMeta("player2Profile", accounts.player2Profile), getAccountMeta("payer", accounts.payer), getAccountMeta("magicProgram", accounts.magicProgram), getAccountMeta("magicContext", accounts.magicContext)], data: getPersistResultsInstructionDataEncoder().encode({}), programAddress } as PersistResultsInstruction<TProgramAddress, TAccountGameSession, TAccountPlayer1Profile, TAccountPlayer2Profile, TAccountPayer, TAccountMagicProgram, TAccountMagicContext>);
+}
+
+export type ParsedPersistResultsInstruction<TProgram extends string = typeof RPS_GAME_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;
+accounts: {
+gameSession: TAccountMetas[0];
+player1Profile: TAccountMetas[1];
+player2Profile: TAccountMetas[2];
+payer: TAccountMetas[3];
+magicProgram: TAccountMetas[4];
+magicContext: TAccountMetas[5];
+};
+data: PersistResultsInstructionData; };
+
+export function parsePersistResultsInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedPersistResultsInstruction<TProgram, TAccountMetas> {
+  if (instruction.accounts.length < 6) {
+  throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: 6 });
+}
+let accountIndex = 0;
+const getNextAccount = () => {
+  const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;
+  accountIndex += 1;
+  return accountMeta;
+}
+  return { programAddress: instruction.programAddress, accounts: { gameSession: getNextAccount(), player1Profile: getNextAccount(), player2Profile: getNextAccount(), payer: getNextAccount(), magicProgram: getNextAccount(), magicContext: getNextAccount() }, data: getPersistResultsInstructionDataDecoder().decode(instruction.data) };
+}

package/src/generated/rps-game/instructions/processUndelegation.ts

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

package/src/generated/rps-game/instructions/startGame.ts

@@ -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 { 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';
+import { getAccountMetaFactory, getAddressFromResolvedInstructionAccount, getNonNullResolvedInstructionInput, type ResolvedInstructionAccount } 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 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>[] = []> =
+Instruction<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]>;
+
+export type StartGameInstructionData = { discriminator: ReadonlyUint8Array; gameId: bigint; opponent: Address;  };
+
+export type StartGameInstructionDataArgs = { gameId: number | bigint; opponent: Address;  };
+
+export function getStartGameInstructionDataEncoder(): FixedSizeEncoder<StartGameInstructionDataArgs> {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['gameId', getU64Encoder()], ['opponent', getAddressEncoder()]]), (value) => ({ ...value, discriminator: START_GAME_DISCRIMINATOR }));
+}
+
+export function getStartGameInstructionDataDecoder(): FixedSizeDecoder<StartGameInstructionData> {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['gameId', getU64Decoder()], ['opponent', getAddressDecoder()]]);
+}
+
+export function getStartGameInstructionDataCodec(): FixedSizeCodec<StartGameInstructionDataArgs, StartGameInstructionData> {
+    return combineCodec(getStartGameInstructionDataEncoder(), getStartGameInstructionDataDecoder());
+}
+
+export type StartGameAsyncInput<TAccountGameSession extends string = string, TAccountPlayer extends string = string, TAccountSystemProgram extends string = string> =  {
+  gameSession?: Address<TAccountGameSession>;
+player: TransactionSigner<TAccountPlayer>;
+systemProgram?: Address<TAccountSystemProgram>;
+gameId: StartGameInstructionDataArgs["gameId"];
+opponent: StartGameInstructionDataArgs["opponent"];
+}
+
+export 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>> {
+  // 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 as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+
+// 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' as Address<'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 as StartGameInstructionDataArgs), programAddress } as StartGameInstruction<TProgramAddress, TAccountGameSession, TAccountPlayer, TAccountSystemProgram>);
+}
+
+export type StartGameInput<TAccountGameSession extends string = string, TAccountPlayer extends string = string, TAccountSystemProgram extends string = string> =  {
+  gameSession: Address<TAccountGameSession>;
+player: TransactionSigner<TAccountPlayer>;
+systemProgram?: Address<TAccountSystemProgram>;
+gameId: StartGameInstructionDataArgs["gameId"];
+opponent: StartGameInstructionDataArgs["opponent"];
+}
+
+export 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> {
+  // 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 as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+
+// Original args.
+const args = { ...input,  };
+
+
+// Resolve default values.
+if (!accounts.systemProgram.value) {
+accounts.systemProgram.value = '11111111111111111111111111111111' as Address<'11111111111111111111111111111111'>;
+}
+
+const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+return Object.freeze({ accounts: [getAccountMeta("gameSession", accounts.gameSession), getAccountMeta("player", accounts.player), getAccountMeta("systemProgram", accounts.systemProgram)], data: getStartGameInstructionDataEncoder().encode(args as StartGameInstructionDataArgs), programAddress } as StartGameInstruction<TProgramAddress, TAccountGameSession, TAccountPlayer, TAccountSystemProgram>);
+}
+
+export type ParsedStartGameInstruction<TProgram extends string = typeof RPS_GAME_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;
+accounts: {
+gameSession: TAccountMetas[0];
+player: TAccountMetas[1];
+systemProgram: TAccountMetas[2];
+};
+data: StartGameInstructionData; };
+
+export function parseStartGameInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedStartGameInstruction<TProgram, TAccountMetas> {
+  if (instruction.accounts.length < 3) {
+  throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: 3 });
+}
+let accountIndex = 0;
+const getNextAccount = () => {
+  const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;
+  accountIndex += 1;
+  return accountMeta;
+}
+  return { programAddress: instruction.programAddress, accounts: { gameSession: getNextAccount(), player: getNextAccount(), systemProgram: getNextAccount() }, data: getStartGameInstructionDataDecoder().decode(instruction.data) };
+}

package/src/generated/rps-game/instructions/startGameWithTicket.ts

@@ -0,0 +1,121 @@
+/**
+ * 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, 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 { getAccountMetaFactory, getAddressFromResolvedInstructionAccount, getNonNullResolvedInstructionInput, type ResolvedInstructionAccount } 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 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 function getStartGameWithTicketInstructionDataEncoder(): FixedSizeEncoder<StartGameWithTicketInstructionDataArgs> {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['gameId', getU64Encoder()], ['opponent', getAddressEncoder()]]), (value) => ({ ...value, discriminator: START_GAME_WITH_TICKET_DISCRIMINATOR }));
+}
+
+export function getStartGameWithTicketInstructionDataDecoder(): FixedSizeDecoder<StartGameWithTicketInstructionData> {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['gameId', getU64Decoder()], ['opponent', getAddressDecoder()]]);
+}
+
+export function getStartGameWithTicketInstructionDataCodec(): FixedSizeCodec<StartGameWithTicketInstructionDataArgs, StartGameWithTicketInstructionData> {
+    return combineCodec(getStartGameWithTicketInstructionDataEncoder(), getStartGameWithTicketInstructionDataDecoder());
+}
+
+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 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>> {
+  // 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 as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+
+// 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' as Address<'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 as StartGameWithTicketInstructionDataArgs), programAddress } as 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 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> {
+  // 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 as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+
+// Original args.
+const args = { ...input,  };
+
+
+// Resolve default values.
+if (!accounts.systemProgram.value) {
+accounts.systemProgram.value = '11111111111111111111111111111111' as Address<'11111111111111111111111111111111'>;
+}
+
+const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+return Object.freeze({ accounts: [getAccountMeta("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>);
+}
+
+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 function parseStartGameWithTicketInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedStartGameWithTicketInstruction<TProgram, TAccountMetas> {
+  if (instruction.accounts.length < 4) {
+  throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: 4 });
+}
+let accountIndex = 0;
+const getNextAccount = () => {
+  const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;
+  accountIndex += 1;
+  return accountMeta;
+}
+  return { programAddress: instruction.programAddress, accounts: { gameSession: getNextAccount(), player: getNextAccount(), matchTicket: getNextAccount(), systemProgram: getNextAccount() }, data: getStartGameWithTicketInstructionDataDecoder().decode(instruction.data) };
+}

package/src/generated/rps-game/programs/index.ts

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

package/src/generated/rps-game/programs/rpsGame.ts

@@ -0,0 +1,95 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import { assertIsInstructionWithAccounts, containsBytes, fixEncoderSize, getBytesEncoder, SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT, SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, SolanaError, type Address, type ClientWithPayer, type ClientWithRpc, type ClientWithTransactionPlanning, type ClientWithTransactionSending, type GetAccountInfoApi, type GetMultipleAccountsApi, type Instruction, type InstructionWithData, type ReadonlyUint8Array } from '@solana/kit';
+import { addSelfFetchFunctions, addSelfPlanAndSendFunctions, type SelfFetchFunctions, type SelfPlanAndSendFunctions } from '@solana/program-client-core';
+import { getGameSessionCodec, getPlayerProfileCodec, type GameSession, type GameSessionArgs, type PlayerProfile, type PlayerProfileArgs } from '../accounts';
+import { 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';
+
+export const RPS_GAME_PROGRAM_ADDRESS = '8ohu3RobXyZ2DebyJjbs2co9YCG275FUsVckEcmDbCos' as Address<'8ohu3RobXyZ2DebyJjbs2co9YCG275FUsVckEcmDbCos'>;
+
+export enum RpsGameAccount { GameSession, PlayerProfile }
+
+export function identifyRpsGameAccount(account: { data: ReadonlyUint8Array } | ReadonlyUint8Array): RpsGameAccount {
+    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 enum RpsGameInstruction { ClosePlayer, DelegatePda, InitializePlayer, MakeChoice, OnMatchFound, PersistResults, ProcessUndelegation, StartGame, StartGameWithTicket }
+
+export function identifyRpsGameInstruction(instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array): RpsGameInstruction {
+    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 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 function parseRpsGameInstruction<TProgram extends string>(
+            instruction: Instruction<TProgram> 
+                & InstructionWithData<ReadonlyUint8Array>
+        ): ParsedRpsGameInstruction<TProgram> {
+            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 as string, programName: "rpsGame" });
+            }
+        }
+
+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 function rpsGameProgram() {
+    return <T extends RpsGamePluginRequirements>(client: T) => {
+        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)) } } };
+    };
+}
+
+type MakeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

package/src/generated/rps-game/types/accountType.ts

@@ -0,0 +1,36 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import { combineCodec, getAddressDecoder, getAddressEncoder, getDiscriminatedUnionDecoder, getDiscriminatedUnionEncoder, getStructDecoder, getStructEncoder, getU64Decoder, getU64Encoder, 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 function getAccountTypeEncoder(): Encoder<AccountTypeArgs> {
+    return getDiscriminatedUnionEncoder([['PlayerProfile', getStructEncoder([['player', getAddressEncoder()]])], ['GameSession', getStructEncoder([['p1', getAddressEncoder()], ['p2', getAddressEncoder()], ['id', getU64Encoder()]])]]);
+}
+
+export function getAccountTypeDecoder(): Decoder<AccountType> {
+    return getDiscriminatedUnionDecoder([['PlayerProfile', getStructDecoder([['player', getAddressDecoder()]])], ['GameSession', getStructDecoder([['p1', getAddressDecoder()], ['p2', getAddressDecoder()], ['id', getU64Decoder()]])]]);
+}
+
+export function getAccountTypeCodec(): Codec<AccountTypeArgs, AccountType> {
+    return combineCodec(getAccountTypeEncoder(), getAccountTypeDecoder());
+}
+
+// Data Enum Helpers.
+export function accountType(kind: 'PlayerProfile', data: GetDiscriminatedUnionVariantContent<AccountTypeArgs, '__kind', 'PlayerProfile'>): GetDiscriminatedUnionVariant<AccountTypeArgs, '__kind', 'PlayerProfile'>;
+export function accountType(kind: 'GameSession', data: GetDiscriminatedUnionVariantContent<AccountTypeArgs, '__kind', 'GameSession'>): GetDiscriminatedUnionVariant<AccountTypeArgs, '__kind', 'GameSession'>;
+export function accountType<K extends AccountTypeArgs['__kind'], Data>(kind: K, data?: Data) {
+  return Array.isArray(data) ? { __kind: kind, fields: data } : { __kind: kind, ...(data ?? {}) };
+}
+
+export function isAccountType<K extends AccountType['__kind']>(kind: K, value: AccountType): value is AccountType & { __kind: K } {
+  return value.__kind === kind;
+};

package/src/generated/rps-game/types/choice.ts

@@ -0,0 +1,25 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import { combineCodec, getEnumDecoder, getEnumEncoder, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder } from '@solana/kit';
+
+export enum Choice { Rock, Paper, Scissors };
+
+export type ChoiceArgs = Choice;
+
+export function getChoiceEncoder(): FixedSizeEncoder<ChoiceArgs> {
+    return getEnumEncoder(Choice);
+}
+
+export function getChoiceDecoder(): FixedSizeDecoder<Choice> {
+    return getEnumDecoder(Choice);
+}
+
+export function getChoiceCodec(): FixedSizeCodec<ChoiceArgs, Choice> {
+    return combineCodec(getChoiceEncoder(), getChoiceDecoder());
+}