feat(e2e, lit-client, networks): add shiva env helpers and improve resilience

Author: Ansonhkg

packages/e2e/src/helper/ShivaClient/createShivaClient.ts

@@ -61,6 +61,16 @@ type PollTestnetStateOptions = {
   intervalMs?: number;
 };
 
+type WaitForTestnetInfoOptions = {
+  timeoutMs?: number;
+  intervalMs?: number;
+};
+
+export type ShivaTestnetInfo = {
+  rpc_url?: string;
+  [key: string]: unknown;
+};
+
 /**
  * High-level interface surfaced by {@link createShivaClient}.
  */
@@ -90,7 +100,11 @@ export type ShivaClient = {
     options?: PollTestnetStateOptions
   ) => Promise<TestNetState>;
   /** Retrieve the full testnet configuration (contract ABIs, RPC URL, etc.). */
-  getTestnetInfo: () => Promise<unknown>;
+  getTestnetInfo: () => Promise<ShivaTestnetInfo | null>;
+  /** Poll the manager until `/test/get/info/testnet/<id>` returns a payload. */
+  waitForTestnetInfo: (
+    options?: WaitForTestnetInfoOptions
+  ) => Promise<ShivaTestnetInfo>;
   /** Shut down the underlying testnet through the Shiva manager. */
   deleteTestnet: () => Promise<boolean>;
 
