chore: WiP - still need to test explicit imports from 'bare' (non node: prefixed) builtins in deps

But it appears to be alive

Author: MaximusHaximus

packages/libs/lit-action-bundler/src/lib/shims/buffer.ts renamed to packages/libs/lit-action-bundler/buffer.js

@@ -2,6 +2,4 @@
 // @ts-nocheck
 export * from 'node:buffer';
 import { default as buffer } from 'node:buffer';
-export const kMaxLength = 4294967296;
-buffer.kMaxLength = kMaxLength;
 export default buffer;

packages/libs/lit-action-bundler/package.json

@@ -29,9 +29,15 @@
     "!**/*.tsbuildinfo"
   ],
   "dependencies": {
+    "@lit-protocol/auth-helpers": "^7.2.0",
+    "@lit-protocol/constants": "^7.2.0",
+    "@lit-protocol/lit-node-client": "^7.2.0",
     "esbuild": "^0.25.5",
     "ethers": "5.8.0",
     "ipfs-only-hash": "^4.0.0",
     "tslib": "^2.8.1"
+  },
+  "devDependencies": {
+    "@lit-protocol/types": "^7.2.0"
   }
 }

packages/libs/lit-action-bundler/src/LitNodeClient/LitNodeClientInstance.ts

@@ -0,0 +1,71 @@
+import type { LIT_NETWORKS_KEYS } from '@lit-protocol/types';
+
+import { LitNodeClient } from '@lit-protocol/lit-node-client';
+
+export class LitNodeClientInstance {
+  private readonly litNodeClientInstance: LitNodeClient;
+
+  private isConnected = false;
+
+  private connectHandle: Promise<boolean> | null = null;
+
+  constructor({ network }: { network: LIT_NETWORKS_KEYS }) {
+    this.litNodeClientInstance = new LitNodeClient({
+      debug: true,
+      litNetwork: network,
+    });
+  }
+
+  async connect(): Promise<boolean> {
+    if (!this.isConnected) {
+      // Coalesce concurrent calls
+      if (this.connectHandle) {
+        return this.connectHandle;
+      }
+
+      // Stash a handle so concurrent calls to connect are coaelesced into 1
+      this.connectHandle = this.litNodeClientInstance.connect().then(() => true);
+
+      try {
+        // Don't return until we know the result of pending connect attempt
+        await this.connectHandle;
+        this.isConnected = true;
+      } catch (e) {
+        // We allow multiple calls to (retries!) to `connect()` even in case where one succeeded
+        // if `isConnected` is false (e.g. a prior attempt failed)
+        this.isConnected = false;
+        throw e;
+      } finally {
+        this.connectHandle = null;
+      }
+      return this.isConnected;
+    }
+
+    return true;
+  }
+
+  async disconnect(): Promise<void> {
+    if (!this.isConnected && this.connectHandle) {
+      // Wait for connect attempt to finish so we don't end up just re-adding the listener when it finishes.
+      try {
+        await this.connectHandle;
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      } catch (e) {
+        /* Ignore errors on connect; we're disconnecting! */
+      }
+    }
+
+    try {
+      await this.litNodeClientInstance.disconnect();
+    } catch (e) {
+      /* We did our best */
+      console.log('Failed to disconnect from LitNodeClientInstance.', (e as Error).message);
+    } finally {
+      this.isConnected = false;
+    }
+  }
+
+  get litNodeClient(): LitNodeClient {
+    return this.litNodeClientInstance;
+  }
+}

packages/libs/lit-action-bundler/src/LitNodeClient/generateVincentToolSessionSigs.ts

@@ -0,0 +1,47 @@
+// src/toolClient/execute/generateVincentToolSessionSigs.ts
+
+import type { ethers } from 'ethers';
+
+import type { LitNodeClient } from '@lit-protocol/lit-node-client';
+
+import {
+  createSiweMessageWithRecaps,
+  generateAuthSig,
+  LitActionResource,
+  LitPKPResource,
+} from '@lit-protocol/auth-helpers';
+import { LIT_ABILITY } from '@lit-protocol/constants';
+
+/** @hidden */
+export const generateVincentToolSessionSigs = async ({
+  litNodeClient,
+  ethersSigner,
+}: {
+  litNodeClient: LitNodeClient;
+  ethersSigner: ethers.Signer;
+}) => {
+  return litNodeClient.getSessionSigs({
+    chain: 'ethereum',
+    resourceAbilityRequests: [
+      { resource: new LitPKPResource('*'), ability: LIT_ABILITY.PKPSigning },
+      { resource: new LitActionResource('*'), ability: LIT_ABILITY.LitActionExecution },
+    ],
+    authNeededCallback: async ({ resourceAbilityRequests, uri }) => {
+      const [walletAddress, nonce] = await Promise.all([
+        ethersSigner.getAddress(),
+        litNodeClient.getLatestBlockhash(),
+      ]);
+
+      const toSign = await createSiweMessageWithRecaps({
+        uri: uri || 'http://localhost:3000',
+        expiration: new Date(Date.now() + 1000 * 60 * 10).toISOString(),
+        resources: resourceAbilityRequests || [],
+        walletAddress,
+        nonce,
+        litNodeClient,
+      });
+
+      return await generateAuthSig({ signer: ethersSigner, toSign });
+    },
+  });
+};

