@1upmonster/duel 0.1.8 → 0.2.2

package/src/duel.json

@@ -759,8 +759,7 @@
           "name": "tenant"
         },
         {
-          "name": "player_data",
-          "writable": true
+          "name": "player_data"
         },
         {
           "name": "player_ticket",
@@ -832,6 +831,71 @@
           }
         }
       ]
+    },
+    {
+      "name": "setup_ticket_permission",
+      "docs": [
+        "Set up permission for ticket PDA so queueAuthority can write it on TEE.",
+        "Must be called BEFORE delegate_ticket while the program still owns the PDA."
+      ],
+      "discriminator": [
+        164,
+        29,
+        7,
+        235,
+        183,
+        223,
+        11,
+        85
+      ],
+      "accounts": [
+        {
+          "name": "ticket",
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  116,
+                  105,
+                  99,
+                  107,
+                  101,
+                  116
+                ]
+              },
+              {
+                "kind": "account",
+                "path": "player"
+              },
+              {
+                "kind": "account",
+                "path": "tenant"
+              }
+            ]
+          }
+        },
+        {
+          "name": "tenant"
+        },
+        {
+          "name": "player",
+          "writable": true,
+          "signer": true
+        },
+        {
+          "name": "permission",
+          "writable": true
+        },
+        {
+          "name": "permission_program"
+        },
+        {
+          "name": "system_program",
+          "address": "11111111111111111111111111111111"
+        }
+      ],
+      "args": []
     }
   ],
   "accounts": [
@@ -920,11 +984,6 @@
       "code": 6005,
       "name": "InvalidTicketAccount",
       "msg": "Invalid ticket account"
-    },
-    {
-      "code": 6006,
-      "name": "MissingCallbackProgram",
-      "msg": "Missing or invalid callback program in remaining accounts"
     }
   ],
   "types": [

package/src/encryption.ts

@@ -1,6 +1,3 @@
-import { PublicKey } from "@solana/web3.js";
-// import { x25519 } from "@noble/curves/ed25519"; 
-
 export class EncryptionProvider {
     private keyPair: CryptoKeyPair | null = null;
     

package/src/generated/duel/accounts/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 './matchTicket';
+export * from './queue';
+export * from './tenant';

package/src/generated/duel/accounts/matchTicket.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, getI64Decoder, getI64Encoder, getStructDecoder, getStructEncoder, getU8Decoder, getU8Encoder, transformEncoder, type Account, type Address, type Codec, type Decoder, type EncodedAccount, type Encoder, type FetchAccountConfig, type FetchAccountsConfig, type MaybeAccount, type MaybeEncodedAccount, type ReadonlyUint8Array } from '@solana/kit';
+import { getTicketStatusDecoder, getTicketStatusEncoder, type TicketStatus, type TicketStatusArgs } from '../types';
+
+export const MATCH_TICKET_DISCRIMINATOR = new Uint8Array([11, 131, 4, 157, 207, 79, 126, 5]);
+
+export function getMatchTicketDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(MATCH_TICKET_DISCRIMINATOR); }
+
+export type MatchTicket = { discriminator: ReadonlyUint8Array; player: Address; tenant: Address; status: TicketStatus; createdAt: bigint; bump: number;  };
+
+export type MatchTicketArgs = { player: Address; tenant: Address; status: TicketStatusArgs; createdAt: number | bigint; bump: number;  };
+
+/** Gets the encoder for {@link MatchTicketArgs} account data. */
+export function getMatchTicketEncoder(): Encoder<MatchTicketArgs> {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['player', getAddressEncoder()], ['tenant', getAddressEncoder()], ['status', getTicketStatusEncoder()], ['createdAt', getI64Encoder()], ['bump', getU8Encoder()]]), (value) => ({ ...value, discriminator: MATCH_TICKET_DISCRIMINATOR }));
+}
+
+/** Gets the decoder for {@link MatchTicket} account data. */
+export function getMatchTicketDecoder(): Decoder<MatchTicket> {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['player', getAddressDecoder()], ['tenant', getAddressDecoder()], ['status', getTicketStatusDecoder()], ['createdAt', getI64Decoder()], ['bump', getU8Decoder()]]);
+}
+
+/** Gets the codec for {@link MatchTicket} account data. */
+export function getMatchTicketCodec(): Codec<MatchTicketArgs, MatchTicket> {
+    return combineCodec(getMatchTicketEncoder(), getMatchTicketDecoder());
+}
+
+export function decodeMatchTicket<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<MatchTicket, TAddress>;
+export function decodeMatchTicket<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<MatchTicket, TAddress>;
+export function decodeMatchTicket<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>): Account<MatchTicket, TAddress> | MaybeAccount<MatchTicket, TAddress> {
+  return decodeAccount(encodedAccount as MaybeEncodedAccount<TAddress>, getMatchTicketDecoder());
+}
+
+export async function fetchMatchTicket<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<Account<MatchTicket, TAddress>> {
+  const maybeAccount = await fetchMaybeMatchTicket(rpc, address, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+
+export async function fetchMaybeMatchTicket<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<MaybeAccount<MatchTicket, TAddress>> {
+  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  return decodeMatchTicket(maybeAccount);
+}
+
+export async function fetchAllMatchTicket(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<Account<MatchTicket>[]> {
+  const maybeAccounts = await fetchAllMaybeMatchTicket(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+
+export async function fetchAllMaybeMatchTicket(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<MaybeAccount<MatchTicket>[]> {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeMatchTicket(maybeAccount));
+}

package/src/generated/duel/accounts/queue.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, getArrayDecoder, getArrayEncoder, getBytesDecoder, getBytesEncoder, getStructDecoder, getStructEncoder, getU64Decoder, getU64Encoder, getU8Decoder, getU8Encoder, transformEncoder, type Account, type Address, type Codec, type Decoder, type EncodedAccount, type Encoder, type FetchAccountConfig, type FetchAccountsConfig, type MaybeAccount, type MaybeEncodedAccount, type ReadonlyUint8Array } from '@solana/kit';
+import { getMatchEntryDecoder, getMatchEntryEncoder, getPendingMatchDecoder, getPendingMatchEncoder, getQueueEntryDecoder, getQueueEntryEncoder, type MatchEntry, type MatchEntryArgs, type PendingMatch, type PendingMatchArgs, type QueueEntry, type QueueEntryArgs } from '../types';
+
+export const QUEUE_DISCRIMINATOR = new Uint8Array([204, 167, 6, 247, 20, 33, 2, 188]);
+
+export function getQueueDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(QUEUE_DISCRIMINATOR); }
+
+export type Queue = { discriminator: ReadonlyUint8Array; authority: Address; tenant: Address; bump: number; matchCounter: bigint; entries: Array<QueueEntry>; matches: Array<MatchEntry>; pendingMatches: Array<PendingMatch>;  };
+
+export type QueueArgs = { authority: Address; tenant: Address; bump: number; matchCounter: number | bigint; entries: Array<QueueEntryArgs>; matches: Array<MatchEntryArgs>; pendingMatches: Array<PendingMatchArgs>;  };
+
+/** Gets the encoder for {@link QueueArgs} account data. */
+export function getQueueEncoder(): Encoder<QueueArgs> {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['authority', getAddressEncoder()], ['tenant', getAddressEncoder()], ['bump', getU8Encoder()], ['matchCounter', getU64Encoder()], ['entries', getArrayEncoder(getQueueEntryEncoder())], ['matches', getArrayEncoder(getMatchEntryEncoder())], ['pendingMatches', getArrayEncoder(getPendingMatchEncoder())]]), (value) => ({ ...value, discriminator: QUEUE_DISCRIMINATOR }));
+}
+
+/** Gets the decoder for {@link Queue} account data. */
+export function getQueueDecoder(): Decoder<Queue> {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['authority', getAddressDecoder()], ['tenant', getAddressDecoder()], ['bump', getU8Decoder()], ['matchCounter', getU64Decoder()], ['entries', getArrayDecoder(getQueueEntryDecoder())], ['matches', getArrayDecoder(getMatchEntryDecoder())], ['pendingMatches', getArrayDecoder(getPendingMatchDecoder())]]);
+}
+
+/** Gets the codec for {@link Queue} account data. */
+export function getQueueCodec(): Codec<QueueArgs, Queue> {
+    return combineCodec(getQueueEncoder(), getQueueDecoder());
+}
+
+export function decodeQueue<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<Queue, TAddress>;
+export function decodeQueue<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<Queue, TAddress>;
+export function decodeQueue<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>): Account<Queue, TAddress> | MaybeAccount<Queue, TAddress> {
+  return decodeAccount(encodedAccount as MaybeEncodedAccount<TAddress>, getQueueDecoder());
+}
+
+export async function fetchQueue<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<Account<Queue, TAddress>> {
+  const maybeAccount = await fetchMaybeQueue(rpc, address, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+
+export async function fetchMaybeQueue<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<MaybeAccount<Queue, TAddress>> {
+  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  return decodeQueue(maybeAccount);
+}
+
+export async function fetchAllQueue(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<Account<Queue>[]> {
+  const maybeAccounts = await fetchAllMaybeQueue(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+
+export async function fetchAllMaybeQueue(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<MaybeAccount<Queue>[]> {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeQueue(maybeAccount));
+}

package/src/generated/duel/accounts/tenant.ts

@@ -0,0 +1,76 @@
+/**
+ * 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, getU32Decoder, getU32Encoder, getU64Decoder, getU64Encoder, getU8Decoder, getU8Encoder, 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';
+
+export const TENANT_DISCRIMINATOR = new Uint8Array([61, 43, 215, 51, 232, 242, 209, 170]);
+
+export function getTenantDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(TENANT_DISCRIMINATOR); }
+
+export type Tenant = { discriminator: ReadonlyUint8Array; authority: Address; tenantProgramId: Address; eloOffset: number; eloSize: number; eloWindow: bigint; callbackProgramId: Option<Address>; callbackDiscriminator: Option<ReadonlyUint8Array>;  };
+
+export type TenantArgs = { authority: Address; tenantProgramId: Address; eloOffset: number; eloSize: number; eloWindow: number | bigint; callbackProgramId: OptionOrNullable<Address>; callbackDiscriminator: OptionOrNullable<ReadonlyUint8Array>;  };
+
+/** Gets the encoder for {@link TenantArgs} account data. */
+export function getTenantEncoder(): Encoder<TenantArgs> {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['authority', getAddressEncoder()], ['tenantProgramId', getAddressEncoder()], ['eloOffset', getU32Encoder()], ['eloSize', getU8Encoder()], ['eloWindow', getU64Encoder()], ['callbackProgramId', getOptionEncoder(getAddressEncoder())], ['callbackDiscriminator', getOptionEncoder(fixEncoderSize(getBytesEncoder(), 8))]]), (value) => ({ ...value, discriminator: TENANT_DISCRIMINATOR }));
+}
+
+/** Gets the decoder for {@link Tenant} account data. */
+export function getTenantDecoder(): Decoder<Tenant> {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['authority', getAddressDecoder()], ['tenantProgramId', getAddressDecoder()], ['eloOffset', getU32Decoder()], ['eloSize', getU8Decoder()], ['eloWindow', getU64Decoder()], ['callbackProgramId', getOptionDecoder(getAddressDecoder())], ['callbackDiscriminator', getOptionDecoder(fixDecoderSize(getBytesDecoder(), 8))]]);
+}
+
+/** Gets the codec for {@link Tenant} account data. */
+export function getTenantCodec(): Codec<TenantArgs, Tenant> {
+    return combineCodec(getTenantEncoder(), getTenantDecoder());
+}
+
+export function decodeTenant<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<Tenant, TAddress>;
+export function decodeTenant<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<Tenant, TAddress>;
+export function decodeTenant<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>): Account<Tenant, TAddress> | MaybeAccount<Tenant, TAddress> {
+  return decodeAccount(encodedAccount as MaybeEncodedAccount<TAddress>, getTenantDecoder());
+}
+
+export async function fetchTenant<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<Account<Tenant, TAddress>> {
+  const maybeAccount = await fetchMaybeTenant(rpc, address, config);
+  assertAccountExists(maybeAccount);
+  return maybeAccount;
+}
+
+export async function fetchMaybeTenant<TAddress extends string = string>(
+  rpc: Parameters<typeof fetchEncodedAccount>[0],
+  address: Address<TAddress>,
+  config?: FetchAccountConfig,
+): Promise<MaybeAccount<Tenant, TAddress>> {
+  const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+  return decodeTenant(maybeAccount);
+}
+
+export async function fetchAllTenant(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<Account<Tenant>[]> {
+  const maybeAccounts = await fetchAllMaybeTenant(rpc, addresses, config);
+  assertAccountsExist(maybeAccounts);
+  return maybeAccounts;
+}
+
+export async function fetchAllMaybeTenant(
+  rpc: Parameters<typeof fetchEncodedAccounts>[0],
+  addresses: Array<Address>,
+  config?: FetchAccountsConfig,
+): Promise<MaybeAccount<Tenant>[]> {
+  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+  return maybeAccounts.map((maybeAccount) => decodeTenant(maybeAccount));
+}

package/src/generated/duel/errors/duel.ts

@@ -0,0 +1,46 @@
+/**
+ * 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 { DUEL_PROGRAM_ADDRESS } from '../programs';
+
+/** InvalidTenant: Account does not belong to the specified Tenant Program */
+export const DUEL_ERROR__INVALID_TENANT = 0x1770; // 6000
+/** DataTooSmall: Account data too small for ELO read */
+export const DUEL_ERROR__DATA_TOO_SMALL = 0x1771; // 6001
+/** Unauthorized: Unauthorized access */
+export const DUEL_ERROR__UNAUTHORIZED = 0x1772; // 6002
+/** InvalidEloSize: Invalid ELO size (must be 1, 2, 4, or 8 bytes) */
+export const DUEL_ERROR__INVALID_ELO_SIZE = 0x1773; // 6003
+/** InvalidTicketStatus: Invalid ticket status for this operation */
+export const DUEL_ERROR__INVALID_TICKET_STATUS = 0x1774; // 6004
+/** InvalidTicketAccount: Invalid ticket account */
+export const DUEL_ERROR__INVALID_TICKET_ACCOUNT = 0x1775; // 6005
+
+export type DuelError = typeof DUEL_ERROR__DATA_TOO_SMALL | typeof DUEL_ERROR__INVALID_ELO_SIZE | typeof DUEL_ERROR__INVALID_TENANT | typeof DUEL_ERROR__INVALID_TICKET_ACCOUNT | typeof DUEL_ERROR__INVALID_TICKET_STATUS | typeof DUEL_ERROR__UNAUTHORIZED;
+
+let duelErrorMessages: Record<DuelError, string> | undefined;
+if (process.env.NODE_ENV !== 'production') {
+  duelErrorMessages = { [DUEL_ERROR__DATA_TOO_SMALL]: `Account data too small for ELO read`, [DUEL_ERROR__INVALID_ELO_SIZE]: `Invalid ELO size (must be 1, 2, 4, or 8 bytes)`, [DUEL_ERROR__INVALID_TENANT]: `Account does not belong to the specified Tenant Program`, [DUEL_ERROR__INVALID_TICKET_ACCOUNT]: `Invalid ticket account`, [DUEL_ERROR__INVALID_TICKET_STATUS]: `Invalid ticket status for this operation`, [DUEL_ERROR__UNAUTHORIZED]: `Unauthorized access` };
+}
+
+export function getDuelErrorMessage(code: DuelError): string {
+  if (process.env.NODE_ENV !== 'production') {
+    return (duelErrorMessages as Record<DuelError, string>)[code];
+  }
+
+  return 'Error message not available in production bundles.';
+}
+
+export function isDuelError<TProgramErrorCode extends DuelError>(
+    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, DUEL_PROGRAM_ADDRESS, code);
+}

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

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

