@solana/kora 0.2.1 → 0.3.0-beta.2

package/dist/src/plugin.js

@@ -0,0 +1,179 @@
+import { address, blockhash, signature } from '@solana/kit';
+import { KoraClient } from './client.js';
+/**
+ * Creates a Kora Kit plugin that adds Kora paymaster functionality to a Kit client.
+ *
+ * The plugin exposes all Kora RPC methods with Kit-typed responses (Address, Blockhash).
+ *
+ * **Note:** The plugin pattern with `createClient().use()` requires `@solana/kit` v6.8.0+.
+ * For older kit versions, use `KoraClient` directly instead.
+ *
+ * @param config - Plugin configuration
+ * @param config.endpoint - Kora RPC endpoint URL
+ * @param config.apiKey - Optional API key for authentication
+ * @param config.hmacSecret - Optional HMAC secret for signature-based authentication
+ * @returns A Kit plugin function that adds `.kora` to the client
+ *
+ * @example
+ * ```typescript
+ * import { createClient } from '@solana/kit';
+ * import { koraPlugin } from '@solana/kora';
+ *
+ * const client = createClient()
+ *   .use(koraPlugin({ endpoint: 'https://kora.example.com' }));
+ *
+ * // All responses have Kit-typed fields
+ * const config = await client.kora.getConfig();
+ * // config.fee_payers is Address[] not string[]
+ *
+ * const { signer_pubkey } = await client.kora.signTransaction({ transaction: tx });
+ * // signer_pubkey is Address not string
+ * ```
+ */
+export function koraPlugin(config) {
+    const client = config.koraClient ??
+        new KoraClient({
+            apiKey: config.apiKey,
+            getRecaptchaToken: config.getRecaptchaToken,
+            hmacSecret: config.hmacSecret,
+            rpcUrl: config.endpoint,
+        });
+    return (c) => ({
+        ...c,
+        kora: {
+            /**
+             * Estimates the bundle fee with Kit-typed addresses.
+             */
+            async estimateBundleFee(request) {
+                const result = await client.estimateBundleFee(request);
+                return {
+                    fee_in_lamports: result.fee_in_lamports,
+                    fee_in_token: result.fee_in_token,
+                    payment_address: address(result.payment_address),
+                    signer_pubkey: address(result.signer_pubkey),
+                };
+            },
+            /**
+             * Estimates the transaction fee with Kit-typed addresses.
+             */
+            async estimateTransactionFee(request) {
+                const result = await client.estimateTransactionFee(request);
+                return {
+                    fee_in_lamports: result.fee_in_lamports,
+                    fee_in_token: result.fee_in_token,
+                    payment_address: address(result.payment_address),
+                    signer_pubkey: address(result.signer_pubkey),
+                };
+            },
+            /**
+             * Gets the latest blockhash with Kit Blockhash type.
+             */
+            async getBlockhash() {
+                const result = await client.getBlockhash();
+                return {
+                    blockhash: blockhash(result.blockhash),
+                };
+            },
+            /**
+             * Retrieves the current Kora server configuration with Kit-typed addresses.
+             */
+            async getConfig() {
+                const result = await client.getConfig();
+                return {
+                    enabled_methods: result.enabled_methods,
+                    fee_payers: result.fee_payers.map(addr => address(addr)),
+                    validation_config: {
+                        ...result.validation_config,
+                        allowed_programs: Array.isArray(result.validation_config.allowed_programs)
+                            ? result.validation_config.allowed_programs.map(addr => address(addr))
+                            : result.validation_config.allowed_programs,
+                        allowed_spl_paid_tokens: result.validation_config.allowed_spl_paid_tokens.map(addr => address(addr)),
+                        allowed_tokens: result.validation_config.allowed_tokens.map(addr => address(addr)),
+                        disallowed_accounts: result.validation_config.disallowed_accounts.map(addr => address(addr)),
+                    },
+                };
+            },
+            /**
+             * Retrieves the payer signer and payment destination with Kit-typed addresses.
+             */
+            async getPayerSigner() {
+                const result = await client.getPayerSigner();
+                return {
+                    payment_address: address(result.payment_address),
+                    signer_address: address(result.signer_address),
+                };
+            },
+            /**
+             * Creates a payment instruction with Kit-typed response.
+             */
+            async getPaymentInstruction(request) {
+                const result = await client.getPaymentInstruction(request);
+                return {
+                    original_transaction: result.original_transaction,
+                    payment_address: address(result.payment_address),
+                    payment_amount: result.payment_amount,
+                    payment_instruction: result.payment_instruction,
+                    payment_token: address(result.payment_token),
+                    signer_address: address(result.signer_address),
+                };
+            },
+            /**
+             * Retrieves the list of tokens supported for fee payment with Kit-typed addresses.
+             */
+            async getSupportedTokens() {
+                const result = await client.getSupportedTokens();
+                return {
+                    tokens: result.tokens.map(addr => address(addr)),
+                };
+            },
+            /**
+             * Gets the version of the Kora server.
+             */
+            async getVersion() {
+                return await client.getVersion();
+            },
+            /**
+             * Signs and sends a bundle of transactions via Jito with Kit-typed response.
+             */
+            async signAndSendBundle(request) {
+                const result = await client.signAndSendBundle(request);
+                return {
+                    bundle_uuid: result.bundle_uuid,
+                    signed_transactions: result.signed_transactions,
+                    signer_pubkey: address(result.signer_pubkey),
+                };
+            },
+            /**
+             * Signs and sends a transaction with Kit-typed response.
+             */
+            async signAndSendTransaction(request) {
+                const result = await client.signAndSendTransaction(request);
+                return {
+                    signature: signature(result.signature),
+                    signed_transaction: result.signed_transaction,
+                    signer_pubkey: address(result.signer_pubkey),
+                };
+            },
+            /**
+             * Signs a bundle of transactions with Kit-typed response.
+             */
+            async signBundle(request) {
+                const result = await client.signBundle(request);
+                return {
+                    signed_transactions: result.signed_transactions,
+                    signer_pubkey: address(result.signer_pubkey),
+                };
+            },
+            /**
+             * Signs a transaction with Kit-typed response.
+             */
+            async signTransaction(request) {
+                const result = await client.signTransaction(request);
+                return {
+                    signed_transaction: result.signed_transaction,
+                    signer_pubkey: address(result.signer_pubkey),
+                };
+            },
+        },
+    });
+}

