moonwall 1.0.0-dev.0

package/dist/internal/logging.d.ts

@@ -0,0 +1,7 @@
+import type { ApiPromise } from "@polkadot/api";
+import { setupLogger as createTestLogger } from "./logger.js";
+export declare const setupLogger: typeof createTestLogger;
+export declare function log(...msg: any[]): void;
+export declare const printTokens: (api: ApiPromise, tokens: bigint, decimals?: number, pad?: number) => string;
+export declare const printEvents: (api: ApiPromise, hash?: string) => Promise<void>;
+//# sourceMappingURL=logging.d.ts.map

package/dist/internal/logging.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logging.d.ts","sourceRoot":"","sources":["../../src/internal/logging.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGhD,OAAO,EAAE,WAAW,IAAI,gBAAgB,EAAE,oBAAoB;AAG9D,eAAO,MAAM,WAAW,yBAAmB,CAAC;AAE5C,wBAAgB,GAAG,CAAC,GAAG,GAAG,EAAE,GAAG,EAAE,QAIhC;AAED,eAAO,MAAM,WAAW,GAAI,KAAK,UAAU,EAAE,QAAQ,MAAM,EAAE,iBAAY,EAAE,YAAO,WAWjF,CAAC;AAEF,eAAO,MAAM,WAAW,GAAU,KAAK,UAAU,EAAE,OAAO,MAAM,kBA2B/D,CAAC"}

package/dist/internal/logging.js

@@ -0,0 +1,36 @@
+import { mapExtrinsics } from "../api/testing/blocks.js";
+import { setupLogger as createTestLogger } from "./logger.js";
+// Re-export setupLogger from logger.ts for backward compatibility
+export const setupLogger = createTestLogger;
+export function log(...msg) {
+    if (process.argv?.[2] && process.argv[2] === "--printlogs") {
+        console.log(...msg);
+    }
+}
+export const printTokens = (api, tokens, decimals = 2, pad = 9) => {
+    if (!api.registry.chainDecimals[0]) {
+        throw new Error("Chain decimals not found for system token");
+    }
+    return `${(Math.ceil(Number(tokens / 10n ** BigInt(api.registry.chainDecimals[0] - decimals))) /
+        10 ** decimals)
+        .toString()
+        .padStart(pad)} ${api.registry.chainTokens[0]}`;
+};
+export const printEvents = async (api, hash) => {
+    const blockHash = hash || (await api.rpc.chain.getBlockHash()).toString();
+    const apiAt = await api.at(blockHash);
+    const { block } = await api.rpc.chain.getBlock(blockHash);
+    const allRecords = (await apiAt.query.system.events());
+    const txsWithEvents = mapExtrinsics(block.extrinsics, allRecords);
+    console.log(`===== Block #${block.header.number.toString()}: ${blockHash}`);
+    console.log(block.header.toHuman());
+    console.log(txsWithEvents
+        .map(({ extrinsic, events }, i) => `  [${i}]: ${extrinsic.method.section.toString()}. ` +
+        `${extrinsic.method.method.toString()}\n` +
+        `  - 0x${Buffer.from(extrinsic.data).toString("hex")}\n${events
+            .map((event) => `    * ${event.section.toString()}.${event.method.toString()}:\n${event.data
+            .map((datum) => `      - ${datum.toHex()}`)
+            .join("\n")}`)
+            .join("\n")}`)
+        .join("\n"));
+};

package/dist/moondebug.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env -S node --inspect
+import "./cli/cmds/entrypoint.js";
+//# sourceMappingURL=moondebug.d.ts.map

package/dist/moondebug.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"moondebug.d.ts","sourceRoot":"","sources":["../src/moondebug.ts"],"names":[],"mappings":";AACA,kCAAkC"}

package/dist/moondebug.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env -S node --inspect
+import "./cli/cmds/entrypoint.js";

