feat(artillery): enhance stress testing configurations and add new scripts

- Added new artillery commands for balance status and sign session key tests, improving testing capabilities.
- Updated the PKP sign configuration to use a multi-endpoint processor for better flexibility.
- Introduced a new balance status script to monitor account balances during tests.
- Refactored existing scripts to include debug logging for HTTP responses, aiding in troubleshooting.

Author: Ansonhkg

e2e/artillery/configs/pkp-sign.yml

@@ -16,7 +16,7 @@ config:
     - duration: 60
       arrivalRate: 5
       name: "Ramp Down"
-  processor: "../src/processors/pkpSign.ts"
+  processor: "../src/processors/multi-endpoints.ts"
 
 scenarios:
   - name: "PKP Sign Stress Test"

e2e/artillery/configs/sign-session-key.yml

@@ -0,0 +1,27 @@
+config:
+  target: "dummy"
+  phases:
+    # Over 60s, ramp up to creating 50 vusers per second
+    - duration: 60
+      arrivalRate: 5
+      # rampTo: 50
+      rampTo: 10
+      name: "Ramp Up"
+    # Over 300s, create 50 vusers per second
+    - duration: 300
+      # arrivalRate: 50
+      arrivalRate: 10
+      name: "Sustained Sign Session Key"
+    # Over 60s, ramp down to creating 5 vusers per second
+    - duration: 60
+      arrivalRate: 5
+      name: "Ramp Down"
+  processor: "../src/processors/multi-endpoints.ts"
+
+scenarios:
+  - name: "Sign Session Key Stress Test"
+    weight: 100
+    flow:
+
+      - function: "runSignSessionKeyTest"
+      - think: 0.1 

e2e/artillery/src/balance-status.ts

@@ -0,0 +1,25 @@
+import { createLitClient } from "@lit-protocol/lit-client";
+import * as NetworkManager from "../../src/helper/NetworkManager";
+import * as AccountManager from '../src/AccountManager';
+
+(async () => {
+
+  // 1. Setup network and chain client
+  const networkModule = await NetworkManager.getLitNetworkModule();
+  const publicClient = await NetworkManager.getViemPublicClient({ networkModule });
+  const litClient = await createLitClient({ network: networkModule });
+
+  // 2. Get the master account
+  const masterAccount = await AccountManager.getMasterAccount();
+
+  // every 5 seconds, check the balance of the master account
+  setInterval(async () => {
+    await AccountManager.getAccountDetails({
+      accountLabel: "Master Account",
+      account: masterAccount,
+      publicClient,
+      litClient,
+    });
+  }, 3000);
+
+})();

e2e/artillery/src/init.ts

@@ -83,21 +83,21 @@ const LEDGER_MINIMUM_BALANCE = 10000;
   console.log('✅ Master Account PKP:', masterAccountPkp);
 
   // create pkp auth context
-  const masterAccountPkpAuthContext = await authManager.createPkpAuthContext({
-    authData: masterAccountAuthData,
-    pkpPublicKey: masterAccountPkp.publicKey,
-    authConfig: {
-      resources: [
-        ['pkp-signing', '*'],
-        ['lit-action-execution', '*'],
-        ['access-control-condition-decryption', '*'],
-      ],
-      expiration: new Date(Date.now() + 1000 * 60 * 15).toISOString(),
-    },
-    litClient: litClient,
-  });
+  // const masterAccountPkpAuthContext = await authManager.createPkpAuthContext({
+  //   authData: masterAccountAuthData,
+  //   pkpPublicKey: masterAccountPkp.publicKey,
+  //   authConfig: {
+  //     resources: [
+  //       ['pkp-signing', '*'],
+  //       ['lit-action-execution', '*'],
+  //       ['access-control-condition-decryption', '*'],
+  //     ],
+  //     expiration: new Date(Date.now() + 1000 * 60 * 15).toISOString(),
+  //   },
+  //   litClient: litClient,
+  // });
 
-  console.log('✅ Master Account PKP Auth Context:', masterAccountPkpAuthContext);
+  // console.log('✅ Master Account PKP Auth Context:', masterAccountPkpAuthContext);
 
   // 6. create the auth context (this should be generated each time)
   // const masterAccountAuthContext = await authManager.createEoaAuthContext({

e2e/artillery/src/processors/multi-endpoints.ts

