@1upmonster/duel 0.1.8 → 0.2.1

package/dist/admin.d.ts

@@ -1,49 +1,27 @@
-import * as anchor from "@coral-xyz/anchor";
-import * as web3 from "@solana/web3.js";
-import type { Duel } from "./types.js";
-export type EloDataType = 'u8' | 'u16' | 'u32' | 'u64';
+import { type Address, type TransactionSigner, type Rpc, type SolanaRpcApi } from "@solana/kit";
+export type EloDataType = "u8" | "u16" | "u32" | "u64";
 export interface InitializeTenantOptions {
-    authority?: web3.PublicKey;
-    eloWindow?: number;
+    authority?: Address;
+    eloWindow?: bigint;
     eloOffset?: number;
     eloDataType?: EloDataType;
-    callbackProgramId?: web3.PublicKey | null;
+    callbackProgramId?: Address | null;
     callbackDiscriminator?: number[] | null;
 }
 export declare class MatchmakingAdmin {
-    program: anchor.Program<Duel>;
-    provider: anchor.AnchorProvider;
-    constructor(provider: anchor.AnchorProvider, programId: web3.PublicKey | string);
-    getQueuePda(authority: web3.PublicKey): web3.PublicKey;
-    getTenantPda(authority: web3.PublicKey): web3.PublicKey;
-    getTicketPda(player: web3.PublicKey, tenant: web3.PublicKey): web3.PublicKey;
-    /**
-     * Fetch Queue account data
-     */
-    getQueue(queuePda: web3.PublicKey): Promise<any>;
-    /**
-     * Fetch Tenant account data
-     */
-    getTenant(tenantPda: web3.PublicKey): Promise<any>;
-    /**
-     * Initialize a Tenant (with optional callback config)
-     */
-    initializeTenant(tenantProgramId: web3.PublicKey, options?: InitializeTenantOptions, confirmOptions?: web3.ConfirmOptions, signers?: web3.Keypair[]): Promise<web3.TransactionSignature>;
-    /**
-     * Initialize a Queue
-     */
-    initializeQueue(authority: web3.PublicKey, tenant: web3.PublicKey, confirmOptions?: web3.ConfirmOptions, signers?: web3.Keypair[]): Promise<web3.TransactionSignature>;
-    /**
-     * Delegate Queue to TEE
-     */
-    delegateQueue(authority: web3.PublicKey, validator?: web3.PublicKey, confirmOptions?: web3.ConfirmOptions, signers?: web3.Keypair[]): Promise<web3.TransactionSignature>;
-    /**
-     * Flush pending matches - crank instruction to update opponent tickets
-     * Can be called by any TEE-authenticated wallet (permissionless)
-     */
-    flushMatches(queue: web3.PublicKey, tenant: web3.PublicKey, ticketPdas: web3.PublicKey[], callbackProgram?: web3.PublicKey, confirmOptions?: web3.ConfirmOptions, signers?: web3.Keypair[]): Promise<web3.TransactionSignature>;
-    /**
-     * Commit matched tickets back to L1 (runs in TEE)
-     */
-    commitTickets(tenant: web3.PublicKey, ticketPdas: web3.PublicKey[], confirmOptions?: web3.ConfirmOptions, signers?: web3.Keypair[]): Promise<web3.TransactionSignature>;
+    rpc: Rpc<SolanaRpcApi>;
+    signer: TransactionSigner;
+    programId: Address;
+    constructor(rpc: Rpc<SolanaRpcApi>, signer: TransactionSigner, programId?: Address);
+    getQueuePda(authority: Address): Promise<Address>;
+    getTenantPda(authority: Address): Promise<Address>;
+    getTicketPda(player: Address, tenant: Address): Promise<Address>;
+    getQueue(queuePda: Address): Promise<import("@solana/accounts").Account<import("./generated/duel/index.js").Queue, string>>;
+    initializeTenant(tenantProgramId: Address, options?: InitializeTenantOptions): Promise<string>;
+    initializeQueue(_authority: Address, tenant: Address): Promise<string>;
+    delegateQueue(authority: Address, validator?: Address): Promise<string>;
+    flushMatches(queue: Address, tenant: Address, ticketPdas: Address[], callbackProgram?: Address): Promise<string>;
+    commitTickets(tenant: Address, ticketPdas: Address[]): Promise<string>;
+    /** Create a new MatchmakingAdmin pointing at a TEE RPC endpoint. */
+    withRpc(teeUrl: string): MatchmakingAdmin;
 }

package/dist/admin.js

@@ -1,137 +1,102 @@
-import * as anchor from "@coral-xyz/anchor";
-import { BN } from "bn.js";
-import * as web3 from "@solana/web3.js";
-import IDL from "./duel.json" with { type: "json" };
+import { createSolanaRpc, } from "@solana/kit";
+import { getInitializeTenantInstructionAsync, getInitializeQueueInstructionAsync, getDelegateQueueInstructionAsync, getFlushMatchesInstruction, getCommitTicketsInstruction, fetchQueue, accountType, } from "./generated/duel/index.js";
+import { sendInstruction } from "./transaction.js";
 import * as utils from "./utils.js";
-const TICKET_SEED = "ticket";
 function getEloSize(dataType) {
     switch (dataType) {
-        case 'u8': return 1;
-        case 'u16': return 2;
-        case 'u32': return 4;
-        case 'u64': return 8;
+        case "u8": return 1;
+        case "u16": return 2;
+        case "u32": return 4;
+        case "u64": return 8;
     }
 }
