@1upmonster/duel 0.1.8 → 0.2.2

package/dist/tee.js

@@ -0,0 +1,62 @@
+import { getBase58Decoder, createSignableMessage, } from "@solana/kit";
+/**
+ * Authenticate with the MagicBlock TEE via challenge-sign flow.
+ */
+export async function getAuthToken(rpcUrl, signer) {
+    const challengeRes = await fetch(`${rpcUrl}/auth/challenge?pubkey=${signer.address}`);
+    if (!challengeRes.ok) {
+        throw new Error(`TEE challenge failed: ${challengeRes.statusText}`);
+    }
+    const { challenge } = (await challengeRes.json());
+    const challengeBytes = new TextEncoder().encode(challenge);
+    const [sigDict] = await signer.signMessages([createSignableMessage(challengeBytes)]);
+    const signature = sigDict[signer.address];
+    const signatureString = getBase58Decoder().decode(signature);
+    const tokenRes = await fetch(`${rpcUrl}/auth/login`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+            pubkey: signer.address,
+            challenge,
+            signature: signatureString,
+        }),
+    });
+    const authJson = (await tokenRes.json());
+    if (tokenRes.status !== 200) {
+        throw new Error(`Failed to authenticate: ${authJson.error}`);
+    }
+    const expiresAt = authJson.expiresAt ?? Date.now() + 1000 * 60 * 60 * 24 * 30;
+    return { token: authJson.token, expiresAt };
+}
+/**
+ * Poll the TEE /permission endpoint until the given PDA has authorized users,
+ * indicating delegation is active. Returns false on timeout (does not throw).
+ */
+export async function waitUntilPermissionActive(teeUrlWithToken, pda, timeoutMs = 30000) {
+    // Parse URL: "https://host/path?token=xxx" -> baseUrl="https://host/path", tokenParam="token=xxx"
+    const [baseUrl, tokenParam] = teeUrlWithToken.replace("/?", "?").split("?");
+    let permissionUrl;
+    if (tokenParam) {
+        permissionUrl = `${baseUrl}/permission?${tokenParam}&pubkey=${pda}`;
+    }
+    else {
+        permissionUrl = `${baseUrl}/permission?pubkey=${pda}`;
+    }
+    const start = Date.now();
+    while (Date.now() - start < timeoutMs) {
+        try {
+            const res = await fetch(permissionUrl);
+            if (res.ok) {
+                const { authorizedUsers } = (await res.json());
+                if (authorizedUsers && authorizedUsers.length > 0)
+                    return true;
+            }
+        }
+        catch {
+            // ignore transient errors, keep polling
+        }
+        await new Promise((r) => setTimeout(r, 400));
+    }
+    return false;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/transaction.d.ts

@@ -0,0 +1,11 @@
+import { type Instruction, type SolanaRpcApi, type Rpc, type TransactionSigner } from "@solana/kit";
+type SolanaRpc = Rpc<SolanaRpcApi>;
+/**
+ * Build, sign with a Kit keypair signer, and send a single instruction.
+ */
+export declare function sendInstruction(rpc: SolanaRpc, instruction: Instruction, signer: TransactionSigner): Promise<string>;
+/**
+ * Build, sign, and send multiple instructions in a single transaction.
+ */
+export declare function sendInstructions(rpc: SolanaRpc, instructions: Instruction[], signer: TransactionSigner): Promise<string>;
+export {};

package/dist/transaction.js

@@ -0,0 +1,50 @@
+import { createTransactionMessage, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, appendTransactionMessageInstruction, appendTransactionMessageInstructions, signTransactionMessageWithSigners, getBase64EncodedWireTransaction, pipe, } from "@solana/kit";
+/**
+ * Build, sign with a Kit keypair signer, and send a single instruction.
+ */
+export async function sendInstruction(rpc, instruction, signer) {
+    const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const tx = pipe(createTransactionMessage({ version: 0 }), (m) => setTransactionMessageFeePayerSigner(signer, m), (m) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m), (m) => appendTransactionMessageInstruction(instruction, m));
+    const signedTx = await signTransactionMessageWithSigners(tx);
+    const encoded = getBase64EncodedWireTransaction(signedTx);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const sig = await rpc.sendTransaction(encoded, {
+        encoding: "base64",
+        skipPreflight: true,
+    }).send();
+    // Poll for status to detect runtime errors
+    for (let i = 0; i < 8; i++) {
+        await new Promise(r => setTimeout(r, 1000));
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const statuses = await rpc.getSignatureStatuses([sig], { searchTransactionHistory: false }).send().catch(() => null);
+        const status = statuses?.value?.[0];
+        if (status) {
+            if (status.err) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                console.error(`[TX] ${sig.slice(0, 16)}... FAILED:`, JSON.stringify(status.err, (_, v) => typeof v === 'bigint' ? v.toString() : v));
+            }
+            else if (status.confirmationStatus) {
+                console.log(`[TX] ${sig.slice(0, 16)}... ${status.confirmationStatus}`);
+            }
+            break;
+        }
+    }
+    return sig;
+}
+/**
+ * Build, sign, and send multiple instructions in a single transaction.
+ */
+export async function sendInstructions(rpc, instructions, signer) {
+    const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const tx = pipe(createTransactionMessage({ version: 0 }), (m) => setTransactionMessageFeePayerSigner(signer, m), (m) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m), (m) => appendTransactionMessageInstructions(instructions, m));
+    const signedTx = await signTransactionMessageWithSigners(tx);
+    const encoded = getBase64EncodedWireTransaction(signedTx);
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return rpc.sendTransaction(encoded, {
+        encoding: "base64",
+        skipPreflight: true,
+    }).send();
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/utils.d.ts

