@1upmonster/duel 0.2.2 → 0.2.3

package/dist/transaction.d.ts

@@ -2,10 +2,12 @@ import { type Instruction, type SolanaRpcApi, type Rpc, type TransactionSigner }
 type SolanaRpc = Rpc<SolanaRpcApi>;
 /**
  * Build, sign with a Kit keypair signer, and send a single instruction.
+ * Throws if the transaction is rejected or times out.
  */
 export declare function sendInstruction(rpc: SolanaRpc, instruction: Instruction, signer: TransactionSigner): Promise<string>;
 /**
  * Build, sign, and send multiple instructions in a single transaction.
+ * Throws if the transaction is rejected or times out.
  */
 export declare function sendInstructions(rpc: SolanaRpc, instructions: Instruction[], signer: TransactionSigner): Promise<string>;
 export {};

package/dist/transaction.js

@@ -1,6 +1,30 @@
 import { createTransactionMessage, setTransactionMessageFeePayerSigner, setTransactionMessageLifetimeUsingBlockhash, appendTransactionMessageInstruction, appendTransactionMessageInstructions, signTransactionMessageWithSigners, getBase64EncodedWireTransaction, pipe, } from "@solana/kit";
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const bigIntReplacer = (_, v) => typeof v === 'bigint' ? v.toString() : v;
+/**
+ * Poll for transaction confirmation and throw if it failed.
+ * This ensures callers always know immediately when a transaction is rejected.
+ */
+async function confirmTransaction(rpc, sig) {
+    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) {
+                throw new Error(`[TX] ${sig.slice(0, 16)}... FAILED: ${JSON.stringify(status.err, bigIntReplacer)}`);
+            }
+            console.log(`[TX] ${sig.slice(0, 16)}... ${status.confirmationStatus}`);
+            return;
+        }
+    }
+    // No status after 8s — treat as timeout rather than silently succeeding
+    throw new Error(`[TX] ${sig.slice(0, 16)}... confirmation timeout (no status after 8s)`);
+}
 /**
  * Build, sign with a Kit keypair signer, and send a single instruction.
+ * Throws if the transaction is rejected or times out.
  */
 export async function sendInstruction(rpc, instruction, signer) {
     const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
@@ -13,27 +37,12 @@ export async function sendInstruction(rpc, instruction, signer) {
         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;
-        }
-    }
+    await confirmTransaction(rpc, sig);
     return sig;
 }
 /**
  * Build, sign, and send multiple instructions in a single transaction.
+ * Throws if the transaction is rejected or times out.
  */
 export async function sendInstructions(rpc, instructions, signer) {
     const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
@@ -42,9 +51,11 @@ export async function sendInstructions(rpc, instructions, signer) {
     const signedTx = await signTransactionMessageWithSigners(tx);
     const encoded = getBase64EncodedWireTransaction(signedTx);
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return rpc.sendTransaction(encoded, {
+    const sig = await rpc.sendTransaction(encoded, {
         encoding: "base64",
         skipPreflight: true,
     }).send();
+    await confirmTransaction(rpc, sig);
+    return sig;
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"transaction.js","sourceRoot":"","sources":["../src/transaction.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  createTransactionMessage,\n  setTransactionMessageFeePayerSigner,\n  setTransactionMessageLifetimeUsingBlockhash,\n  appendTransactionMessageInstruction,\n  appendTransactionMessageInstructions,\n  signTransactionMessageWithSigners,\n  getBase64EncodedWireTransaction,\n  pipe,\n  type Instruction,\n  type SolanaRpcApi,\n  type Rpc,\n  type TransactionSigner,\n} from \"@solana/kit\";\n\ntype SolanaRpc = Rpc<SolanaRpcApi>;\n\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nconst bigIntReplacer = (_: string, v: unknown) => typeof v === 'bigint' ? v.toString() : v;\n\n/**\n * Poll for transaction confirmation and throw if it failed.\n * This ensures callers always know immediately when a transaction is rejected.\n */\nasync function confirmTransaction(rpc: SolanaRpc, sig: string): Promise<void> {\n  for (let i = 0; i < 8; i++) {\n    await new Promise(r => setTimeout(r, 1000));\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const statuses = await (rpc as any).getSignatureStatuses([sig], { searchTransactionHistory: false }).send().catch(() => null);\n    const status = statuses?.value?.[0];\n    if (status) {\n      if (status.err) {\n        throw new Error(`[TX] ${sig.slice(0, 16)}... FAILED: ${JSON.stringify(status.err, bigIntReplacer)}`);\n      }\n      console.log(`[TX] ${sig.slice(0, 16)}... ${status.confirmationStatus}`);\n      return;\n    }\n  }\n  // No status after 8s — treat as timeout rather than silently succeeding\n  throw new Error(`[TX] ${sig.slice(0, 16)}... confirmation timeout (no status after 8s)`);\n}\n\n/**\n * Build, sign with a Kit keypair signer, and send a single instruction.\n * Throws if the transaction is rejected or times out.\n */\nexport async function sendInstruction(\n  rpc: SolanaRpc,\n  instruction: Instruction,\n  signer: TransactionSigner,\n): Promise<string> {\n  const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const tx: any = pipe(\n    createTransactionMessage({ version: 0 as const }),\n    (m) => setTransactionMessageFeePayerSigner(signer, m),\n    (m) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m),\n    (m) => appendTransactionMessageInstruction(instruction, m),\n  );\n\n  const signedTx = await signTransactionMessageWithSigners(tx);\n  const encoded = getBase64EncodedWireTransaction(signedTx);\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const sig = await (rpc.sendTransaction(encoded as any, {\n    encoding: \"base64\",\n    skipPreflight: true,\n  }).send() as Promise<string>);\n\n  await confirmTransaction(rpc, sig);\n  return sig;\n}\n\n/**\n * Build, sign, and send multiple instructions in a single transaction.\n * Throws if the transaction is rejected or times out.\n */\nexport async function sendInstructions(\n  rpc: SolanaRpc,\n  instructions: Instruction[],\n  signer: TransactionSigner,\n): Promise<string> {\n  const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const tx: any = pipe(\n    createTransactionMessage({ version: 0 as const }),\n    (m) => setTransactionMessageFeePayerSigner(signer, m),\n    (m) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, m),\n    (m) => appendTransactionMessageInstructions(instructions, m),\n  );\n\n  const signedTx = await signTransactionMessageWithSigners(tx);\n  const encoded = getBase64EncodedWireTransaction(signedTx);\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  const sig = await (rpc.sendTransaction(encoded as any, {\n    encoding: \"base64\",\n    skipPreflight: true,\n  }).send() as Promise<string>);\n\n  await confirmTransaction(rpc, sig);\n  return sig;\n}\n"]}

package/dist/utils.d.ts

@@ -1,4 +1,14 @@
 import { type Address } from "@solana/kit";
+export declare const PERMISSION_PROGRAM: Address;
+export declare const DELEGATION_PROGRAM: Address;
+/** Derives the Permission PDA for a given permissioned account. */
+export declare function derivePermissionPda(accountAddress: Address): Promise<Address>;
+/** Derives the DELeGG delegation PDAs for the Permission PDA (used in DelegatePermission ix). */
+export declare function derivePermissionDelegationPdas(permissionPda: Address): Promise<{
+    delegationBuffer: Address;
+    delegationRecord: Address;
+    delegationMetadata: Address;
+}>;
 export declare const QUEUE_SEED = "queue";
 export declare const TENANT_SEED = "tenant";
 export declare const TICKET_SEED = "ticket";

package/dist/utils.js

@@ -1,6 +1,33 @@
 import { getProgramDerivedAddress, getAddressEncoder, getUtf8Encoder, } from "@solana/kit";
 const addressEncoder = getAddressEncoder();
 const utf8Encoder = getUtf8Encoder();
+export const PERMISSION_PROGRAM = "ACLseoPoyC3cBqoUtkbjZ4aDrkurZW86v19pXz2XQnp1";
+export const DELEGATION_PROGRAM = "DELeGGvXpWV2fqJUhqcF5ZSYMS4JTLjteaAMARRSaeSh";
+/** Derives the Permission PDA for a given permissioned account. */
+export async function derivePermissionPda(accountAddress) {
+    const [pda] = await getProgramDerivedAddress({
+        programAddress: PERMISSION_PROGRAM,
+        seeds: [utf8Encoder.encode("permission:"), addressEncoder.encode(accountAddress)],
+    });
+    return pda;
+}
+/** Derives the DELeGG delegation PDAs for the Permission PDA (used in DelegatePermission ix). */
+export async function derivePermissionDelegationPdas(permissionPda) {
+    const [delegationRecord] = await getProgramDerivedAddress({
+        programAddress: DELEGATION_PROGRAM,
+        seeds: [utf8Encoder.encode("delegation"), addressEncoder.encode(permissionPda)],
+    });
+    const [delegationMetadata] = await getProgramDerivedAddress({
+        programAddress: DELEGATION_PROGRAM,
+        seeds: [utf8Encoder.encode("delegation-metadata"), addressEncoder.encode(permissionPda)],
+    });
+    // Buffer PDA is under the ownerProgram (PERMISSION_PROGRAM for the Permission PDA)
+    const [delegationBuffer] = await getProgramDerivedAddress({
+        programAddress: PERMISSION_PROGRAM,
+        seeds: [utf8Encoder.encode("buffer"), addressEncoder.encode(permissionPda)],
+    });
+    return { delegationBuffer, delegationRecord, delegationMetadata };
+}
 export const QUEUE_SEED = "queue";
 export const TENANT_SEED = "tenant";
 export const TICKET_SEED = "ticket";
@@ -29,4 +56,4 @@ export async function deriveTicketPda(programId, player, 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.2.2",
+  "version": "0.2.3",
   "type": "module",
   "description": "SDK for Private Matchmaking on Solana",
   "license": "MIT",

package/src/admin.ts

@@ -1,14 +1,17 @@
 import {
   createSolanaRpc,
+  AccountRole,
   type Address,
   type TransactionSigner,
   type Rpc,
   type SolanaRpcApi,
+  type Instruction,
 } from "@solana/kit";
 import {
   getInitializeTenantInstructionAsync,
   getInitializeQueueInstructionAsync,
   getDelegateQueueInstructionAsync,
+  getSetupQueuePermissionInstructionAsync,
   getFlushMatchesInstruction,
   getCommitTicketsInstruction,
   fetchQueue,
@@ -114,6 +117,39 @@ export class MatchmakingAdmin {
     validator?: Address,
   ): Promise<string> {
     const queuePda = await this.getQueuePda(authority);
+
+    // 1. Create Permission PDA for the queue (CPI from duel program with invoke_signed)
+    const permissionPda = await utils.derivePermissionPda(queuePda);
+    const setupIx = await getSetupQueuePermissionInstructionAsync({
+      authority: this.signer,
+      permission: permissionPda,
+      permissionProgram: utils.PERMISSION_PROGRAM,
+    }, { programAddress: this.programId });
+    await sendInstruction(this.rpc, setupIx, this.signer);
+
+    // 2. Delegate Permission PDA to TEE (called on permission program, authority signs)
+    const { delegationBuffer, delegationRecord, delegationMetadata } =
+      await utils.derivePermissionDelegationPdas(permissionPda);
+    const delegatePermIx: Instruction = {
+      programAddress: utils.PERMISSION_PROGRAM,
+      data: new Uint8Array([3, 0, 0, 0, 0, 0, 0, 0]), // discriminator = 3 (DelegatePermission)
+      accounts: [
+        { address: this.signer.address, role: AccountRole.WRITABLE_SIGNER },           // payer
+        { address: this.signer.address, role: AccountRole.READONLY_SIGNER },            // authority
+        { address: queuePda, role: AccountRole.READONLY },                              // permissionedAccount (not signer)
+        { address: permissionPda, role: AccountRole.WRITABLE },                         // permission PDA
+        { address: "11111111111111111111111111111111" as Address, role: AccountRole.READONLY }, // system_program
+        { address: utils.PERMISSION_PROGRAM, role: AccountRole.READONLY },              // owner_program
+        { address: delegationBuffer, role: AccountRole.WRITABLE },
+        { address: delegationRecord, role: AccountRole.WRITABLE },
+        { address: delegationMetadata, role: AccountRole.WRITABLE },
+        { address: utils.DELEGATION_PROGRAM, role: AccountRole.READONLY },
+        ...(validator ? [{ address: validator, role: AccountRole.READONLY }] : []),
+      ],
+    };
+    await sendInstruction(this.rpc, delegatePermIx, this.signer);
+
+    // 3. Delegate queue PDA to TEE (existing DELeGG flow)
     const ix = await getDelegateQueueInstructionAsync({
       pda: queuePda,
       payer: this.signer,

package/src/duel.json

@@ -832,6 +832,63 @@
         }
       ]
     },
+    {
+      "name": "setup_queue_permission",
+      "docs": [
+        "Set up permission for queue PDA so only the authority can read it on TEE.",
+        "Must be called BEFORE delegate_queue while the program still owns the PDA."
+      ],
+      "discriminator": [
+        223,
+        132,
+        77,
+        15,
+        224,
+        155,
+        125,
+        224
+      ],
+      "accounts": [
+        {
+          "name": "queue",
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  113,
+                  117,
+                  101,
+                  117,
+                  101
+                ]
+              },
+              {
+                "kind": "account",
+                "path": "authority"
+              }
+            ]
+          }
+        },
+        {
+          "name": "authority",
+          "writable": true,
+          "signer": true
+        },
+        {
+          "name": "permission",
+          "writable": true
+        },
+        {
+          "name": "permission_program"
+        },
+        {
+          "name": "system_program",
+          "address": "11111111111111111111111111111111"
+        }
+      ],
+      "args": []
+    },
     {
       "name": "setup_ticket_permission",
       "docs": [

package/src/generated/duel/instructions/delegateQueue.ts

@@ -65,10 +65,10 @@ if (!accounts.bufferPda.value) {
 accounts.bufferPda.value = await getProgramDerivedAddress({ programAddress: 'EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X' as Address<'EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X'>, seeds: [getBytesEncoder().encode(new Uint8Array([98, 117, 102, 102, 101, 114])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("pda", accounts.pda.value))] });
 }
 if (!accounts.delegationRecordPda.value) {
-accounts.delegationRecordPda.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([100, 101, 108, 101, 103, 97, 116, 105, 111, 110])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("pda", accounts.pda.value))] });
+accounts.delegationRecordPda.value = await getProgramDerivedAddress({ programAddress: 'DELeGGvXpWV2fqJUhqcF5ZSYMS4JTLjteaAMARRSaeSh' as Address<'DELeGGvXpWV2fqJUhqcF5ZSYMS4JTLjteaAMARRSaeSh'>, seeds: [getBytesEncoder().encode(new Uint8Array([100, 101, 108, 101, 103, 97, 116, 105, 111, 110])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("pda", accounts.pda.value))] });
 }
 if (!accounts.delegationMetadataPda.value) {
-accounts.delegationMetadataPda.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([100, 101, 108, 101, 103, 97, 116, 105, 111, 110, 45, 109, 101, 116, 97, 100, 97, 116, 97])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("pda", accounts.pda.value))] });
+accounts.delegationMetadataPda.value = await getProgramDerivedAddress({ programAddress: 'DELeGGvXpWV2fqJUhqcF5ZSYMS4JTLjteaAMARRSaeSh' as Address<'DELeGGvXpWV2fqJUhqcF5ZSYMS4JTLjteaAMARRSaeSh'>, seeds: [getBytesEncoder().encode(new Uint8Array([100, 101, 108, 101, 103, 97, 116, 105, 111, 110, 45, 109, 101, 116, 97, 100, 97, 116, 97])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("pda", accounts.pda.value))] });
 }
 if (!accounts.ownerProgram.value) {
 accounts.ownerProgram.value = 'EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X' as Address<'EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X'>;

package/src/generated/duel/instructions/delegateTicket.ts

@@ -65,10 +65,10 @@ if (!accounts.bufferPda.value) {
 accounts.bufferPda.value = await getProgramDerivedAddress({ programAddress: 'EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X' as Address<'EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X'>, seeds: [getBytesEncoder().encode(new Uint8Array([98, 117, 102, 102, 101, 114])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("pda", accounts.pda.value))] });
 }
 if (!accounts.delegationRecordPda.value) {
-accounts.delegationRecordPda.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([100, 101, 108, 101, 103, 97, 116, 105, 111, 110])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("pda", accounts.pda.value))] });
+accounts.delegationRecordPda.value = await getProgramDerivedAddress({ programAddress: 'DELeGGvXpWV2fqJUhqcF5ZSYMS4JTLjteaAMARRSaeSh' as Address<'DELeGGvXpWV2fqJUhqcF5ZSYMS4JTLjteaAMARRSaeSh'>, seeds: [getBytesEncoder().encode(new Uint8Array([100, 101, 108, 101, 103, 97, 116, 105, 111, 110])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("pda", accounts.pda.value))] });
 }
 if (!accounts.delegationMetadataPda.value) {
-accounts.delegationMetadataPda.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([100, 101, 108, 101, 103, 97, 116, 105, 111, 110, 45, 109, 101, 116, 97, 100, 97, 116, 97])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("pda", accounts.pda.value))] });
+accounts.delegationMetadataPda.value = await getProgramDerivedAddress({ programAddress: 'DELeGGvXpWV2fqJUhqcF5ZSYMS4JTLjteaAMARRSaeSh' as Address<'DELeGGvXpWV2fqJUhqcF5ZSYMS4JTLjteaAMARRSaeSh'>, seeds: [getBytesEncoder().encode(new Uint8Array([100, 101, 108, 101, 103, 97, 116, 105, 111, 110, 45, 109, 101, 116, 97, 100, 97, 116, 97])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("pda", accounts.pda.value))] });
 }
 if (!accounts.ownerProgram.value) {
 accounts.ownerProgram.value = 'EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X' as Address<'EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X'>;

package/src/generated/duel/instructions/index.ts

@@ -17,4 +17,5 @@ export * from './initializeQueue';
 export * from './initializeTenant';
 export * from './joinQueue';
 export * from './processUndelegation';
+export * from './setupQueuePermission';
 export * from './setupTicketPermission';

package/src/generated/duel/instructions/setupQueuePermission.ts

@@ -0,0 +1,112 @@
+/**
+ * This code was AUTOGENERATED using the Codama library.
+ * Please DO NOT EDIT THIS FILE, instead use visitors
+ * to add features, then rerun Codama to update it.
+ *
+ * @see https://github.com/codama-idl/codama
+ */
+
+import { combineCodec, fixDecoderSize, fixEncoderSize, getAddressEncoder, getBytesDecoder, getBytesEncoder, getProgramDerivedAddress, getStructDecoder, getStructEncoder, SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, SolanaError, transformEncoder, type AccountMeta, type AccountSignerMeta, type Address, type FixedSizeCodec, type FixedSizeDecoder, type FixedSizeEncoder, type Instruction, type InstructionWithAccounts, type InstructionWithData, type ReadonlyAccount, type ReadonlyUint8Array, type TransactionSigner, type WritableAccount, type WritableSignerAccount } from '@solana/kit';
+import { getAccountMetaFactory, getAddressFromResolvedInstructionAccount, type ResolvedInstructionAccount } from '@solana/program-client-core';
+import { DUEL_PROGRAM_ADDRESS } from '../programs';
+
+export const SETUP_QUEUE_PERMISSION_DISCRIMINATOR = new Uint8Array([223, 132, 77, 15, 224, 155, 125, 224]);
+
+export function getSetupQueuePermissionDiscriminatorBytes() { return fixEncoderSize(getBytesEncoder(), 8).encode(SETUP_QUEUE_PERMISSION_DISCRIMINATOR); }
+
+export type SetupQueuePermissionInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountQueue extends string | AccountMeta<string> = string, TAccountAuthority extends string | AccountMeta<string> = string, TAccountPermission extends string | AccountMeta<string> = string, TAccountPermissionProgram extends string | AccountMeta<string> = string, TAccountSystemProgram extends string | AccountMeta<string> = "11111111111111111111111111111111", TRemainingAccounts extends readonly AccountMeta<string>[] = []> =
+Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array> & InstructionWithAccounts<[TAccountQueue extends string ? ReadonlyAccount<TAccountQueue> : TAccountQueue, TAccountAuthority extends string ? WritableSignerAccount<TAccountAuthority> & AccountSignerMeta<TAccountAuthority> : TAccountAuthority, TAccountPermission extends string ? WritableAccount<TAccountPermission> : TAccountPermission, TAccountPermissionProgram extends string ? ReadonlyAccount<TAccountPermissionProgram> : TAccountPermissionProgram, TAccountSystemProgram extends string ? ReadonlyAccount<TAccountSystemProgram> : TAccountSystemProgram, ...TRemainingAccounts]>;
+
+export type SetupQueuePermissionInstructionData = { discriminator: ReadonlyUint8Array;  };
+
+export type SetupQueuePermissionInstructionDataArgs = {  };
+
+export function getSetupQueuePermissionInstructionDataEncoder(): FixedSizeEncoder<SetupQueuePermissionInstructionDataArgs> {
+    return transformEncoder(getStructEncoder([['discriminator', fixEncoderSize(getBytesEncoder(), 8)]]), (value) => ({ ...value, discriminator: SETUP_QUEUE_PERMISSION_DISCRIMINATOR }));
+}
+
+export function getSetupQueuePermissionInstructionDataDecoder(): FixedSizeDecoder<SetupQueuePermissionInstructionData> {
+    return getStructDecoder([['discriminator', fixDecoderSize(getBytesDecoder(), 8)]]);
+}
+
+export function getSetupQueuePermissionInstructionDataCodec(): FixedSizeCodec<SetupQueuePermissionInstructionDataArgs, SetupQueuePermissionInstructionData> {
+    return combineCodec(getSetupQueuePermissionInstructionDataEncoder(), getSetupQueuePermissionInstructionDataDecoder());
+}
+
+export type SetupQueuePermissionAsyncInput<TAccountQueue extends string = string, TAccountAuthority extends string = string, TAccountPermission extends string = string, TAccountPermissionProgram extends string = string, TAccountSystemProgram extends string = string> =  {
+  queue?: Address<TAccountQueue>;
+authority: TransactionSigner<TAccountAuthority>;
+permission: Address<TAccountPermission>;
+permissionProgram: Address<TAccountPermissionProgram>;
+systemProgram?: Address<TAccountSystemProgram>;
+}
+
+export async function getSetupQueuePermissionInstructionAsync<TAccountQueue extends string, TAccountAuthority extends string, TAccountPermission extends string, TAccountPermissionProgram extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: SetupQueuePermissionAsyncInput<TAccountQueue, TAccountAuthority, TAccountPermission, TAccountPermissionProgram, TAccountSystemProgram>, config?: { programAddress?: TProgramAddress } ): Promise<SetupQueuePermissionInstruction<TProgramAddress, TAccountQueue, TAccountAuthority, TAccountPermission, TAccountPermissionProgram, TAccountSystemProgram>> {
+  // Program address.
+const programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;
+
+ // Original accounts.
+const originalAccounts = { queue: { value: input.queue ?? null, isWritable: false }, authority: { value: input.authority ?? null, isWritable: true }, permission: { value: input.permission ?? null, isWritable: true }, permissionProgram: { value: input.permissionProgram ?? null, isWritable: false }, systemProgram: { value: input.systemProgram ?? null, isWritable: false } }
+const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+
+// Resolve default values.
+if (!accounts.queue.value) {
+accounts.queue.value = await getProgramDerivedAddress({ programAddress, seeds: [getBytesEncoder().encode(new Uint8Array([113, 117, 101, 117, 101])), getAddressEncoder().encode(getAddressFromResolvedInstructionAccount("authority", accounts.authority.value))] });
+}
+if (!accounts.systemProgram.value) {
+accounts.systemProgram.value = '11111111111111111111111111111111' as Address<'11111111111111111111111111111111'>;
+}
+
+const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+return Object.freeze({ accounts: [getAccountMeta("queue", accounts.queue), getAccountMeta("authority", accounts.authority), getAccountMeta("permission", accounts.permission), getAccountMeta("permissionProgram", accounts.permissionProgram), getAccountMeta("systemProgram", accounts.systemProgram)], data: getSetupQueuePermissionInstructionDataEncoder().encode({}), programAddress } as SetupQueuePermissionInstruction<TProgramAddress, TAccountQueue, TAccountAuthority, TAccountPermission, TAccountPermissionProgram, TAccountSystemProgram>);
+}
+
+export type SetupQueuePermissionInput<TAccountQueue extends string = string, TAccountAuthority extends string = string, TAccountPermission extends string = string, TAccountPermissionProgram extends string = string, TAccountSystemProgram extends string = string> =  {
+  queue: Address<TAccountQueue>;
+authority: TransactionSigner<TAccountAuthority>;
+permission: Address<TAccountPermission>;
+permissionProgram: Address<TAccountPermissionProgram>;
+systemProgram?: Address<TAccountSystemProgram>;
+}
+
+export function getSetupQueuePermissionInstruction<TAccountQueue extends string, TAccountAuthority extends string, TAccountPermission extends string, TAccountPermissionProgram extends string, TAccountSystemProgram extends string, TProgramAddress extends Address = typeof DUEL_PROGRAM_ADDRESS>(input: SetupQueuePermissionInput<TAccountQueue, TAccountAuthority, TAccountPermission, TAccountPermissionProgram, TAccountSystemProgram>, config?: { programAddress?: TProgramAddress } ): SetupQueuePermissionInstruction<TProgramAddress, TAccountQueue, TAccountAuthority, TAccountPermission, TAccountPermissionProgram, TAccountSystemProgram> {
+  // Program address.
+const programAddress = config?.programAddress ?? DUEL_PROGRAM_ADDRESS;
+
+ // Original accounts.
+const originalAccounts = { queue: { value: input.queue ?? null, isWritable: false }, authority: { value: input.authority ?? null, isWritable: true }, permission: { value: input.permission ?? null, isWritable: true }, permissionProgram: { value: input.permissionProgram ?? null, isWritable: false }, systemProgram: { value: input.systemProgram ?? null, isWritable: false } }
+const accounts = originalAccounts as Record<keyof typeof originalAccounts, ResolvedInstructionAccount>;
+
+
+// Resolve default values.
+if (!accounts.systemProgram.value) {
+accounts.systemProgram.value = '11111111111111111111111111111111' as Address<'11111111111111111111111111111111'>;
+}
+
+const getAccountMeta = getAccountMetaFactory(programAddress, 'programId');
+return Object.freeze({ accounts: [getAccountMeta("queue", accounts.queue), getAccountMeta("authority", accounts.authority), getAccountMeta("permission", accounts.permission), getAccountMeta("permissionProgram", accounts.permissionProgram), getAccountMeta("systemProgram", accounts.systemProgram)], data: getSetupQueuePermissionInstructionDataEncoder().encode({}), programAddress } as SetupQueuePermissionInstruction<TProgramAddress, TAccountQueue, TAccountAuthority, TAccountPermission, TAccountPermissionProgram, TAccountSystemProgram>);
+}
+
+export type ParsedSetupQueuePermissionInstruction<TProgram extends string = typeof DUEL_PROGRAM_ADDRESS, TAccountMetas extends readonly AccountMeta[] = readonly AccountMeta[]> = { programAddress: Address<TProgram>;
+accounts: {
+queue: TAccountMetas[0];
+authority: TAccountMetas[1];
+permission: TAccountMetas[2];
+permissionProgram: TAccountMetas[3];
+systemProgram: TAccountMetas[4];
+};
+data: SetupQueuePermissionInstructionData; };
+
+export function parseSetupQueuePermissionInstruction<TProgram extends string, TAccountMetas extends readonly AccountMeta[]>(instruction: Instruction<TProgram> & InstructionWithAccounts<TAccountMetas> & InstructionWithData<ReadonlyUint8Array>): ParsedSetupQueuePermissionInstruction<TProgram, TAccountMetas> {
+  if (instruction.accounts.length < 5) {
+  throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__INSUFFICIENT_ACCOUNT_METAS, { actualAccountMetas: instruction.accounts.length, expectedAccountMetas: 5 });
+}
+let accountIndex = 0;
+const getNextAccount = () => {
+  const accountMeta = (instruction.accounts as TAccountMetas)[accountIndex]!;
+  accountIndex += 1;
+  return accountMeta;
+}
+  return { programAddress: instruction.programAddress, accounts: { queue: getNextAccount(), authority: getNextAccount(), permission: getNextAccount(), permissionProgram: getNextAccount(), systemProgram: getNextAccount() }, data: getSetupQueuePermissionInstructionDataDecoder().decode(instruction.data) };
+}

