feat(networks): enable naga-local overrides with bundled signatures helper

Author: Ansonhkg

packages/contracts/src/custom-network-signatures.ts

@@ -34,14 +34,24 @@ interface ContractInfo {
   name: string;
 }
 
-interface GenerateSignaturesOptions {
+export interface GenerateSignaturesOptions {
   jsonFilePath: string;
   networkName?: string;
   outputDir?: string;
   useScriptDirectory?: boolean; // If true, paths are relative to script location
   callerPath?: string; // The import.meta.url of the calling script
 }
 
+export interface BuildSignaturesFromContextOptions
+  extends Omit<GenerateSignaturesOptions, 'outputDir'> {}
+
+export interface BuildSignaturesFromContextResult {
+  signatures: GeneratedSignatures;
+  networkName: string;
+  resolvedJsonPath: string;
+  baseDirectory: string;
+}
+
 /**
  * Gets the base directory for resolving paths
  * @param useScriptDirectory - Whether to use script's directory or current working directory
@@ -179,6 +189,43 @@ function generateAbiSignatures(networkData: NetworkCache) {
   return signatures;
 }
 
+export type GeneratedSignatures = ReturnType<typeof generateAbiSignatures>;
+
+export function buildSignaturesFromContext(
+  options: BuildSignaturesFromContextOptions
+): BuildSignaturesFromContextResult {
+  const {
+    jsonFilePath,
+    networkName = 'custom-network',
+    useScriptDirectory = false,
+    callerPath,
+  } = options;
+
+  if (useScriptDirectory && !callerPath) {
+    throw new Error(
+      'callerPath (import.meta.url) is required when useScriptDirectory is true'
+    );
+  }
+
+  const baseDirectory = getBaseDirectory(useScriptDirectory, callerPath);
+  const resolvedJsonPath = resolvePath(jsonFilePath, baseDirectory);
+
+  console.log(`📝 Processing custom network context: ${resolvedJsonPath}`);
+
+  const rawJsonData = JSON.parse(fs.readFileSync(resolvedJsonPath, 'utf8'));
+  const jsonData = convertToNetworkCache(rawJsonData, networkName);
+
+  console.log('📊 Generating signatures...');
+  const signatures = generateAbiSignatures(jsonData);
+
+  return {
+    signatures,
+    networkName,
+    resolvedJsonPath,
+    baseDirectory,
+  };
+}
+
 /**
  * Generates signature files from a network context JSON file
  * @param options - Configuration options
@@ -187,45 +234,24 @@ function generateAbiSignatures(networkData: NetworkCache) {
 export async function generateSignaturesFromContext(
   options: GenerateSignaturesOptions
 ): Promise<void> {
-  const {
-    jsonFilePath,
-    networkName = 'custom-network',
-    outputDir = './dist/signatures',
-    useScriptDirectory = false,
-    callerPath,
-  } = options;
-
   try {
-    if (useScriptDirectory && !callerPath) {
-      throw new Error(
-        'callerPath (import.meta.url) is required when useScriptDirectory is true'
-      );
-    }
+    const {
+      signatures,
+      networkName,
+      resolvedJsonPath,
+      baseDirectory,
+    } = buildSignaturesFromContext(options);
 
-    const baseDir = getBaseDirectory(useScriptDirectory, callerPath);
-    // Don't force relative for jsonFilePath (allow absolute paths)
-    const resolvedJsonPath = resolvePath(jsonFilePath, baseDir);
-    // Force relative for outputDir (always relative to script)
-    const resolvedOutputDir = resolvePath(outputDir, baseDir, true);
+    const outputDir = options.outputDir ?? './dist/signatures';
+    const resolvedOutputDir = resolvePath(outputDir, baseDirectory, true);
 
     // Ensure output directory exists
     if (!fs.existsSync(resolvedOutputDir)) {
       fs.mkdirSync(resolvedOutputDir, { recursive: true });
     }
 
-    console.log(`📝 Processing custom network context: ${resolvedJsonPath}`);
     console.log(`📁 Output directory: ${resolvedOutputDir}`);
 
-    // Read and parse the JSON file
-    const rawJsonData = JSON.parse(fs.readFileSync(resolvedJsonPath, 'utf8'));
-
-    // Convert to NetworkCache format
-    const jsonData = convertToNetworkCache(rawJsonData, networkName);
-
-    // Generate signatures using the standard format
-    console.log('📊 Generating signatures...');
-    const signatures = generateAbiSignatures(jsonData);
-
     // Write signatures to file
     const outputPath = path.join(resolvedOutputDir, `${networkName}.js`);
     const outputPathCjs = path.join(resolvedOutputDir, `${networkName}.cjs`);

packages/e2e/src/init.ts

@@ -125,7 +125,32 @@ export const init = async (
 
   // Dynamic import of network module
   const networksModule = await import('@lit-protocol/networks');
-  const _baseNetworkModule = networksModule[config.importName];
+  let _baseNetworkModule = networksModule[config.importName];
+
+  if (_network === 'naga-local') {
+    const localContextPath = process.env['NAGA_LOCAL_CONTEXT_PATH'];
+    if (localContextPath) {
+      const withLocalContext = (_baseNetworkModule as any)?.withLocalContext;
+
+      if (typeof withLocalContext === 'function') {
+        const localContextName = process.env['NAGA_LOCAL_CONTEXT_NAME'];
+
+        console.log(
+          '✅ Loading naga-local signatures from NAGA_LOCAL_CONTEXT_PATH:',
+          localContextPath
+        );
+
+        _baseNetworkModule = await withLocalContext({
+          networkContextPath: localContextPath,
+          networkName: localContextName,
+        });
+      } else {
+        console.warn(
+          '⚠️ NAGA_LOCAL_CONTEXT_PATH is set but nagaLocal.withLocalContext is unavailable in the current networks build.'
+        );
+      }
+    }
+  }
 
   // Optional RPC override from env
   const rpcOverride = process.env['LIT_YELLOWSTONE_PRIVATE_RPC_URL'];

packages/networks/src/networks/vNaga/envs/naga-local/index.ts

@@ -1 +1,2 @@
 export { nagaLocal } from './naga-local.module';
+export type { NagaLocal, NagaLocalContextOptions } from './naga-local.module';

packages/networks/src/networks/vNaga/envs/naga-local/naga-local.env.ts

@@ -3,7 +3,7 @@ import * as chainInfo from '../../../../chains/Anvil';
 import { NAGA_ENDPOINT } from '../../shared/managers/endpoints-manager/endpoints';
 import type { NagaEndpointsType } from '../../shared/managers/endpoints-manager/endpoints';
 import { BaseNetworkEnvironment } from '../base/BaseNetworkEnvironment';
-import { signatures } from './generated/naga-develop';
+import { signatures as defaultSignatures } from './generated/naga-develop';
 
 const NETWORK = 'custom';
 const PROTOCOL = 'http://'; // Note: Different from dev/staging
@@ -15,16 +15,20 @@ export interface NagaLocalSpecificConfigs {
   privateKey?: Hex; // Note: Local has private key config
 }
 
-export type NagaLocalSignatures = typeof signatures;
+export type NagaLocalSignatures = typeof defaultSignatures;
 
 export class NagaLocalEnvironment extends BaseNetworkEnvironment<
   NagaLocalSignatures,
   NagaLocalSpecificConfigs
 > {
-  constructor(options?: { rpcUrlOverride?: string }) {
+  constructor(options?: {
+    rpcUrlOverride?: string;
+    signatures?: NagaLocalSignatures;
+  }) {
+    const resolvedSignatures = options?.signatures ?? defaultSignatures;
     super({
       network: NETWORK,
-      abiSignatures: signatures, // Note: Uses locally generated signatures
+      abiSignatures: resolvedSignatures, // Note: Uses locally generated signatures
       networkSpecificConfigs: {
         realmId: DEFAULT_REALM_ID,
         privateKey: chainInfo.DEV_PRIVATE_KEY, // Note: Includes private key

packages/networks/src/networks/vNaga/envs/naga-local/naga-local.module.ts

@@ -1,21 +1,76 @@
+import { buildSignaturesFromContext } from '@lit-protocol/contracts/custom-network-signatures';
 import { createBaseModule } from '../../shared/factories/BaseModuleFactory';
-import { createChainManager } from './chain-manager/createChainManager';
-import { nagaLocalEnvironment } from './naga-local.env';
+import { createChainManagerFactory } from '../../shared/factories/BaseChainManagerFactory';
+import {
+  NagaLocalEnvironment,
+  nagaLocalEnvironment,
+  type NagaLocalSignatures,
+} from './naga-local.env';
 import type { ExpectedAccountOrWalletClient } from '../../shared/managers/contract-manager/createContractsManager';
 
-const baseModule = createBaseModule({
-  networkConfig: nagaLocalEnvironment.getConfig(),
-  moduleName: nagaLocalEnvironment.getNetworkName(),
-  createChainManager: (account: ExpectedAccountOrWalletClient) =>
-    createChainManager(account),
-});
-
-// Add local-specific methods and maintain backward compatibility
-const nagaLocal = {
-  ...baseModule,
-  // Local environment specific getter for private key
-  getPrivateKey: () => nagaLocalEnvironment.getPrivateKey(),
+type NagaLocalContextOptions = {
+  networkContextPath: string;
+  networkName?: string;
+  rpcUrlOverride?: string;
 };
 
-export type NagaLocal = typeof nagaLocal;
+const createChainManager = (
+  env: NagaLocalEnvironment,
+  account: ExpectedAccountOrWalletClient
+) => createChainManagerFactory(env.getConfig(), account);
+
+const buildModule = (env: NagaLocalEnvironment) => {
+  const base = createBaseModule({
+    networkConfig: env.getConfig(),
+    moduleName: env.getNetworkName(),
+    createChainManager: (account: ExpectedAccountOrWalletClient) =>
+      createChainManager(env, account),
+  });
+
+  const createWithEnv = (nextEnv: NagaLocalEnvironment) =>
+    buildModule(nextEnv);
+
+  const withOverrides = (overrides: { rpcUrl?: string }) => {
+    const resolvedRpc =
+      overrides.rpcUrl ?? env.getConfig().rpcUrl;
+
+    return createWithEnv(
+      new NagaLocalEnvironment({
+        rpcUrlOverride: resolvedRpc,
+        signatures: env.getConfig().abiSignatures,
+      })
+    );
+  };
+
+  const withLocalContext = (options: NagaLocalContextOptions) => {
+    const { networkContextPath, networkName, rpcUrlOverride } = options;
+
+    const { signatures } = buildSignaturesFromContext({
+      jsonFilePath: networkContextPath,
+      networkName: networkName ?? 'naga-develop',
+    });
+
+    const resolvedSignatures =
+      signatures as unknown as NagaLocalSignatures;
+
+    return createWithEnv(
+      new NagaLocalEnvironment({
+        rpcUrlOverride: rpcUrlOverride ?? env.getConfig().rpcUrl,
+        signatures: resolvedSignatures,
+      })
+    );
+  };
+
+  return {
+    ...base,
+    getPrivateKey: () => env.getPrivateKey(),
+    withOverrides,
+    withLocalContext,
+  };
+};
+
+const nagaLocal = buildModule(nagaLocalEnvironment);
+
+export type NagaLocal = ReturnType<typeof buildModule>;
+export type { NagaLocalContextOptions };
 export { nagaLocal };

packages/networks/src/networks/vNaga/index.ts

@@ -1,6 +1,9 @@
 // Naga Local
 export { nagaLocal } from './envs/naga-local';
-export type { NagaLocal as NagaLocalModule } from './envs/naga-local/naga-local.module';
+export type {
+  NagaLocal as NagaLocalModule,
+  NagaLocalContextOptions,
+} from './envs/naga-local/naga-local.module';
 
 // Naga Dev
 export { nagaDev } from './envs/naga-dev';