@@ -1,7 +1,7 @@
-import * as web3 from "@solana/web3.js";
+import { type Address } from "@solana/kit";
 export declare const QUEUE_SEED = "queue";
 export declare const TENANT_SEED = "tenant";
 export declare const TICKET_SEED = "ticket";
-export declare function deriveQueuePda(programId: web3.PublicKey, authority: web3.PublicKey): web3.PublicKey;
-export declare function deriveTenantPda(programId: web3.PublicKey, authority: web3.PublicKey): web3.PublicKey;
-export declare function deriveTicketPda(programId: web3.PublicKey, player: web3.PublicKey, tenant: web3.PublicKey): web3.PublicKey;
+export declare function deriveQueuePda(programId: Address, authority: Address): Promise<Address>;
+export declare function deriveTenantPda(programId: Address, authority: Address): Promise<Address>;
+export declare function deriveTicketPda(programId: Address, player: Address, tenant: Address): Promise<Address>;

package/dist/utils.js

@@ -1,17 +1,32 @@
-import * as web3 from "@solana/web3.js";
+import { getProgramDerivedAddress, getAddressEncoder, getUtf8Encoder, } from "@solana/kit";
+const addressEncoder = getAddressEncoder();
+const utf8Encoder = getUtf8Encoder();
 export const QUEUE_SEED = "queue";
 export const TENANT_SEED = "tenant";
 export const TICKET_SEED = "ticket";