+const DUEL_PROGRAM_ID = "EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X";
 export class MatchmakingAdmin {
-    constructor(provider, programId) {
-        const address = typeof programId === "string" ? programId : programId.toBase58();
-        const idl = { ...IDL, address };
-        this.program = new anchor.Program(idl, provider);
-        this.provider = provider;
+    constructor(rpc, signer, programId = DUEL_PROGRAM_ID) {
+        this.rpc = rpc;
+        this.signer = signer;
+        this.programId = programId;
     }
-    // Derive PDAs Helpers
-    getQueuePda(authority) {
-        return utils.deriveQueuePda(this.program.programId, authority);
+    async getQueuePda(authority) {
+        return utils.deriveQueuePda(this.programId, authority);
     }
-    getTenantPda(authority) {
-        return utils.deriveTenantPda(this.program.programId, authority);
+    async getTenantPda(authority) {
+        return utils.deriveTenantPda(this.programId, authority);
     }
-    getTicketPda(player, tenant) {
-        return utils.deriveTicketPda(this.program.programId, player, tenant);
+    async getTicketPda(player, tenant) {
+        return utils.deriveTicketPda(this.programId, player, tenant);
     }
-    /**
-     * Fetch Queue account data
-     */
     async getQueue(queuePda) {
-        return await this.program.account.queue.fetch(queuePda);
+        return fetchQueue(this.rpc, queuePda);
     }
-    /**
-     * Fetch Tenant account data
-     */
-    async getTenant(tenantPda) {
-        return await this.program.account.tenant.fetch(tenantPda);
-    }
-    /**
-     * Initialize a Tenant (with optional callback config)
-     */
-    async initializeTenant(tenantProgramId, options, confirmOptions, signers = []) {
-        const { authority = tenantProgramId, eloWindow = 100, eloOffset = 40, eloDataType = 'u16', callbackProgramId = null, callbackDiscriminator = null, } = options || {};
+    async initializeTenant(tenantProgramId, options) {
+        const { eloWindow = 100n, eloOffset = 40, eloDataType = "u16", callbackProgramId = null, callbackDiscriminator = null, } = options || {};
         const eloSize = getEloSize(eloDataType);
-        const tenantPda = this.getTenantPda(authority);
-        return await this.program.methods
-            .initializeTenant(tenantProgramId, eloOffset, eloSize, new BN(eloWindow), callbackProgramId || null, callbackDiscriminator ? Array.from(Buffer.from(callbackDiscriminator)) : null)
-            .accountsPartial({
-            tenant: tenantPda,
-            authority: authority,
-        })
-            .signers(signers)
-            .rpc(confirmOptions);
+        const ix = await getInitializeTenantInstructionAsync({
+            authority: this.signer,
+            tenantProgramId,
+            eloOffset,
+            eloSize,
+            eloWindow,
+            callbackProgramId: callbackProgramId ? { __option: "Some", value: callbackProgramId } : { __option: "None" },
+            callbackDiscriminator: callbackDiscriminator
+                ? { __option: "Some", value: new Uint8Array(callbackDiscriminator) }
+                : { __option: "None" },
+        }, { programAddress: this.programId });
+        return sendInstruction(this.rpc, ix, this.signer);
     }
-    /**
-     * Initialize a Queue
-     */
-    async initializeQueue(authority, tenant, confirmOptions, signers = []) {
-        const queuePda = this.getQueuePda(authority);
-        return await this.program.methods
-            .initializeQueue()
-            .accountsPartial({
-            queue: queuePda,
-            tenant: tenant,
-            authority: authority,
-        })
-            .signers(signers)
-            .rpc(confirmOptions);
+    async initializeQueue(_authority, tenant) {
+        const ix = await getInitializeQueueInstructionAsync({
+            authority: this.signer,
+            tenant,
+        }, { programAddress: this.programId });
+        return sendInstruction(this.rpc, ix, this.signer);
     }
-    /**
-     * Delegate Queue to TEE
-     */
-    async delegateQueue(authority, validator = new web3.PublicKey("FnE6VJT5QNZdedZPnCoLsARgBwoE6DeJNjBs2H1gySXA"), confirmOptions, signers = []) {
-        const queuePda = this.getQueuePda(authority);
-        return await this.program.methods
-            .delegateQueue({ queue: { authority } })
-            .accounts({
+    async delegateQueue(authority, validator) {
+        const queuePda = await this.getQueuePda(authority);
+        const ix = await getDelegateQueueInstructionAsync({
             pda: queuePda,
-            payer: authority,
-            validator: validator,
-        })
-            .signers(signers)
-            .rpc(confirmOptions);
+            payer: this.signer,
+            validator,
+            accountType: accountType("Queue", { authority }),
+        }, { programAddress: this.programId });
+        return sendInstruction(this.rpc, ix, this.signer);
+    }
+    async flushMatches(queue, tenant, ticketPdas, callbackProgram) {
+        const ix = getFlushMatchesInstruction({
+            queue,
+            tenant,
+            signer: this.signer,
+        }, { programAddress: this.programId });
+        const remainingAccounts = [
+            ...ticketPdas.map((address) => ({ address, role: 1 })),
+            ...(callbackProgram ? [{ address: callbackProgram, role: 0 }] : []),
+        ];
+        const ixWithRemaining = {
+            ...ix,
+            accounts: [...ix.accounts, ...remainingAccounts],
+        };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return sendInstruction(this.rpc, ixWithRemaining, this.signer);
     }
-    /**
-     * Flush pending matches - crank instruction to update opponent tickets
-     * Can be called by any TEE-authenticated wallet (permissionless)
-     */
-    async flushMatches(queue, tenant, ticketPdas, callbackProgram, confirmOptions, signers = []) {
-        const remainingAccounts = ticketPdas.map(pda => ({
-            pubkey: pda,
-            isSigner: false,
-            isWritable: true,
-        }));
-        if (callbackProgram) {
-            remainingAccounts.push({
-                pubkey: callbackProgram,
-                isSigner: false,
-                isWritable: false,
-            });
-        }
-        return await this.program.methods
-            .flushMatches()
-            .accountsPartial({
-            queue: queue,
-            tenant: tenant,
-            signer: this.provider.publicKey,
-        })
-            .remainingAccounts(remainingAccounts)
-            .signers(signers)
-            .rpc(confirmOptions);
+    async commitTickets(tenant, ticketPdas) {
+        const ix = getCommitTicketsInstruction({
+            tenant,
+            payer: this.signer,
+        }, { programAddress: this.programId });
+        const ixWithRemaining = {
+            ...ix,
+            accounts: [
+                ...ix.accounts,
+                ...ticketPdas.map((address) => ({ address, role: 1 })),
+            ],
+        };
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return sendInstruction(this.rpc, ixWithRemaining, this.signer);
     }
-    /**
-     * Commit matched tickets back to L1 (runs in TEE)
-     */
-    async commitTickets(tenant, ticketPdas, confirmOptions, signers = []) {
-        return await this.program.methods
-            .commitTickets()
-            .accountsPartial({
-            tenant: tenant,
-            payer: this.provider.publicKey,
-        })
-            .remainingAccounts(ticketPdas.map(pda => ({
-            pubkey: pda,
-            isSigner: false,
-            isWritable: true,
-        })))
-            .signers(signers)
-            .rpc(confirmOptions);
+    /** Create a new MatchmakingAdmin pointing at a TEE RPC endpoint. */
+    withRpc(teeUrl) {
+        return new MatchmakingAdmin(createSolanaRpc(teeUrl), this.signer, this.programId);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"admin.js","sourceRoot":"","sources":["../src/admin.ts"],"names":[],"mappings":"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","sourcesContent":["import * as anchor from \"@coral-xyz/anchor\";\nimport { BN } from \"bn.js\";\nimport * as web3 from \"@solana/web3.js\";\nimport type { Duel } from \"./types.js\";\nimport IDL from \"./duel.json\" with { type: \"json\" };\nimport * as utils from \"./utils.js\";\n\nconst TICKET_SEED = \"ticket\";\n\nexport type EloDataType = 'u8' | 'u16' | 'u32' | 'u64';\n\nexport interface InitializeTenantOptions {\n  authority?: web3.PublicKey;\n  eloWindow?: number;\n  eloOffset?: number;\n  eloDataType?: EloDataType;\n  callbackProgramId?: web3.PublicKey | null;\n  callbackDiscriminator?: number[] | null;\n}\n\nfunction getEloSize(dataType: EloDataType): number {\n  switch (dataType) {\n    case 'u8': return 1;\n    case 'u16': return 2;\n    case 'u32': return 4;\n    case 'u64': return 8;\n  }\n}\n\nexport class MatchmakingAdmin {\n  public program: anchor.Program<Duel>;\n  public provider: anchor.AnchorProvider;\n\n  constructor(provider: anchor.AnchorProvider, programId: web3.PublicKey | string) {\n    const address = typeof programId === \"string\" ? programId : programId.toBase58();\n    const idl = { ...IDL, address };\n    this.program = new anchor.Program(idl as any, provider);\n    this.provider = provider;\n  }\n\n  // Derive PDAs Helpers\n  getQueuePda(authority: web3.PublicKey): web3.PublicKey {\n    return utils.deriveQueuePda(this.program.programId, authority);\n  }\n\n  getTenantPda(authority: web3.PublicKey): web3.PublicKey {\n    return utils.deriveTenantPda(this.program.programId, authority);\n  }\n\n  getTicketPda(player: web3.PublicKey, tenant: web3.PublicKey): web3.PublicKey {\n    return utils.deriveTicketPda(this.program.programId, player, tenant);\n  }\n\n  /**\n   * Fetch Queue account data\n   */\n  async getQueue(queuePda: web3.PublicKey): Promise<any> {\n    return await this.program.account.queue.fetch(queuePda);\n  }\n\n  /**\n   * Fetch Tenant account data\n   */\n  async getTenant(tenantPda: web3.PublicKey): Promise<any> {\n    return await this.program.account.tenant.fetch(tenantPda);\n  }\n\n  /**\n   * Initialize a Tenant (with optional callback config)\n   */\n  async initializeTenant(\n    tenantProgramId: web3.PublicKey,\n    options?: InitializeTenantOptions,\n    confirmOptions?: web3.ConfirmOptions,\n    signers: web3.Keypair[] = []\n  ): Promise<web3.TransactionSignature> {\n    const {\n      authority = tenantProgramId,\n      eloWindow = 100,\n      eloOffset = 40,\n      eloDataType = 'u16',\n      callbackProgramId = null,\n      callbackDiscriminator = null,\n    } = options || {};\n\n    const eloSize = getEloSize(eloDataType);\n    const tenantPda = this.getTenantPda(authority);\n\n    return await this.program.methods\n      .initializeTenant(\n        tenantProgramId,\n        eloOffset,\n        eloSize,\n        new BN(eloWindow),\n        callbackProgramId || null,\n        callbackDiscriminator ? Array.from(Buffer.from(callbackDiscriminator)) : null\n      )\n      .accountsPartial({\n        tenant: tenantPda,\n        authority: authority,\n      })\n      .signers(signers)\n      .rpc(confirmOptions);\n  }\n\n  /**\n   * Initialize a Queue\n   */\n  async initializeQueue(\n    authority: web3.PublicKey,\n    tenant: web3.PublicKey,\n    confirmOptions?: web3.ConfirmOptions,\n    signers: web3.Keypair[] = []\n  ): Promise<web3.TransactionSignature> {\n    const queuePda = this.getQueuePda(authority);\n    return await this.program.methods\n      .initializeQueue()\n      .accountsPartial({\n        queue: queuePda,\n        tenant: tenant,\n        authority: authority,\n      })\n      .signers(signers)\n      .rpc(confirmOptions);\n  }\n\n  /**\n   * Delegate Queue to TEE\n   */\n  async delegateQueue(\n    authority: web3.PublicKey,\n    validator: web3.PublicKey = new web3.PublicKey(\"FnE6VJT5QNZdedZPnCoLsARgBwoE6DeJNjBs2H1gySXA\"),\n    confirmOptions?: web3.ConfirmOptions,\n    signers: web3.Keypair[] = []\n  ): Promise<web3.TransactionSignature> {\n      const queuePda = this.getQueuePda(authority);\n      return await this.program.methods\n        .delegateQueue({ queue: { authority } } as any)\n        .accounts({\n            pda: queuePda,\n            payer: authority,\n            validator: validator,\n        } as unknown as any)\n        .signers(signers)\n        .rpc(confirmOptions);\n  }\n\n  /**\n   * Flush pending matches - crank instruction to update opponent tickets\n   * Can be called by any TEE-authenticated wallet (permissionless)\n   */\n  async flushMatches(\n    queue: web3.PublicKey,\n    tenant: web3.PublicKey,\n    ticketPdas: web3.PublicKey[],\n    callbackProgram?: web3.PublicKey,\n    confirmOptions?: web3.ConfirmOptions,\n    signers: web3.Keypair[] = []\n  ): Promise<web3.TransactionSignature> {\n    const remainingAccounts = ticketPdas.map(pda => ({\n      pubkey: pda,\n      isSigner: false,\n      isWritable: true,\n    }));\n\n    if (callbackProgram) {\n      remainingAccounts.push({\n        pubkey: callbackProgram,\n        isSigner: false,\n        isWritable: false,\n      });\n    }\n\n    return await this.program.methods\n      .flushMatches()\n      .accountsPartial({\n        queue: queue,\n        tenant: tenant,\n        signer: this.provider.publicKey,\n      })\n      .remainingAccounts(remainingAccounts)\n      .signers(signers)\n      .rpc(confirmOptions);\n  }\n\n  /**\n   * Commit matched tickets back to L1 (runs in TEE)\n   */\n  async commitTickets(\n    tenant: web3.PublicKey,\n    ticketPdas: web3.PublicKey[],\n    confirmOptions?: web3.ConfirmOptions,\n    signers: web3.Keypair[] = []\n  ): Promise<web3.TransactionSignature> {\n    return await this.program.methods\n      .commitTickets()\n      .accountsPartial({\n        tenant: tenant,\n        payer: this.provider.publicKey,\n      })\n      .remainingAccounts(\n        ticketPdas.map(pda => ({\n          pubkey: pda,\n          isSigner: false,\n          isWritable: true,\n        }))\n      )\n      .signers(signers)\n      .rpc(confirmOptions);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"admin.js","sourceRoot":"","sources":["../src/admin.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  createSolanaRpc,\n  type Address,\n  type TransactionSigner,\n  type Rpc,\n  type SolanaRpcApi,\n} from \"@solana/kit\";\nimport {\n  getInitializeTenantInstructionAsync,\n  getInitializeQueueInstructionAsync,\n  getDelegateQueueInstructionAsync,\n  getFlushMatchesInstruction,\n  getCommitTicketsInstruction,\n  fetchQueue,\n  accountType,\n} from \"./generated/duel/index.js\";\nimport { sendInstruction } from \"./transaction.js\";\nimport * as utils from \"./utils.js\";\n\nexport type EloDataType = \"u8\" | \"u16\" | \"u32\" | \"u64\";\n\nexport interface InitializeTenantOptions {\n  authority?: Address;\n  eloWindow?: bigint;\n  eloOffset?: number;\n  eloDataType?: EloDataType;\n  callbackProgramId?: Address | null;\n  callbackDiscriminator?: number[] | null;\n}\n\nfunction getEloSize(dataType: EloDataType): number {\n  switch (dataType) {\n    case \"u8\": return 1;\n    case \"u16\": return 2;\n    case \"u32\": return 4;\n    case \"u64\": return 8;\n  }\n}\n\nconst DUEL_PROGRAM_ID = \"EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X\" as Address;\n\nexport class MatchmakingAdmin {\n  public rpc: Rpc<SolanaRpcApi>;\n  public signer: TransactionSigner;\n  public programId: Address;\n\n  constructor(\n    rpc: Rpc<SolanaRpcApi>,\n    signer: TransactionSigner,\n    programId: Address = DUEL_PROGRAM_ID,\n  ) {\n    this.rpc = rpc;\n    this.signer = signer;\n    this.programId = programId;\n  }\n\n  async getQueuePda(authority: Address): Promise<Address> {\n    return utils.deriveQueuePda(this.programId, authority);\n  }\n\n  async getTenantPda(authority: Address): Promise<Address> {\n    return utils.deriveTenantPda(this.programId, authority);\n  }\n\n  async getTicketPda(player: Address, tenant: Address): Promise<Address> {\n    return utils.deriveTicketPda(this.programId, player, tenant);\n  }\n\n  async getQueue(queuePda: Address) {\n    return fetchQueue(this.rpc, queuePda);\n  }\n\n  async initializeTenant(\n    tenantProgramId: Address,\n    options?: InitializeTenantOptions,\n  ): Promise<string> {\n    const {\n      eloWindow = 100n,\n      eloOffset = 40,\n      eloDataType = \"u16\",\n      callbackProgramId = null,\n      callbackDiscriminator = null,\n    } = options || {};\n\n    const eloSize = getEloSize(eloDataType);\n    const ix = await getInitializeTenantInstructionAsync({\n      authority: this.signer,\n      tenantProgramId,\n      eloOffset,\n      eloSize,\n      eloWindow,\n      callbackProgramId: callbackProgramId ? { __option: \"Some\", value: callbackProgramId } : { __option: \"None\" },\n      callbackDiscriminator: callbackDiscriminator\n        ? { __option: \"Some\", value: new Uint8Array(callbackDiscriminator) }\n        : { __option: \"None\" },\n    }, { programAddress: this.programId });\n\n    return sendInstruction(this.rpc, ix, this.signer);\n  }\n\n  async initializeQueue(\n    _authority: Address,\n    tenant: Address,\n  ): Promise<string> {\n    const ix = await getInitializeQueueInstructionAsync({\n      authority: this.signer,\n      tenant,\n    }, { programAddress: this.programId });\n    return sendInstruction(this.rpc, ix, this.signer);\n  }\n\n  async delegateQueue(\n    authority: Address,\n    validator?: Address,\n  ): Promise<string> {\n    const queuePda = await this.getQueuePda(authority);\n    const ix = await getDelegateQueueInstructionAsync({\n      pda: queuePda,\n      payer: this.signer,\n      validator,\n      accountType: accountType(\"Queue\", { authority }),\n    }, { programAddress: this.programId });\n    return sendInstruction(this.rpc, ix, this.signer);\n  }\n\n  async flushMatches(\n    queue: Address,\n    tenant: Address,\n    ticketPdas: Address[],\n    callbackProgram?: Address,\n  ): Promise<string> {\n    const ix = getFlushMatchesInstruction({\n      queue,\n      tenant,\n      signer: this.signer,\n    }, { programAddress: this.programId });\n\n    const remainingAccounts = [\n      ...ticketPdas.map((address) => ({ address, role: 1 as const })),\n      ...(callbackProgram ? [{ address: callbackProgram, role: 0 as const }] : []),\n    ];\n\n    const ixWithRemaining = {\n      ...ix,\n      accounts: [...ix.accounts, ...remainingAccounts],\n    };\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    return sendInstruction(this.rpc, ixWithRemaining as any, this.signer);\n  }\n\n  async commitTickets(\n    tenant: Address,\n    ticketPdas: Address[],\n  ): Promise<string> {\n    const ix = getCommitTicketsInstruction({\n      tenant,\n      payer: this.signer,\n    }, { programAddress: this.programId });\n\n    const ixWithRemaining = {\n      ...ix,\n      accounts: [\n        ...ix.accounts,\n        ...ticketPdas.map((address) => ({ address, role: 1 as const })),\n      ],\n    };\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    return sendInstruction(this.rpc, ixWithRemaining as any, this.signer);\n  }\n\n  /** Create a new MatchmakingAdmin pointing at a TEE RPC endpoint. */\n  withRpc(teeUrl: string): MatchmakingAdmin {\n    return new MatchmakingAdmin(createSolanaRpc(teeUrl), this.signer, this.programId);\n  }\n}\n"]}

package/dist/encryption.js

@@ -1,4 +1,3 @@
-// import { x25519 } from "@noble/curves/ed25519"; 
 export class EncryptionProvider {
     constructor() {
         this.keyPair = null;
@@ -94,4 +93,4 @@ export class EncryptionProvider {
         return new Uint8Array(raw);
     }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"encryption.js","sourceRoot":"","sources":["../src/encryption.ts"],"names":[],"mappings":"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","sourcesContent":["import { PublicKey } from \"@solana/web3.js\";\n// import { x25519 } from \"@noble/curves/ed25519\"; \n\nexport class EncryptionProvider {\n    private keyPair: CryptoKeyPair | null = null;\n    \n    // Check for crypto availability\n    private get crypto(): Crypto {\n        if (typeof globalThis.crypto !== 'undefined') {\n            return globalThis.crypto;\n        }\n        // Fallback for Node < 19 if global crypto not set (though SDK likely targets modern envs)\n        try {\n            return require('crypto').webcrypto;\n        } catch (e) {\n            throw new Error(\"WebCrypto API not available.\");\n        }\n    }\n\n    /**\n     * Generate a fresh ephemeral keypair for the session (X25519/P-256).\n     */\n    async generateSessionKey(): Promise<CryptoKey> {\n        this.keyPair = await this.crypto.subtle.generateKey(\n            {\n                name: \"ECDH\",\n                namedCurve: \"P-256\", \n            },\n            true,\n            [\"deriveKey\", \"deriveBits\"]\n        ) as CryptoKeyPair;\n        \n        return this.keyPair.publicKey;\n    }\n\n    /**\n     * Derive shared secret and encrypt payload.\n     */\n    async encryptPayload(\n        data: Uint8Array, \n        teePublicKeyBytes: Uint8Array\n    ): Promise<{ encrypted: Uint8Array, clientPublicKey: Uint8Array }> {\n        if (!this.keyPair) {\n            await this.generateSessionKey();\n        }\n\n        // Import TEE Public Key\n        // Fix: Explicitly cast to BufferSource/any because TS gets confused with SharedArrayBuffer in some envs\n        const teeKey = await this.crypto.subtle.importKey(\n            \"raw\",\n            teePublicKeyBytes as unknown as BufferSource,\n            { name: \"ECDH\", namedCurve: \"P-256\" }, \n            false,\n            []\n        );\n\n        // Derive Shared Secret (AES-GCM Key)\n        const sharedKey = await this.crypto.subtle.deriveKey(\n            {\n                name: \"ECDH\",\n                public: teeKey,\n            },\n            this.keyPair!.privateKey,\n            {\n                name: \"AES-GCM\",\n                length: 256,\n            },\n            false,\n            [\"encrypt\", \"decrypt\"]\n        );\n\n        // Encrypt Data\n        const iv = this.crypto.getRandomValues(new Uint8Array(12));\n        const encryptedBuffer = await this.crypto.subtle.encrypt(\n            {\n                name: \"AES-GCM\",\n                iv: iv,\n            },\n            sharedKey,\n            data as unknown as BufferSource\n        );\n\n        // Concatenate IV + CipherText\n        const encrypted = new Uint8Array(iv.length + encryptedBuffer.byteLength);\n        encrypted.set(iv);\n        encrypted.set(new Uint8Array(encryptedBuffer), iv.length);\n\n        // Export Client Public Key\n        const clientPubRaw = await this.crypto.subtle.exportKey(\"raw\", this.keyPair!.publicKey);\n\n        return {\n            encrypted,\n            clientPublicKey: new Uint8Array(clientPubRaw)\n        };\n    }\n    \n    /**\n     * Decrypt a response from the TEE.\n     */\n    async decryptResponse(\n        encryptedData: Uint8Array, \n        teePublicKeyBytes: Uint8Array\n    ): Promise<Uint8Array> {\n          if (!this.keyPair) throw new Error(\"No session key\");\n          \n           // Import TEE Public Key\n        const teeKey = await this.crypto.subtle.importKey(\n            \"raw\",\n            teePublicKeyBytes as unknown as BufferSource,\n            { name: \"ECDH\", namedCurve: \"P-256\" }, \n            false,\n            []\n        );\n\n        // Derive Shared Secret\n        const sharedKey = await this.crypto.subtle.deriveKey(\n            {\n                name: \"ECDH\",\n                public: teeKey,\n            },\n            this.keyPair!.privateKey,\n            {\n                name: \"AES-GCM\",\n                length: 256,\n            },\n            false,\n            [\"encrypt\", \"decrypt\"]\n        );\n        \n        const iv = encryptedData.slice(0, 12);\n        const ciphertext = encryptedData.slice(12);\n        \n        const decrypted = await this.crypto.subtle.decrypt(\n            {\n                name: \"AES-GCM\",\n                iv: iv,\n            },\n            sharedKey,\n            ciphertext as unknown as BufferSource\n        );\n        \n        return new Uint8Array(decrypted);\n    }\n\n    /**\n     * Helper to generate a valid random P-256 Public Key (65 bytes) for testing.\n     */\n    async createMockValidatorKey(): Promise<Uint8Array> {\n        const pair = await this.crypto.subtle.generateKey(\n            { name: \"ECDH\", namedCurve: \"P-256\" },\n            true, \n            [\"deriveKey\"]\n        ) as CryptoKeyPair;\n        const raw = await this.crypto.subtle.exportKey(\"raw\", pair.publicKey);\n        return new Uint8Array(raw);\n    }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"encryption.js","sourceRoot":"","sources":["../src/encryption.ts"],"names":[],"mappings":"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","sourcesContent":["export class EncryptionProvider {\n    private keyPair: CryptoKeyPair | null = null;\n    \n    // Check for crypto availability\n    private get crypto(): Crypto {\n        if (typeof globalThis.crypto !== 'undefined') {\n            return globalThis.crypto;\n        }\n        // Fallback for Node < 19 if global crypto not set (though SDK likely targets modern envs)\n        try {\n            return require('crypto').webcrypto;\n        } catch (e) {\n            throw new Error(\"WebCrypto API not available.\");\n        }\n    }\n\n    /**\n     * Generate a fresh ephemeral keypair for the session (X25519/P-256).\n     */\n    async generateSessionKey(): Promise<CryptoKey> {\n        this.keyPair = await this.crypto.subtle.generateKey(\n            {\n                name: \"ECDH\",\n                namedCurve: \"P-256\", \n            },\n            true,\n            [\"deriveKey\", \"deriveBits\"]\n        ) as CryptoKeyPair;\n        \n        return this.keyPair.publicKey;\n    }\n\n    /**\n     * Derive shared secret and encrypt payload.\n     */\n    async encryptPayload(\n        data: Uint8Array, \n        teePublicKeyBytes: Uint8Array\n    ): Promise<{ encrypted: Uint8Array, clientPublicKey: Uint8Array }> {\n        if (!this.keyPair) {\n            await this.generateSessionKey();\n        }\n\n        // Import TEE Public Key\n        // Fix: Explicitly cast to BufferSource/any because TS gets confused with SharedArrayBuffer in some envs\n        const teeKey = await this.crypto.subtle.importKey(\n            \"raw\",\n            teePublicKeyBytes as unknown as BufferSource,\n            { name: \"ECDH\", namedCurve: \"P-256\" }, \n            false,\n            []\n        );\n\n        // Derive Shared Secret (AES-GCM Key)\n        const sharedKey = await this.crypto.subtle.deriveKey(\n            {\n                name: \"ECDH\",\n                public: teeKey,\n            },\n            this.keyPair!.privateKey,\n            {\n                name: \"AES-GCM\",\n                length: 256,\n            },\n            false,\n            [\"encrypt\", \"decrypt\"]\n        );\n\n        // Encrypt Data\n        const iv = this.crypto.getRandomValues(new Uint8Array(12));\n        const encryptedBuffer = await this.crypto.subtle.encrypt(\n            {\n                name: \"AES-GCM\",\n                iv: iv,\n            },\n            sharedKey,\n            data as unknown as BufferSource\n        );\n\n        // Concatenate IV + CipherText\n        const encrypted = new Uint8Array(iv.length + encryptedBuffer.byteLength);\n        encrypted.set(iv);\n        encrypted.set(new Uint8Array(encryptedBuffer), iv.length);\n\n        // Export Client Public Key\n        const clientPubRaw = await this.crypto.subtle.exportKey(\"raw\", this.keyPair!.publicKey);\n\n        return {\n            encrypted,\n            clientPublicKey: new Uint8Array(clientPubRaw)\n        };\n    }\n    \n    /**\n     * Decrypt a response from the TEE.\n     */\n    async decryptResponse(\n        encryptedData: Uint8Array, \n        teePublicKeyBytes: Uint8Array\n    ): Promise<Uint8Array> {\n          if (!this.keyPair) throw new Error(\"No session key\");\n          \n           // Import TEE Public Key\n        const teeKey = await this.crypto.subtle.importKey(\n            \"raw\",\n            teePublicKeyBytes as unknown as BufferSource,\n            { name: \"ECDH\", namedCurve: \"P-256\" }, \n            false,\n            []\n        );\n\n        // Derive Shared Secret\n        const sharedKey = await this.crypto.subtle.deriveKey(\n            {\n                name: \"ECDH\",\n                public: teeKey,\n            },\n            this.keyPair!.privateKey,\n            {\n                name: \"AES-GCM\",\n                length: 256,\n            },\n            false,\n            [\"encrypt\", \"decrypt\"]\n        );\n        \n        const iv = encryptedData.slice(0, 12);\n        const ciphertext = encryptedData.slice(12);\n        \n        const decrypted = await this.crypto.subtle.decrypt(\n            {\n                name: \"AES-GCM\",\n                iv: iv,\n            },\n            sharedKey,\n            ciphertext as unknown as BufferSource\n        );\n        \n        return new Uint8Array(decrypted);\n    }\n\n    /**\n     * Helper to generate a valid random P-256 Public Key (65 bytes) for testing.\n     */\n    async createMockValidatorKey(): Promise<Uint8Array> {\n        const pair = await this.crypto.subtle.generateKey(\n            { name: \"ECDH\", namedCurve: \"P-256\" },\n            true, \n            [\"deriveKey\"]\n        ) as CryptoKeyPair;\n        const raw = await this.crypto.subtle.exportKey(\"raw\", pair.publicKey);\n        return new Uint8Array(raw);\n    }\n}\n"]}

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

package/dist/generated/duel/accounts/index.js

@@ -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';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZ2VuZXJhdGVkL2R1ZWwvYWNjb3VudHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7OztHQU1HO0FBRUgsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYyxVQUFVLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIFRoaXMgY29kZSB3YXMgQVVUT0dFTkVSQVRFRCB1c2luZyB0aGUgQ29kYW1hIGxpYnJhcnkuXG4gKiBQbGVhc2UgRE8gTk9UIEVESVQgVEhJUyBGSUxFLCBpbnN0ZWFkIHVzZSB2aXNpdG9yc1xuICogdG8gYWRkIGZlYXR1cmVzLCB0aGVuIHJlcnVuIENvZGFtYSB0byB1cGRhdGUgaXQuXG4gKlxuICogQHNlZSBodHRwczovL2dpdGh1Yi5jb20vY29kYW1hLWlkbC9jb2RhbWFcbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL21hdGNoVGlja2V0JztcbmV4cG9ydCAqIGZyb20gJy4vcXVldWUnO1xuZXhwb3J0ICogZnJvbSAnLi90ZW5hbnQnOyJdfQ==

package/dist/generated/duel/accounts/matchTicket.d.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 { fetchEncodedAccount, fetchEncodedAccounts, 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 { type TicketStatus, type TicketStatusArgs } from '../types';
+export declare const MATCH_TICKET_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getMatchTicketDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+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 declare function getMatchTicketEncoder(): Encoder<MatchTicketArgs>;
+/** Gets the decoder for {@link MatchTicket} account data. */
+export declare function getMatchTicketDecoder(): Decoder<MatchTicket>;
+/** Gets the codec for {@link MatchTicket} account data. */
+export declare function getMatchTicketCodec(): Codec<MatchTicketArgs, MatchTicket>;
+export declare function decodeMatchTicket<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<MatchTicket, TAddress>;
+export declare function decodeMatchTicket<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<MatchTicket, TAddress>;
+export declare function fetchMatchTicket<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<MatchTicket, TAddress>>;
+export declare function fetchMaybeMatchTicket<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<MatchTicket, TAddress>>;
+export declare function fetchAllMatchTicket(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<MatchTicket>[]>;
+export declare function fetchAllMaybeMatchTicket(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<MatchTicket>[]>;

package/dist/generated/duel/accounts/matchTicket.js

@@ -0,0 +1,45 @@
+/**
+ * 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 } from '@solana/kit';
+import { getTicketStatusDecoder, getTicketStatusEncoder } 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); }
+/** Gets the encoder for {@link MatchTicketArgs} account data. */
+export function getMatchTicketEncoder() {
+    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() {
+    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() {
+    return combineCodec(getMatchTicketEncoder(), getMatchTicketDecoder());
+}
+export function decodeMatchTicket(encodedAccount) {
+    return decodeAccount(encodedAccount, getMatchTicketDecoder());
+}
+export async function fetchMatchTicket(rpc, address, config) {
+    const maybeAccount = await fetchMaybeMatchTicket(rpc, address, config);
+    assertAccountExists(maybeAccount);
+    return maybeAccount;
+}
+export async function fetchMaybeMatchTicket(rpc, address, config) {
+    const maybeAccount = await fetchEncodedAccount(rpc, address, config);
+    return decodeMatchTicket(maybeAccount);
+}
+export async function fetchAllMatchTicket(rpc, addresses, config) {
+    const maybeAccounts = await fetchAllMaybeMatchTicket(rpc, addresses, config);
+    assertAccountsExist(maybeAccounts);
+    return maybeAccounts;
+}
+export async function fetchAllMaybeMatchTicket(rpc, addresses, config) {
+    const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);
+    return maybeAccounts.map((maybeAccount) => decodeMatchTicket(maybeAccount));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"matchTicket.js","sourceRoot":"","sources":["../../../../src/generated/duel/accounts/matchTicket.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * This code was AUTOGENERATED using the Codama library.\n * Please DO NOT EDIT THIS FILE, instead use visitors\n * to add features, then rerun Codama to update it.\n *\n * @see https://github.com/codama-idl/codama\n */\n\nimport { 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';\nimport { getTicketStatusDecoder, getTicketStatusEncoder, type TicketStatus, type TicketStatusArgs } from '../types';\n\nexport const MATCH_TICKET_DISCRIMINATOR = new Uint8Array([11, 131, 4, 157, 207, 79, 126, 5]);\n\nexport function getMatchTicketDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(MATCH_TICKET_DISCRIMINATOR); }\n\nexport type MatchTicket = { discriminator: ReadonlyUint8Array; player: Address; tenant: Address; status: TicketStatus; createdAt: bigint; bump: number;  };\n\nexport type MatchTicketArgs = { player: Address; tenant: Address; status: TicketStatusArgs; createdAt: number | bigint; bump: number;  };\n\n/** Gets the encoder for {@link MatchTicketArgs} account data. */\nexport function getMatchTicketEncoder(): Encoder<MatchTicketArgs> {\n    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)], ['player', getAddressEncoder()], ['tenant', getAddressEncoder()], ['status', getTicketStatusEncoder()], ['createdAt', getI64Encoder()], ['bump', getU8Encoder()]]), (value) => ({ ...value, discriminator: MATCH_TICKET_DISCRIMINATOR }));\n}\n\n/** Gets the decoder for {@link MatchTicket} account data. */\nexport function getMatchTicketDecoder(): Decoder<MatchTicket> {\n    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)], ['player', getAddressDecoder()], ['tenant', getAddressDecoder()], ['status', getTicketStatusDecoder()], ['createdAt', getI64Decoder()], ['bump', getU8Decoder()]]);\n}\n\n/** Gets the codec for {@link MatchTicket} account data. */\nexport function getMatchTicketCodec(): Codec<MatchTicketArgs, MatchTicket> {\n    return combineCodec(getMatchTicketEncoder(), getMatchTicketDecoder());\n}\n\nexport function decodeMatchTicket<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<MatchTicket, TAddress>;\nexport function decodeMatchTicket<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<MatchTicket, TAddress>;\nexport function decodeMatchTicket<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress> | MaybeEncodedAccount<TAddress>): Account<MatchTicket, TAddress> | MaybeAccount<MatchTicket, TAddress> {\n  return decodeAccount(encodedAccount as MaybeEncodedAccount<TAddress>, getMatchTicketDecoder());\n}\n\nexport async function fetchMatchTicket<TAddress extends string = string>(\n  rpc: Parameters<typeof fetchEncodedAccount>[0],\n  address: Address<TAddress>,\n  config?: FetchAccountConfig,\n): Promise<Account<MatchTicket, TAddress>> {\n  const maybeAccount = await fetchMaybeMatchTicket(rpc, address, config);\n  assertAccountExists(maybeAccount);\n  return maybeAccount;\n}\n\nexport async function fetchMaybeMatchTicket<TAddress extends string = string>(\n  rpc: Parameters<typeof fetchEncodedAccount>[0],\n  address: Address<TAddress>,\n  config?: FetchAccountConfig,\n): Promise<MaybeAccount<MatchTicket, TAddress>> {\n  const maybeAccount = await fetchEncodedAccount(rpc, address, config);\n  return decodeMatchTicket(maybeAccount);\n}\n\nexport async function fetchAllMatchTicket(\n  rpc: Parameters<typeof fetchEncodedAccounts>[0],\n  addresses: Array<Address>,\n  config?: FetchAccountsConfig,\n): Promise<Account<MatchTicket>[]> {\n  const maybeAccounts = await fetchAllMaybeMatchTicket(rpc, addresses, config);\n  assertAccountsExist(maybeAccounts);\n  return maybeAccounts;\n}\n\nexport async function fetchAllMaybeMatchTicket(\n  rpc: Parameters<typeof fetchEncodedAccounts>[0],\n  addresses: Array<Address>,\n  config?: FetchAccountsConfig,\n): Promise<MaybeAccount<MatchTicket>[]> {\n  const maybeAccounts = await fetchEncodedAccounts(rpc, addresses, config);\n  return maybeAccounts.map((maybeAccount) => decodeMatchTicket(maybeAccount));\n}"]}

package/dist/generated/duel/accounts/queue.d.ts

@@ -0,0 +1,42 @@
+/**
+ * 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 { fetchEncodedAccount, fetchEncodedAccounts, 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 { type MatchEntry, type MatchEntryArgs, type PendingMatch, type PendingMatchArgs, type QueueEntry, type QueueEntryArgs } from '../types';
+export declare const QUEUE_DISCRIMINATOR: Uint8Array<ArrayBuffer>;
+export declare function getQueueDiscriminatorBytes(): ReadonlyUint8Array<ArrayBuffer>;
+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 declare function getQueueEncoder(): Encoder<QueueArgs>;
+/** Gets the decoder for {@link Queue} account data. */
+export declare function getQueueDecoder(): Decoder<Queue>;
+/** Gets the codec for {@link Queue} account data. */
+export declare function getQueueCodec(): Codec<QueueArgs, Queue>;
+export declare function decodeQueue<TAddress extends string = string>(encodedAccount: EncodedAccount<TAddress>): Account<Queue, TAddress>;
+export declare function decodeQueue<TAddress extends string = string>(encodedAccount: MaybeEncodedAccount<TAddress>): MaybeAccount<Queue, TAddress>;
+export declare function fetchQueue<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<Account<Queue, TAddress>>;
+export declare function fetchMaybeQueue<TAddress extends string = string>(rpc: Parameters<typeof fetchEncodedAccount>[0], address: Address<TAddress>, config?: FetchAccountConfig): Promise<MaybeAccount<Queue, TAddress>>;
+export declare function fetchAllQueue(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<Account<Queue>[]>;
+export declare function fetchAllMaybeQueue(rpc: Parameters<typeof fetchEncodedAccounts>[0], addresses: Array<Address>, config?: FetchAccountsConfig): Promise<MaybeAccount<Queue>[]>;