packages/libs/lit-action-bundler/src/LitNodeClient/getLitNodeClient.ts

@@ -0,0 +1,32 @@
+import type { LitNodeClient } from '@lit-protocol/lit-node-client';
+import type { LIT_NETWORKS_KEYS } from '@lit-protocol/types';
+
+import { LitNodeClientInstance } from './LitNodeClientInstance';
+
+let instance: LitNodeClientInstance | null = null;
+
+export async function getLitNodeClientInstance({
+  network,
+}: {
+  network: LIT_NETWORKS_KEYS;
+}): Promise<LitNodeClient> {
+  if (instance) {
+    // connect() is idempotent; if we're retrying from outside, attempt to connect again
+    // This is a no-op if already connected 🎉 but if a prior attempt fails, it'll try again.
+    await instance.connect();
+    return instance.litNodeClient;
+  }
+
+  instance = new LitNodeClientInstance({ network });
+  await instance.connect();
+
+  return instance.litNodeClient;
+}
+
+export async function disconnectLitNodeClientInstance() {
+  if (instance) {
+    await instance.disconnect();
+    instance = null;
+  }
+  return true;
+}

packages/libs/lit-action-bundler/src/bundleTest.spec.ts

@@ -2,15 +2,37 @@ import type { BuildResult } from 'esbuild';
 
 import path from 'path';
 
-import esbuild from 'esbuild';
+import { build } from 'esbuild';
 
 import type { BuildLitActionOptions } from './types';
 
 import { aliasFetch } from './plugins/aliasFetch';
 import { createBundledFile } from './plugins/createBundledFile';
+import { nodeBuiltinDenoShims } from './plugins/nodeBuiltinDenoShims';
 import { wrapIIFEInStringPlugin } from './plugins/wrapIIFEInString';
 import { assertOutputFiles } from './utils';
 
