@1upmonster/duel 0.1.8 → 0.2.2

package/README.md

@@ -1,13 +1,8 @@
 # @1upmonster/duel
 
-TypeScript SDK for **Duel** - a privacy-focused matchmaking protocol on Solana using MagicBlock's Ephemeral Rollups (TEE).
+TypeScript SDK for **Duel** — a privacy-preserving matchmaking protocol on Solana using MagicBlock Ephemeral Rollups (TEE).
 
-## Features
-
-- **Privacy-First**: Player ELO and queue status hidden in TEE
-- **Client-Side**: Players join queues directly from their wallets (no CPI required)
-- **Automatic Matching**: TEE processes matches based on ELO windows
-- **Easy Integration**: Simple SDK for both game owners and players
+Built on [`@solana/kit`](https://github.com/anza-xyz/kit). No `@coral-xyz/anchor` or legacy `web3.js` dependency.
 
 ## Installation
 
@@ -17,85 +12,141 @@ npm install @1upmonster/duel
 
 ## Quick Start
 
-### For Game Owners
-
-Initialize matchmaking infrastructure for your game:
+### For Game Owners (`MatchmakingAdmin`)
 
 ```typescript
 import { MatchmakingAdmin } from "@1upmonster/duel";
-import { AnchorProvider } from "@coral-xyz/anchor";
-
-const admin = new MatchmakingAdmin(provider);
-
-// 1. Initialize Tenant for your Game Program
-await admin.initializeTenant(gameProgramId, {
-  authority,      // optional, defaults to gameProgramId
-  eloWindow: 200, // optional, default 100
-  eloOffset: 40,  // optional, default 40
-  eloDataType: 'u16' // optional, default 'u16' (u8/u16/u32/u64)
+import { createSolanaRpc, createKeyPairSignerFromBytes } from "@solana/kit";
+import * as crypto from "crypto";
+
+const rpc = createSolanaRpc("https://api.devnet.solana.com");
+const signer = await createKeyPairSignerFromBytes(/* your keypair bytes */);
+const admin = new MatchmakingAdmin(rpc, signer);
+
+// 1. Initialize Tenant — stores callback config on L1
+const callbackDiscriminator = Array.from(
+  crypto.createHash("sha256").update("global:on_match_found").digest().slice(0, 8)
+);
+await admin.initializeTenant(YOUR_GAME_PROGRAM_ID, {
+  eloWindow: 100n,       // max ELO diff for a match
+  eloOffset: 40,         // byte offset of ELO in player account
+  eloDataType: "u64",    // u8 | u16 | u32 | u64
+  callbackProgramId: YOUR_GAME_PROGRAM_ID,
+  callbackDiscriminator,
 });
 
-// 2. Initialize a Matchmaking Queue
-const tenantPda = admin.getTenantPda(authority);
+// 2. Create and delegate queue to TEE
+const authority = signer.address;
 await admin.initializeQueue(authority, tenantPda);
-
-// 3. Delegate to TEE Validator
 await admin.delegateQueue(authority, validatorPubkey);
-```
-
-### ELO Data Types
-
-The SDK supports different ELO data types to optimize storage:
-- `'u8'`: 0-255 (1 byte)
-- `'u16'`: 0-65,535 (2 bytes) **[DEFAULT]**
-- `'u32'`: 0-4,294,967,295 (4 bytes)
-- `'u64'`: 0-18,446,744,073,709,551,615 (8 bytes)
 
-### For Players
+// 3. After players have matched, flush opponent tickets + commit all to L1
+await admin.resolveMatches(queuePda, tenantPda, [p1TicketPda, p2TicketPda]);
+```
 
-Join the private matchmaking queue:
+### For Players (`MatchmakingPlayer`)
 
 ```typescript
 import { MatchmakingPlayer } from "@1upmonster/duel";
-
-const player = new MatchmakingPlayer(provider);
-
-// Join queue (matching happens automatically in TEE)
-await player.joinQueue(queuePda, tenantPda, playerProfilePda);
+import { getAuthToken } from "@1upmonster/duel";
+import { createSolanaRpc } from "@solana/kit";
+
+const l1Rpc = createSolanaRpc("https://api.devnet.solana.com");
+const player = new MatchmakingPlayer(l1Rpc, signer);
+
+// High-level: creates ticket on L1, delegates to TEE, joins queue in one call
+const { token } = await getAuthToken("https://tee.magicblock.app", signer);
+const teeRpc = createSolanaRpc(`https://tee.magicblock.app?token=${token}`);
+
+const ticketPda = await player.enterQueue(
+  tenantPda,
+  queuePda,
+  playerProfilePda,
+  teeRpc,
+  `https://tee.magicblock.app?token=${token}`,
+  validatorPubkey,        // optional TEE validator
+  YOUR_GAME_PROGRAM_ID,   // optional: callback fires via Tenant PDA when matched
+);
+
+// Poll L1 until the ticket shows Matched status
+const match = await player.pollForMatch(ticketPda);
+// match = { opponent: Address, matchId: bigint }
 ```
 
 ## API Reference
 
 ### `MatchmakingAdmin`
 
-**Constructor**
-- `new MatchmakingAdmin(provider: AnchorProvider, programId?: PublicKey)`
+**Constructor:** `new MatchmakingAdmin(rpc, signer, programId?)`
 
-**Methods**
-- `initializeTenant(authority, tenantProgramId, eloWindow?, eloOffset?)` - Set up game tenant
-- `initializeQueue(authority, tenant)` - Create matchmaking queue
-- `delegateQueue(authority, validator?)` - Delegate to TEE validator
-- `getTenantPda(authority)` - Derive tenant PDA
-- `getQueuePda(authority)` - Derive queue PDA
+| Method | Description |
+|---|---|
+| `initializeTenant(tenantProgramId, options?)` | Create Tenant PDA with ELO config and optional callback |
+| `initializeQueue(authority, tenant)` | Create Queue PDA linked to tenant |
+| `delegateQueue(authority, validator?)` | Delegate queue to TEE (makes it private) |
+| `flushMatches(queue, tenant, ticketPdas)` | Update opponent tickets from pending matches |
+| `commitTickets(tenant, ticketPdas)` | Push matched ticket state back to L1 |
+| `resolveMatches(queue, tenant, ticketPdas, settlementDelayMs?)` | High-level: flush + wait + commit |
+| `getQueue(queuePda)` | Fetch queue account |
+| `getQueuePda(authority)` | Derive queue PDA |
+| `getTenantPda(authority)` | Derive tenant PDA |
 
 ### `MatchmakingPlayer`
 
-**Constructor**
-- `new MatchmakingPlayer(provider: AnchorProvider, programId?: PublicKey)`
+**Constructor:** `new MatchmakingPlayer(rpc, signer, programId?)`
+
+| Method | Description |
+|---|---|
+| `enterQueue(tenant, queue, playerData, teeRpc, teeUrlWithToken, validator?, callbackProgram?)` | High-level: create ticket → delegate → join queue |
+| `createTicket(tenant)` | Create MatchTicket PDA on L1 |
+| `delegateTicket(player, tenant, validator?)` | Delegate ticket to TEE |
+| `joinQueue(queue, tenant, playerData, callbackProgram?)` | Join queue in TEE; callback fires via Tenant PDA on match |
+| `cancelTicket(tenant)` | Cancel search (sets ticket to Cancelled) |
+| `closeTicket(tenant)` | Reclaim rent after match or cancel |
+| `pollForMatch(ticketPda, maxAttempts?, pollInterval?)` | Poll L1 until ticket is Matched |
+| `getTicket(ticketPda)` | Fetch ticket account |
+| `withRpc(teeUrl)` | Return a new client pointing at a different RPC |
+
+### `getAuthToken(rpcUrl, signer)`
+
+Authenticate with the MagicBlock TEE. Returns `{ token, expiresAt }`. The token is passed as `?token=<jwt>` in the TEE RPC URL.
+
+### `waitUntilPermissionActive(teeUrlWithToken, pda)`
 
-**Methods**
-- `joinQueue(queue, tenant, playerData)` - Join matchmaking queue
+Poll the TEE until a delegated PDA is active (authorized users list is non-empty).
 
-## How It Works
+## How the Callback Works
+
+When a match is found during `join_queue`, the duel program fires a CPI callback **signed by the Tenant PDA** via `invoke_signed`. This is cryptographically unforgeable — game programs can verify the signer is the Tenant PDA without any additional access control:
+
+```rust
+pub fn on_match_found(
+    ctx: Context<OnMatchFound>,
+    player1: Pubkey,
+    player2: Pubkey,
+    match_id: u64,
+) -> Result<()> {
+    // ctx.accounts.signer.key() == Tenant PDA — verified by the runtime
+    // Only the duel program can produce this signer
+    Ok(())
+}
+
+#[derive(Accounts)]
+pub struct OnMatchFound<'info> {
+    pub signer: Signer<'info>, // will be the Tenant PDA
+}
+```
 
-1. **Queue Joining**: Players call `joinQueue` directly via SDK
-2. **Matching**: TEE automatically processes matches based on ELO windows
-3. **Privacy**: Queue state is only visible within the TEE, not on L1
+Pass the callback program as `remaining_accounts` in `joinQueue` (or via `callbackProgram` param in the SDK) for the callback to fire.
 
-## Links
+## ELO Data Types
 
-- [GitHub Repository](https://github.com/val-samonte/private-matchmaking)
-- [Full Documentation](https://github.com/val-samonte/private-matchmaking#readme)
+| Type | Bytes | Range |
+|---|---|---|
+| `"u8"` | 1 | 0–255 |
+| `"u16"` | 2 | 0–65,535 |
+| `"u32"` | 4 | 0–4,294,967,295 |
+| `"u64"` | 8 | 0–18,446,744,073,709,551,615 |
 
 ## License
 

package/dist/admin.d.ts

@@ -1,49 +1,34 @@
-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;
+    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[]): Promise<string>;
+    commitTickets(tenant: Address, ticketPdas: Address[]): Promise<string>;
     /**
-     * Fetch Queue account data
+     * High-level: full match resolution flow (runs on TEE).
+     * Reads the queue's pending matches, flushes them (updating opponent tickets),
+     * waits for TEE settlement, then commits all tickets back to L1.
+     * Use individual methods (flushMatches, commitTickets) as escape hatches if needed.
      */
-    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>;
+    resolveMatches(queue: Address, tenant: Address, ticketPdas: Address[], settlementDelayMs?: number): Promise<void>;
+    /** Create a new MatchmakingAdmin pointing at a TEE RPC endpoint. */
+    withRpc(teeUrl: string): MatchmakingAdmin;
 }

package/dist/admin.js

@@ -1,137 +1,116 @@
-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);
-    }
-    /**
-     * Fetch Tenant account data
-     */
-    async getTenant(tenantPda) {
-        return await this.program.account.tenant.fetch(tenantPda);
+        return fetchQueue(this.rpc, queuePda);
     }
-    /**
-     * 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) {
+        const ix = getFlushMatchesInstruction({
+            queue,
+            tenant,
+            signer: 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);
+    }
+    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);
     }
     /**
-     * Flush pending matches - crank instruction to update opponent tickets
-     * Can be called by any TEE-authenticated wallet (permissionless)
+     * High-level: full match resolution flow (runs on TEE).
+     * Reads the queue's pending matches, flushes them (updating opponent tickets),
+     * waits for TEE settlement, then commits all tickets back to L1.
+     * Use individual methods (flushMatches, commitTickets) as escape hatches if needed.
      */
-    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,
-            });
+    async resolveMatches(queue, tenant, ticketPdas, settlementDelayMs = 3000) {
+        const queueData = await this.getQueue(queue);
+        const pendingTicketPdas = await Promise.all(queueData.data.pendingMatches.map((pm) => utils.deriveTicketPda(this.programId, pm.player, tenant)));
+        if (pendingTicketPdas.length > 0) {
+            await this.flushMatches(queue, tenant, pendingTicketPdas);
+            await new Promise((r) => setTimeout(r, settlementDelayMs));
         }
-        return await this.program.methods
-            .flushMatches()
-            .accountsPartial({
-            queue: queue,
-            tenant: tenant,
-            signer: this.provider.publicKey,
-        })
-            .remainingAccounts(remainingAccounts)
-            .signers(signers)
-            .rpc(confirmOptions);
+        await this.commitTickets(tenant, ticketPdas);
     }
-    /**
-     * 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  ): Promise<string> {\n    const ix = getFlushMatchesInstruction({\n      queue,\n      tenant,\n      signer: 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  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  /**\n   * High-level: full match resolution flow (runs on TEE).\n   * Reads the queue's pending matches, flushes them (updating opponent tickets),\n   * waits for TEE settlement, then commits all tickets back to L1.\n   * Use individual methods (flushMatches, commitTickets) as escape hatches if needed.\n   */\n  async resolveMatches(\n    queue: Address,\n    tenant: Address,\n    ticketPdas: Address[],\n    settlementDelayMs = 3000,\n  ): Promise<void> {\n    const queueData = await this.getQueue(queue);\n    const pendingTicketPdas = await Promise.all(\n      queueData.data.pendingMatches.map((pm) =>\n        utils.deriveTicketPda(this.programId, pm.player, tenant),\n      ),\n    );\n\n    if (pendingTicketPdas.length > 0) {\n      await this.flushMatches(queue, tenant, pendingTicketPdas);\n      await new Promise((r) => setTimeout(r, settlementDelayMs));\n    }\n\n    await this.commitTickets(tenant, ticketPdas);\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"]}