@1upmonster/duel 0.1.8 → 0.2.2

package/src/generated/duel/programs/duel.ts

@@ -0,0 +1,108 @@
+/**
+ * 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 { getMatchTicketCodec, getQueueCodec, getTenantCodec, type MatchTicket, type MatchTicketArgs, type Queue, type QueueArgs, type Tenant, type TenantArgs } from '../accounts';
+import { getCancelTicketInstructionAsync, getCloseTicketInstructionAsync, getCommitTicketsInstruction, getCreateTicketInstructionAsync, getDelegateQueueInstructionAsync, getDelegateTicketInstructionAsync, getFlushMatchesInstruction, getInitializeQueueInstructionAsync, getInitializeTenantInstructionAsync, getJoinQueueInstructionAsync, getProcessUndelegationInstruction, getSetupTicketPermissionInstructionAsync, parseCancelTicketInstruction, parseCloseTicketInstruction, parseCommitTicketsInstruction, parseCreateTicketInstruction, parseDelegateQueueInstruction, parseDelegateTicketInstruction, parseFlushMatchesInstruction, parseInitializeQueueInstruction, parseInitializeTenantInstruction, parseJoinQueueInstruction, parseProcessUndelegationInstruction, parseSetupTicketPermissionInstruction, type CancelTicketAsyncInput, type CloseTicketAsyncInput, type CommitTicketsInput, type CreateTicketAsyncInput, type DelegateQueueAsyncInput, type DelegateTicketAsyncInput, type FlushMatchesInput, type InitializeQueueAsyncInput, type InitializeTenantAsyncInput, type JoinQueueAsyncInput, type ParsedCancelTicketInstruction, type ParsedCloseTicketInstruction, type ParsedCommitTicketsInstruction, type ParsedCreateTicketInstruction, type ParsedDelegateQueueInstruction, type ParsedDelegateTicketInstruction, type ParsedFlushMatchesInstruction, type ParsedInitializeQueueInstruction, type ParsedInitializeTenantInstruction, type ParsedJoinQueueInstruction, type ParsedProcessUndelegationInstruction, type ParsedSetupTicketPermissionInstruction, type ProcessUndelegationInput, type SetupTicketPermissionAsyncInput } from '../instructions';
+
+export const DUEL_PROGRAM_ADDRESS = 'EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X' as Address<'EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X'>;
+
+export enum DuelAccount { MatchTicket, Queue, Tenant }
+
+export function identifyDuelAccount(account: { data: ReadonlyUint8Array } | ReadonlyUint8Array): DuelAccount {
+    const data = 'data' in account ? account.data : account;
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([11, 131, 4, 157, 207, 79, 126, 5])), 0)) { return DuelAccount.MatchTicket; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([204, 167, 6, 247, 20, 33, 2, 188])), 0)) { return DuelAccount.Queue; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([61, 43, 215, 51, 232, 242, 209, 170])), 0)) { return DuelAccount.Tenant; }
+    throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT, { accountData: data, programName: "duel" });
+}
+
+export enum DuelInstruction { CancelTicket, CloseTicket, CommitTickets, CreateTicket, DelegateQueue, DelegateTicket, FlushMatches, InitializeQueue, InitializeTenant, JoinQueue, ProcessUndelegation, SetupTicketPermission }
+
+export function identifyDuelInstruction(instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array): DuelInstruction {
+    const data = 'data' in instruction ? instruction.data : instruction;
+    if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([216, 28, 247, 206, 195, 171, 100, 143])), 0)) { return DuelInstruction.CancelTicket; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([66, 209, 114, 197, 75, 27, 182, 117])), 0)) { return DuelInstruction.CloseTicket; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([245, 199, 81, 0, 62, 133, 18, 22])), 0)) { return DuelInstruction.CommitTickets; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([16, 178, 122, 25, 213, 85, 96, 129])), 0)) { return DuelInstruction.CreateTicket; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([31, 200, 139, 125, 93, 239, 83, 87])), 0)) { return DuelInstruction.DelegateQueue; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([195, 3, 78, 64, 128, 235, 209, 171])), 0)) { return DuelInstruction.DelegateTicket; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([49, 148, 163, 71, 77, 63, 197, 76])), 0)) { return DuelInstruction.FlushMatches; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([174, 102, 132, 232, 90, 202, 27, 20])), 0)) { return DuelInstruction.InitializeQueue; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([94, 120, 34, 186, 57, 167, 241, 206])), 0)) { return DuelInstruction.InitializeTenant; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([157, 115, 48, 109, 65, 86, 203, 238])), 0)) { return DuelInstruction.JoinQueue; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([196, 28, 41, 206, 48, 37, 51, 167])), 0)) { return DuelInstruction.ProcessUndelegation; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([164, 29, 7, 235, 183, 223, 11, 85])), 0)) { return DuelInstruction.SetupTicketPermission; }
+    throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, { instructionData: data, programName: "duel" });
+}
+
+export type ParsedDuelInstruction<TProgram extends string = 'EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X'> =
+| { instructionType: DuelInstruction.CancelTicket } & ParsedCancelTicketInstruction<TProgram>
+| { instructionType: DuelInstruction.CloseTicket } & ParsedCloseTicketInstruction<TProgram>
+| { instructionType: DuelInstruction.CommitTickets } & ParsedCommitTicketsInstruction<TProgram>
+| { instructionType: DuelInstruction.CreateTicket } & ParsedCreateTicketInstruction<TProgram>
+| { instructionType: DuelInstruction.DelegateQueue } & ParsedDelegateQueueInstruction<TProgram>
+| { instructionType: DuelInstruction.DelegateTicket } & ParsedDelegateTicketInstruction<TProgram>
+| { instructionType: DuelInstruction.FlushMatches } & ParsedFlushMatchesInstruction<TProgram>
+| { instructionType: DuelInstruction.InitializeQueue } & ParsedInitializeQueueInstruction<TProgram>
+| { instructionType: DuelInstruction.InitializeTenant } & ParsedInitializeTenantInstruction<TProgram>
+| { instructionType: DuelInstruction.JoinQueue } & ParsedJoinQueueInstruction<TProgram>
+| { instructionType: DuelInstruction.ProcessUndelegation } & ParsedProcessUndelegationInstruction<TProgram>
+| { instructionType: DuelInstruction.SetupTicketPermission } & ParsedSetupTicketPermissionInstruction<TProgram>
+
+
+        export function parseDuelInstruction<TProgram extends string>(
+            instruction: Instruction<TProgram> 
+                & InstructionWithData<ReadonlyUint8Array>
+        ): ParsedDuelInstruction<TProgram> {
+            const instructionType = identifyDuelInstruction(instruction);
+            switch (instructionType) {
+                case DuelInstruction.CancelTicket: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: DuelInstruction.CancelTicket, ...parseCancelTicketInstruction(instruction) }; }
+case DuelInstruction.CloseTicket: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: DuelInstruction.CloseTicket, ...parseCloseTicketInstruction(instruction) }; }
+case DuelInstruction.CommitTickets: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: DuelInstruction.CommitTickets, ...parseCommitTicketsInstruction(instruction) }; }
+case DuelInstruction.CreateTicket: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: DuelInstruction.CreateTicket, ...parseCreateTicketInstruction(instruction) }; }
+case DuelInstruction.DelegateQueue: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: DuelInstruction.DelegateQueue, ...parseDelegateQueueInstruction(instruction) }; }
+case DuelInstruction.DelegateTicket: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: DuelInstruction.DelegateTicket, ...parseDelegateTicketInstruction(instruction) }; }
+case DuelInstruction.FlushMatches: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: DuelInstruction.FlushMatches, ...parseFlushMatchesInstruction(instruction) }; }
+case DuelInstruction.InitializeQueue: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: DuelInstruction.InitializeQueue, ...parseInitializeQueueInstruction(instruction) }; }
+case DuelInstruction.InitializeTenant: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: DuelInstruction.InitializeTenant, ...parseInitializeTenantInstruction(instruction) }; }
+case DuelInstruction.JoinQueue: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: DuelInstruction.JoinQueue, ...parseJoinQueueInstruction(instruction) }; }
+case DuelInstruction.ProcessUndelegation: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: DuelInstruction.ProcessUndelegation, ...parseProcessUndelegationInstruction(instruction) }; }
+case DuelInstruction.SetupTicketPermission: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: DuelInstruction.SetupTicketPermission, ...parseSetupTicketPermissionInstruction(instruction) }; }
+                default: throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, { instructionType: instructionType as string, programName: "duel" });
+            }
+        }
+
+export type DuelPlugin = { accounts: DuelPluginAccounts; instructions: DuelPluginInstructions; }
+
+export type DuelPluginAccounts = { matchTicket: ReturnType<typeof getMatchTicketCodec> & SelfFetchFunctions<MatchTicketArgs, MatchTicket>; queue: ReturnType<typeof getQueueCodec> & SelfFetchFunctions<QueueArgs, Queue>; tenant: ReturnType<typeof getTenantCodec> & SelfFetchFunctions<TenantArgs, Tenant>; }
+
+export type DuelPluginInstructions = { cancelTicket: (input: CancelTicketAsyncInput) => ReturnType<typeof getCancelTicketInstructionAsync> & SelfPlanAndSendFunctions; closeTicket: (input: CloseTicketAsyncInput) => ReturnType<typeof getCloseTicketInstructionAsync> & SelfPlanAndSendFunctions; commitTickets: (input: MakeOptional<CommitTicketsInput, "payer">) => ReturnType<typeof getCommitTicketsInstruction> & SelfPlanAndSendFunctions; createTicket: (input: CreateTicketAsyncInput) => ReturnType<typeof getCreateTicketInstructionAsync> & SelfPlanAndSendFunctions; delegateQueue: (input: MakeOptional<DelegateQueueAsyncInput, "payer">) => ReturnType<typeof getDelegateQueueInstructionAsync> & SelfPlanAndSendFunctions; delegateTicket: (input: MakeOptional<DelegateTicketAsyncInput, "payer">) => ReturnType<typeof getDelegateTicketInstructionAsync> & SelfPlanAndSendFunctions; flushMatches: (input: FlushMatchesInput) => ReturnType<typeof getFlushMatchesInstruction> & SelfPlanAndSendFunctions; initializeQueue: (input: InitializeQueueAsyncInput) => ReturnType<typeof getInitializeQueueInstructionAsync> & SelfPlanAndSendFunctions; initializeTenant: (input: InitializeTenantAsyncInput) => ReturnType<typeof getInitializeTenantInstructionAsync> & SelfPlanAndSendFunctions; joinQueue: (input: JoinQueueAsyncInput) => ReturnType<typeof getJoinQueueInstructionAsync> & SelfPlanAndSendFunctions; processUndelegation: (input: MakeOptional<ProcessUndelegationInput, "payer">) => ReturnType<typeof getProcessUndelegationInstruction> & SelfPlanAndSendFunctions; setupTicketPermission: (input: SetupTicketPermissionAsyncInput) => ReturnType<typeof getSetupTicketPermissionInstructionAsync> & SelfPlanAndSendFunctions; }
+
+export type DuelPluginRequirements = ClientWithRpc<GetAccountInfoApi & GetMultipleAccountsApi> & ClientWithPayer & ClientWithTransactionPlanning & ClientWithTransactionSending
+
+export function duelProgram() {
+    return <T extends DuelPluginRequirements>(client: T) => {
+        return { ...client, duel: <DuelPlugin>{ accounts: { matchTicket: addSelfFetchFunctions(client, getMatchTicketCodec()), queue: addSelfFetchFunctions(client, getQueueCodec()), tenant: addSelfFetchFunctions(client, getTenantCodec()) }, instructions: { cancelTicket: input => addSelfPlanAndSendFunctions(client, getCancelTicketInstructionAsync(input)), closeTicket: input => addSelfPlanAndSendFunctions(client, getCloseTicketInstructionAsync(input)), commitTickets: input => addSelfPlanAndSendFunctions(client, getCommitTicketsInstruction({ ...input, payer: input.payer ?? client.payer })), createTicket: input => addSelfPlanAndSendFunctions(client, getCreateTicketInstructionAsync(input)), delegateQueue: input => addSelfPlanAndSendFunctions(client, getDelegateQueueInstructionAsync({ ...input, payer: input.payer ?? client.payer })), delegateTicket: input => addSelfPlanAndSendFunctions(client, getDelegateTicketInstructionAsync({ ...input, payer: input.payer ?? client.payer })), flushMatches: input => addSelfPlanAndSendFunctions(client, getFlushMatchesInstruction(input)), initializeQueue: input => addSelfPlanAndSendFunctions(client, getInitializeQueueInstructionAsync(input)), initializeTenant: input => addSelfPlanAndSendFunctions(client, getInitializeTenantInstructionAsync(input)), joinQueue: input => addSelfPlanAndSendFunctions(client, getJoinQueueInstructionAsync(input)), processUndelegation: input => addSelfPlanAndSendFunctions(client, getProcessUndelegationInstruction({ ...input, payer: input.payer ?? client.payer.address })), setupTicketPermission: input => addSelfPlanAndSendFunctions(client, getSetupTicketPermissionInstructionAsync(input)) } } };
+    };
+}
+
+type MakeOptional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

package/src/generated/duel/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 './duel';

package/src/generated/duel/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, type Address, type Codec, type Decoder, type Encoder, type GetDiscriminatedUnionVariant, type GetDiscriminatedUnionVariantContent } from '@solana/kit';
+
+export type AccountType = { __kind: "Queue", authority: Address;  } | { __kind: "Ticket", player: Address; tenant: Address;  };
+
+export type AccountTypeArgs = AccountType;
+
+export function getAccountTypeEncoder(): Encoder<AccountTypeArgs> {
+    return getDiscriminatedUnionEncoder([['Queue', getStructEncoder([['authority', getAddressEncoder()]])], ['Ticket', getStructEncoder([['player', getAddressEncoder()], ['tenant', getAddressEncoder()]])]]);
+}
+
+export function getAccountTypeDecoder(): Decoder<AccountType> {
+    return getDiscriminatedUnionDecoder([['Queue', getStructDecoder([['authority', getAddressDecoder()]])], ['Ticket', getStructDecoder([['player', getAddressDecoder()], ['tenant', getAddressDecoder()]])]]);
+}
+
+export function getAccountTypeCodec(): Codec<AccountTypeArgs, AccountType> {
+    return combineCodec(getAccountTypeEncoder(), getAccountTypeDecoder());
+}
+
+// Data Enum Helpers.
+export function accountType(kind: 'Queue', data: GetDiscriminatedUnionVariantContent<AccountTypeArgs, '__kind', 'Queue'>): GetDiscriminatedUnionVariant<AccountTypeArgs, '__kind', 'Queue'>;
+export function accountType(kind: 'Ticket', data: GetDiscriminatedUnionVariantContent<AccountTypeArgs, '__kind', 'Ticket'>): GetDiscriminatedUnionVariant<AccountTypeArgs, '__kind', 'Ticket'>;
+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/duel/types/index.ts

@@ -0,0 +1,14 @@
+/**
+ * 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 './matchEntry';
+export * from './matchFound';
+export * from './pendingMatch';
+export * from './queueEntry';
+export * from './ticketStatus';

package/src/generated/duel/types/matchEntry.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, getAddressDecoder, getAddressEncoder, getI64Decoder, getI64Encoder, getStructDecoder, getStructEncoder, getU64Decoder, getU64Encoder, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder } from '@solana/kit';
+
+export type MatchEntry = { player1: Address; player2: Address; matchId: bigint; timestamp: bigint;  };
+
+export type MatchEntryArgs = { player1: Address; player2: Address; matchId: number | bigint; timestamp: number | bigint;  };
+
+export function getMatchEntryEncoder(): FixedSizeEncoder<MatchEntryArgs> {
+    return getStructEncoder([['player1', getAddressEncoder()], ['player2', getAddressEncoder()], ['matchId', getU64Encoder()], ['timestamp', getI64Encoder()]]);
+}
+
+export function getMatchEntryDecoder(): FixedSizeDecoder<MatchEntry> {
+    return getStructDecoder([['player1', getAddressDecoder()], ['player2', getAddressDecoder()], ['matchId', getU64Decoder()], ['timestamp', getI64Decoder()]]);
+}
+
+export function getMatchEntryCodec(): FixedSizeCodec<MatchEntryArgs, MatchEntry> {
+    return combineCodec(getMatchEntryEncoder(), getMatchEntryDecoder());
+}

package/src/generated/duel/types/matchFound.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, getAddressDecoder, getAddressEncoder, getI64Decoder, getI64Encoder, getStructDecoder, getStructEncoder, getU64Decoder, getU64Encoder, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder } from '@solana/kit';
+
+export type MatchFound = { player1: Address; player2: Address; matchId: bigint; timestamp: bigint;  };
+
+export type MatchFoundArgs = { player1: Address; player2: Address; matchId: number | bigint; timestamp: number | bigint;  };
+
+export function getMatchFoundEncoder(): FixedSizeEncoder<MatchFoundArgs> {
+    return getStructEncoder([['player1', getAddressEncoder()], ['player2', getAddressEncoder()], ['matchId', getU64Encoder()], ['timestamp', getI64Encoder()]]);
+}
+
+export function getMatchFoundDecoder(): FixedSizeDecoder<MatchFound> {
+    return getStructDecoder([['player1', getAddressDecoder()], ['player2', getAddressDecoder()], ['matchId', getU64Decoder()], ['timestamp', getI64Decoder()]]);
+}
+
+export function getMatchFoundCodec(): FixedSizeCodec<MatchFoundArgs, MatchFound> {
+    return combineCodec(getMatchFoundEncoder(), getMatchFoundDecoder());
+}

package/src/generated/duel/types/pendingMatch.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, getAddressDecoder, getAddressEncoder, getStructDecoder, getStructEncoder, getU64Decoder, getU64Encoder, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder } from '@solana/kit';
+
+export type PendingMatch = { player: Address; opponent: Address; matchId: bigint;  };
+
+export type PendingMatchArgs = { player: Address; opponent: Address; matchId: number | bigint;  };
+
+export function getPendingMatchEncoder(): FixedSizeEncoder<PendingMatchArgs> {
+    return getStructEncoder([['player', getAddressEncoder()], ['opponent', getAddressEncoder()], ['matchId', getU64Encoder()]]);
+}
+
+export function getPendingMatchDecoder(): FixedSizeDecoder<PendingMatch> {
+    return getStructDecoder([['player', getAddressDecoder()], ['opponent', getAddressDecoder()], ['matchId', getU64Decoder()]]);
+}
+
+export function getPendingMatchCodec(): FixedSizeCodec<PendingMatchArgs, PendingMatch> {
+    return combineCodec(getPendingMatchEncoder(), getPendingMatchDecoder());
+}

package/src/generated/duel/types/queueEntry.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, getAddressDecoder, getAddressEncoder, getStructDecoder, getStructEncoder, getU64Decoder, getU64Encoder, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder } from '@solana/kit';
+
+export type QueueEntry = { player: Address; elo: bigint;  };
+
+export type QueueEntryArgs = { player: Address; elo: number | bigint;  };
+
+export function getQueueEntryEncoder(): FixedSizeEncoder<QueueEntryArgs> {
+    return getStructEncoder([['player', getAddressEncoder()], ['elo', getU64Encoder()]]);
+}
+
+export function getQueueEntryDecoder(): FixedSizeDecoder<QueueEntry> {
+    return getStructDecoder([['player', getAddressDecoder()], ['elo', getU64Decoder()]]);
+}
+
+export function getQueueEntryCodec(): FixedSizeCodec<QueueEntryArgs, QueueEntry> {
+    return combineCodec(getQueueEntryEncoder(), getQueueEntryDecoder());
+}

package/src/generated/duel/types/ticketStatus.ts

@@ -0,0 +1,38 @@
+/**
+ * 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, getUnitDecoder, getUnitEncoder, type Address, type Codec, type Decoder, type Encoder, type GetDiscriminatedUnionVariant, type GetDiscriminatedUnionVariantContent } from '@solana/kit';
+
+export type TicketStatus = { __kind: "Searching" } | { __kind: "Matched", opponent: Address; matchId: bigint;  } | { __kind: "Expired" } | { __kind: "Cancelled" };
+
+export type TicketStatusArgs = { __kind: "Searching" } | { __kind: "Matched", opponent: Address; matchId: number | bigint;  } | { __kind: "Expired" } | { __kind: "Cancelled" };
+
+export function getTicketStatusEncoder(): Encoder<TicketStatusArgs> {
+    return getDiscriminatedUnionEncoder([['Searching', getUnitEncoder()], ['Matched', getStructEncoder([['opponent', getAddressEncoder()], ['matchId', getU64Encoder()]])], ['Expired', getUnitEncoder()], ['Cancelled', getUnitEncoder()]]);
+}
+
+export function getTicketStatusDecoder(): Decoder<TicketStatus> {
+    return getDiscriminatedUnionDecoder([['Searching', getUnitDecoder()], ['Matched', getStructDecoder([['opponent', getAddressDecoder()], ['matchId', getU64Decoder()]])], ['Expired', getUnitDecoder()], ['Cancelled', getUnitDecoder()]]);
+}
+
+export function getTicketStatusCodec(): Codec<TicketStatusArgs, TicketStatus> {
+    return combineCodec(getTicketStatusEncoder(), getTicketStatusDecoder());
+}
+
+// Data Enum Helpers.
+export function ticketStatus(kind: 'Searching'): GetDiscriminatedUnionVariant<TicketStatusArgs, '__kind', 'Searching'>;
+export function ticketStatus(kind: 'Matched', data: GetDiscriminatedUnionVariantContent<TicketStatusArgs, '__kind', 'Matched'>): GetDiscriminatedUnionVariant<TicketStatusArgs, '__kind', 'Matched'>;
+export function ticketStatus(kind: 'Expired'): GetDiscriminatedUnionVariant<TicketStatusArgs, '__kind', 'Expired'>;
+export function ticketStatus(kind: 'Cancelled'): GetDiscriminatedUnionVariant<TicketStatusArgs, '__kind', 'Cancelled'>;
+export function ticketStatus<K extends TicketStatusArgs['__kind'], Data>(kind: K, data?: Data) {
+  return Array.isArray(data) ? { __kind: kind, fields: data } : { __kind: kind, ...(data ?? {}) };
+}
+
+export function isTicketStatus<K extends TicketStatus['__kind']>(kind: K, value: TicketStatus): value is TicketStatus & { __kind: K } {
+  return value.__kind === kind;
+};

package/src/generated/rps-game/accounts/gameSession.ts

@@ -0,0 +1,77 @@
+/**
+ * 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 { assertAccountExists, assertAccountsExist, combineCodec, decodeAccount, fetchEncodedAccount, fetchEncodedAccounts, fixDecoderSize, fixEncoderSize, getAddressDecoder, getAddressEncoder, getBytesDecoder, getBytesEncoder, getOptionDecoder, getOptionEncoder, getStructDecoder, getStructEncoder, getU64Decoder, getU64Encoder, transformEncoder, type Account, type Address, type Codec, type Decoder, type EncodedAccount, type Encoder, type FetchAccountConfig, type FetchAccountsConfig, type MaybeAccount, type MaybeEncodedAccount, type Option, type OptionOrNullable, type ReadonlyUint8Array } from '@solana/kit';
+import { getChoiceDecoder, getChoiceEncoder, getGameResultDecoder, getGameResultEncoder, type Choice, type ChoiceArgs, type GameResult, type GameResultArgs } from '../types';
+
+export const GAME_SESSION_DISCRIMINATOR = new Uint8Array([150, 116, 20, 197, 205, 121, 220, 240]);
+
+export function getGameSessionDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(GAME_SESSION_DISCRIMINATOR); }
+
+export type GameSession = { discriminator: ReadonlyUint8Array; gameId: bigint; player1: Address; player2: Address; player1Choice: Option<Choice>; player2Choice: Option<Choice>; result: GameResult;  };
+
+export type GameSessionArgs = { gameId: number | bigint; player1: Address; player2: Address; player1Choice: OptionOrNullable<ChoiceArgs>; player2Choice: OptionOrNullable<ChoiceArgs>; result: GameResultArgs;  };
+
+/** Gets the encoder for {@link GameSessionArgs} account data. */
+export function getGameSessionEncoder(): Encoder<GameSessionArgs> {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['gameId', getU64Encoder()], ['player1', getAddressEncoder()], ['player2', getAddressEncoder()], ['player1Choice', getOptionEncoder(getChoiceEncoder())], ['player2Choice', getOptionEncoder(getChoiceEncoder())], ['result', getGameResultEncoder()]]), (value) => ({ ...value, discriminator: GAME_SESSION_DISCRIMINATOR }));
+}
+
+/** Gets the decoder for {@link GameSession} account data. */
+export function getGameSessionDecoder(): Decoder<GameSession> {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['gameId', getU64Decoder()], ['player1', getAddressDecoder()], ['player2', getAddressDecoder()], ['player1Choice', getOptionDecoder(getChoiceDecoder())], ['player2Choice', getOptionDecoder(getChoiceDecoder())], ['result', getGameResultDecoder()]]);
+}
+
+/** Gets the codec for {@link GameSession} account data. */
+export function getGameSessionCodec(): Codec<GameSessionArgs, GameSession> {
+    return combineCodec(getGameSessionEncoder(), getGameSessionDecoder());
+}
+
+export function decodeGameSession<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<GameSession, TAddress>;
+export function decodeGameSession<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<GameSession, TAddress>;
+export function decodeGameSession<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>): Account<GameSession, TAddress> | MaybeAccount<GameSession, TAddress> {
+  return decodeAccount(encodedAccount as MaybeEncodedAccount<TAddress>, getGameSessionDecoder());
+}
+
+export async function fetchGameSession<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<Account<GameSession, TAddress>> {
+  const maybeAccount = await fetchMaybeGameSession(rpc, address, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+
+export async function fetchMaybeGameSession<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<MaybeAccount<GameSession, TAddress>> {
+  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  return decodeGameSession(maybeAccount);
+}
+
+export async function fetchAllGameSession(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<Account<GameSession>[]> {
+  const maybeAccounts = await fetchAllMaybeGameSession(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+
+export async function fetchAllMaybeGameSession(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<MaybeAccount<GameSession>[]> {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeGameSession(maybeAccount));
+}

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

@@ -0,0 +1,10 @@
+/**
+ * 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 './gameSession';
+export * from './playerProfile';

package/src/generated/rps-game/accounts/playerProfile.ts

@@ -0,0 +1,80 @@
+/**
+ * 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 { assertAccountExists, assertAccountsExist, combineCodec, decodeAccount, fetchEncodedAccount, fetchEncodedAccounts, fixDecoderSize, fixEncoderSize, getAddressDecoder, getAddressEncoder, getBytesDecoder, getBytesEncoder, getStructDecoder, getStructEncoder, getU64Decoder, getU64Encoder, transformEncoder, type Account, type Address, type EncodedAccount, type FetchAccountConfig, type FetchAccountsConfig, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type MaybeAccount, type MaybeEncodedAccount, type ReadonlyUint8Array } from '@solana/kit';
+
+export const PLAYER_PROFILE_DISCRIMINATOR = new Uint8Array([82, 226, 99, 87, 164, 130, 181, 80]);
+
+export function getPlayerProfileDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(PLAYER_PROFILE_DISCRIMINATOR); }
+
+export type PlayerProfile = { discriminator: ReadonlyUint8Array; player: Address; elo: bigint; gamesPlayed: bigint; gamesWon: bigint;  };
+
+export type PlayerProfileArgs = { player: Address; elo: number | bigint; gamesPlayed: number | bigint; gamesWon: number | bigint;  };
+
+/** Gets the encoder for {@link PlayerProfileArgs} account data. */
+export function getPlayerProfileEncoder(): FixedSizeEncoder<PlayerProfileArgs> {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['player', getAddressEncoder()], ['elo', getU64Encoder()], ['gamesPlayed', getU64Encoder()], ['gamesWon', getU64Encoder()]]), (value) => ({ ...value, discriminator: PLAYER_PROFILE_DISCRIMINATOR }));
+}
+
+/** Gets the decoder for {@link PlayerProfile} account data. */
+export function getPlayerProfileDecoder(): FixedSizeDecoder<PlayerProfile> {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['player', getAddressDecoder()], ['elo', getU64Decoder()], ['gamesPlayed', getU64Decoder()], ['gamesWon', getU64Decoder()]]);
+}
+
+/** Gets the codec for {@link PlayerProfile} account data. */
+export function getPlayerProfileCodec(): FixedSizeCodec<PlayerProfileArgs, PlayerProfile> {
+    return combineCodec(getPlayerProfileEncoder(), getPlayerProfileDecoder());
+}
+
+export function decodePlayerProfile<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<PlayerProfile, TAddress>;
+export function decodePlayerProfile<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<PlayerProfile, TAddress>;
+export function decodePlayerProfile<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>): Account<PlayerProfile, TAddress> | MaybeAccount<PlayerProfile, TAddress> {
+  return decodeAccount(encodedAccount as MaybeEncodedAccount<TAddress>, getPlayerProfileDecoder());
+}
+
+export async function fetchPlayerProfile<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<Account<PlayerProfile, TAddress>> {
+  const maybeAccount = await fetchMaybePlayerProfile(rpc, address, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+
+export async function fetchMaybePlayerProfile<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<MaybeAccount<PlayerProfile, TAddress>> {
+  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  return decodePlayerProfile(maybeAccount);
+}
+
+export async function fetchAllPlayerProfile(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<Account<PlayerProfile>[]> {
+  const maybeAccounts = await fetchAllMaybePlayerProfile(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+
+export async function fetchAllMaybePlayerProfile(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<MaybeAccount<PlayerProfile>[]> {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodePlayerProfile(maybeAccount));
+}
+
+export function getPlayerProfileSize(): number {
+  return 64;
+}

package/src/generated/rps-game/errors/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/errors/rpsGame.ts

@@ -0,0 +1,40 @@
+/**
+ * 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 { isProgramError, type Address, type SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM, type SolanaError } from '@solana/kit';
+import { RPS_GAME_PROGRAM_ADDRESS } from '../programs';
+
+/** AlreadyChose: Already chose */
+export const RPS_GAME_ERROR__ALREADY_CHOSE = 0x1770; // 6000
+/** InvalidPlayer: Invalid player */
+export const RPS_GAME_ERROR__INVALID_PLAYER = 0x1771; // 6001
+/** InvalidMatchTicket: Invalid match ticket - not matched or wrong opponent */
+export const RPS_GAME_ERROR__INVALID_MATCH_TICKET = 0x1772; // 6002
+
+export type RpsGameError = typeof RPS_GAME_ERROR__ALREADY_CHOSE | typeof RPS_GAME_ERROR__INVALID_MATCH_TICKET | typeof RPS_GAME_ERROR__INVALID_PLAYER;
+
+let rpsGameErrorMessages: Record<RpsGameError, string> | undefined;
+if (process.env.NODE_ENV !== 'production') {
+  rpsGameErrorMessages = { [RPS_GAME_ERROR__ALREADY_CHOSE]: `Already chose`, [RPS_GAME_ERROR__INVALID_MATCH_TICKET]: `Invalid match ticket - not matched or wrong opponent`, [RPS_GAME_ERROR__INVALID_PLAYER]: `Invalid player` };
+}
+
+export function getRpsGameErrorMessage(code: RpsGameError): string {
+  if (process.env.NODE_ENV !== 'production') {
+    return (rpsGameErrorMessages as Record<RpsGameError, string>)[code];
+  }
+
+  return 'Error message not available in production bundles.';
+}
+
+export function isRpsGameError<TProgramErrorCode extends RpsGameError>(
+    error: unknown,
+    transactionMessage: { instructions: Record<number, { programAddress: Address }> },
+    code?: TProgramErrorCode,
+): error is SolanaError<typeof SOLANA_ERROR__INSTRUCTION_ERROR__CUSTOM> & Readonly<{ context: Readonly<{ code: TProgramErrorCode }> }> {
+  return isProgramError<TProgramErrorCode>(error, transactionMessage, RPS_GAME_PROGRAM_ADDRESS, code);
+}

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

@@ -0,0 +1,13 @@
+/**
+ * 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 './accounts';
+export * from './errors';
+export * from './instructions';
+export * from './programs';
+export * from './types';