@1upmonster/duel 0.1.8 → 0.2.1

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());
+}

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

@@ -0,0 +1,37 @@
+/**
+ * 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, getTupleDecoder, getTupleEncoder, getUnitDecoder, getUnitEncoder, type Address, type Codec, type Decoder, type Encoder, type GetDiscriminatedUnionVariant, type GetDiscriminatedUnionVariantContent } from '@solana/kit';
+
+export type GameResult = { __kind: "Winner", fields: readonly [Address];  } | { __kind: "Tie" } | { __kind: "None" };
+
+export type GameResultArgs = GameResult;
+
+export function getGameResultEncoder(): Encoder<GameResultArgs> {
+    return getDiscriminatedUnionEncoder([['Winner', getStructEncoder([['fields', getTupleEncoder([getAddressEncoder()])]])], ['Tie', getUnitEncoder()], ['None', getUnitEncoder()]]);
+}
+
+export function getGameResultDecoder(): Decoder<GameResult> {
+    return getDiscriminatedUnionDecoder([['Winner', getStructDecoder([['fields', getTupleDecoder([getAddressDecoder()])]])], ['Tie', getUnitDecoder()], ['None', getUnitDecoder()]]);
+}
+
+export function getGameResultCodec(): Codec<GameResultArgs, GameResult> {
+    return combineCodec(getGameResultEncoder(), getGameResultDecoder());
+}
+
+// Data Enum Helpers.
+export function gameResult(kind: 'Winner', data: GetDiscriminatedUnionVariantContent<GameResultArgs, '__kind', 'Winner'>['fields']): GetDiscriminatedUnionVariant<GameResultArgs, '__kind', 'Winner'>;
+export function gameResult(kind: 'Tie'): GetDiscriminatedUnionVariant<GameResultArgs, '__kind', 'Tie'>;
+export function gameResult(kind: 'None'): GetDiscriminatedUnionVariant<GameResultArgs, '__kind', 'None'>;
+export function gameResult<K extends GameResultArgs['__kind'], Data>(kind: K, data?: Data) {
+  return Array.isArray(data) ? { __kind: kind, fields: data } : { __kind: kind, ...(data ?? {}) };
+}
+
+export function isGameResult<K extends GameResult['__kind']>(kind: K, value: GameResult): value is GameResult & { __kind: K } {
+  return value.__kind === kind;
+};

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

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

package/src/index.ts

@@ -1,4 +1,5 @@
 export * from "./admin.js";
 export * from "./player.js";
-export * from "./types.js";
+export * from "./tee.js";
 export * as utils from "./utils.js";
+export { fetchMaybeTenant, fetchTenant, fetchMaybeQueue, fetchQueue } from "./generated/duel/index.js";