@@ -0,0 +1,184 @@
+import { createAuthManager, storagePlugins } from "@lit-protocol/auth";
+import { createLitClient } from "@lit-protocol/lit-client";
+import { z } from "zod";
+import * as StateManager from "../StateManager";
+import * as NetworkManager from "../../../src/helper/NetworkManager";
+import * as AccountManager from "../AccountManager";
+
+// PKP Sign Result Schema
+const PkpSignResultSchema = z.object({
+  signature: z.string().regex(/^0x[a-fA-F0-9]+$/, "Invalid hex signature"),
+  verifyingKey: z.string().regex(/^0x[a-fA-F0-9]+$/, "Invalid hex verifying key"),
+  signedData: z.string().regex(/^0x[a-fA-F0-9]+$/, "Invalid hex signed data"),
+  recoveryId: z.number().int().min(0).max(3, "Recovery ID must be 0-3"),
+  publicKey: z.string().regex(/^0x[a-fA-F0-9]+$/, "Invalid hex public key"),
+  sigType: z.string().min(1, "Signature type cannot be empty"),
+});
+
+// Global variables to cache expensive operations
+let litClient: any = null;
+let authManager: any = null;
+let masterAccountAuthContext: any = null;
+let networkModule: any = null;
+let masterAccount: any = null;
+
+/**
+ * Initialise shared resources once
+ */
+const initialiseSharedResources = async () => {
+  if (!litClient) {
+    console.log('🔧 Initializing shared resources...');
+
+    // Import network module
+    networkModule = await NetworkManager.getLitNetworkModule();
+
+    // Create LitClient
+    litClient = await createLitClient({ network: networkModule });
+
+    // Create AuthManager
+    authManager = createAuthManager({
+      storage: storagePlugins.localStorageNode({
+        appName: 'artillery-testing-app',
+        networkName: `${process.env['NETWORK']}-artillery`,
+        storagePath: './lit-auth-artillery',
+      }),
+    });
+
+    console.log('✅ Shared resources initialised');
+  }
+};
+
+/**
+ * Create auth context from stored state
+ */
+const createAuthContextFromState = async () => {
+  if (!masterAccountAuthContext) {
+    const state = await StateManager.readFile();
+
+    // Validate that master account authData and PKP exist
+    if (!state.masterAccount.authData) {
+      throw new Error('❌ Master account authData not found in state. Run init.ts first.');
+    }
+
+    if (!state.masterAccount.pkp) {
+      throw new Error('❌ Master account PKP not found in state. Run init.ts first.');
+    }
+
+    // Get the master account from environment (same as init.ts)
+    if (!masterAccount) {
+      masterAccount = await AccountManager.getMasterAccount();
+    }
+
+    // Create auth context for master account
+    masterAccountAuthContext = await authManager.createEoaAuthContext({
+      config: {
+        account: masterAccount,
+      },
+      authConfig: {
+        statement: 'I authorize the Lit Protocol to execute this Lit Action.',
+        domain: 'example.com',
+        resources: [
+          ['lit-action-execution', '*'],
+          ['pkp-signing', '*'],
+          ['access-control-condition-decryption', '*'],
+        ],
+        capabilityAuthSigs: [],
+        expiration: new Date(Date.now() + 1000 * 60 * 15).toISOString(),
+      },
+      litClient: litClient,
+    });
+  }
+
+  return masterAccountAuthContext;
+};
+
+/**
+ * test the '/web/pkp/sign' endpoint
+ */
+export async function runPkpSignTest() {
+  const startTime = Date.now();
+
+  try {
+    // 1. Initialise shared resources (only happens once)
+    await initialiseSharedResources();
+
+    // 2. Read state
+    const state = await StateManager.readFile();
+
+    // Create auth context
+    const authContext = await createAuthContextFromState();
+
+    // Perform pkpSign operation
+    const result = await litClient.chain.ethereum.pkpSign({
+      authContext: authContext,
+      pubKey: state.masterAccount.pkp.publicKey,
+      toSign: `Hello from Artillery! ${Date.now()}`, // Unique message per request
+    });
+
+    // Validate the result using Zod schema
+    const validatedResult = PkpSignResultSchema.parse(result);
+
+    const endTime = Date.now();
+    const duration = endTime - startTime;
+
+    console.log(`✅ pkpSign successful in ${duration}ms`);
+    console.log('✅ pkpSign result:', validatedResult);
+
+    // For Artillery, just return - no need to call next()
+    return;
+
+  } catch (error) {
+    const endTime = Date.now();
+    const duration = endTime - startTime;
+
+    console.error(`❌ pkpSign failed in ${duration}ms:`, error instanceof Error ? error.message : String(error));
+
+    // Throw the error to let Artillery handle it
+    throw error;
+  }
+}
+
+// test '/web/sign_session_key' endpoint
+export async function runSignSessionKeyTest() {
+
+  // ❗️ IT'S IMPORTANT TO SET THIS TO FALSE FOR TESTING
+  const DELEGATION_AUTH_SIG_CACHE = false;
+
+  const startTime = Date.now();
+
+  try {
+    // 1. initialise shared resources
+    await initialiseSharedResources();
+
+    // 2. Read state
+    const state = await StateManager.readFile();
+
+    const masterAccountPkpAuthContext = await authManager.createPkpAuthContext({
+      authData: state.masterAccount.authData,
+      pkpPublicKey: state.masterAccount.pkp.publicKey,
+      authConfig: {
+        resources: [
+          ['pkp-signing', '*'],
+          ['lit-action-execution', '*'],
+          ['access-control-condition-decryption', '*'],
+        ],
+        expiration: new Date(Date.now() + 1000 * 60 * 15).toISOString(),
+      },
+      litClient: litClient,
+      cache: {
+        delegationAuthSig: DELEGATION_AUTH_SIG_CACHE,
+      }
+    });
+
+    // console.log('✅ Master Account PKP Auth Context:', masterAccountPkpAuthContext);
+
+  } catch (error) {
+    const endTime = Date.now();
+    const duration = endTime - startTime;
+
+    console.error(`❌ signSessionKey failed in ${duration}ms:`, error instanceof Error ? error.message : String(error));
+
+    // Throw the error to let Artillery handle it
+    throw error;
+  }
+}

