moonwall 1.0.0-dev.0

package/dist/services/config/configAccessors.js

@@ -0,0 +1,149 @@
+import { readFileSync } from "node:fs";
+import JSONC from "jsonc-parser";
+import path, { extname } from "node:path";
+let cachedConfig;
+/**
+ * Sets the cached config. Used by async loaders to populate the cache.
+ * @internal
+ */
+export function setCachedConfig(config) {
+    cachedConfig = config;
+}
+/**
+ * Gets the cached config if available.
+ * @internal
+ */
+export function getCachedConfig() {
+    return cachedConfig;
+}
+function parseConfigSync(filePath) {
+    let result;
+    const file = readFileSync(filePath, "utf8");
+    switch (extname(filePath)) {
+        case ".json":
+            result = JSON.parse(file);
+            break;
+        case ".config":
+            result = JSONC.parse(file);
+            break;
+        default:
+            result = undefined;
+            break;
+    }
+    return result;
+}
+function replaceEnvVars(value) {
+    if (typeof value === "string") {
+        return value.replace(/\$\{([^}]+)\}/g, (match, group) => {
+            const envVarValue = process.env[group];
+            return envVarValue || match;
+        });
+    }
+    if (Array.isArray(value)) {
+        return value.map(replaceEnvVars);
+    }
+    if (typeof value === "object" && value !== null) {
+        return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, replaceEnvVars(v)]));
+    }
+    return value;
+}
+/**
+ * Imports the Moonwall config from the path specified in MOON_CONFIG_PATH.
+ * Uses a cached version if available.
+ */
+export function importJsonConfig() {
+    if (cachedConfig) {
+        return cachedConfig;
+    }
+    const configPath = process.env.MOON_CONFIG_PATH;
+    if (!configPath) {
+        throw new Error("No moonwall config path set. This is a defect, please raise it.");
+    }
+    const filePath = path.isAbsolute(configPath) ? configPath : path.join(process.cwd(), configPath);
+    try {
+        const config = parseConfigSync(filePath);
+        const replacedConfig = replaceEnvVars(config);
+        cachedConfig = replacedConfig;
+        return cachedConfig;
+    }
+    catch (e) {
+        console.error(e);
+        throw new Error(`Error import config at ${filePath}`, { cause: e });
+    }
+}
+/**
+ * Caches the config from the MOON_CONFIG_PATH environment variable.
+ */
+export function cacheConfig() {
+    const configPath = process.env.MOON_CONFIG_PATH;
+    if (!configPath) {
+        throw new Error(`Environment ${process.env.MOON_TEST_ENV} not found in config`);
+    }
+    const filePath = path.isAbsolute(configPath) ? configPath : path.join(process.cwd(), configPath);
+    try {
+        const config = parseConfigSync(filePath);
+        const replacedConfig = replaceEnvVars(config);
+        cachedConfig = replacedConfig;
+    }
+    catch (e) {
+        console.error(e);
+        throw new Error(`Error import config at ${filePath}`, { cause: e });
+    }
+}
+/**
+ * Gets the current environment configuration based on MOON_TEST_ENV.
+ */
+export function getEnvironmentFromConfig() {
+    const globalConfig = importJsonConfig();
+    const config = globalConfig.environments.find(({ name }) => name === process.env.MOON_TEST_ENV);
+    if (!config) {
+        throw new Error(`Environment ${process.env.MOON_TEST_ENV} not found in config`);
+    }
+    return config;
+}
+/**
+ * Checks if the current environment is an Ethereum-compatible dev config.
+ */
+export function isEthereumDevConfig() {
+    const env = getEnvironmentFromConfig();
+    return env.foundation.type === "dev" && !env.foundation.launchSpec[0].disableDefaultEthProviders;
+}
+/**
+ * Checks if the current environment is an Ethereum-compatible zombie config.
+ */
+export function isEthereumZombieConfig() {
+    const env = getEnvironmentFromConfig();
+    return env.foundation.type === "zombie" && !env.foundation.zombieSpec.disableDefaultEthProviders;
+}
+/**
+ * Checks if a specific option is set in the current environment config.
+ */
+export function isOptionSet(option) {
+    const env = getEnvironmentFromConfig();
+    const optionValue = traverseConfig(env, option);
+    return optionValue !== undefined;
+}
+function traverseConfig(configObj, option) {
+    if (typeof configObj !== "object" || !configObj)
+        return undefined;
+    if (Object.hasOwn(configObj, option)) {
+        return configObj[option];
+    }
+    for (const key in configObj) {
+        const result = traverseConfig(configObj[key], option);
+        if (result !== undefined) {
+            return result;
+        }
+    }
+    return undefined;
+}
+/**
+ * Loads environment variables defined in the current environment config.
+ */
+export function loadEnvVars() {
+    const env = getEnvironmentFromConfig();
+    for (const envVar of env.envVars || []) {
+        const [key, value] = envVar.split("=");
+        process.env[key] = value;
+    }
+}