package/src/generated/duel/instructions/cancelTicket.ts

@@ -0,0 +1,100 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import { combineCodec, fixDecoderSize, fixEncoderSize, getAddressEncoder, getBytesDecoder, getBytesEncoder, getProgramDerivedAddress, getStructDecoder, getStructEncoder, SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, SolanaError, transformEncoder, type AccountMeta, type AccountSignerMeta, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type Instruction, type InstructionWithAccounts, type InstructionWithData, type ReadonlyAccount, type ReadonlySignerAccount, type ReadonlyUint8Array, type TransactionSigner, type WritableAccount } from '@solana/kit';
+import { getAccountMetaFactory, getAddressFromResolvedInstructionAccount, type ResolvedInstructionAccount } from '@solana/program-client-core';
+import { DUEL_PROGRAM_ADDRESS } from '../programs';
+
+export const CANCEL_TICKET_DISCRIMINATOR = new Uint8Array([216, 28, 247, 206, 195, 171, 100, 143]);
+
+export function getCancelTicketDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(CANCEL_TICKET_DISCRIMINATOR); }
+
+export type CancelTicketInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountTicket extends string | AccountMeta<string> = string, TAccountTenant extends string | AccountMeta<string> = string, TAccountPlayer extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> =
+Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountTicket extends string ? WritableAccount<TAccountTicket> : TAccountTicket, TAccountTenant extends string ? ReadonlyAccount<TAccountTenant> : TAccountTenant, TAccountPlayer extends string ? ReadonlySignerAccount<TAccountPlayer> & AccountSignerMeta<TAccountPlayer> : TAccountPlayer, ...TRemainingAccounts]>;
+
+export type CancelTicketInstructionData = { discriminator: ReadonlyUint8Array;  };
+
+export type CancelTicketInstructionDataArgs = {  };
+
+export function getCancelTicketInstructionDataEncoder(): FixedSizeEncoder<CancelTicketInstructionDataArgs> {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({ ...value, discriminator: CANCEL_TICKET_DISCRIMINATOR }));
+}
+
+export function getCancelTicketInstructionDataDecoder(): FixedSizeDecoder<CancelTicketInstructionData> {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);
+}
+
+export function getCancelTicketInstructionDataCodec(): FixedSizeCodec<CancelTicketInstructionDataArgs, CancelTicketInstructionData> {
+    return combineCodec(getCancelTicketInstructionDataEncoder(), getCancelTicketInstructionDataDecoder());
+}
+
+export type CancelTicketAsyncInput<TAccountTicket extends string = string, TAccountTenant extends string = string, TAccountPlayer extends string = string> =  {
+  ticket?: Address<TAccountTicket>;
+tenant: Address<TAccountTenant>;
+player: TransactionSigner<TAccountPlayer>;
+}
+
+export async function getCancelTicketInstructionAsync<TAccountTicket extends string, TAccountTenant extends string, TAccountPlayer extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: CancelTicketAsyncInput<TAccountTicket, TAccountTenant, TAccountPlayer>, config?: { programAddress?: TProgramAddress } ): Promise<CancelTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer>> {
+  // Program address.
+const programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;
+
+ // Original accounts.
+const originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? null, isWritable: false } }
+const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+
+// Resolve default values.
+if (!accounts.ticket.value) {
+accounts.ticket.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([116, 105, 99, 107, 101, 116])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("player", accounts.player.value)), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("tenant", accounts.tenant.value))] });
+}
+
+const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+return Object.freeze({ accounts: [getAccountMeta("ticket", accounts.ticket), getAccountMeta("tenant", accounts.tenant), getAccountMeta("player", accounts.player)], data: getCancelTicketInstructionDataEncoder().encode({}), programAddress } as CancelTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer>);
+}
+
+export type CancelTicketInput<TAccountTicket extends string = string, TAccountTenant extends string = string, TAccountPlayer extends string = string> =  {
+  ticket: Address<TAccountTicket>;
+tenant: Address<TAccountTenant>;
+player: TransactionSigner<TAccountPlayer>;
+}
+
+export function getCancelTicketInstruction<TAccountTicket extends string, TAccountTenant extends string, TAccountPlayer extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: CancelTicketInput<TAccountTicket, TAccountTenant, TAccountPlayer>, config?: { programAddress?: TProgramAddress } ): CancelTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer> {
+  // Program address.
+const programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;
+
+ // Original accounts.
+const originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? null, isWritable: false } }
+const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+
+
+
+const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+return Object.freeze({ accounts: [getAccountMeta("ticket", accounts.ticket), getAccountMeta("tenant", accounts.tenant), getAccountMeta("player", accounts.player)], data: getCancelTicketInstructionDataEncoder().encode({}), programAddress } as CancelTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer>);
+}
+
+export type ParsedCancelTicketInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;
+accounts: {
+ticket: TAccountMetas[0];
+tenant: TAccountMetas[1];
+player: TAccountMetas[2];
+};
+data: CancelTicketInstructionData; };
+
+export function parseCancelTicketInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedCancelTicketInstruction<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: { ticket: getNextAccount(), tenant: getNextAccount(), player: getNextAccount() }, data: getCancelTicketInstructionDataDecoder().decode(instruction.data) };
+}