package/dist/services/cache/FileLock.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Cross-process file lock with staleness detection.
+ * Uses atomic mkdir + PID/timestamp metadata to prevent deadlocks.
+ */
+import { FileSystem } from "@effect/platform";
+import { Duration, Effect } from "effect";
+import { FileLockError } from "../errors.js";
+export declare const acquireFileLock: (lockPath: string, timeout?: Duration.Duration) => Effect.Effect<void, FileLockError, FileSystem.FileSystem>;
+export declare const releaseFileLock: (lockPath: string) => Effect.Effect<void, never, FileSystem.FileSystem>;
+export declare const withFileLock: <A, E, R>(lockPath: string, effect: Effect.Effect<A, E, R>, timeout?: Duration.Duration) => Effect.Effect<A, E | FileLockError, R | FileSystem.FileSystem>;
+//# sourceMappingURL=FileLock.d.ts.map

package/dist/services/cache/FileLock.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FileLock.d.ts","sourceRoot":"","sources":["../../../src/services/cache/FileLock.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAY,MAAM,QAAQ,CAAC;AAEpD,OAAO,EAAE,aAAa,EAAE,qBAAqB;AA+E7C,eAAO,MAAM,eAAe,GAC1B,UAAU,MAAM,EAChB,2BAA6B,KAC5B,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,aAAa,EAAE,UAAU,CAAC,UAAU,CAIxD,CAAC;AAEJ,eAAO,MAAM,eAAe,GAC1B,UAAU,MAAM,KACf,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,UAAU,CAAC,UAAU,CAI/C,CAAC;AAEL,eAAO,MAAM,YAAY,GAAI,CAAC,EAAE,CAAC,EAAE,CAAC,EAClC,UAAU,MAAM,EAChB,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,EAC9B,2BAA6B,KAC5B,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,aAAa,EAAE,CAAC,GAAG,UAAU,CAAC,UAAU,CAK7D,CAAC"}

package/dist/services/cache/FileLock.js

@@ -0,0 +1,68 @@
+/**
+ * Cross-process file lock with staleness detection.
+ * Uses atomic mkdir + PID/timestamp metadata to prevent deadlocks.
+ */
+import { FileSystem } from "@effect/platform";
+import { Duration, Effect, Schedule } from "effect";
+import * as os from "node:os";
+import { FileLockError } from "../errors.js";
+const LOCK_MAX_AGE = Duration.minutes(2);
+const LOCK_POLL_INTERVAL = Duration.millis(500);
+const isProcessAlive = (pid) => Effect.try(() => {
+    process.kill(pid, 0);
+    return true;
+}).pipe(Effect.orElseSucceed(() => false));
+const isLockStale = (info) => Effect.gen(function* () {
+    const isTimedOut = Date.now() - info.timestamp > Duration.toMillis(LOCK_MAX_AGE);
+    if (isTimedOut)
+        return true;
+    const isSameHost = info.hostname === os.hostname();
+    if (!isSameHost)
+        return false;
+    const alive = yield* isProcessAlive(info.pid);
+    return !alive;
+});
+const cleanupStaleLock = (lockPath) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const infoPath = `${lockPath}/lock.json`;
+    const exists = yield* fs.exists(infoPath).pipe(Effect.orElseSucceed(() => false));
+    if (!exists)
+        return;
+    const content = yield* fs.readFileString(infoPath).pipe(Effect.orElseSucceed(() => ""));
+    const info = yield* Effect.try(() => JSON.parse(content)).pipe(Effect.orElseSucceed(() => null));
+    if (!info)
+        return;
+    const stale = yield* isLockStale(info);
+    if (stale) {
+        yield* fs.remove(lockPath, { recursive: true }).pipe(Effect.ignore);
+    }
+});
+const writeLockInfo = (lockPath) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const info = {
+        pid: process.pid,
+        timestamp: Date.now(),
+        hostname: os.hostname(),
+    };
+    yield* fs.writeFileString(`${lockPath}/lock.json`, JSON.stringify(info)).pipe(Effect.ignore);
+});
+/**
+ * Single attempt to acquire lock - fails if lock exists
+ */
+const tryAcquireLock = (lockPath) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    // Clean up stale locks before attempting
+    yield* cleanupStaleLock(lockPath);
+    // Atomic directory creation - fails if exists
+    yield* fs
+        .makeDirectory(lockPath)
+        .pipe(Effect.mapError(() => new FileLockError({ reason: "acquisition_failed", lockPath })));
+    // Write lock metadata
+    yield* writeLockInfo(lockPath);
+});
+export const acquireFileLock = (lockPath, timeout = Duration.minutes(2)) => tryAcquireLock(lockPath).pipe(Effect.retry(Schedule.fixed(LOCK_POLL_INTERVAL).pipe(Schedule.upTo(timeout))), Effect.catchAll(() => Effect.fail(new FileLockError({ reason: "timeout", lockPath }))));
+export const releaseFileLock = (lockPath) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    yield* fs.remove(lockPath, { recursive: true }).pipe(Effect.ignore);
+});
+export const withFileLock = (lockPath, effect, timeout = Duration.minutes(2)) => Effect.acquireUseRelease(acquireFileLock(lockPath, timeout), () => effect, () => releaseFileLock(lockPath));