package/dist/services/config/index.d.ts

@@ -0,0 +1,2 @@
+export { importJsonConfig, cacheConfig, getEnvironmentFromConfig, isEthereumDevConfig, isEthereumZombieConfig, isOptionSet, loadEnvVars, setCachedConfig, getCachedConfig, } from "./configAccessors.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/services/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/config/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,WAAW,EACX,wBAAwB,EACxB,mBAAmB,EACnB,sBAAsB,EACtB,WAAW,EACX,WAAW,EACX,eAAe,EACf,eAAe,GAChB,6BAA6B"}

package/dist/services/config/index.js

@@ -0,0 +1 @@
+export { importJsonConfig, cacheConfig, getEnvironmentFromConfig, isEthereumDevConfig, isEthereumZombieConfig, isOptionSet, loadEnvVars, setCachedConfig, getCachedConfig, } from "./configAccessors.js";

package/dist/services/errors.d.ts

@@ -0,0 +1,72 @@
+declare const PortDiscoveryError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "PortDiscoveryError";
+} & Readonly<A>;
+/**
+ * Error thrown when port discovery fails
+ */
+export declare class PortDiscoveryError extends PortDiscoveryError_base<{
+    readonly cause: unknown;
+    readonly pid: number;
+    readonly attempts: number;
+}> {
+}
+declare const NodeLaunchError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "NodeLaunchError";
+} & Readonly<A>;
+/**
+ * Error thrown when node launch fails
+ */
+export declare class NodeLaunchError extends NodeLaunchError_base<{
+    readonly cause: unknown;
+    readonly command: string;
+    readonly args: ReadonlyArray<string>;
+}> {
+}
+declare const NodeReadinessError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "NodeReadinessError";
+} & Readonly<A>;
+/**
+ * Error thrown when node readiness check fails
+ */
+export declare class NodeReadinessError extends NodeReadinessError_base<{
+    readonly cause: unknown;
+    readonly port: number;
+    readonly attemptsExhausted: number;
+}> {
+}
+declare const ProcessError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ProcessError";
+} & Readonly<A>;
+/**
+ * Error thrown when process operations fail
+ */
+export declare class ProcessError extends ProcessError_base<{
+    readonly cause: unknown;
+    readonly pid?: number;
+    readonly operation: "spawn" | "kill" | "check";
+}> {
+}
+declare const StartupCacheError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "StartupCacheError";
+} & Readonly<A>;
+/**
+ * Error thrown when startup cache operations fail
+ */
+export declare class StartupCacheError extends StartupCacheError_base<{
+    readonly cause: unknown;
+    readonly operation: "hash" | "precompile" | "cache" | "lock" | "chainspec";
+}> {
+}
+declare const FileLockError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").Equals<A, {}> extends true ? void : { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }) => import("effect/Cause").YieldableError & {
+    readonly _tag: "FileLockError";
+} & Readonly<A>;
+/**
+ * Error thrown when file lock operations fail
+ */
+export declare class FileLockError extends FileLockError_base<{
+    readonly reason: "timeout" | "acquisition_failed";
+    readonly lockPath: string;
+}> {
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/services/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/services/errors.ts"],"names":[],"mappings":";;;AAEA;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,wBAAuC;IAC7E,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B,CAAC;CAAG;;;;AAEL;;GAEG;AACH,qBAAa,eAAgB,SAAQ,qBAAoC;IACvE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC;CACtC,CAAC;CAAG;;;;AAEL;;GAEG;AACH,qBAAa,kBAAmB,SAAQ,wBAAuC;IAC7E,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,iBAAiB,EAAE,MAAM,CAAC;CACpC,CAAC;CAAG;;;;AAEL;;GAEG;AACH,qBAAa,YAAa,SAAQ,kBAAiC;IACjE,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,OAAO,GAAG,MAAM,GAAG,OAAO,CAAC;CAChD,CAAC;CAAG;;;;AAEL;;GAEG;AACH,qBAAa,iBAAkB,SAAQ,uBAAsC;IAC3E,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,GAAG,OAAO,GAAG,MAAM,GAAG,WAAW,CAAC;CAC5E,CAAC;CAAG;;;;AAEL;;GAEG;AACH,qBAAa,aAAc,SAAQ,mBAAkC;IACnE,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,oBAAoB,CAAC;IAClD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B,CAAC;CAAG"}

package/dist/services/errors.js

@@ -0,0 +1,31 @@
+import { Data } from "effect";
+/**
+ * Error thrown when port discovery fails
+ */
+export class PortDiscoveryError extends Data.TaggedError("PortDiscoveryError") {
+}
+/**
+ * Error thrown when node launch fails
+ */
+export class NodeLaunchError extends Data.TaggedError("NodeLaunchError") {
+}
+/**
+ * Error thrown when node readiness check fails
+ */
+export class NodeReadinessError extends Data.TaggedError("NodeReadinessError") {
+}
+/**
+ * Error thrown when process operations fail
+ */
+export class ProcessError extends Data.TaggedError("ProcessError") {
+}
+/**
+ * Error thrown when startup cache operations fail
+ */
+export class StartupCacheError extends Data.TaggedError("StartupCacheError") {
+}
+/**
+ * Error thrown when file lock operations fail
+ */
+export class FileLockError extends Data.TaggedError("FileLockError") {
+}

package/dist/services/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./errors.js";
+export * from "./process/index.js";
+export * from "./network/index.js";
+export * from "./chopsticks/index.js";
+export * from "./cache/index.js";
+export * from "./config/index.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/services/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"AAAA,4BAA4B;AAC5B,mCAAmC;AACnC,mCAAmC;AACnC,sCAAsC;AACtC,iCAAiC;AACjC,kCAAkC"}

package/dist/services/index.js

@@ -0,0 +1,6 @@
+export * from "./errors.js";
+export * from "./process/index.js";
+export * from "./network/index.js";
+export * from "./chopsticks/index.js";
+export * from "./cache/index.js";
+export * from "./config/index.js";

package/dist/services/network/NodeReadinessService.d.ts

@@ -0,0 +1,35 @@
+import { Socket } from "@effect/platform";
+import { Context, Effect, Layer } from "effect";
+import { NodeReadinessError } from "../errors.js";
+/**
+ * Configuration for readiness check
+ */
+export interface ReadinessConfig {
+    readonly port: number;
+    readonly isEthereumChain: boolean;
+    readonly maxAttempts?: number;
+}
+declare const NodeReadinessService_base: Context.TagClass<NodeReadinessService, "NodeReadinessService", {
+    /**
+     * Check if node is ready to accept connections
+     * @param config Readiness check configuration
+     * @returns true if node is ready
+     */
+    readonly checkReady: (config: ReadinessConfig) => Effect.Effect<boolean, NodeReadinessError>;
+}>;
+/**
+ * Service for checking node readiness via WebSocket JSON-RPC
+ */
+export declare class NodeReadinessService extends NodeReadinessService_base {
+}
+/**
+ * Live implementation of NodeReadinessService
+ */
+export declare const NodeReadinessServiceLive: Layer.Layer<NodeReadinessService, never, never>;
+/**
+ * Test implementation that accepts a custom Socket layer
+ * Used for testing with mock Sockets
+ */
+export declare const makeNodeReadinessServiceTest: (socketLayer: Layer.Layer<Socket.Socket>) => Layer.Layer<NodeReadinessService>;
+export {};
+//# sourceMappingURL=NodeReadinessService.d.ts.map

package/dist/services/network/NodeReadinessService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NodeReadinessService.d.ts","sourceRoot":"","sources":["../../../src/services/network/NodeReadinessService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAG1C,OAAO,EAAE,OAAO,EAAY,MAAM,EAAS,KAAK,EAAwB,MAAM,QAAQ,CAAC;AACvF,OAAO,EAAE,kBAAkB,EAAE,qBAAqB;AAKlD;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAC;IAClC,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;;IAQG;;;;OAIG;yBACkB,CAAC,MAAM,EAAE,eAAe,KAAK,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,kBAAkB,CAAC;;AAXhG;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,yBAUvC;CAAG;AAsKN;;GAEG;AACH,eAAO,MAAM,wBAAwB,iDAEnC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,4BAA4B,GACvC,aAAa,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,MAAM,CAAC,KACtC,KAAK,CAAC,KAAK,CAAC,oBAAoB,CAI/B,CAAC"}

package/dist/services/network/NodeReadinessService.js

@@ -0,0 +1,120 @@
+import { Socket } from "@effect/platform";
+import * as NodeSocket from "@effect/platform-node/NodeSocket";
+import { createLogger } from "../../util/index.js";
+import { Context, Deferred, Effect, Fiber, Layer, Schedule } from "effect";
+import { NodeReadinessError } from "../errors.js";
+const logger = createLogger({ name: "NodeReadinessService" });
+const debug = logger.debug.bind(logger);
+/**
+ * Service for checking node readiness via WebSocket JSON-RPC
+ */
+export class NodeReadinessService extends Context.Tag("NodeReadinessService")() {
+}
+/**
+ * Send JSON-RPC request and wait for response using Effect Socket
+ */
+const sendRpcRequest = (method) => Effect.flatMap(Deferred.make(), (responseDeferred) => Effect.flatMap(Socket.Socket, (socket) => Effect.flatMap(socket.writer, (writer) => {
+    debug(`Checking method: ${method}`);
+    const request = new TextEncoder().encode(JSON.stringify({
+        jsonrpc: "2.0",
+        id: Math.floor(Math.random() * 10000),
+        method,
+        params: [],
+    }));
+    // Set up message handler
+    const handleMessages = socket.runRaw((data) => {
+        try {
+            const message = typeof data === "string" ? data : new TextDecoder().decode(data);
+            debug(`Got message for ${method}: ${message.substring(0, 100)}`);
+            const response = JSON.parse(message);
+            debug(`Parsed response: jsonrpc=${response.jsonrpc}, error=${response.error}`);
+            if (response.jsonrpc === "2.0" && !response.error) {
+                debug(`Method ${method} succeeded!`);
+                return Deferred.succeed(responseDeferred, true);
+            }
+        }
+        catch (e) {
+            debug(`Parse error for ${method}: ${e}`);
+        }
+        return Effect.void;
+    });
+    // Send request and wait for response
+    return Effect.flatMap(Effect.fork(handleMessages), (messageFiber) => Effect.flatMap(writer(request), () => 
+    // Wait for either:
+    // 1. Deferred resolving with response (success)
+    // 2. Timeout (fails with error)
+    // Also check if the message fiber has failed
+    Deferred.await(responseDeferred).pipe(Effect.timeoutFail({
+        duration: "2 seconds",
+        onTimeout: () => new Error("RPC request timed out waiting for response"),
+    }), 
+    // After getting result, check if fiber failed and prefer that error
+    Effect.flatMap((result) => Fiber.poll(messageFiber).pipe(Effect.flatMap((pollResult) => {
+        if (pollResult._tag === "Some") {
+            const exit = pollResult.value;
+            if (exit._tag === "Failure") {
+                // Fiber failed - propagate that error instead of returning result
+                return Effect.failCause(exit.cause);
+            }
+        }
+        return Effect.succeed(result);
+    }))))).pipe(Effect.ensuring(Fiber.interrupt(messageFiber)), Effect.catchAll((cause) => Effect.fail(new NodeReadinessError({
+        cause,
+        port: 0, // Will be filled in by caller
+        attemptsExhausted: 1,
+    })))));
+})));
+/**
+ * Attempt single WebSocket readiness check using Effect Socket
+ */
+const attemptReadinessCheck = (config) => Effect.logDebug(`Attempting readiness check on port ${config.port}, isEthereum: ${config.isEthereumChain}`).pipe(Effect.flatMap(() => Effect.scoped(Effect.flatMap(sendRpcRequest("system_chain"), (systemChainOk) => {
+    if (systemChainOk) {
+        return Effect.succeed(true);
+    }
+    // If Ethereum chain, also try eth_chainId
+    if (config.isEthereumChain) {
+        return sendRpcRequest("eth_chainId");
+    }
+    return Effect.succeed(false);
+})).pipe(Effect.timeoutFail({
+    duration: "3 seconds",
+    onTimeout: () => new NodeReadinessError({
+        cause: new Error("Readiness check timed out"),
+        port: config.port,
+        attemptsExhausted: 1,
+    }),
+}), Effect.catchAll((cause) => Effect.fail(new NodeReadinessError({
+    cause,
+    port: config.port,
+    attemptsExhausted: 1,
+}))))));
+/**
+ * Check node readiness with retry (internal, requires Socket.Socket)
+ */
+const checkReadyWithRetryInternal = (config) => {
+    const maxAttempts = config.maxAttempts || 200;
+    return attemptReadinessCheck(config).pipe(Effect.retry(Schedule.fixed("50 millis").pipe(Schedule.compose(Schedule.recurs(maxAttempts - 1)))), Effect.catchAll((error) => Effect.fail(new NodeReadinessError({
+        cause: error,
+        port: config.port,
+        attemptsExhausted: maxAttempts,
+    }))));
+};
+/**
+ * Check node readiness with retry (public, provides real WebSocket layer)
+ */
+const checkReadyWithRetry = (config) => {
+    return checkReadyWithRetryInternal(config).pipe(Effect.provide(NodeSocket.layerWebSocket(`ws://localhost:${config.port}`)));
+};
+/**
+ * Live implementation of NodeReadinessService
+ */
+export const NodeReadinessServiceLive = Layer.succeed(NodeReadinessService, {
+    checkReady: checkReadyWithRetry,
+});
+/**
+ * Test implementation that accepts a custom Socket layer
+ * Used for testing with mock Sockets
+ */
+export const makeNodeReadinessServiceTest = (socketLayer) => Layer.succeed(NodeReadinessService, {
+    checkReady: (config) => checkReadyWithRetryInternal(config).pipe(Effect.provide(socketLayer)),
+});

package/dist/services/network/PortDiscoveryService.d.ts

@@ -0,0 +1,22 @@
+import { Effect, Context, Layer } from "effect";
+import { PortDiscoveryError } from "../errors.js";
+declare const PortDiscoveryService_base: Context.TagClass<PortDiscoveryService, "PortDiscoveryService", {
+    /**
+     * Discover ports used by a process ID with automatic retry
+     * @param pid Process ID to inspect
+     * @param maxAttempts Maximum number of retry attempts (default: 30)
+     * @returns First discovered port number
+     */
+    readonly discoverPort: (pid: number, maxAttempts?: number) => Effect.Effect<number, PortDiscoveryError>;
+}>;
+/**
+ * Service for discovering ports used by a process
+ */
+export declare class PortDiscoveryService extends PortDiscoveryService_base {
+}
+/**
+ * Live implementation of PortDiscoveryService
+ */
+export declare const PortDiscoveryServiceLive: Layer.Layer<PortDiscoveryService, never, never>;
+export {};
+//# sourceMappingURL=PortDiscoveryService.d.ts.map

package/dist/services/network/PortDiscoveryService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PortDiscoveryService.d.ts","sourceRoot":"","sources":["../../../src/services/network/PortDiscoveryService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAY,MAAM,QAAQ,CAAC;AAG1D,OAAO,EAAE,kBAAkB,EAAE,qBAAqB;;IAU9C;;;;;OAKG;2BACoB,CACrB,GAAG,EAAE,MAAM,EACX,WAAW,CAAC,EAAE,MAAM,KACjB,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC;;AAflD;;GAEG;AACH,qBAAa,oBAAqB,SAAQ,yBAcvC;CAAG;AAgGN;;GAEG;AACH,eAAO,MAAM,wBAAwB,iDAEnC,CAAC"}

package/dist/services/network/PortDiscoveryService.js

@@ -0,0 +1,77 @@
+import { Effect, Context, Layer, Schedule } from "effect";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import { PortDiscoveryError } from "../errors.js";
+const execAsync = promisify(exec);
+/**
+ * Service for discovering ports used by a process
+ */
+export class PortDiscoveryService extends Context.Tag("PortDiscoveryService")() {
+}
+/**
+ * Parse ports from lsof output
+ * Example lsof line: "node 97796 user 26u IPv6 0xb6c3e894a2247189 0t0 TCP *:8000 (LISTEN)"
+ */
+const parsePortsFromLsof = (stdout) => {
+    const ports = [];
+    const lines = stdout.split("\n");
+    for (const line of lines) {
+        const regex = /(?:.+):(\d+)/;
+        const match = line.match(regex);
+        if (match) {
+            ports.push(Number.parseInt(match[1], 10));
+        }
+    }
+    return ports;
+};
+/**
+ * Attempt to discover ports for a given PID
+ */
+const attemptPortDiscovery = (pid) => Effect.tryPromise({
+    try: () => execAsync(`lsof -p ${pid} -n -P | grep LISTEN`),
+    catch: (cause) => new PortDiscoveryError({
+        cause,
+        pid,
+        attempts: 1,
+    }),
+}).pipe(Effect.flatMap(({ stdout }) => {
+    const ports = parsePortsFromLsof(stdout);
+    if (ports.length === 0) {
+        return Effect.fail(new PortDiscoveryError({
+            cause: new Error("No ports found in lsof output"),
+            pid,
+            attempts: 1,
+        }));
+    }
+    // Find RPC port with fallback logic:
+    // 1. Exclude the p2p port 30333 and metrics port 9615
+    // 2. If only one port found, accept it (must be the RPC port)
+    // 3. Otherwise fail with informative error
+    const rpcPort = ports.find((p) => p !== 30333 && p !== 9615);
+    if (!rpcPort) {
+        // Fallback: if only one port, it must be the RPC port (e.g., Chopsticks ephemeral ports)
+        if (ports.length === 1) {
+            return Effect.succeed(ports[0]);
+        }
+        return Effect.fail(new PortDiscoveryError({
+            cause: new Error(`No RPC port found in range 9000-20000 and multiple ports detected (found ports: ${ports.join(", ")})`),
+            pid,
+            attempts: 1,
+        }));
+    }
+    return Effect.succeed(rpcPort);
+}));
+/**
+ * Discover port with fixed interval retry
+ */
+const discoverPortWithRetry = (pid, maxAttempts = 1200) => attemptPortDiscovery(pid).pipe(Effect.retry(Schedule.fixed("50 millis").pipe(Schedule.compose(Schedule.recurs(maxAttempts - 1)))), Effect.catchAll((error) => Effect.fail(new PortDiscoveryError({
+    cause: error,
+    pid,
+    attempts: maxAttempts,
+}))));
+/**
+ * Live implementation of PortDiscoveryService
+ */
+export const PortDiscoveryServiceLive = Layer.succeed(PortDiscoveryService, {
+    discoverPort: discoverPortWithRetry,
+});

package/dist/services/network/RpcPortDiscoveryService.d.ts

@@ -0,0 +1,25 @@
+import { Context, Effect, Layer } from "effect";
+import { PortDiscoveryError } from "../errors.js";
+declare const RpcPortDiscoveryService_base: Context.TagClass<RpcPortDiscoveryService, "RpcPortDiscoveryService", {
+    /**
+     * Discover RPC port by testing actual RPC connectivity on all candidate ports
+     * @param config Discovery configuration
+     * @returns First port that responds to RPC calls
+     */
+    readonly discoverRpcPort: (config: {
+        pid: number;
+        isEthereumChain: boolean;
+        maxAttempts?: number;
+    }) => Effect.Effect<number, PortDiscoveryError>;
+}>;
+/**
+ * Service for discovering RPC ports by testing actual connectivity
+ */
+export declare class RpcPortDiscoveryService extends RpcPortDiscoveryService_base {
+}
+/**
+ * Live implementation of RpcPortDiscoveryService
+ */
+export declare const RpcPortDiscoveryServiceLive: Layer.Layer<RpcPortDiscoveryService, never, never>;
+export {};
+//# sourceMappingURL=RpcPortDiscoveryService.d.ts.map

package/dist/services/network/RpcPortDiscoveryService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RpcPortDiscoveryService.d.ts","sourceRoot":"","sources":["../../../src/services/network/RpcPortDiscoveryService.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,OAAO,EAAY,MAAM,EAAE,KAAK,EAAgC,MAAM,QAAQ,CAAC;AACxF,OAAO,EAAE,kBAAkB,EAAE,qBAAqB;;IAW9C;;;;OAIG;8BACuB,CAAC,MAAM,EAAE;QACjC,GAAG,EAAE,MAAM,CAAC;QACZ,eAAe,EAAE,OAAO,CAAC;QACzB,WAAW,CAAC,EAAE,MAAM,CAAC;KACtB,KAAK,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC;;AAfnD;;GAEG;AACH,qBAAa,uBAAwB,SAAQ,4BAc1C;CAAG;AAkON;;GAEG;AACH,eAAO,MAAM,2BAA2B,oDAEtC,CAAC"}