@@ -321,11 +335,47 @@ export const createShivaClient = async (
   };
 
   const getTestnetInfo = async () => {
-    const response = await fetchShiva<unknown>(
+    const response = await fetchShiva<ShivaTestnetInfo>(
       baseUrl,
       `/test/get/info/testnet/${testnetId}`
     );
-    return response.body;
+    return response.body ?? null;
+  };
+
+  const waitForTestnetInfo = async (
+    options: WaitForTestnetInfoOptions = {}
+  ): Promise<ShivaTestnetInfo> => {
+    const {
+      timeoutMs = DEFAULT_STATE_POLL_TIMEOUT,
+      intervalMs = DEFAULT_STATE_POLL_INTERVAL,
+    } = options;
+    const deadline = Date.now() + timeoutMs;
+    let lastError: unknown;
+
+    for (;;) {
+      try {
+        const info = await getTestnetInfo();
+        if (info) {
+          return info;
+        }
+      } catch (error) {
+        lastError = error;
+      }
+
+      if (Date.now() >= deadline) {
+        const lastErrorMessage =
+          lastError instanceof Error
+            ? lastError.message
+            : lastError
+            ? String(lastError)
+            : 'No response body received.';
+        throw new Error(
+          `Timed out after ${timeoutMs}ms waiting for testnet info for ${testnetId}. Last error: ${lastErrorMessage}`
+        );
+      }
+
+      await new Promise((resolve) => setTimeout(resolve, intervalMs));
+    }
   };
 
   const deleteTestnet = async () => {
@@ -344,6 +394,7 @@ export const createShivaClient = async (
     stopRandomNodeAndWait,
     pollTestnetState,
     getTestnetInfo,
+    waitForTestnetInfo,
     deleteTestnet,
 
     // utils

packages/e2e/src/helper/ShivaClient/createShivaEnv.ts

@@ -0,0 +1,46 @@
+import { SUPPORTED_NETWORKS, type SupportedNetwork } from '../createEnvVars';
+
+export type ShivaEnvVars = {
+  network: SupportedNetwork;
+  shivaBaseUrl: string;
+  litNodeBin: string;
+  litActionsBin: string;
+};
+
+export const createShivaEnvVars = (): ShivaEnvVars => {
+  const networkEnv = process.env['NETWORK'];
+  if (
+    !networkEnv ||
+    !SUPPORTED_NETWORKS.includes(networkEnv as SupportedNetwork)
+  ) {
+    throw new Error(
+      `Unsupported or missing NETWORK env var. Supported values: ${SUPPORTED_NETWORKS.join(
+        ', '
+      )}`
+    );
+  }
+
+  const network = networkEnv as SupportedNetwork;
+
+  const shivaBaseUrl = process.env['SHIVA_BASE_URL'];
+  if (!shivaBaseUrl) {
+    throw new Error('Missing SHIVA_BASE_URL env var.');
+  }
+
+  const litNodeBin = process.env['LIT_NODE_BIN'];
+  if (!litNodeBin) {
+    throw new Error('Missing LIT_NODE_BIN env var.');
+  }
+
+  const litActionsBin = process.env['LIT_ACTIONS_BIN'];
+  if (!litActionsBin) {
+    throw new Error('Missing LIT_ACTIONS_BIN env var.');
+  }
+
+  return {
+    network,
+    shivaBaseUrl,
+    litNodeBin,
+    litActionsBin,
+  };
+};

packages/e2e/src/helper/createEnvVars.ts

@@ -1,8 +1,14 @@
-const supportedNetworks = ['naga-local', 'naga-test', 'naga-dev'] as const;
+export const SUPPORTED_NETWORKS = [
+  'naga-local',
+  'naga-test',
+  'naga-dev',
+  'naga-staging',
+] as const;
+export type SupportedNetwork = (typeof SUPPORTED_NETWORKS)[number];
 type EnvName = 'local' | 'live';
 
 export type EnvVars = {
-  network: string;
+  network: SupportedNetwork;
   privateKey: `0x${string}`;
   rpcUrl?: string | undefined;
   localContextPath?: string;
@@ -19,14 +25,19 @@ const testEnv: Record<
 
 export function createEnvVars(): EnvVars {
   // 1. Get network string
-  const network = process.env['NETWORK']!!;
+  const networkEnv = process.env['NETWORK'];
 
-  if (!network || !supportedNetworks.includes(network as any)) {
+  if (
+    !networkEnv ||
+    !SUPPORTED_NETWORKS.includes(networkEnv as SupportedNetwork)
+  ) {
     throw new Error(
-      `❌ NETWORK env var is not set or not supported. Found. ${network}`
+      `❌ NETWORK env var is not set or not supported. Found. ${networkEnv}`
     );
   }
 
+  const network = networkEnv as SupportedNetwork;
+
   const selectedNetwork = network.includes('local') ? 'local' : 'live';
 
   // 2. Get private key
@@ -71,7 +82,11 @@ export function createEnvVars(): EnvVars {
   }
 
   // -- live networks
-  if (network === 'naga-dev' || network === 'naga-test') {
+  if (
+    network === 'naga-dev' ||
+    network === 'naga-test' ||
+    network === 'naga-staging'
+  ) {
     const liveRpcUrl = process.env['LIT_YELLOWSTONE_PRIVATE_RPC_URL'];
 
     if (liveRpcUrl) {

packages/e2e/src/helper/createTestEnv.ts

@@ -2,6 +2,7 @@ import {
   LitNetworkModule,
   nagaDev,
   nagaLocal,
+  nagaStaging,
   nagaTest,
   PaymentManager,
 } from '@lit-protocol/networks';
@@ -46,36 +47,45 @@ export const createTestEnv = async (envVars: EnvVars): Promise<TestEnv> => {
     ledgerDepositAmount: '',
   };
 
-  if (envVars.network === 'naga-local') {
-    networkModule = nagaLocal
-      .withLocalContext({
-        networkContextPath: envVars.localContextPath,
-        networkName: 'naga-local',
-      })
-      .withOverrides({
-        rpcUrl: envVars.rpcUrl,
-      });
-    config = CONFIG.LOCAL;
-  } else if (
-    envVars.network === 'naga-dev' ||
-    envVars.network === 'naga-test'
-  ) {
-    if (envVars.network === 'naga-dev') {
-      networkModule = nagaDev;
-    } else if (envVars.network === 'naga-test') {
-      networkModule = nagaTest;
+  switch (envVars.network) {
+    case 'naga-local': {
+      networkModule = nagaLocal
+        .withLocalContext({
+          networkContextPath: envVars.localContextPath,
+          networkName: 'naga-local',
+        })
+        .withOverrides({
+          rpcUrl: envVars.rpcUrl,
+        });
+      config = CONFIG.LOCAL;
+      break;
     }
+    case 'naga-dev':
+    case 'naga-test':
+    case 'naga-staging': {
+      if (envVars.network === 'naga-dev') {
+        networkModule = nagaDev;
+      } else if (envVars.network === 'naga-test') {
+        networkModule = nagaTest;
+      } else {
+        networkModule = nagaStaging;
+      }
 
-    if (envVars.rpcUrl) {
-      console.log(
-        `🔧 Overriding RPC URL for ${envVars.network} to ${envVars.rpcUrl}`
-      );
-      networkModule = networkModule.withOverrides({
-        rpcUrl: envVars.rpcUrl,
-      });
-    }
+      if (envVars.rpcUrl) {
+        console.log(
+          `🔧 Overriding RPC URL for ${envVars.network} to ${envVars.rpcUrl}`
+        );
+        networkModule = networkModule.withOverrides({
+          rpcUrl: envVars.rpcUrl,
+        });
+      }
 
-    config = CONFIG.LIVE;
+      config = CONFIG.LIVE;
+      break;
+    }
+    default: {
+      throw new Error(`Unsupported network: ${envVars.network}`);
+    }
   }
 
   // 2. Create Lit Client

packages/e2e/src/index.ts

@@ -10,11 +10,15 @@ export type { AuthContext } from './types';
 
 // re-export new helpers that should be used to refactor the `init.ts` proces
 // see packages/e2e/src/tickets/delegation.suite.ts for usage examples
-export { createEnvVars } from './helper/createEnvVars';
+export { createEnvVars, SUPPORTED_NETWORKS } from './helper/createEnvVars';
+export type { SupportedNetwork } from './helper/createEnvVars';
 export { createTestAccount } from './helper/createTestAccount';
 export { createTestEnv } from './helper/createTestEnv';
 export type { CreateTestAccountResult } from './helper/createTestAccount';
 export { registerPaymentDelegationTicketSuite } from './tickets/delegation.suite';
 
 // -- Shiva
 export { createShivaClient } from './helper/ShivaClient/createShivaClient';
+export { createShivaEnvVars } from './helper/ShivaClient/createShivaEnv';
+export type { ShivaTestnetInfo } from './helper/ShivaClient/createShivaClient';
+export type { ShivaEnvVars } from './helper/ShivaClient/createShivaEnv';

packages/e2e/src/tickets/executeJs/pkp-authsig.spec.ts

@@ -0,0 +1,93 @@
+import { createAccBuilder } from '@lit-protocol/access-control-conditions';
+import { ViemAccountAuthenticator } from '@lit-protocol/auth';
+import { createSiweMessage } from '@lit-protocol/auth-helpers';
+import { createEnvVars } from '../../helper/createEnvVars';
+import { createTestAccount } from '../../helper/createTestAccount';
+import { createTestEnv } from '../../helper/createTestEnv';
+
+const CHECK_CONDITIONS_LIT_ACTION = `
+(async () => {
+  const { conditions, authSig } = jsParams;
+  const isAuthorized = await Lit.Actions.checkConditions({
+    conditions,
+    authSig,
+    chain: 'ethereum',
+  });
+
+  Lit.Actions.setResponse({ response: isAuthorized ? 'true' : 'false' });
+})();
+`;
+
+describe('PKP AuthSig Access Control', () => {
+  let testEnv: Awaited<ReturnType<typeof createTestEnv>>;
+
+  beforeAll(async () => {
+    const envVars = createEnvVars();
+    testEnv = await createTestEnv(envVars);
+  });
+
+  it('allows a PKP to satisfy wallet-ownership ACCs via a PKP-generated authSig', async () => {
+    const pkpOwner = await createTestAccount(testEnv, {
+      label: 'PKP ACC Owner',
+      fundAccount: true,
+      fundLedger: true,
+      hasEoaAuthContext: true,
+      hasPKP: true,
+      fundPKP: true,
+      hasPKPAuthContext: true,
+      fundPKPLedger: true,
+    });
+
+    const { pkp, pkpAuthContext, pkpViemAccount } = pkpOwner;
+
+    if (!pkp || !pkp.ethAddress) {
+      throw new Error(
+        'PKP data with ethereum address is required for this test'
+      );
+    }
+
+    if (!pkpAuthContext) {
+      throw new Error('PKP auth context was not created');
+    }
+
+    if (!pkpViemAccount) {
+      throw new Error('PKP viem account was not initialized');
+    }
+
+    // Ensure the PKP ledger has enough balance to pay for executeJs
+    await testEnv.masterPaymentManager.depositForUser({
+      userAddress: pkp.ethAddress as `0x${string}`,
+      amountInEth: '0.2',
+    });
+
+    const accessControlConditions = createAccBuilder()
+      .requireWalletOwnership(pkp.ethAddress)
+      .on('ethereum')
+      .build();
+
+    const siweMessage = await createSiweMessage({
+      walletAddress: pkpViemAccount.address,
+      nonce: (await testEnv.litClient.getContext()).latestBlockhash,
+    });
+
+    const pkpAuthSig = await ViemAccountAuthenticator.createAuthSig(
+      pkpViemAccount,
+      siweMessage
+    );
+
+    expect(pkpAuthSig.address?.toLowerCase()).toBe(
+      pkp.ethAddress.toLowerCase()
+    );
+
+    const executionResult = await testEnv.litClient.executeJs({
+      code: CHECK_CONDITIONS_LIT_ACTION,
+      authContext: pkpAuthContext,
+      jsParams: {
+        conditions: accessControlConditions,
+        // authSig: pkpAuthSig,
+      },
+    });
+
+    expect(executionResult.response).toBe('true');
+  });
+});