package/dist/services/cache/StartupCacheService.d.ts

@@ -0,0 +1,23 @@
+import { Context, Effect, Layer } from "effect";
+import { StartupCacheError } from "../errors.js";
+export interface StartupCacheConfig {
+    readonly binPath: string;
+    readonly chainArg?: string;
+    readonly cacheDir: string;
+    readonly generateRawChainSpec?: boolean;
+    readonly isDevMode?: boolean;
+}
+export interface StartupCacheResult {
+    readonly precompiledPath: string;
+    readonly fromCache: boolean;
+    readonly rawChainSpecPath?: string;
+}
+declare const StartupCacheService_base: Context.TagClass<StartupCacheService, "StartupCacheService", {
+    readonly getCachedArtifacts: (config: StartupCacheConfig) => Effect.Effect<StartupCacheResult, StartupCacheError>;
+}>;
+export declare class StartupCacheService extends StartupCacheService_base {
+}
+export declare const StartupCacheServiceLive: Layer.Layer<StartupCacheService, never, never>;
+export declare const StartupCacheServiceTestable: Layer.Layer<StartupCacheService, never, never>;
+export {};
+//# sourceMappingURL=StartupCacheService.d.ts.map

package/dist/services/cache/StartupCacheService.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StartupCacheService.d.ts","sourceRoot":"","sources":["../../../src/services/cache/StartupCacheService.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,OAAO,EAAY,MAAM,EAAE,KAAK,EAAkB,MAAM,QAAQ,CAAC;AAE1E,OAAO,EAAE,iBAAiB,EAAsB,qBAAqB;AAKrE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,oBAAoB,CAAC,EAAE,OAAO,CAAC;IACxC,QAAQ,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,gBAAgB,CAAC,EAAE,MAAM,CAAC;CACpC;;iCAKgC,CAC3B,MAAM,EAAE,kBAAkB,KACvB,MAAM,CAAC,MAAM,CAAC,kBAAkB,EAAE,iBAAiB,CAAC;;AAL7D,qBAAa,mBAAoB,SAAQ,wBAOtC;CAAG;AAwPN,eAAO,MAAM,uBAAuB,gDAQlC,CAAC;AAEH,eAAO,MAAM,2BAA2B,gDAOtC,CAAC"}

package/dist/services/cache/StartupCacheService.js