package/src/generated/duel/programs/duel.ts

@@ -9,7 +9,7 @@
 import { assertIsInstructionWithAccounts, containsBytes, fixEncoderSize, getBytesEncoder, SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT, SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, SolanaError, type Address, type ClientWithPayer, type ClientWithRpc, type ClientWithTransactionPlanning, type ClientWithTransactionSending, type GetAccountInfoApi, type GetMultipleAccountsApi, type Instruction, type InstructionWithData, type ReadonlyUint8Array } from '@solana/kit';
 import { addSelfFetchFunctions, addSelfPlanAndSendFunctions, type SelfFetchFunctions, type SelfPlanAndSendFunctions } from '@solana/program-client-core';
 import { getMatchTicketCodec, getQueueCodec, getTenantCodec, type MatchTicket, type MatchTicketArgs, type Queue, type QueueArgs, type Tenant, type TenantArgs } from '../accounts';
-import { getCancelTicketInstructionAsync, getCloseTicketInstructionAsync, getCommitTicketsInstruction, getCreateTicketInstructionAsync, getDelegateQueueInstructionAsync, getDelegateTicketInstructionAsync, getFlushMatchesInstruction, getInitializeQueueInstructionAsync, getInitializeTenantInstructionAsync, getJoinQueueInstructionAsync, getProcessUndelegationInstruction, getSetupTicketPermissionInstructionAsync, parseCancelTicketInstruction, parseCloseTicketInstruction, parseCommitTicketsInstruction, parseCreateTicketInstruction, parseDelegateQueueInstruction, parseDelegateTicketInstruction, parseFlushMatchesInstruction, parseInitializeQueueInstruction, parseInitializeTenantInstruction, parseJoinQueueInstruction, parseProcessUndelegationInstruction, parseSetupTicketPermissionInstruction, type CancelTicketAsyncInput, type CloseTicketAsyncInput, type CommitTicketsInput, type CreateTicketAsyncInput, type DelegateQueueAsyncInput, type DelegateTicketAsyncInput, type FlushMatchesInput, type InitializeQueueAsyncInput, type InitializeTenantAsyncInput, type JoinQueueAsyncInput, type ParsedCancelTicketInstruction, type ParsedCloseTicketInstruction, type ParsedCommitTicketsInstruction, type ParsedCreateTicketInstruction, type ParsedDelegateQueueInstruction, type ParsedDelegateTicketInstruction, type ParsedFlushMatchesInstruction, type ParsedInitializeQueueInstruction, type ParsedInitializeTenantInstruction, type ParsedJoinQueueInstruction, type ParsedProcessUndelegationInstruction, type ParsedSetupTicketPermissionInstruction, type ProcessUndelegationInput, type SetupTicketPermissionAsyncInput } from '../instructions';
+import { getCancelTicketInstructionAsync, getCloseTicketInstructionAsync, getCommitTicketsInstruction, getCreateTicketInstructionAsync, getDelegateQueueInstructionAsync, getDelegateTicketInstructionAsync, getFlushMatchesInstruction, getInitializeQueueInstructionAsync, getInitializeTenantInstructionAsync, getJoinQueueInstructionAsync, getProcessUndelegationInstruction, getSetupQueuePermissionInstructionAsync, getSetupTicketPermissionInstructionAsync, parseCancelTicketInstruction, parseCloseTicketInstruction, parseCommitTicketsInstruction, parseCreateTicketInstruction, parseDelegateQueueInstruction, parseDelegateTicketInstruction, parseFlushMatchesInstruction, parseInitializeQueueInstruction, parseInitializeTenantInstruction, parseJoinQueueInstruction, parseProcessUndelegationInstruction, parseSetupQueuePermissionInstruction, parseSetupTicketPermissionInstruction, type CancelTicketAsyncInput, type CloseTicketAsyncInput, type CommitTicketsInput, type CreateTicketAsyncInput, type DelegateQueueAsyncInput, type DelegateTicketAsyncInput, type FlushMatchesInput, type InitializeQueueAsyncInput, type InitializeTenantAsyncInput, type JoinQueueAsyncInput, type ParsedCancelTicketInstruction, type ParsedCloseTicketInstruction, type ParsedCommitTicketsInstruction, type ParsedCreateTicketInstruction, type ParsedDelegateQueueInstruction, type ParsedDelegateTicketInstruction, type ParsedFlushMatchesInstruction, type ParsedInitializeQueueInstruction, type ParsedInitializeTenantInstruction, type ParsedJoinQueueInstruction, type ParsedProcessUndelegationInstruction, type ParsedSetupQueuePermissionInstruction, type ParsedSetupTicketPermissionInstruction, type ProcessUndelegationInput, type SetupQueuePermissionAsyncInput, type SetupTicketPermissionAsyncInput } from '../instructions';
 
 export const DUEL_PROGRAM_ADDRESS = 'EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X' as Address<'EdZzUwKd1X2ZWjxLPpz1cpEzMF7RUZC43Pq64v1VcK5X'>;
 