package/dist/src/types/index.d.ts

@@ -1,22 +1,7 @@
-import { Instruction, TransactionSigner } from '@solana/kit';
+import { Instruction, type MicroLamports, type TransactionSigner } from '@solana/kit';
 /**
  * Request Types
  */
-/**
- * Parameters for creating a token transfer transaction.
- */
-export interface TransferTransactionRequest {
-    /** Amount to transfer in the token's smallest unit (e.g., lamports for SOL) */
-    amount: number;
-    /** Public key of the destination wallet (not token account) */
-    destination: string;
-    /** Optional signer address for the transaction */
-    signer_key?: string;
-    /** Public key of the source wallet (not token account) */
-    source: string;
-    /** Mint address of the token to transfer */
-    token: string;
-}
 /**
  * Parameters for signing a transaction.
  */
@@ -27,24 +12,68 @@ export interface SignTransactionRequest {
     signer_key?: string;
     /** Base64-encoded transaction to sign */
     transaction: string;
+    /** Optional user ID for usage tracking (required when pricing is free and usage tracking is enabled) */
+    user_id?: string;
 }
+/**
+ * The transaction lifecycle milestone the server waits for before responding,
+ * ordered by increasing assurance: `signed` < `sent` < `confirmed`:
+ * - `confirmed`: wait for on-chain confirmation (default)
+ * - `sent`: return once the RPC node accepts the transaction
+ * - `signed`: return as soon as signing completes and broadcast in the background
+ */
+export type RespondAfter = 'confirmed' | 'sent' | 'signed';
 /**
  * Parameters for signing and sending a transaction.
  */
 export interface SignAndSendTransactionRequest {
+    /** Optional milestone to wait for before responding (defaults to "confirmed") */
+    respond_after?: RespondAfter;
     /** Optional signer verification during transaction simulation (defaults to false) */
     sig_verify?: boolean;
     /** Optional signer address for the transaction */
     signer_key?: string;
     /** Base64-encoded transaction to sign and send */
     transaction: string;
+    /** Optional user ID for usage tracking (required when pricing is free and usage tracking is enabled) */
+    user_id?: string;
+}
+/**
+ * Parameters for signing a bundle of transactions.
+ */
+export interface SignBundleRequest {
+    /** Optional signer verification during transaction simulation (defaults to false) */
+    sig_verify?: boolean;
+    /** Optional indices of transactions to sign (defaults to all if not specified) */
+    sign_only_indices?: number[];
+    /** Optional signer address for the transactions */
+    signer_key?: string;
+    /** Array of base64-encoded transactions to sign */
+    transactions: string[];
+    /** Optional user ID for usage tracking (required when pricing is free and usage tracking is enabled) */
+    user_id?: string;
+}
+/**
+ * Parameters for signing and sending a bundle of transactions via Jito.
+ */
+export interface SignAndSendBundleRequest {
+    /** Optional signer verification during transaction simulation (defaults to false) */
+    sig_verify?: boolean;
+    /** Optional indices of transactions to sign (defaults to all if not specified) */
+    sign_only_indices?: number[];
+    /** Optional signer address for the transactions */
+    signer_key?: string;
+    /** Array of base64-encoded transactions to sign and send */
+    transactions: string[];
+    /** Optional user ID for usage tracking (required when pricing is free and usage tracking is enabled) */
+    user_id?: string;
 }
 /**
  * Parameters for estimating transaction fees.
  */
 export interface EstimateTransactionFeeRequest {
     /** Mint address of the token to calculate fees in */
-    fee_token: string;
+    fee_token?: string;
     /** Optional signer verification during transaction simulation (defaults to false) */
     sig_verify?: boolean;
     /** Optional signer address for the transaction */
@@ -52,6 +81,21 @@ export interface EstimateTransactionFeeRequest {
     /** Base64-encoded transaction to estimate fees for */
     transaction: string;
 }
+/**
+ * Parameters for estimating bundle fees.
+ */
+export interface EstimateBundleFeeRequest {
+    /** Mint address of the token to calculate fees in */
+    fee_token?: string;
+    /** Optional signer verification during transaction simulation (defaults to false) */
+    sig_verify?: boolean;
+    /** Optional indices of transactions to estimate fees for (defaults to all if not specified) */
+    sign_only_indices?: number[];
+    /** Optional signer address for the transactions */
+    signer_key?: string;
+    /** Array of base64-encoded transactions to estimate fees for */
+    transactions: string[];
+}
 /**
  * Parameters for getting a payment instruction.
  */
@@ -75,21 +119,6 @@ export interface GetPaymentInstructionRequest {
 /**
  * Response Types
  */
-/**
- * Response from creating a transfer transaction.
- */
-export interface TransferTransactionResponse {
-    /** Recent blockhash used in the transaction */
-    blockhash: string;
-    /** Parsed instructions from the transaction message */
-    instructions: Instruction[];
-    /** Base64-encoded message */
-    message: string;
-    /** Public key of the signer used to send the transaction */
-    signer_pubkey: string;
-    /** Base64-encoded signed transaction */
-    transaction: string;
-}
 /**
  * Response from signing a transaction.
  */
@@ -110,6 +139,26 @@ export interface SignAndSendTransactionResponse {
     /** Public key of the signer used to send the transaction */
     signer_pubkey: string;
 }
+/**
+ * Response from signing a bundle of transactions.
+ */
+export interface SignBundleResponse {
+    /** Array of base64-encoded signed transactions */
+    signed_transactions: string[];
+    /** Public key of the signer used to sign the transactions */
+    signer_pubkey: string;
+}
+/**
+ * Response from signing and sending a bundle of transactions via Jito.
+ */
+export interface SignAndSendBundleResponse {
+    /** UUID of the submitted Jito bundle */
+    bundle_uuid: string;
+    /** Array of base64-encoded signed transactions */
+    signed_transactions: string[];
+    /** Public key of the signer used to sign the transactions */
+    signer_pubkey: string;
+}
 /**
  * Response containing the latest blockhash.
  */
@@ -117,6 +166,13 @@ export interface GetBlockhashResponse {
     /** Base58-encoded blockhash */
     blockhash: string;
 }
+/**
+ * Response containing the server version.
+ */
+export interface GetVersionResponse {
+    /** Server version string */
+    version: string;
+}
 /**
  * Response containing supported token mint addresses.
  */
@@ -133,7 +189,22 @@ export interface EstimateTransactionFeeResponse {
     /**
      * Transaction fee in the requested token (in decimals value of the token, e.g. 10^6 for USDC)
      */
-    fee_in_token: number;
+    fee_in_token?: number;
+    /** Public key of the payment destination */
+    payment_address: string;
+    /** Public key of the signer used to estimate the fee */
+    signer_pubkey: string;
+}
+/**
+ * Response containing estimated bundle fees.
+ */
+export interface EstimateBundleFeeResponse {
+    /** Total bundle fee in lamports across all transactions */
+    fee_in_lamports: number;
+    /**
+     * Total bundle fee in the requested token (in decimals value of the token, e.g. 10^6 for USDC)
+     */
+    fee_in_token?: number;
     /** Public key of the payment destination */
     payment_address: string;
     /** Public key of the signer used to estimate the fee */
@@ -173,8 +244,8 @@ export type PriceSource = 'Jupiter' | 'Mock';
  * Validation configuration for the Kora server.
  */
 export interface ValidationConfig {
-    /** List of allowed Solana program IDs */
-    allowed_programs: string[];
+    /** List of allowed Solana program IDs, or "All" to allow any program. */
+    allowed_programs: 'All' | string[];
     /** List of SPL tokens accepted for paid transactions */
     allowed_spl_paid_tokens: string[];
     /** List of allowed token mint addresses for fee payment */
@@ -225,18 +296,28 @@ export type PriceConfig = PriceModel;
  * Enabled status for methods for the Kora server.
  */
 export interface EnabledMethods {
+    /** Whether the estimate_bundle_fee method is enabled (requires bundle.enabled = true) */
+    estimate_bundle_fee: boolean;
     /** Whether the estimate_transaction_fee method is enabled */
     estimate_transaction_fee: boolean;
     /** Whether the get_blockhash method is enabled */
     get_blockhash: boolean;
     /** Whether the get_config method is enabled */
     get_config: boolean;
+    /** Whether the get_payer_signer method is enabled */
+    get_payer_signer: boolean;
     /** Whether the get_supported_tokens method is enabled */
     get_supported_tokens: boolean;
+    /** Whether the get_version method is enabled */
+    get_version: boolean;
     /** Whether the liveness method is enabled */
     liveness: boolean;
+    /** Whether the sign_and_send_bundle method is enabled (requires bundle.enabled = true) */
+    sign_and_send_bundle: boolean;
     /** Whether the sign_and_send_transaction method is enabled */
     sign_and_send_transaction: boolean;
+    /** Whether the sign_bundle method is enabled (requires bundle.enabled = true) */
+    sign_bundle: boolean;
     /** Whether the sign_transaction method is enabled */
     sign_transaction: boolean;
     /** Whether the transfer_transaction method is enabled */
@@ -293,6 +374,12 @@ export interface SplTokenInstructionPolicy {
     allow_close_account: boolean;
     /** Allow fee payer to freeze SPL token accounts */
     allow_freeze_account: boolean;
+    /** Allow fee payer to initialize SPL token accounts */
+    allow_initialize_account: boolean;
+    /** Allow fee payer to initialize SPL token mints */
+    allow_initialize_mint: boolean;
+    /** Allow fee payer to initialize SPL multisig accounts */
+    allow_initialize_multisig: boolean;
     /** Allow fee payer to mint SPL tokens */
     allow_mint_to: boolean;
     /** Allow fee payer to revoke SPL token delegates */
@@ -316,6 +403,12 @@ export interface Token2022InstructionPolicy {
     allow_close_account: boolean;
     /** Allow fee payer to freeze Token2022 accounts */
     allow_freeze_account: boolean;
+    /** Allow fee payer to initialize Token2022 accounts */
+    allow_initialize_account: boolean;
+    /** Allow fee payer to initialize Token2022 mints */
+    allow_initialize_mint: boolean;
+    /** Allow fee payer to initialize Token2022 multisig accounts */
+    allow_initialize_multisig: boolean;
     /** Allow fee payer to mint Token2022 tokens */
     allow_mint_to: boolean;
     /** Allow fee payer to revoke Token2022 delegates */
@@ -347,6 +440,10 @@ export interface FeePayerPolicy {
 export interface RpcError {
     /** Error code */
     code: number;
+    /** Optional structured data about the error */
+    data?: {
+        error_type: string;
+    };
     /** Human-readable error message */
     message: string;
 }
@@ -372,6 +469,8 @@ export interface AuthenticationHeaders {
     'x-api-key'?: string;
     /** HMAC SHA256 signature of timestamp + body */
     'x-hmac-signature'?: string;
+    /** reCAPTCHA v3 token for bot protection */
+    'x-recaptcha-token'?: string;
     /** Unix timestamp for HMAC authentication */
     'x-timestamp'?: string;
 }
@@ -381,6 +480,13 @@ export interface AuthenticationHeaders {
 export interface KoraClientOptions {
     /** Optional API key for authentication */
     apiKey?: string;
+    /**
+     * Optional callback to get a reCAPTCHA v3 token for bot protection.
+     * Called for every request when provided; server determines which methods require it.
+     * @example Browser: `() => grecaptcha.execute('site-key', { action: 'sign' })`
+     * @example Testing: `() => 'test-token'`
+     */
+    getRecaptchaToken?: () => Promise<string> | string;
     /** Optional HMAC secret for signature-based authentication */
     hmacSecret?: string;
     /** URL of the Kora RPC server */
@@ -389,15 +495,25 @@ export interface KoraClientOptions {
 /**
  * Plugin Types - Kit-typed responses for the Kora plugin
  */
-import type { Address, Base64EncodedWireTransaction, Blockhash, Instruction as KitInstruction, MicroLamports, Signature } from '@solana/kit';
+import type { Address, Base64EncodedWireTransaction, Blockhash, Instruction as KitInstruction, Signature } from '@solana/kit';
+import { KoraClient } from '../client.js';
 /** Configuration options for the Kora Kit plugin */
 export interface KoraPluginConfig {
     /** Optional API key for authentication */
     apiKey?: string;
     /** Kora RPC endpoint URL */
     endpoint: string;
+    /**
+     * Optional callback to get a reCAPTCHA v3 token for bot protection.
+     * Called for every request when provided; server determines which methods require it.
+     * @example Browser: `() => grecaptcha.execute('site-key', { action: 'sign' })`
+     * @example Testing: `() => 'test-token'`
+     */
+    getRecaptchaToken?: () => Promise<string> | string;
     /** Optional HMAC secret for signature-based authentication */
     hmacSecret?: string;
+    /** Existing Kora Client for reusing existing instance */
+    koraClient?: KoraClient;
 }
 /** Plugin response for getPayerSigner with Kit Address types */
 export interface KitPayerSignerResponse {
@@ -421,7 +537,7 @@ export interface KitEstimateFeeResponse {
     /** Transaction fee in lamports */
     fee_in_lamports: number;
     /** Transaction fee in the requested token */
-    fee_in_token: number;
+    fee_in_token?: number;
     /** Public key of the payment destination */
     payment_address: Address;
     /** Public key of the signer used to estimate the fee */
@@ -443,19 +559,6 @@ export interface KitSignAndSendTransactionResponse {
     /** Public key of the signer used to send the transaction */
     signer_pubkey: Address;
 }
-/** Plugin response for transferTransaction with Kit types */
-export interface KitTransferTransactionResponse {
-    /** Recent blockhash used in the transaction */
-    blockhash: Blockhash;
-    /** Parsed instructions from the transaction message */
-    instructions: KitInstruction[];
-    /** Base64-encoded message */
-    message: string;
-    /** Public key of the signer used to send the transaction */
-    signer_pubkey: Address;
-    /** Base64-encoded signed transaction */
-    transaction: Base64EncodedWireTransaction;
-}
 /** Plugin response for getPaymentInstruction with Kit types */
 export interface KitPaymentInstructionResponse {
     /** Base64-encoded original transaction */
@@ -480,10 +583,37 @@ export interface KitConfigResponse {
     /** Validation rules and constraints */
     validation_config: KitValidationConfig;
 }
+/** Plugin response for estimateBundleFee with Kit types */
+export interface KitEstimateBundleFeeResponse {
+    /** Total bundle fee in lamports across all transactions */
+    fee_in_lamports: number;
+    /** Total bundle fee in the requested token */
+    fee_in_token?: number;
+    /** Public key of the payment destination */
+    payment_address: Address;
+    /** Public key of the signer used to estimate the fee */
+    signer_pubkey: Address;
+}
+/** Plugin response for signBundle with Kit types */
+export interface KitSignBundleResponse {
+    /** Array of base64-encoded signed transactions */
+    signed_transactions: Base64EncodedWireTransaction[];
+    /** Public key of the signer used to sign the transactions */
+    signer_pubkey: Address;
+}
+/** Plugin response for signAndSendBundle with Kit types */
+export interface KitSignAndSendBundleResponse {
+    /** UUID of the submitted Jito bundle */
+    bundle_uuid: string;
+    /** Array of base64-encoded signed transactions */
+    signed_transactions: Base64EncodedWireTransaction[];
+    /** Public key of the signer used to sign the transactions */
+    signer_pubkey: Address;
+}
 /** Plugin validation config with Kit Address types */
 export interface KitValidationConfig {
-    /** List of allowed Solana program IDs */
-    allowed_programs: Address[];
+    /** List of allowed Solana program IDs, or "All" to allow any program. */
+    allowed_programs: 'All' | Address[];
     /** List of SPL tokens accepted for paid transactions */
     allowed_spl_paid_tokens: Address[];
     /** List of allowed token mint addresses for fee payment */
@@ -504,41 +634,31 @@ export interface KitValidationConfig {
     token2022: Token2022Config;
 }
 /**
- * Configuration for creating a Kora Kit client.
+ * Kit Client Types
+ */
+/**
+ * Configuration for the {@link kora} bundle plugin.
  *
- * @example
- * ```ts
- * const client = await createKitKoraClient({
- *   endpoint: 'https://kora.example.com',
- *   rpcUrl: 'https://api.mainnet-beta.solana.com',
- *   feeToken: address('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'),
- *   feePayerWallet: myWalletSigner, // TransactionSigner that authorizes SPL fee payment
- * });
- * ```
- */
-export interface KoraKitClientConfig {
-    /** Optional API key for authentication */
+ * The user's signer is read from `client.identity` (set via `identity()` from
+ * `@solana/kit-plugin-signer`), so this config intentionally omits any signer field.
+ */
+export interface KoraBundleConfig {
     readonly apiKey?: string;
-    /** Optional compute unit limit (uses provisory/simulation if not set) */
     readonly computeUnitLimit?: number;
-    /** Optional priority fee in micro-lamports */
     readonly computeUnitPrice?: MicroLamports;
-    /** Kora RPC endpoint URL */
     readonly endpoint: string;
-    /** Wallet signer paying SPL fees (must be a real signer so the payment transfer is authorized) */
-    readonly feePayerWallet: TransactionSigner;
-    /** SPL mint address for fee payment */
     readonly feeToken: Address;
-    /** Optional HMAC secret for signature-based authentication */
+    readonly getRecaptchaToken?: () => Promise<string> | string;
     readonly hmacSecret?: string;
-    /**
-     * Solana RPC URL used for compute unit estimation and program plugin compatibility.
-     * The client simulates transactions against this RPC node to determine optimal
-     * compute unit limits (resulting in lower fees), and exposes it as `ClientWithRpc`
-     * so Kit program plugins like `tokenProgram()` work out of the box.
-     * This must be a direct Solana RPC URL (not the Kora endpoint).
-     */
     readonly rpcUrl: string;
-    /** Token program ID for fee payment (defaults to TOKEN_PROGRAM_ADDRESS; use TOKEN_2022_PROGRAM_ADDRESS for Token-2022) */
     readonly tokenProgramId?: Address;
+    readonly userId?: string;
+}
+/**
+ * Configuration for {@link createKitKoraClient}.
+ *
+ * @deprecated Use {@link KoraBundleConfig} with the {@link kora} plugin instead.
+ */
+export interface KoraKitClientConfig extends KoraBundleConfig {
+    readonly feePayerWallet: TransactionSigner;
 }

package/dist/test/auth-setup.js

@@ -5,34 +5,34 @@ export function runAuthenticationTests() {
     describe('Authentication', () => {
         it('should fail with incorrect API key', async () => {
             const client = new KoraClient({
-                rpcUrl: koraRpcUrl,
                 apiKey: 'WRONG-API-KEY',
+                rpcUrl: koraRpcUrl,
             });
             // Auth failure should result in an error (empty response body causes JSON parse error)
             await expect(client.getConfig()).rejects.toThrow();
         });
         it('should fail with incorrect HMAC secret', async () => {
             const client = new KoraClient({
-                rpcUrl: koraRpcUrl,
                 hmacSecret: 'WRONG-HMAC-SECRET',
+                rpcUrl: koraRpcUrl,
             });
             // Auth failure should result in an error
             await expect(client.getConfig()).rejects.toThrow();
         });
         it('should fail with both incorrect credentials', async () => {
             const client = new KoraClient({
-                rpcUrl: koraRpcUrl,
                 apiKey: 'WRONG-API-KEY',
                 hmacSecret: 'WRONG-HMAC-SECRET',
+                rpcUrl: koraRpcUrl,
             });
             // Auth failure should result in an error
             await expect(client.getConfig()).rejects.toThrow();
         });
         it('should succeed with correct credentials', async () => {
             const client = new KoraClient({
-                rpcUrl: koraRpcUrl,
                 apiKey: 'test-api-key-123',
                 hmacSecret: 'test-hmac-secret-456',
+                rpcUrl: koraRpcUrl,
             });
             const config = await client.getConfig();
             expect(config).toBeDefined();