@@ -0,0 +1,159 @@
+import { Command, FileSystem, Path } from "@effect/platform";
+import { NodeContext } from "@effect/platform-node";
+import { createLogger } from "../../util/index.js";
+import { Context, Duration, Effect, Layer, Option, Stream } from "effect";
+import * as crypto from "node:crypto";
+import { StartupCacheError } from "../errors.js";
+import { withFileLock } from "./FileLock.js";
+const logger = createLogger({ name: "StartupCacheService" });
+export class StartupCacheService extends Context.Tag("StartupCacheService")() {
+}
+// =============================================================================
+// Helper functions
+// =============================================================================
+const hashFile = (filePath) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const hash = crypto.createHash("sha256");
+    yield* fs
+        .stream(filePath)
+        .pipe(Stream.runForEach((chunk) => Effect.sync(() => hash.update(chunk))));
+    return hash.digest("hex");
+}).pipe(Effect.mapError((cause) => new StartupCacheError({ cause, operation: "hash" })));
+const findPrecompiledWasm = (dir) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const pathService = yield* Path.Path;
+    const exists = yield* fs.exists(dir);
+    if (!exists)
+        return Option.none();
+    const files = yield* fs.readDirectory(dir).pipe(Effect.orElseSucceed(() => []));
+    const wasmFile = files.find((f) => f.startsWith("precompiled_wasm_") || f.endsWith(".cwasm") || f.endsWith(".wasm"));
+    return wasmFile ? Option.some(pathService.join(dir, wasmFile)) : Option.none();
+}).pipe(Effect.catchAll(() => Effect.succeed(Option.none())));
+const checkCache = (cacheDir, hashPath, expectedHash) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const savedHash = yield* fs.readFileString(hashPath).pipe(Effect.orElseSucceed(() => ""));
+    if (savedHash.trim() !== expectedHash)
+        return Option.none();
+    const wasmPath = yield* findPrecompiledWasm(cacheDir);
+    if (Option.isNone(wasmPath))
+        return Option.none();
+    const accessible = yield* fs.access(wasmPath.value).pipe(Effect.as(true), Effect.orElseSucceed(() => false));
+    return accessible ? wasmPath : Option.none();
+});
+// =============================================================================
+// Precompilation commands
+// =============================================================================
+const runPrecompile = (binPath, chainArg, outputDir) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const pathService = yield* Path.Path;
+    const args = chainArg
+        ? ["precompile-wasm", chainArg, outputDir]
+        : ["precompile-wasm", outputDir];
+    logger.debug(`Precompiling: ${binPath} ${args.join(" ")}`);
+    const startTime = Date.now();
+    const exitCode = yield* Command.exitCode(Command.make(binPath, ...args)).pipe(Effect.mapError((e) => new StartupCacheError({ cause: e, operation: "precompile" })));
+    const files = yield* fs
+        .readDirectory(outputDir)
+        .pipe(Effect.mapError((e) => new StartupCacheError({ cause: e, operation: "precompile" })));
+    const wasmFile = files.find((f) => f.startsWith("precompiled_wasm_") || f.endsWith(".cwasm") || f.endsWith(".wasm"));
+    if (!wasmFile) {
+        return yield* Effect.fail(new StartupCacheError({
+            cause: `precompile-wasm failed (code ${exitCode}): no WASM file generated`,
+            operation: "precompile",
+        }));
+    }
+    const wasmPath = pathService.join(outputDir, wasmFile);
+    logger.debug(`Precompiled in ${Date.now() - startTime}ms: ${wasmPath}`);
+    return wasmPath;
+});
+const generateRawChainSpec = (binPath, chainName, outputPath) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const args = chainName === "dev" || chainName === "default"
+        ? ["build-spec", "--dev", "--raw"]
+        : ["build-spec", `--chain=${chainName}`, "--raw"];
+    logger.debug(`Generating raw chain spec: ${binPath} ${args.join(" ")}`);
+    const stdout = yield* Command.string(Command.make(binPath, ...args)).pipe(Effect.mapError((e) => new StartupCacheError({ cause: e, operation: "chainspec" })));
+    if (!stdout.length) {
+        return yield* Effect.fail(new StartupCacheError({ cause: "build-spec produced no output", operation: "chainspec" }));
+    }
+    yield* fs
+        .writeFileString(outputPath, stdout)
+        .pipe(Effect.mapError((e) => new StartupCacheError({ cause: e, operation: "chainspec" })));
+    return outputPath;
+});
+const maybeGetRawChainSpec = (binPath, chainName, cacheSubDir, shouldGenerate) => Effect.gen(function* () {
+    if (!shouldGenerate)
+        return Option.none();
+    const fs = yield* FileSystem.FileSystem;
+    const pathService = yield* Path.Path;
+    const rawSpecPath = pathService.join(cacheSubDir, `${chainName}-raw.json`);
+    const exists = yield* fs.exists(rawSpecPath).pipe(Effect.orElseSucceed(() => false));
+    if (exists)
+        return Option.some(rawSpecPath);
+    return yield* generateRawChainSpec(binPath, chainName, rawSpecPath).pipe(Effect.map((Option.some)), Effect.catchAll(() => Effect.succeed(Option.none())));
+});
+// =============================================================================
+// Main implementation
+// =============================================================================
+const getCachedArtifactsImpl = (config) => Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    const pathService = yield* Path.Path;
+    const binaryHash = yield* hashFile(config.binPath);
+    const shortHash = binaryHash.substring(0, 12);
+    const chainName = config.isDevMode
+        ? "dev"
+        : config.chainArg?.match(/--chain[=\s]?(\S+)/)?.[1] || "default";
+    const binName = pathService.basename(config.binPath);
+    const cacheSubDir = pathService.join(config.cacheDir, `${binName}-${chainName}-${shortHash}`);
+    const hashPath = pathService.join(cacheSubDir, "binary.hash");
+    const lockPath = pathService.join(config.cacheDir, `${binName}-${chainName}.lock`);
+    yield* fs
+        .makeDirectory(cacheSubDir, { recursive: true })
+        .pipe(Effect.mapError((e) => new StartupCacheError({ cause: e, operation: "cache" })));
+    // Fast path: cache exists
+    const cached = yield* checkCache(cacheSubDir, hashPath, binaryHash);
+    if (Option.isSome(cached)) {
+        logger.debug(`Using cached precompiled WASM: ${cached.value}`);
+        const rawChainSpecPath = yield* maybeGetRawChainSpec(config.binPath, chainName, cacheSubDir, config.generateRawChainSpec ?? false);
+        return {
+            precompiledPath: cached.value,
+            fromCache: true,
+            rawChainSpecPath: Option.getOrUndefined(rawChainSpecPath),
+        };
+    }
+    // Need to build - acquire lock using shared FileLock module
+    return yield* withFileLock(lockPath, Effect.gen(function* () {
+        // Double-check after acquiring lock
+        const nowCached = yield* checkCache(cacheSubDir, hashPath, binaryHash);
+        if (Option.isSome(nowCached)) {
+            logger.debug(`Using cached precompiled WASM (created by another process): ${nowCached.value}`);
+            const rawChainSpecPath = yield* maybeGetRawChainSpec(config.binPath, chainName, cacheSubDir, config.generateRawChainSpec ?? false);
+            return {
+                precompiledPath: nowCached.value,
+                fromCache: true,
+                rawChainSpecPath: Option.getOrUndefined(rawChainSpecPath),
+            };
+        }
+        // Build
+        logger.debug("Precompiling WASM (this may take a moment)...");
+        const wasmPath = yield* runPrecompile(config.binPath, config.chainArg, cacheSubDir);
+        yield* fs
+            .writeFileString(hashPath, binaryHash)
+            .pipe(Effect.mapError((e) => new StartupCacheError({ cause: e, operation: "cache" })));
+        const rawChainSpecPath = yield* maybeGetRawChainSpec(config.binPath, chainName, cacheSubDir, config.generateRawChainSpec ?? false);
+        return {
+            precompiledPath: wasmPath,
+            fromCache: false,
+            rawChainSpecPath: Option.getOrUndefined(rawChainSpecPath),
+        };
+    }), Duration.minutes(2));
+});
+// =============================================================================
+// Service Layer
+// =============================================================================
+export const StartupCacheServiceLive = Layer.succeed(StartupCacheService, {
+    getCachedArtifacts: (config) => getCachedArtifactsImpl(config).pipe(Effect.mapError((e) => e._tag === "FileLockError" ? new StartupCacheError({ cause: e, operation: "lock" }) : e), Effect.provide(NodeContext.layer)),
+});
+export const StartupCacheServiceTestable = Layer.succeed(StartupCacheService, {
+    getCachedArtifacts: (config) => getCachedArtifactsImpl(config).pipe(Effect.mapError((e) => e._tag === "FileLockError" ? new StartupCacheError({ cause: e, operation: "lock" }) : e)),
+});

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

