@1upmonster/duel 0.1.7 → 0.2.1

package/dist/player.js

@@ -1,167 +1,87 @@
-import * as anchor from "@coral-xyz/anchor";
-import * as web3 from "@solana/web3.js";
-import { createRequire } from "module";
-const IDL = createRequire(import.meta.url)("./duel.json");
+import { createSolanaRpc, } from "@solana/kit";
+import { getCreateTicketInstructionAsync, getDelegateTicketInstructionAsync, getJoinQueueInstructionAsync, getCancelTicketInstructionAsync, getCloseTicketInstructionAsync, fetchMaybeMatchTicket, accountType, } from "./generated/duel/index.js";
+import { sendInstruction } from "./transaction.js";
 import * as utils from "./utils.js";
+const DUEL_PROGRAM_ID = "EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X";
 export class MatchmakingPlayer {
-    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 MatchTicket PDA
-     */
-    getTicketPda(player, tenant) {
-        return utils.deriveTicketPda(this.program.programId, player, tenant);
+    async getTicketPda(player, tenant) {
+        return utils.deriveTicketPda(this.programId, player, tenant);
     }
-    /**
-     * Fetch MatchTicket account data
-     */
     async getTicket(ticketPda) {
-        return await this.program.account.matchTicket.fetch(ticketPda);
+        return fetchMaybeMatchTicket(this.rpc, ticketPda);
     }
-    /**
-     * Create MatchTicket PDA on L1
-     */
-    async createTicket(tenant, confirmOptions, signers = []) {
-        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) {
+        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, tenant, validator = new web3.PublicKey("FnE6VJT5QNZdedZPnCoLsARgBwoE6DeJNjBs2H1gySXA"), confirmOptions, signers = []) {
-        const ticketPda = this.getTicketPda(player, tenant);
-        return await this.program.methods
-            .delegateTicket({ ticket: { player, tenant } })
-            .accounts({
+    async delegateTicket(player, tenant, validator) {
+        const ticketPda = await this.getTicketPda(player, tenant);
+        const ix = await getDelegateTicketInstructionAsync({
             pda: ticketPda,
-            payer: this.provider.publicKey,
-            validator: validator,
-        })
-            .signers(signers)
-            .rpc(confirmOptions);
+            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, tenant, playerData, confirmOptions, signers = []) {
-        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);
+    async joinQueue(queue, tenant, playerData) {
+        const ix = await getJoinQueueInstructionAsync({
+            queue,
+            tenant,
+            playerData,
+            signer: this.signer,
+        }, { programAddress: this.programId });
+        return sendInstruction(this.rpc, ix, this.signer);
     }
-    /**
-     * Cancel search, marks ticket as Cancelled (runs in TEE)
-     */
-    async cancelTicket(tenant, confirmOptions, signers = []) {
-        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);
+    async cancelTicket(tenant) {
+        const ix = await getCancelTicketInstructionAsync({
+            player: this.signer,
+            tenant,
+        }, { programAddress: this.programId });
+        return sendInstruction(this.rpc, ix, this.signer);
     }
-    /**
-     * Close ticket and reclaim rent (L1, after match consumed or cancelled)
-     */
-    async closeTicket(tenant, confirmOptions, signers = []) {
-        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);
-    }
-    /**
-     * Wait for match by subscribing to ticket PDA changes on L1.
-     * Returns match info when ticket status changes to Matched.
-     */
-    async waitForMatch(ticketPda, connection, timeoutMs = 120000) {
-        return new Promise((resolve, reject) => {
-            let subscriptionId = null;
-            let timeoutId = 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) => {
-                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) {
+        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, connection, maxAttempts = 60, pollInterval = 2000, signal) {
+    async pollForMatch(ticketPda, maxAttempts = 60, pollInterval = 2000, signal) {
         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)
+                const maybeTicket = await fetchMaybeMatchTicket(this.rpc, ticketPda);
+                if (!maybeTicket.exists)
                     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 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;
     }
+    /** Create a new MatchmakingPlayer pointing at a TEE RPC endpoint. */
+    withRpc(teeUrl) {
+        return new MatchmakingPlayer(createSolanaRpc(teeUrl), this.signer, this.programId);
+    }
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"player.js","sourceRoot":"","sources":["../src/player.ts"],"names":[],"mappings":"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","sourcesContent":["import * as anchor from \"@coral-xyz/anchor\";\nimport * as web3 from \"@solana/web3.js\";\nimport type { Duel } from \"./types.js\";\nimport { createRequire } from \"module\";\nconst IDL = createRequire(import.meta.url)(\"./duel.json\");\nimport * as utils from \"./utils.js\";\n\nexport class MatchmakingPlayer {\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  /**\n   * Derive MatchTicket PDA\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 MatchTicket account data\n   */\n  async getTicket(ticketPda: web3.PublicKey): Promise<any> {\n    return await this.program.account.matchTicket.fetch(ticketPda);\n  }\n\n  /**\n   * Create MatchTicket PDA on L1\n   */\n  async createTicket(\n    tenant: web3.PublicKey,\n    confirmOptions?: web3.ConfirmOptions,\n    signers: web3.Keypair[] = []\n  ): Promise<web3.TransactionSignature> {\n    const ticketPda = this.getTicketPda(this.provider.publicKey, tenant);\n    return await this.program.methods\n      .createTicket()\n      .accountsPartial({\n        ticket: ticketPda,\n        tenant: tenant,\n        player: this.provider.publicKey,\n      })\n      .signers(signers)\n      .rpc(confirmOptions);\n  }\n\n  /**\n   * Delegate ticket into TEE (becomes invisible on L1)\n   */\n  async delegateTicket(\n    player: web3.PublicKey,\n    tenant: web3.PublicKey,\n    validator: web3.PublicKey = new web3.PublicKey(\"FnE6VJT5QNZdedZPnCoLsARgBwoE6DeJNjBs2H1gySXA\"),\n    confirmOptions?: web3.ConfirmOptions,\n    signers: web3.Keypair[] = []\n  ): Promise<web3.TransactionSignature> {\n    const ticketPda = this.getTicketPda(player, tenant);\n    return await this.program.methods\n      .delegateTicket({ ticket: { player, tenant } } as any)\n      .accounts({\n        pda: ticketPda,\n        payer: this.provider.publicKey,\n        validator: validator,\n      } as any)\n      .signers(signers)\n      .rpc(confirmOptions);\n  }\n\n  /**\n   * Join Queue (TEE Aware) - now requires ticket\n   */\n  async joinQueue(\n    queue: web3.PublicKey,\n    tenant: web3.PublicKey,\n    playerData: web3.PublicKey,\n    confirmOptions?: web3.ConfirmOptions,\n    signers: web3.Keypair[] = []\n  ): Promise<web3.TransactionSignature> {\n    const ticketPda = this.getTicketPda(this.provider.publicKey, tenant);\n    return await this.program.methods\n      .joinQueue()\n      .accountsPartial({\n        queue: queue,\n        tenant: tenant,\n        playerData: playerData,\n        playerTicket: ticketPda,\n        signer: this.provider.publicKey,\n      })\n      .signers(signers)\n      .rpc(confirmOptions);\n  }\n\n  /**\n   * Cancel search, marks ticket as Cancelled (runs in TEE)\n   */\n  async cancelTicket(\n    tenant: web3.PublicKey,\n    confirmOptions?: web3.ConfirmOptions,\n    signers: web3.Keypair[] = []\n  ): Promise<web3.TransactionSignature> {\n    const ticketPda = this.getTicketPda(this.provider.publicKey, tenant);\n    return await this.program.methods\n      .cancelTicket()\n      .accountsPartial({\n        ticket: ticketPda,\n        tenant: tenant,\n        player: this.provider.publicKey,\n      })\n      .signers(signers)\n      .rpc(confirmOptions);\n  }\n\n  /**\n   * Close ticket and reclaim rent (L1, after match consumed or cancelled)\n   */\n  async closeTicket(\n    tenant: web3.PublicKey,\n    confirmOptions?: web3.ConfirmOptions,\n    signers: web3.Keypair[] = []\n  ): Promise<web3.TransactionSignature> {\n    const ticketPda = this.getTicketPda(this.provider.publicKey, tenant);\n    return await this.program.methods\n      .closeTicket()\n      .accountsPartial({\n        ticket: ticketPda,\n        tenant: tenant,\n        player: this.provider.publicKey,\n      })\n      .signers(signers)\n      .rpc(confirmOptions);\n  }\n\n  /**\n   * Wait for match by subscribing to ticket PDA changes on L1.\n   * Returns match info when ticket status changes to Matched.\n   */\n  async waitForMatch(\n    ticketPda: web3.PublicKey,\n    connection: web3.Connection,\n    timeoutMs: number = 120000\n  ): Promise<{ opponent: web3.PublicKey; matchId: anchor.BN } | null> {\n    return new Promise((resolve, reject) => {\n      let subscriptionId: number | null = null;\n      let timeoutId: ReturnType<typeof setTimeout> | null = null;\n\n      const cleanup = () => {\n        if (timeoutId) clearTimeout(timeoutId);\n        if (subscriptionId !== null) {\n          connection.removeAccountChangeListener(subscriptionId);\n        }\n      };\n\n      // Set timeout\n      timeoutId = setTimeout(() => {\n        cleanup();\n        resolve(null);\n      }, timeoutMs);\n\n      // Subscribe to account changes on L1\n      subscriptionId = connection.onAccountChange(\n        ticketPda,\n        (accountInfo: web3.AccountInfo<Buffer>) => {\n          try {\n            const decoded = this.program.coder.accounts.decode(\n              \"matchTicket\",\n              accountInfo.data\n            );\n            if (decoded.status.matched) {\n              cleanup();\n              resolve({\n                opponent: decoded.status.matched.opponent,\n                matchId: decoded.status.matched.matchId,\n              });\n            }\n          } catch (e) {\n            // Ignore decode errors (account may be in transition)\n          }\n        },\n        \"confirmed\"\n      );\n    });\n  }\n\n  /**\n   * Poll L1 for ticket status (fallback for environments without websocket)\n   */\n  async pollForMatch(\n    ticketPda: web3.PublicKey,\n    connection: web3.Connection,\n    maxAttempts: number = 60,\n    pollInterval: number = 2000,\n    signal?: AbortSignal\n  ): Promise<{ opponent: web3.PublicKey; matchId: anchor.BN } | null> {\n    for (let i = 0; i < maxAttempts; i++) {\n      if (signal?.aborted) return null;\n\n      await new Promise(resolve => setTimeout(resolve, pollInterval));\n\n      try {\n        const accountInfo = await connection.getAccountInfo(ticketPda);\n        if (!accountInfo) continue;\n\n        const decoded = this.program.coder.accounts.decode(\n          \"matchTicket\",\n          accountInfo.data\n        );\n\n        if (decoded.status.matched) {\n          return {\n            opponent: decoded.status.matched.opponent,\n            matchId: decoded.status.matched.matchId,\n          };\n        }\n      } catch (e) {\n        // Account may not exist yet or be in transition\n      }\n    }\n    return null;\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"player.js","sourceRoot":"","sources":["../src/player.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  getCreateTicketInstructionAsync,\n  getDelegateTicketInstructionAsync,\n  getJoinQueueInstructionAsync,\n  getCancelTicketInstructionAsync,\n  getCloseTicketInstructionAsync,\n  fetchMaybeMatchTicket,\n  accountType,\n} from \"./generated/duel/index.js\";\nimport { sendInstruction } from \"./transaction.js\";\nimport * as utils from \"./utils.js\";\n\nconst DUEL_PROGRAM_ID = \"EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X\" as Address;\n\nexport class MatchmakingPlayer {\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 getTicketPda(player: Address, tenant: Address): Promise<Address> {\n    return utils.deriveTicketPda(this.programId, player, tenant);\n  }\n\n  async getTicket(ticketPda: Address) {\n    return fetchMaybeMatchTicket(this.rpc, ticketPda);\n  }\n\n  async createTicket(tenant: Address): Promise<string> {\n    const ix = await getCreateTicketInstructionAsync({\n      player: this.signer,\n      tenant,\n    }, { programAddress: this.programId });\n    return sendInstruction(this.rpc, ix, this.signer);\n  }\n\n  async delegateTicket(\n    player: Address,\n    tenant: Address,\n    validator?: Address,\n  ): Promise<string> {\n    const ticketPda = await this.getTicketPda(player, tenant);\n    const ix = await getDelegateTicketInstructionAsync({\n      pda: ticketPda,\n      payer: this.signer,\n      validator,\n      accountType: accountType(\"Ticket\", { player, tenant }),\n    }, { programAddress: this.programId });\n    return sendInstruction(this.rpc, ix, this.signer);\n  }\n\n  async joinQueue(\n    queue: Address,\n    tenant: Address,\n    playerData: Address,\n  ): Promise<string> {\n    const ix = await getJoinQueueInstructionAsync({\n      queue,\n      tenant,\n      playerData,\n      signer: this.signer,\n    }, { programAddress: this.programId });\n    return sendInstruction(this.rpc, ix, this.signer);\n  }\n\n  async cancelTicket(tenant: Address): Promise<string> {\n    const ix = await getCancelTicketInstructionAsync({\n      player: this.signer,\n      tenant,\n    }, { programAddress: this.programId });\n    return sendInstruction(this.rpc, ix, this.signer);\n  }\n\n  async closeTicket(tenant: Address): Promise<string> {\n    const ix = await getCloseTicketInstructionAsync({\n      player: this.signer,\n      tenant,\n    }, { programAddress: this.programId });\n    return sendInstruction(this.rpc, ix, this.signer);\n  }\n\n  /**\n   * Poll L1 for ticket status.\n   * Returns match info when status becomes Matched.\n   */\n  async pollForMatch(\n    ticketPda: Address,\n    maxAttempts = 60,\n    pollInterval = 2000,\n    signal?: AbortSignal,\n  ): Promise<{ opponent: Address; matchId: bigint } | null> {\n    for (let i = 0; i < maxAttempts; i++) {\n      if (signal?.aborted) return null;\n      await new Promise((r) => setTimeout(r, pollInterval));\n      try {\n        const maybeTicket = await fetchMaybeMatchTicket(this.rpc, ticketPda);\n        if (!maybeTicket.exists) continue;\n        const status = maybeTicket.data.status;\n        if (status.__kind === \"Matched\") {\n          return { opponent: status.opponent, matchId: status.matchId };\n        }\n      } catch {\n        // Ignore decode errors during transition\n      }\n    }\n    return null;\n  }\n\n  /** Create a new MatchmakingPlayer pointing at a TEE RPC endpoint. */\n  withRpc(teeUrl: string): MatchmakingPlayer {\n    return new MatchmakingPlayer(createSolanaRpc(teeUrl), this.signer, this.programId);\n  }\n}\n"]}

package/dist/tee.d.ts

@@ -0,0 +1,14 @@
+import { type Address, type MessagePartialSigner } from "@solana/kit";
+export type { MessagePartialSigner as MessageSigner };
+/**
+ * Authenticate with the MagicBlock TEE via challenge-sign flow.
+ */
+export declare function getAuthToken(rpcUrl: string, signer: MessagePartialSigner): Promise<{
+    token: string;
+    expiresAt: number;
+}>;
+/**
+ * Poll the TEE /permission endpoint until the given PDA has authorized users,
+ * indicating delegation is active. Returns false on timeout (does not throw).
+ */
+export declare function waitUntilPermissionActive(teeUrlWithToken: string, pda: Address, timeoutMs?: number): Promise<boolean>;

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

package/package.json

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