@1upmonster/duel 0.1.8 → 0.2.2

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

@@ -0,0 +1,37 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import { combineCodec, getAddressDecoder, getAddressEncoder, getDiscriminatedUnionDecoder, getDiscriminatedUnionEncoder, getStructDecoder, getStructEncoder, getTupleDecoder, getTupleEncoder, getUnitDecoder, getUnitEncoder, type Address, type Codec, type Decoder, type Encoder, type GetDiscriminatedUnionVariant, type GetDiscriminatedUnionVariantContent } from '@solana/kit';
+
+export type GameResult = { __kind: "Winner", fields: readonly [Address];  } | { __kind: "Tie" } | { __kind: "None" };
+
+export type GameResultArgs = GameResult;
+
+export function getGameResultEncoder(): Encoder<GameResultArgs> {
+    return getDiscriminatedUnionEncoder([['Winner', getStructEncoder([['fields', getTupleEncoder([getAddressEncoder()])]])], ['Tie', getUnitEncoder()], ['None', getUnitEncoder()]]);
+}
+
+export function getGameResultDecoder(): Decoder<GameResult> {
+    return getDiscriminatedUnionDecoder([['Winner', getStructDecoder([['fields', getTupleDecoder([getAddressDecoder()])]])], ['Tie', getUnitDecoder()], ['None', getUnitDecoder()]]);
+}
+
+export function getGameResultCodec(): Codec<GameResultArgs, GameResult> {
+    return combineCodec(getGameResultEncoder(), getGameResultDecoder());
+}
+
+// Data Enum Helpers.
+export function gameResult(kind: 'Winner', data: GetDiscriminatedUnionVariantContent<GameResultArgs, '__kind', 'Winner'>['fields']): GetDiscriminatedUnionVariant<GameResultArgs, '__kind', 'Winner'>;
+export function gameResult(kind: 'Tie'): GetDiscriminatedUnionVariant<GameResultArgs, '__kind', 'Tie'>;
+export function gameResult(kind: 'None'): GetDiscriminatedUnionVariant<GameResultArgs, '__kind', 'None'>;
+export function gameResult<K extends GameResultArgs['__kind'], Data>(kind: K, data?: Data) {
+  return Array.isArray(data) ? { __kind: kind, fields: data } : { __kind: kind, ...(data ?? {}) };
+}
+
+export function isGameResult<K extends GameResult['__kind']>(kind: K, value: GameResult): value is GameResult & { __kind: K } {
+  return value.__kind === kind;
+};

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

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

package/src/index.ts

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

package/src/player.ts

@@ -1,225 +1,162 @@
-import * as anchor from "@coral-xyz/anchor";
-import * as web3 from "@solana/web3.js";
-import type { Duel } from "./types.js";
-import IDL from "./duel.json" with { type: "json" };
+import {
+  createSolanaRpc,
+  type Address,
+  type TransactionSigner,
+  type Rpc,
+  type SolanaRpcApi,
+} from "@solana/kit";
+import {
+  getCreateTicketInstructionAsync,
+  getDelegateTicketInstructionAsync,
+  getJoinQueueInstructionAsync,
+  getCancelTicketInstructionAsync,
+  getCloseTicketInstructionAsync,
+  fetchMaybeMatchTicket,
+  accountType,
+} from "./generated/duel/index.js";
+import { sendInstruction } from "./transaction.js";
+import { waitUntilPermissionActive } from "./tee.js";
 import * as utils from "./utils.js";
 