@@ -23,7 +23,7 @@ if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Arr
     throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT, { accountData: data, programName: "duel" });
 }
 
-export enum DuelInstruction { CancelTicket, CloseTicket, CommitTickets, CreateTicket, DelegateQueue, DelegateTicket, FlushMatches, InitializeQueue, InitializeTenant, JoinQueue, ProcessUndelegation, SetupTicketPermission }
+export enum DuelInstruction { CancelTicket, CloseTicket, CommitTickets, CreateTicket, DelegateQueue, DelegateTicket, FlushMatches, InitializeQueue, InitializeTenant, JoinQueue, ProcessUndelegation, SetupQueuePermission, SetupTicketPermission }
 
 export function identifyDuelInstruction(instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array): DuelInstruction {
     const data = 'data' in instruction ? instruction.data : instruction;
@@ -38,6 +38,7 @@ if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Arr
 if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([94, 120, 34, 186, 57, 167, 241, 206])), 0)) { return DuelInstruction.InitializeTenant; }
 if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([157, 115, 48, 109, 65, 86, 203, 238])), 0)) { return DuelInstruction.JoinQueue; }
 if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([196, 28, 41, 206, 48, 37, 51, 167])), 0)) { return DuelInstruction.ProcessUndelegation; }
+if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([223, 132, 77, 15, 224, 155, 125, 224])), 0)) { return DuelInstruction.SetupQueuePermission; }
 if (containsBytes(data, fixEncoderSize(getBytesEncoder(), 8).encode(new Uint8Array([164, 29, 7, 235, 183, 223, 11, 85])), 0)) { return DuelInstruction.SetupTicketPermission; }
     throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION, { instructionData: data, programName: "duel" });
 }