+export function getCompatPluginCreators() {
+  return {
+    aliasFetch: aliasFetch,
+    nodeBuiltinDenoShims: nodeBuiltinDenoShims,
+    wrapIIFEInStringPlugin: wrapIIFEInStringPlugin,
+    createBundledFile: createBundledFile,
+  };
+}
+
+export const esbuildConfigDefaults = {
+  bundle: true,
+  minify: false,
+  sourcemap: false,
+  treeShaking: true,
+  metafile: true,
+  // inject: [path.resolve(__dirname, './plugins/node-global-shims.ts')],
+  platform: 'browser' as const,
+  write: false,
+  external: ['node:*'],
+};
+
 /** Builds a Lit Action
  */
 export async function buildLitAction({
@@ -21,35 +43,34 @@ export async function buildLitAction({
 }: BuildLitActionOptions) {
   const sourceDir = path.dirname(entryPoint);
 
-  await esbuild
-    .build({
-      outdir,
-      tsconfig: tsconfigPath,
-      entryPoints: [entryPoint],
-      bundle: true,
-      minify: false,
-      sourcemap: false,
-      treeShaking: true,
-      metafile: true,
-      plugins: [
-        aliasFetch(),
-        await wrapIIFEInStringPlugin(),
-        await createBundledFile({ sourceDir: sourceDir, getLitActionHandler: getLitActionHandler }),
-      ],
-      platform: 'browser',
-      write: false,
-    })
-    .then((result: BuildResult) => {
-      assertOutputFiles(result);
-
-      result.outputFiles.forEach((file) => {
-        const bytes = file.text.length;
-        const mbInDecimal = (bytes / 1_000_000).toFixed(4);
-
-        const filePathArr = file.path.split('/');
-        console.log(
-          `✅ ${filePathArr.slice(filePathArr.length - 2, filePathArr.length - 1)} - ${mbInDecimal} MB`,
-        );
-      });
+  const plugins = [aliasFetch(), await nodeBuiltinDenoShims(), await wrapIIFEInStringPlugin()];
+
+  if (getLitActionHandler) {
+    plugins.push(
+      await createBundledFile({
+        sourceDir: sourceDir,
+        getLitActionHandler: getLitActionHandler,
+      }),
+    );
+  }
+
+  await build({
+    outdir,
+    tsconfig: tsconfigPath,
+    entryPoints: [entryPoint],
+    plugins,
+    ...esbuildConfigDefaults,
+  }).then((result: BuildResult) => {
+    assertOutputFiles(result);
+
+    result.outputFiles.forEach((file) => {
+      const bytes = file.text.length;
+      const mbInDecimal = (bytes / 1_000_000).toFixed(4);
+
+      const filePathArr = file.path.split('/');
+      console.log(
+        `✅ ${filePathArr.slice(filePathArr.length - 2, filePathArr.length - 1)} - ${mbInDecimal} MB`,
+      );
     });
+  });
 }

packages/libs/lit-action-bundler/src/lib/esbuild/esbuild.ts

@@ -6,7 +6,7 @@ import path from 'path';
 /** @ts-expect-error No types for this pkg */
 import Hash from 'ipfs-only-hash';
 
-import type { GetLitActionHandlerFunc } from '../types';
+import type { GetLitActionWrapperContentFunc } from '../types';
 
 import { getMetadataJsonFileContent } from '../templates';
 import { assertOutputFiles, ensureDirectoryExistence } from '../utils';
@@ -16,7 +16,7 @@ export async function createBundledFile({
   getLitActionHandler,
 }: {
   sourceDir: string;
-  getLitActionHandler: GetLitActionHandlerFunc;
+  getLitActionHandler: GetLitActionWrapperContentFunc;
 }): Promise<Plugin> {
   return {
     name: `create-bundled-lit-action-file`,

packages/libs/lit-action-bundler/src/lib/esbuild/plugins/createBundledFile.ts

@@ -0,0 +1,8 @@
+// shims/node-globals.ts
+export { Buffer } from 'node:buffer';
+export { setTimeout, clearTimeout } from 'node:timers';
+export const process = {
+  env: {
+    NODE_ENV: 'production',
+  },
+};

packages/libs/lit-action-bundler/src/lib/esbuild/plugins/node-global-shims.ts

@@ -0,0 +1,85 @@
+import type { Plugin } from 'esbuild';
+
+import path from 'path';
+
+// Path to the shims directory relative to this file
+const SHIMS_DIR = '../../shims';
+
+export function nodeBuiltinDenoShims(): Plugin {
+  return {
+    name: 'node-builtin-deno-shims',
+    setup(build) {
+      // Handle top-level modules
+      build.onResolve(
+        {
+          filter:
+            /^(node:)?(assert|async_hooks|console|constants|crypto|dgram|dns|events|http|http2|https|net|os|path|querystring|readline|stream|string_decoder|timers|url|util|zlib)$/,
+        },
+        (args) => {
+          const moduleName = args.path.replace(/^node:/, '');
+          const shimPath = path.resolve(__dirname, path.join(SHIMS_DIR, `${moduleName}.js`));
+          return { path: shimPath };
+        },
+      );
+
+      // Handle stream submodules
+      build.onResolve(
+        { filter: /^(node:)?_stream_(duplex|passthrough|readable|transform|writable)$/ },
+        (args) => {
+          const moduleName = args.path.replace(/^node:/, '');
+          const shimPath = path.resolve(__dirname, path.join(SHIMS_DIR, `${moduleName}.js`));
+          return { path: shimPath };
+        },
+      );
+
+      // Handle path submodules
+      build.onResolve({ filter: /^(node:)?path\/(posix|win32)$/ }, (args) => {
+        const modulePath = args.path.replace(/^node:/, '');
+        const shimPath = path.resolve(__dirname, path.join(SHIMS_DIR, `${modulePath}.js`));
+        return { path: shimPath };
+      });
+
+      // Handle assert submodules
+      build.onResolve({ filter: /^(node:)?assert\/(strict)$/ }, (args) => {
+        const modulePath = args.path.replace(/^node:/, '');
+        const shimPath = path.resolve(__dirname, path.join(SHIMS_DIR, `${modulePath}.js`));
+        return { path: shimPath };
+      });
+
+      // Handle readline submodules
+      build.onResolve({ filter: /^(node:)?readline\/(promises)$/ }, (args) => {
+        const modulePath = args.path.replace(/^node:/, '');
+        const shimPath = path.resolve(__dirname, path.join(SHIMS_DIR, `${modulePath}.js`));
+        return { path: shimPath };
+      });
+
+      // Handle stream submodules
+      build.onResolve({ filter: /^(node:)?stream\/(consumers|promises|web)$/ }, (args) => {
+        const modulePath = args.path.replace(/^node:/, '');
+        const shimPath = path.resolve(__dirname, path.join(SHIMS_DIR, `${modulePath}.js`));
+        return { path: shimPath };
+      });
+
+      // Handle timers submodules
+      build.onResolve({ filter: /^(node:)?timers\/(promises)$/ }, (args) => {
+        const modulePath = args.path.replace(/^node:/, '');
+        const shimPath = path.resolve(__dirname, path.join(SHIMS_DIR, `${modulePath}.js`));
+        return { path: shimPath };
+      });
+
+      // Handle dns submodules
+      build.onResolve({ filter: /^(node:)?dns\/(promises)$/ }, (args) => {
+        const modulePath = args.path.replace(/^node:/, '');
+        const shimPath = path.resolve(__dirname, path.join(SHIMS_DIR, `${modulePath}.js`));
+        return { path: shimPath };
+      });
+
+      // Handle util submodules
+      build.onResolve({ filter: /^(node:)?util\/(types)$/ }, (args) => {
+        const modulePath = args.path.replace(/^node:/, '');
+        const shimPath = path.resolve(__dirname, path.join(SHIMS_DIR, `${modulePath}.js`));
+        return { path: shimPath };
+      });
+    },
+  };
+}