@@ -0,0 +1,3 @@
+export * from "./FileLock.js";
+export * from "./StartupCacheService.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/cache/index.ts"],"names":[],"mappings":"AAAA,8BAA8B;AAC9B,yCAAyC"}

package/dist/services/cache/index.js

@@ -0,0 +1,2 @@
+export * from "./FileLock.js";
+export * from "./StartupCacheService.js";

package/dist/services/chopsticks/ChopsticksMultiChain.d.ts

@@ -0,0 +1,158 @@
+/**
+ * Multi-chain Chopsticks support for XCM testing
+ *
+ * This module provides Effect-based support for launching multiple chopsticks
+ * instances and coordinating XCM message passing between them.
+ */
+import { Context, Effect, Layer } from "effect";
+import type { HexString } from "@polkadot/util/types";
+import { type ChopsticksConfig, type BlockCreationResult, ChopsticksSetupError, ChopsticksXcmError, ChopsticksBlockError } from "./ChopsticksService.js";
+import { type ChopsticksServiceImpl } from "./launchChopsticksEffect.js";
+declare const ChopsticksOrchestrationError_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: "ChopsticksOrchestrationError";
+} & Readonly<A>;
+/**
+ * Error thrown when multi-chain orchestration fails
+ */
+export declare class ChopsticksOrchestrationError extends ChopsticksOrchestrationError_base<{
+    readonly cause: unknown;
+    readonly chains: string[];
+    readonly operation: "setup" | "xcm" | "cleanup";
+}> {
+}
+/**
+ * Configuration for a relay chain
+ */
+export interface RelayChainConfig extends ChopsticksConfig {
+    readonly type: "relay";
+}
+/**
+ * Configuration for a parachain
+ */
+export interface ParachainConfig extends ChopsticksConfig {
+    readonly type: "parachain";
+    readonly paraId: number;
+}
+/**
+ * Configuration for multi-chain setup
+ */
+export interface MultiChainConfig {
+    readonly relay: RelayChainConfig;
+    readonly parachains: ParachainConfig[];
+}
+/**
+ * Chain instance with its identifier
+ */
+export interface ChainInstance {
+    readonly service: ChopsticksServiceImpl;
+    readonly type: "relay" | "parachain";
+    readonly paraId?: number;
+}
+/**
+ * Multi-chain orchestration service
+ */
+export interface MultiChainService {
+    /** Access the relay chain */
+    readonly relay: ChopsticksServiceImpl;
+    /** Access a parachain by paraId */
+    readonly parachain: (paraId: number) => ChopsticksServiceImpl | undefined;
+    /** Get all chains */
+    readonly chains: Map<string, ChainInstance>;
+    /** Create blocks on all chains */
+    readonly createBlocksAll: () => Effect.Effect<Map<string, BlockCreationResult>, ChopsticksBlockError>;
+    /**
+     * Send UMP from parachain to relay
+     * (Upward Message Passing: parachain → relay)
+     */
+    readonly sendUmp: (paraId: number, messages: HexString[]) => Effect.Effect<void, ChopsticksXcmError>;
+    /**
+     * Send DMP from relay to parachain
+     * (Downward Message Passing: relay → parachain)
+     */
+    readonly sendDmp: (paraId: number, messages: Array<{
+        sentAt: number;
+        msg: HexString;
+    }>) => Effect.Effect<void, ChopsticksXcmError>;
+    /**
+     * Send HRMP between parachains
+     * (Horizontal Relay-routed Message Passing: parachain → parachain)
+     */
+    readonly sendHrmp: (fromParaId: number, toParaId: number, messages: Array<{
+        sentAt: number;
+        data: HexString;
+    }>) => Effect.Effect<void, ChopsticksXcmError>;
+    /**
+     * Process XCM messages by creating blocks on all chains
+     * This advances all chains to process pending XCM messages
+     */
+    readonly processXcm: () => Effect.Effect<void, ChopsticksBlockError>;
+}
+declare const ChopsticksMultiChainService_base: Context.TagClass<ChopsticksMultiChainService, "ChopsticksMultiChainService", MultiChainService>;
+/**
+ * Service tag for multi-chain orchestration
+ */
+export declare class ChopsticksMultiChainService extends ChopsticksMultiChainService_base {
+}
+/**
+ * Launch a multi-chain setup with manual cleanup
+ *
+ * @param config - Multi-chain configuration
+ * @returns Promise with multi-chain service and cleanup function
+ *
+ * @example
+ * ```typescript
+ * const { service, cleanup } = await launchMultiChainEffect({
+ *   relay: {
+ *     type: "relay",
+ *     endpoint: "wss://rpc.polkadot.io",
+ *     port: 8000,
+ *   },
+ *   parachains: [
+ *     {
+ *       type: "parachain",
+ *       paraId: 2000,
+ *       endpoint: "wss://moonbeam.rpc.io",
+ *       port: 8001,
+ *     },
+ *   ],
+ * });
+ *
+ * // Send XCM message
+ * await Effect.runPromise(service.sendUmp(2000, ["0x..."]));
+ *
+ * // Process messages
+ * await Effect.runPromise(service.processXcm());
+ *
+ * // Cleanup
+ * await cleanup();
+ * ```
+ */
+export declare function launchMultiChainEffect(config: MultiChainConfig): Promise<{
+    service: MultiChainService;
+    cleanup: () => Promise<void>;
+}>;
+/**
+ * Create a Layer for multi-chain setup
+ *
+ * @param config - Multi-chain configuration
+ * @returns Layer providing ChopsticksMultiChainService
+ */
+export declare const ChopsticksMultiChainLayer: (config: MultiChainConfig) => Layer.Layer<ChopsticksMultiChainService, ChopsticksSetupError | ChopsticksOrchestrationError>;
+/**
+ * Helper to create a standard Polkadot + Moonbeam XCM testing setup
+ *
+ * @param relayPort - Port for relay chain (default: 8000)
+ * @param moonbeamPort - Port for Moonbeam parachain (default: 8001)
+ * @returns Multi-chain configuration
+ */
+export declare const createPolkadotMoonbeamConfig: (relayPort?: number, moonbeamPort?: number) => MultiChainConfig;
+/**
+ * Helper to create a standard Kusama + Moonriver XCM testing setup
+ *
+ * @param relayPort - Port for relay chain (default: 8000)
+ * @param moonriverPort - Port for Moonriver parachain (default: 8001)
+ * @returns Multi-chain configuration
+ */
+export declare const createKusamaMoonriverConfig: (relayPort?: number, moonriverPort?: number) => MultiChainConfig;
+export {};
+//# sourceMappingURL=ChopsticksMultiChain.d.ts.map

package/dist/services/chopsticks/ChopsticksMultiChain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ChopsticksMultiChain.d.ts","sourceRoot":"","sources":["../../../src/services/chopsticks/ChopsticksMultiChain.ts"],"names":[],"mappings":"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"}