package.json

@@ -25,7 +25,9 @@
     "auth-services": "cd packages/auth-services && bun run start",
     "test:e2e": "bun test ./e2e/src/e2e.spec.ts -t",
     "artillery:init": "bun run ./e2e/artillery/src/init.ts",
-    "artillery:pkp-sign": "dotenvx run --env-file=.env -- sh -c 'artillery run ./e2e/artillery/configs/pkp-sign.yml ${ARTILLERY_KEY:+--record --key $ARTILLERY_KEY}'"
+    "artillery:balance-status": "LOG_LEVEL=silent bun run ./e2e/artillery/src/balance-status.ts",
+    "artillery:pkp-sign": "DEBUG_HTTP=true LOG_LEVEL=silent dotenvx run --env-file=.env -- sh -c 'artillery run ./e2e/artillery/configs/pkp-sign.yml ${ARTILLERY_KEY:+--record --key $ARTILLERY_KEY}'",
+    "artillery:sign-session-key": "DEBUG_HTTP=true LOG_LEVEL=silent dotenvx run --env-file=.env -- sh -c 'artillery run ./e2e/artillery/configs/sign-session-key.yml ${ARTILLERY_KEY:+--record --key $ARTILLERY_KEY}'"
   },
   "private": true,
   "dependencies": {

packages/lit-client/src/lib/LitNodeClient/LitNodeApi/src/helper/sendNodeRequest.ts

@@ -70,6 +70,23 @@ export async function sendNodeRequest<T>(
 
     const response = await fetch(_fullUrl, req);
 
+    // Only log response details when DEBUG_HTTP is enabled
+    // Safely check for DEBUG_HTTP environment variable in both Node.js and browser
+    let isDebugMode = false;
+    try {
+      isDebugMode = typeof process !== 'undefined' && 
+                   typeof process.env === 'object' && 
+                   process.env['DEBUG_HTTP'] === 'true';
+    } catch (e) {
+      // Ignore any errors - ensures browser compatibility
+      isDebugMode = false;
+    }
+    
+    if (isDebugMode) {
+      const timestamp = new Date().toISOString();
+      console.log(`🔄 response at ${timestamp}`, response);
+    }
+
     const isJson = response.headers
       .get('content-type')
       ?.includes('application/json');