+const DUEL_PROGRAM_ID = "EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X" as Address;
+
 export class MatchmakingPlayer {
-  public program: anchor.Program<Duel>;
-  public provider: anchor.AnchorProvider;
-
-  constructor(provider: anchor.AnchorProvider, programId: web3.PublicKey | string) {
-    const address = typeof programId === "string" ? programId : programId.toBase58();
-    const idl = { ...IDL, address };
-    this.program = new anchor.Program(idl as any, provider);
-    this.provider = provider;
+  public rpc: Rpc<SolanaRpcApi>;
+  public signer: TransactionSigner;
+  public programId: Address;
+
+  constructor(
+    rpc: Rpc<SolanaRpcApi>,
+    signer: TransactionSigner,
+    programId: Address = DUEL_PROGRAM_ID,
+  ) {
+    this.rpc = rpc;
+    this.signer = signer;
+    this.programId = programId;
   }
 
-  /**
-   * Derive MatchTicket PDA
-   */
-  getTicketPda(player: web3.PublicKey, tenant: web3.PublicKey): web3.PublicKey {
-    return utils.deriveTicketPda(this.program.programId, player, tenant);
+  async getTicketPda(player: Address, tenant: Address): Promise<Address> {
+    return utils.deriveTicketPda(this.programId, player, tenant);
   }
 
-  /**
-   * Fetch MatchTicket account data
-   */
-  async getTicket(ticketPda: web3.PublicKey): Promise<any> {
-    return await this.program.account.matchTicket.fetch(ticketPda);
+  async getTicket(ticketPda: Address) {
+    return fetchMaybeMatchTicket(this.rpc, ticketPda);
   }
 
-  /**
-   * Create MatchTicket PDA on L1
-   */
-  async createTicket(
-    tenant: web3.PublicKey,
-    confirmOptions?: web3.ConfirmOptions,
-    signers: web3.Keypair[] = []
-  ): Promise<web3.TransactionSignature> {
-    const ticketPda = this.getTicketPda(this.provider.publicKey, tenant);
-    return await this.program.methods
-      .createTicket()
-      .accountsPartial({
-        ticket: ticketPda,
-        tenant: tenant,
-        player: this.provider.publicKey,
-      })
-      .signers(signers)
-      .rpc(confirmOptions);
+  async createTicket(tenant: Address): Promise<string> {
+    const ix = await getCreateTicketInstructionAsync({
+      player: this.signer,
+      tenant,
+    }, { programAddress: this.programId });
+    return sendInstruction(this.rpc, ix, this.signer);
   }
 
-  /**
-   * Delegate ticket into TEE (becomes invisible on L1)
-   */
   async delegateTicket(
-    player: web3.PublicKey,
-    tenant: web3.PublicKey,
-    validator: web3.PublicKey = new web3.PublicKey("FnE6VJT5QNZdedZPnCoLsARgBwoE6DeJNjBs2H1gySXA"),
-    confirmOptions?: web3.ConfirmOptions,
-    signers: web3.Keypair[] = []
-  ): Promise<web3.TransactionSignature> {
-    const ticketPda = this.getTicketPda(player, tenant);
-    return await this.program.methods
-      .delegateTicket({ ticket: { player, tenant } } as any)
-      .accounts({
-        pda: ticketPda,
-        payer: this.provider.publicKey,
-        validator: validator,
-      } as any)
-      .signers(signers)
-      .rpc(confirmOptions);
+    player: Address,
+    tenant: Address,
+    validator?: Address,
+  ): Promise<string> {
+    const ticketPda = await this.getTicketPda(player, tenant);
+    const ix = await getDelegateTicketInstructionAsync({
+      pda: ticketPda,
+      payer: this.signer,
+      validator,
+      accountType: accountType("Ticket", { player, tenant }),
+    }, { programAddress: this.programId });
+    return sendInstruction(this.rpc, ix, this.signer);
   }
 
-  /**
-   * Join Queue (TEE Aware) - now requires ticket
-   */
   async joinQueue(
-    queue: web3.PublicKey,
-    tenant: web3.PublicKey,
-    playerData: web3.PublicKey,
-    confirmOptions?: web3.ConfirmOptions,
-    signers: web3.Keypair[] = []
-  ): Promise<web3.TransactionSignature> {
-    const ticketPda = this.getTicketPda(this.provider.publicKey, tenant);
-    return await this.program.methods
-      .joinQueue()
-      .accountsPartial({
-        queue: queue,
-        tenant: tenant,
-        playerData: playerData,
-        playerTicket: ticketPda,
-        signer: this.provider.publicKey,
-      })
-      .signers(signers)
-      .rpc(confirmOptions);
-  }
-
-  /**
-   * Cancel search, marks ticket as Cancelled (runs in TEE)
-   */
-  async cancelTicket(
-    tenant: web3.PublicKey,
-    confirmOptions?: web3.ConfirmOptions,
-    signers: web3.Keypair[] = []
-  ): Promise<web3.TransactionSignature> {
-    const ticketPda = this.getTicketPda(this.provider.publicKey, tenant);
-    return await this.program.methods
-      .cancelTicket()
-      .accountsPartial({
-        ticket: ticketPda,
-        tenant: tenant,
-        player: this.provider.publicKey,
-      })
-      .signers(signers)
-      .rpc(confirmOptions);
+    queue: Address,
+    tenant: Address,
+    playerData: Address,
+    callbackProgram?: Address,
+  ): Promise<string> {
+    const ix = await getJoinQueueInstructionAsync({
+      queue,
+      tenant,
+      playerData,
+      signer: this.signer,
+    }, { programAddress: this.programId });
+    const ixFinal = callbackProgram
+      ? { ...ix, accounts: [...ix.accounts, { address: callbackProgram, role: 0 as const }] }
+      : ix;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return sendInstruction(this.rpc, ixFinal as any, this.signer);
   }
 
-  /**
-   * Close ticket and reclaim rent (L1, after match consumed or cancelled)
-   */
-  async closeTicket(
-    tenant: web3.PublicKey,
-    confirmOptions?: web3.ConfirmOptions,
-    signers: web3.Keypair[] = []
-  ): Promise<web3.TransactionSignature> {
-    const ticketPda = this.getTicketPda(this.provider.publicKey, tenant);
-    return await this.program.methods
-      .closeTicket()
-      .accountsPartial({
-        ticket: ticketPda,
-        tenant: tenant,
-        player: this.provider.publicKey,
-      })
-      .signers(signers)
-      .rpc(confirmOptions);
+  async cancelTicket(tenant: Address): Promise<string> {
+    const ix = await getCancelTicketInstructionAsync({
+      player: this.signer,
+      tenant,
+    }, { programAddress: this.programId });
+    return sendInstruction(this.rpc, ix, this.signer);
   }
 
-  /**
-   * Wait for match by subscribing to ticket PDA changes on L1.
-   * Returns match info when ticket status changes to Matched.
-   */
-  async waitForMatch(
-    ticketPda: web3.PublicKey,
-    connection: web3.Connection,
-    timeoutMs: number = 120000
-  ): Promise<{ opponent: web3.PublicKey; matchId: anchor.BN } | null> {
-    return new Promise((resolve, reject) => {
-      let subscriptionId: number | null = null;
-      let timeoutId: ReturnType<typeof setTimeout> | null = null;
-
-      const cleanup = () => {
-        if (timeoutId) clearTimeout(timeoutId);
-        if (subscriptionId !== null) {
-          connection.removeAccountChangeListener(subscriptionId);
-        }
-      };
-
-      // Set timeout
-      timeoutId = setTimeout(() => {
-        cleanup();
-        resolve(null);
-      }, timeoutMs);
-
-      // Subscribe to account changes on L1
-      subscriptionId = connection.onAccountChange(
-        ticketPda,
-        (accountInfo: web3.AccountInfo<Buffer>) => {
-          try {
-            const decoded = this.program.coder.accounts.decode(
-              "matchTicket",
-              accountInfo.data
-            );
-            if (decoded.status.matched) {
-              cleanup();
-              resolve({
-                opponent: decoded.status.matched.opponent,
-                matchId: decoded.status.matched.matchId,
-              });
-            }
-          } catch (e) {
-            // Ignore decode errors (account may be in transition)
-          }
-        },
-        "confirmed"
-      );
-    });
+  async closeTicket(tenant: Address): Promise<string> {
+    const ix = await getCloseTicketInstructionAsync({
+      player: this.signer,
+      tenant,
+    }, { programAddress: this.programId });
+    return sendInstruction(this.rpc, ix, this.signer);
   }
 
   /**
-   * Poll L1 for ticket status (fallback for environments without websocket)
+   * Poll L1 for ticket status.
+   * Returns match info when status becomes Matched.
    */
   async pollForMatch(
-    ticketPda: web3.PublicKey,
-    connection: web3.Connection,
-    maxAttempts: number = 60,
-    pollInterval: number = 2000,
-    signal?: AbortSignal
-  ): Promise<{ opponent: web3.PublicKey; matchId: anchor.BN } | null> {
+    ticketPda: Address,
+    maxAttempts = 60,
+    pollInterval = 2000,
+    signal?: AbortSignal,
+  ): Promise<{ opponent: Address; matchId: bigint } | null> {
     for (let i = 0; i < maxAttempts; i++) {
       if (signal?.aborted) return null;
-
-      await new Promise(resolve => setTimeout(resolve, pollInterval));
-
+      await new Promise((r) => setTimeout(r, pollInterval));
       try {
-        const accountInfo = await connection.getAccountInfo(ticketPda);
-        if (!accountInfo) continue;
-
-        const decoded = this.program.coder.accounts.decode(
-          "matchTicket",
-          accountInfo.data
-        );
-
-        if (decoded.status.matched) {
-          return {
-            opponent: decoded.status.matched.opponent,
-            matchId: decoded.status.matched.matchId,
-          };
+        const maybeTicket = await fetchMaybeMatchTicket(this.rpc, ticketPda);
+        if (!maybeTicket.exists) continue;
+        const status = maybeTicket.data.status;
+        if (status.__kind === "Matched") {
+          return { opponent: status.opponent, matchId: status.matchId };
         }
-      } catch (e) {
-        // Account may not exist yet or be in transition
+      } catch {
+        // Ignore decode errors during transition
       }
     }
     return null;
   }
+
+  /**
+   * High-level: full matchmaking TEE entry flow.
+   * Creates ticket on L1, delegates it to TEE, waits for activation, then joins the queue.
+   * Use individual methods (createTicket, delegateTicket, joinQueue) as escape hatches if needed.
+   */
+  async enterQueue(
+    tenant: Address,
+    queue: Address,
+    playerData: Address,
+    teeRpc: Rpc<SolanaRpcApi>,
+    teeUrlWithToken: string,
+    validator?: Address,
+    callbackProgram?: Address,
+  ): Promise<Address> {
+    const player = this.signer.address as Address;
+    const ticketPda = await this.getTicketPda(player, tenant);
+
+    await this.createTicket(tenant);
+    await this.delegateTicket(player, tenant, validator);
+    await waitUntilPermissionActive(teeUrlWithToken, ticketPda);
+
+    const teeClient = new MatchmakingPlayer(teeRpc, this.signer, this.programId);
+    await teeClient.joinQueue(queue, tenant, playerData, callbackProgram);
+
+    return ticketPda;
+  }
+
+  /** Create a new MatchmakingPlayer pointing at a TEE RPC endpoint. */
+  withRpc(teeUrl: string): MatchmakingPlayer {
+    return new MatchmakingPlayer(createSolanaRpc(teeUrl), this.signer, this.programId);
+  }
 }