@@ -54,6 +55,7 @@ export type ParsedDuelInstruction<TProgram extends string = 'EdZzUwKd1X2ZWjxLPpz
 | { instructionType: DuelInstruction.InitializeTenant } & ParsedInitializeTenantInstruction<TProgram>
 | { instructionType: DuelInstruction.JoinQueue } & ParsedJoinQueueInstruction<TProgram>
 | { instructionType: DuelInstruction.ProcessUndelegation } & ParsedProcessUndelegationInstruction<TProgram>
+| { instructionType: DuelInstruction.SetupQueuePermission } & ParsedSetupQueuePermissionInstruction<TProgram>
 | { instructionType: DuelInstruction.SetupTicketPermission } & ParsedSetupTicketPermissionInstruction<TProgram>
 
 
@@ -85,6 +87,8 @@ case DuelInstruction.JoinQueue: { assertIsInstructionWithAccounts(instruction);
 return { instructionType: DuelInstruction.JoinQueue, ...parseJoinQueueInstruction(instruction) }; }
 case DuelInstruction.ProcessUndelegation: { assertIsInstructionWithAccounts(instruction);
 return { instructionType: DuelInstruction.ProcessUndelegation, ...parseProcessUndelegationInstruction(instruction) }; }
+case DuelInstruction.SetupQueuePermission: { assertIsInstructionWithAccounts(instruction);
+return { instructionType: DuelInstruction.SetupQueuePermission, ...parseSetupQueuePermissionInstruction(instruction) }; }
 case DuelInstruction.SetupTicketPermission: { assertIsInstructionWithAccounts(instruction);
 return { instructionType: DuelInstruction.SetupTicketPermission, ...parseSetupTicketPermissionInstruction(instruction) }; }
                 default: throw new SolanaError(SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE, { instructionType: instructionType as string, programName: "duel" });