package/src/generated/duel/instructions/closeTicket.ts

@@ -0,0 +1,100 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import { combineCodec, fixDecoderSize, fixEncoderSize, getAddressEncoder, getBytesDecoder, getBytesEncoder, getProgramDerivedAddress, getStructDecoder, getStructEncoder, SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, SolanaError, transformEncoder, 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, type ResolvedInstructionAccount } from '@solana/program-client-core';
+import { DUEL_PROGRAM_ADDRESS } from '../programs';
+
+export const CLOSE_TICKET_DISCRIMINATOR = new Uint8Array([66, 209, 114, 197, 75, 27, 182, 117]);
+
+export function getCloseTicketDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(CLOSE_TICKET_DISCRIMINATOR); }
+
+export type CloseTicketInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountTicket extends string | AccountMeta<string> = string, TAccountTenant extends string | AccountMeta<string> = string, TAccountPlayer extends string | AccountMeta<string> = string, TRemainingAccounts extends readonly AccountMeta<string>[] = []> =
+Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountTicket extends string ? WritableAccount<TAccountTicket> : TAccountTicket, TAccountTenant extends string ? ReadonlyAccount<TAccountTenant> : TAccountTenant, TAccountPlayer extends string ? WritableSignerAccount<TAccountPlayer> & AccountSignerMeta<TAccountPlayer> : TAccountPlayer, ...TRemainingAccounts]>;
+
+export type CloseTicketInstructionData = { discriminator: ReadonlyUint8Array;  };
+
+export type CloseTicketInstructionDataArgs = {  };
+
+export function getCloseTicketInstructionDataEncoder(): FixedSizeEncoder<CloseTicketInstructionDataArgs> {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({ ...value, discriminator: CLOSE_TICKET_DISCRIMINATOR }));
+}
+
+export function getCloseTicketInstructionDataDecoder(): FixedSizeDecoder<CloseTicketInstructionData> {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);
+}
+
+export function getCloseTicketInstructionDataCodec(): FixedSizeCodec<CloseTicketInstructionDataArgs, CloseTicketInstructionData> {
+    return combineCodec(getCloseTicketInstructionDataEncoder(), getCloseTicketInstructionDataDecoder());
+}
+
+export type CloseTicketAsyncInput<TAccountTicket extends string = string, TAccountTenant extends string = string, TAccountPlayer extends string = string> =  {
+  ticket?: Address<TAccountTicket>;
+tenant: Address<TAccountTenant>;
+player: TransactionSigner<TAccountPlayer>;
+}
+
+export async function getCloseTicketInstructionAsync<TAccountTicket extends string, TAccountTenant extends string, TAccountPlayer extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: CloseTicketAsyncInput<TAccountTicket, TAccountTenant, TAccountPlayer>, config?: { programAddress?: TProgramAddress } ): Promise<CloseTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer>> {
+  // Program address.
+const programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;
+
+ // Original accounts.
+const originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? null, isWritable: true } }
+const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+
+// Resolve default values.
+if (!accounts.ticket.value) {
+accounts.ticket.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([116, 105, 99, 107, 101, 116])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("player", accounts.player.value)), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("tenant", accounts.tenant.value))] });
+}
+
+const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+return Object.freeze({ accounts: [getAccountMeta("ticket", accounts.ticket), getAccountMeta("tenant", accounts.tenant), getAccountMeta("player", accounts.player)], data: getCloseTicketInstructionDataEncoder().encode({}), programAddress } as CloseTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer>);
+}
+
+export type CloseTicketInput<TAccountTicket extends string = string, TAccountTenant extends string = string, TAccountPlayer extends string = string> =  {
+  ticket: Address<TAccountTicket>;
+tenant: Address<TAccountTenant>;
+player: TransactionSigner<TAccountPlayer>;
+}
+
+export function getCloseTicketInstruction<TAccountTicket extends string, TAccountTenant extends string, TAccountPlayer extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: CloseTicketInput<TAccountTicket, TAccountTenant, TAccountPlayer>, config?: { programAddress?: TProgramAddress } ): CloseTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer> {
+  // Program address.
+const programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;
+
+ // Original accounts.
+const originalAccounts = { ticket: { value: input.ticket ?? null, isWritable: true }, tenant: { value: input.tenant ?? null, isWritable: false }, player: { value: input.player ?? null, isWritable: true } }
+const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+
+
+
+const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+return Object.freeze({ accounts: [getAccountMeta("ticket", accounts.ticket), getAccountMeta("tenant", accounts.tenant), getAccountMeta("player", accounts.player)], data: getCloseTicketInstructionDataEncoder().encode({}), programAddress } as CloseTicketInstruction<TProgramAddress, TAccountTicket, TAccountTenant, TAccountPlayer>);
+}
+
+export type ParsedCloseTicketInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;
+accounts: {
+ticket: TAccountMetas[0];
+tenant: TAccountMetas[1];
+player: TAccountMetas[2];
+};
+data: CloseTicketInstructionData; };
+
+export function parseCloseTicketInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedCloseTicketInstruction<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: { ticket: getNextAccount(), tenant: getNextAccount(), player: getNextAccount() }, data: getCloseTicketInstructionDataDecoder().decode(instruction.data) };
+}