-export function deriveQueuePda(programId, authority) {
-    const [pda] = web3.PublicKey.findProgramAddressSync([Buffer.from(QUEUE_SEED), authority.toBuffer()], programId);
+export async function deriveQueuePda(programId, authority) {
+    const [pda] = await getProgramDerivedAddress({
+        programAddress: programId,
+        seeds: [utf8Encoder.encode(QUEUE_SEED), addressEncoder.encode(authority)],
+    });
     return pda;
 }
-export function deriveTenantPda(programId, authority) {
-    const [pda] = web3.PublicKey.findProgramAddressSync([Buffer.from(TENANT_SEED), authority.toBuffer()], programId);
+export async function deriveTenantPda(programId, authority) {
+    const [pda] = await getProgramDerivedAddress({
+        programAddress: programId,
+        seeds: [utf8Encoder.encode(TENANT_SEED), addressEncoder.encode(authority)],
+    });
     return pda;
 }
-export function deriveTicketPda(programId, player, tenant) {
-    const [pda] = web3.PublicKey.findProgramAddressSync([Buffer.from(TICKET_SEED), player.toBuffer(), tenant.toBuffer()], programId);
+export async function deriveTicketPda(programId, player, tenant) {
+    const [pda] = await getProgramDerivedAddress({
+        programAddress: programId,
+        seeds: [
+            utf8Encoder.encode(TICKET_SEED),
+            addressEncoder.encode(player),
+            addressEncoder.encode(tenant),
+        ],
+    });
     return pda;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@1upmonster/duel",
-  "version": "0.1.8",
+  "version": "0.2.2",
   "type": "module",
   "description": "SDK for Private Matchmaking on Solana",
   "license": "MIT",
@@ -15,13 +15,10 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@coral-xyz/anchor": "^0.32.1",
-    "@magicblock-labs/ephemeral-rollups-sdk": "0.8.0",
-    "@solana/web3.js": "^1.95.3",
-    "bn.js": "^5.2.1"
+    "@solana/kit": "^6.1.0",
+    "@solana/program-client-core": "^6.1.0"
   },
   "devDependencies": {
-    "@types/bn.js": "^5.1.0",
     "@types/node": "^16.0.0",
     "typescript": "~5.7.0"
   }

package/src/admin.ts

@@ -1,211 +1,201 @@
-import * as anchor from "@coral-xyz/anchor";
-import { BN } from "bn.js";
-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 {
+  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";
-
-export type EloDataType = 'u8' | 'u16' | 'u32' | 'u64';
+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;
 }
 
 function getEloSize(dataType: EloDataType): number {
   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;
   }
 }
 
-export class MatchmakingAdmin {
-  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;
-  }
+const DUEL_PROGRAM_ID = "EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X" as Address;
 
-  // Derive PDAs Helpers
-  getQueuePda(authority: web3.PublicKey): web3.PublicKey {
-    return utils.deriveQueuePda(this.program.programId, authority);
+export class MatchmakingAdmin {
+  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;
   }
 
-  getTenantPda(authority: web3.PublicKey): web3.PublicKey {
-    return utils.deriveTenantPda(this.program.programId, authority);
+  async getQueuePda(authority: Address): Promise<Address> {
+    return utils.deriveQueuePda(this.programId, authority);
   }
 
-  getTicketPda(player: web3.PublicKey, tenant: web3.PublicKey): web3.PublicKey {
-    return utils.deriveTicketPda(this.program.programId, player, tenant);
+  async getTenantPda(authority: Address): Promise<Address> {
+    return utils.deriveTenantPda(this.programId, authority);
   }
 
-  /**
-   * Fetch Queue account data
-   */
-  async getQueue(queuePda: web3.PublicKey): Promise<any> {
-    return await this.program.account.queue.fetch(queuePda);
+  async getTicketPda(player: Address, tenant: Address): Promise<Address> {
+    return utils.deriveTicketPda(this.programId, player, tenant);
   }
 
-  /**
-   * Fetch Tenant account data
-   */
-  async getTenant(tenantPda: web3.PublicKey): Promise<any> {
-    return await this.program.account.tenant.fetch(tenantPda);
+  async getQueue(queuePda: Address) {
+    return fetchQueue(this.rpc, queuePda);
   }
 
-  /**
-   * Initialize a Tenant (with optional callback config)
-   */
   async initializeTenant(
-    tenantProgramId: web3.PublicKey,
+    tenantProgramId: Address,
     options?: InitializeTenantOptions,
-    confirmOptions?: web3.ConfirmOptions,
-    signers: web3.Keypair[] = []
-  ): Promise<web3.TransactionSignature> {
+  ): Promise<string> {
     const {
-      authority = tenantProgramId,
-      eloWindow = 100,
+      eloWindow = 100n,
       eloOffset = 40,
-      eloDataType = 'u16',
+      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: web3.PublicKey,
-    tenant: web3.PublicKey,
-    confirmOptions?: web3.ConfirmOptions,
-    signers: web3.Keypair[] = []
-  ): Promise<web3.TransactionSignature> {
-    const queuePda = this.getQueuePda(authority);
-    return await this.program.methods
-      .initializeQueue()
-      .accountsPartial({
-        queue: queuePda,
-        tenant: tenant,
-        authority: authority,
-      })
-      .signers(signers)
-      .rpc(confirmOptions);
+    _authority: Address,
+    tenant: Address,
+  ): Promise<string> {
+    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: web3.PublicKey,
-    validator: web3.PublicKey = new web3.PublicKey("FnE6VJT5QNZdedZPnCoLsARgBwoE6DeJNjBs2H1gySXA"),
-    confirmOptions?: web3.ConfirmOptions,
-    signers: web3.Keypair[] = []
-  ): Promise<web3.TransactionSignature> {
-      const queuePda = this.getQueuePda(authority);
-      return await this.program.methods
-        .delegateQueue({ queue: { authority } } as any)
-        .accounts({
-            pda: queuePda,
-            payer: authority,
-            validator: validator,
-        } as unknown as any)
-        .signers(signers)
-        .rpc(confirmOptions);
+    authority: Address,
+    validator?: Address,
+  ): Promise<string> {
+    const queuePda = await this.getQueuePda(authority);
+    const ix = await getDelegateQueueInstructionAsync({
+      pda: queuePda,
+      payer: this.signer,
+      validator,
+      accountType: accountType("Queue", { authority }),
+    }, { programAddress: this.programId });
+    return sendInstruction(this.rpc, ix, this.signer);
   }
 
-  /**
-   * Flush pending matches - crank instruction to update opponent tickets
-   * Can be called by any TEE-authenticated wallet (permissionless)
-   */
   async flushMatches(
-    queue: web3.PublicKey,
-    tenant: web3.PublicKey,
-    ticketPdas: web3.PublicKey[],
-    callbackProgram?: web3.PublicKey,
-    confirmOptions?: web3.ConfirmOptions,
-    signers: web3.Keypair[] = []
-  ): Promise<web3.TransactionSignature> {
-    const remainingAccounts = ticketPdas.map(pda => ({
-      pubkey: pda,
-      isSigner: false,
-      isWritable: true,
-    }));
-
-    if (callbackProgram) {
-      remainingAccounts.push({
-        pubkey: callbackProgram,
-        isSigner: false,
-        isWritable: false,
-      });
-    }
+    queue: Address,
+    tenant: Address,
+    ticketPdas: Address[],
+  ): Promise<string> {
+    const ix = getFlushMatchesInstruction({
+      queue,
+      tenant,
+      signer: this.signer,
+    }, { programAddress: this.programId });
+
+    const ixWithRemaining = {
+      ...ix,
+      accounts: [
+        ...ix.accounts,
+        ...ticketPdas.map((address) => ({ address, role: 1 as const })),
+      ],
+    };
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return sendInstruction(this.rpc, ixWithRemaining as any, this.signer);
+  }
 
-    return await this.program.methods
-      .flushMatches()
-      .accountsPartial({
-        queue: queue,
-        tenant: tenant,
-        signer: this.provider.publicKey,
-      })
-      .remainingAccounts(remainingAccounts)
-      .signers(signers)
-      .rpc(confirmOptions);
+  async commitTickets(
+    tenant: Address,
+    ticketPdas: Address[],
+  ): Promise<string> {
+    const ix = getCommitTicketsInstruction({
+      tenant,
+      payer: this.signer,
+    }, { programAddress: this.programId });
+
+    const ixWithRemaining = {
+      ...ix,
+      accounts: [
+        ...ix.accounts,
+        ...ticketPdas.map((address) => ({ address, role: 1 as const })),
+      ],
+    };
+
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return sendInstruction(this.rpc, ixWithRemaining as any, this.signer);
   }
 
   /**
-   * Commit matched tickets back to L1 (runs in TEE)
+   * 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 commitTickets(
-    tenant: web3.PublicKey,
-    ticketPdas: web3.PublicKey[],
-    confirmOptions?: web3.ConfirmOptions,
-    signers: web3.Keypair[] = []
-  ): Promise<web3.TransactionSignature> {
-    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);
+  async resolveMatches(
+    queue: Address,
+    tenant: Address,
+    ticketPdas: Address[],
+    settlementDelayMs = 3000,
+  ): Promise<void> {
+    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));
+    }
+
+    await this.commitTickets(tenant, ticketPdas);
+  }
+
+  /** Create a new MatchmakingAdmin pointing at a TEE RPC endpoint. */
+  withRpc(teeUrl: string): MatchmakingAdmin {
+    return new MatchmakingAdmin(createSolanaRpc(teeUrl), this.signer, this.programId);
   }
 }