@@ -95,13 +99,13 @@ export type DuelPlugin = { accounts: DuelPluginAccounts; instructions: DuelPlugi
 
 export type DuelPluginAccounts = { matchTicket: ReturnType<typeof getMatchTicketCodec> & SelfFetchFunctions<MatchTicketArgs, MatchTicket>; queue: ReturnType<typeof getQueueCodec> & SelfFetchFunctions<QueueArgs, Queue>; tenant: ReturnType<typeof getTenantCodec> & SelfFetchFunctions<TenantArgs, Tenant>; }
 
-export type DuelPluginInstructions = { cancelTicket: (input: CancelTicketAsyncInput) => ReturnType<typeof getCancelTicketInstructionAsync> & SelfPlanAndSendFunctions; closeTicket: (input: CloseTicketAsyncInput) => ReturnType<typeof getCloseTicketInstructionAsync> & SelfPlanAndSendFunctions; commitTickets: (input: MakeOptional<CommitTicketsInput, "payer">) => ReturnType<typeof getCommitTicketsInstruction> & SelfPlanAndSendFunctions; createTicket: (input: CreateTicketAsyncInput) => ReturnType<typeof getCreateTicketInstructionAsync> & SelfPlanAndSendFunctions; delegateQueue: (input: MakeOptional<DelegateQueueAsyncInput, "payer">) => ReturnType<typeof getDelegateQueueInstructionAsync> & SelfPlanAndSendFunctions; delegateTicket: (input: MakeOptional<DelegateTicketAsyncInput, "payer">) => ReturnType<typeof getDelegateTicketInstructionAsync> & SelfPlanAndSendFunctions; flushMatches: (input: FlushMatchesInput) => ReturnType<typeof getFlushMatchesInstruction> & SelfPlanAndSendFunctions; initializeQueue: (input: InitializeQueueAsyncInput) => ReturnType<typeof getInitializeQueueInstructionAsync> & SelfPlanAndSendFunctions; initializeTenant: (input: InitializeTenantAsyncInput) => ReturnType<typeof getInitializeTenantInstructionAsync> & SelfPlanAndSendFunctions; joinQueue: (input: JoinQueueAsyncInput) => ReturnType<typeof getJoinQueueInstructionAsync> & SelfPlanAndSendFunctions; processUndelegation: (input: MakeOptional<ProcessUndelegationInput, "payer">) => ReturnType<typeof getProcessUndelegationInstruction> & SelfPlanAndSendFunctions; setupTicketPermission: (input: SetupTicketPermissionAsyncInput) => ReturnType<typeof getSetupTicketPermissionInstructionAsync> & SelfPlanAndSendFunctions; }
+export type DuelPluginInstructions = { cancelTicket: (input: CancelTicketAsyncInput) => ReturnType<typeof getCancelTicketInstructionAsync> & SelfPlanAndSendFunctions; closeTicket: (input: CloseTicketAsyncInput) => ReturnType<typeof getCloseTicketInstructionAsync> & SelfPlanAndSendFunctions; commitTickets: (input: MakeOptional<CommitTicketsInput, "payer">) => ReturnType<typeof getCommitTicketsInstruction> & SelfPlanAndSendFunctions; createTicket: (input: CreateTicketAsyncInput) => ReturnType<typeof getCreateTicketInstructionAsync> & SelfPlanAndSendFunctions; delegateQueue: (input: MakeOptional<DelegateQueueAsyncInput, "payer">) => ReturnType<typeof getDelegateQueueInstructionAsync> & SelfPlanAndSendFunctions; delegateTicket: (input: MakeOptional<DelegateTicketAsyncInput, "payer">) => ReturnType<typeof getDelegateTicketInstructionAsync> & SelfPlanAndSendFunctions; flushMatches: (input: FlushMatchesInput) => ReturnType<typeof getFlushMatchesInstruction> & SelfPlanAndSendFunctions; initializeQueue: (input: InitializeQueueAsyncInput) => ReturnType<typeof getInitializeQueueInstructionAsync> & SelfPlanAndSendFunctions; initializeTenant: (input: InitializeTenantAsyncInput) => ReturnType<typeof getInitializeTenantInstructionAsync> & SelfPlanAndSendFunctions; joinQueue: (input: JoinQueueAsyncInput) => ReturnType<typeof getJoinQueueInstructionAsync> & SelfPlanAndSendFunctions; processUndelegation: (input: MakeOptional<ProcessUndelegationInput, "payer">) => ReturnType<typeof getProcessUndelegationInstruction> & SelfPlanAndSendFunctions; setupQueuePermission: (input: SetupQueuePermissionAsyncInput) => ReturnType<typeof getSetupQueuePermissionInstructionAsync> & SelfPlanAndSendFunctions; setupTicketPermission: (input: SetupTicketPermissionAsyncInput) => ReturnType<typeof getSetupTicketPermissionInstructionAsync> & SelfPlanAndSendFunctions; }
 
 export type DuelPluginRequirements = ClientWithRpc<GetAccountInfoApi & GetMultipleAccountsApi> & ClientWithPayer & ClientWithTransactionPlanning & ClientWithTransactionSending
 
 export function duelProgram() {
     return <T extends DuelPluginRequirements>(client: T) => {
-        return { ...client, duel: <DuelPlugin>{ accounts: { matchTicket: addSelfFetchFunctions(client, getMatchTicketCodec()), queue: addSelfFetchFunctions(client, getQueueCodec()), tenant: addSelfFetchFunctions(client, getTenantCodec()) }, instructions: { cancelTicket: input => addSelfPlanAndSendFunctions(client, getCancelTicketInstructionAsync(input)), closeTicket: input => addSelfPlanAndSendFunctions(client, getCloseTicketInstructionAsync(input)), commitTickets: input => addSelfPlanAndSendFunctions(client, getCommitTicketsInstruction({ ...input, payer: input.payer ?? client.payer })), createTicket: input => addSelfPlanAndSendFunctions(client, getCreateTicketInstructionAsync(input)), delegateQueue: input => addSelfPlanAndSendFunctions(client, getDelegateQueueInstructionAsync({ ...input, payer: input.payer ?? client.payer })), delegateTicket: input => addSelfPlanAndSendFunctions(client, getDelegateTicketInstructionAsync({ ...input, payer: input.payer ?? client.payer })), flushMatches: input => addSelfPlanAndSendFunctions(client, getFlushMatchesInstruction(input)), initializeQueue: input => addSelfPlanAndSendFunctions(client, getInitializeQueueInstructionAsync(input)), initializeTenant: input => addSelfPlanAndSendFunctions(client, getInitializeTenantInstructionAsync(input)), joinQueue: input => addSelfPlanAndSendFunctions(client, getJoinQueueInstructionAsync(input)), processUndelegation: input => addSelfPlanAndSendFunctions(client, getProcessUndelegationInstruction({ ...input, payer: input.payer ?? client.payer.address })), setupTicketPermission: input => addSelfPlanAndSendFunctions(client, getSetupTicketPermissionInstructionAsync(input)) } } };
+        return { ...client, duel: <DuelPlugin>{ accounts: { matchTicket: addSelfFetchFunctions(client, getMatchTicketCodec()), queue: addSelfFetchFunctions(client, getQueueCodec()), tenant: addSelfFetchFunctions(client, getTenantCodec()) }, instructions: { cancelTicket: input => addSelfPlanAndSendFunctions(client, getCancelTicketInstructionAsync(input)), closeTicket: input => addSelfPlanAndSendFunctions(client, getCloseTicketInstructionAsync(input)), commitTickets: input => addSelfPlanAndSendFunctions(client, getCommitTicketsInstruction({ ...input, payer: input.payer ?? client.payer })), createTicket: input => addSelfPlanAndSendFunctions(client, getCreateTicketInstructionAsync(input)), delegateQueue: input => addSelfPlanAndSendFunctions(client, getDelegateQueueInstructionAsync({ ...input, payer: input.payer ?? client.payer })), delegateTicket: input => addSelfPlanAndSendFunctions(client, getDelegateTicketInstructionAsync({ ...input, payer: input.payer ?? client.payer })), flushMatches: input => addSelfPlanAndSendFunctions(client, getFlushMatchesInstruction(input)), initializeQueue: input => addSelfPlanAndSendFunctions(client, getInitializeQueueInstructionAsync(input)), initializeTenant: input => addSelfPlanAndSendFunctions(client, getInitializeTenantInstructionAsync(input)), joinQueue: input => addSelfPlanAndSendFunctions(client, getJoinQueueInstructionAsync(input)), processUndelegation: input => addSelfPlanAndSendFunctions(client, getProcessUndelegationInstruction({ ...input, payer: input.payer ?? client.payer.address })), setupQueuePermission: input => addSelfPlanAndSendFunctions(client, getSetupQueuePermissionInstructionAsync(input)), setupTicketPermission: input => addSelfPlanAndSendFunctions(client, getSetupTicketPermissionInstructionAsync(input)) } } };
     };
 }