@moonwall/cli/dist/internal/effect/ChopsticksMultiChain.js

Testing framework for the Moon family of projects

// src/internal/effect/ChopsticksMultiChain.ts
import { Context as Context2, Data as Data2, Effect as Effect4, Layer as Layer2 } from "effect";
import { createLogger as createLogger3 } from "@moonwall/util";

// src/internal/effect/ChopsticksService.ts
import { Context, Data } from "effect";
var ChopsticksSetupError = class extends Data.TaggedError("ChopsticksSetupError") {
};
var ChopsticksBlockError = class extends Data.TaggedError("ChopsticksBlockError") {
};
var ChopsticksStorageError = class extends Data.TaggedError("ChopsticksStorageError") {
};
var ChopsticksExtrinsicError = class extends Data.TaggedError("ChopsticksExtrinsicError") {
};
var ChopsticksXcmError = class extends Data.TaggedError("ChopsticksXcmError") {
};
var ChopsticksCleanupError = class extends Data.TaggedError("ChopsticksCleanupError") {
};
var ChopsticksService = class extends Context.Tag("ChopsticksService")() {
};
var ChopsticksConfigTag = class extends Context.Tag("ChopsticksConfig")() {
};

// src/internal/effect/launchChopsticksEffect.ts
import { Effect as Effect3, Layer } from "effect";
import { createLogger as createLogger2 } from "@moonwall/util";
import * as fs2 from "fs";
import * as path from "path";

// src/internal/effect/chopsticksConfigParser.ts
import { Effect as Effect2 } from "effect";
import * as fs from "fs";
import * as yaml from "yaml";
import { createLogger } from "@moonwall/util";
var logger = createLogger({ name: "chopsticksConfigParser" });

// src/internal/effect/launchChopsticksEffect.ts
var chopsticksLoggerConfigured = false;
var chopsticksModuleCache = null;
var logger2 = createLogger2({ name: "launchChopsticksEffect" });
function createLogFile(port) {
  const dirPath = path.join(process.cwd(), "tmp", "node_logs");
  if (!fs2.existsSync(dirPath)) {
    fs2.mkdirSync(dirPath, { recursive: true });
  }
  const logPath = path.join(dirPath, `chopsticks_${port}_${Date.now()}.log`);
  const writeStream = fs2.createWriteStream(logPath);
  process.env.MOON_LOG_LOCATION = logPath;
  return { logPath, writeStream };
}
function writeLog(stream, level, message) {
  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
  stream.write(`[${timestamp}] [${level.toUpperCase()}] ${message}
`);
}
var chopsticksLogStream = null;
function setChopsticksLogStream(stream) {
  chopsticksLogStream = stream;
}
function hookLoggerToFile(pinoInstance, loggerName) {
  const wrapMethod = (level, originalMethod) => {
    return function(...args) {
      originalMethod.apply(this, args);
      if (chopsticksLogStream && args.length > 0) {
        const timestamp = (/* @__PURE__ */ new Date()).toISOString();
        const message = typeof args[0] === "string" ? args[0] : JSON.stringify(args[0]);
        chopsticksLogStream.write(
          `[${timestamp}] [${level.toUpperCase()}] (${loggerName}) ${message}
`
        );
      }
    };
  };
  const originalInfo = pinoInstance.info.bind(pinoInstance);
  const originalWarn = pinoInstance.warn.bind(pinoInstance);
  const originalError = pinoInstance.error.bind(pinoInstance);
  const originalDebug = pinoInstance.debug.bind(pinoInstance);
  pinoInstance.info = wrapMethod("info", originalInfo);
  pinoInstance.warn = wrapMethod("warn", originalWarn);
  pinoInstance.error = wrapMethod("error", originalError);
  pinoInstance.debug = wrapMethod("debug", originalDebug);
  const originalChild = pinoInstance.child?.bind(pinoInstance);
  if (originalChild) {
    pinoInstance.child = (bindings) => {
      const child = originalChild(bindings);
      const childName = bindings.name || bindings.child || loggerName;
      hookLoggerToFile(child, childName);
      return child;
    };
  }
}
async function getChopsticksModules(logLevel = "inherit") {
  if (chopsticksModuleCache) {
    return chopsticksModuleCache;
  }
  const chopsticks = await import("@acala-network/chopsticks");
  chopsticksModuleCache = {
    setupWithServer: chopsticks.setupWithServer,
    setStorage: chopsticks.setStorage,
    pinoLogger: chopsticks.pinoLogger,
    defaultLogger: chopsticks.defaultLogger
  };
  const resolvedLevel = logLevel === "inherit" ? process.env.LOG_LEVEL || "info" : logLevel;
  chopsticksModuleCache.pinoLogger.level = resolvedLevel;
  hookLoggerToFile(chopsticksModuleCache.defaultLogger, "chopsticks");
  chopsticksLoggerConfigured = true;
  logger2.debug(`Chopsticks internal logger level: ${resolvedLevel}`);
  return chopsticksModuleCache;
}
var getEndpointString = (endpoint) => {
  if (typeof endpoint === "string") return endpoint;
  if (Array.isArray(endpoint)) return endpoint[0];
  return void 0;
};
var prepareConfigForSetup = (config) => ({
  ...config,
  port: config.port ?? 8e3,
  host: config.host ?? "127.0.0.1",
  "build-block-mode": config["build-block-mode"] ?? "Manual"
});
var createServiceMethods = (chain) => ({
  createBlock: (params) => Effect3.tryPromise({
    try: async () => {
      const block = await chain.newBlock({
        transactions: params?.transactions ?? [],
        upwardMessages: params?.ump ?? {},
        downwardMessages: params?.dmp ?? [],
        horizontalMessages: params?.hrmp ?? {}
      });
      return {
        block: {
          hash: block.hash,
          number: block.number
        }
      };
    },
    catch: (cause) => new ChopsticksBlockError({
      cause,
      operation: "newBlock"
    })
  }),
  setStorage: (params) => Effect3.tryPromise({
    try: async () => {
      const storage = { [params.module]: { [params.method]: params.params } };
      const modules = await getChopsticksModules();
      await modules.setStorage(chain, storage);
    },
    catch: (cause) => new ChopsticksStorageError({
      cause,
      module: params.module,
      method: params.method
    })
  }),
  submitExtrinsic: (extrinsic) => Effect3.tryPromise({
    try: () => chain.submitExtrinsic(extrinsic),
    catch: (cause) => new ChopsticksExtrinsicError({
      cause,
      operation: "submit",
      extrinsic
    })
  }),
  dryRunExtrinsic: (extrinsic, at) => Effect3.tryPromise({
    try: async () => {
      const result = await chain.dryRunExtrinsic(extrinsic, at);
      const isOk = result.outcome.isOk;
      return {
        success: isOk,
        storageDiff: result.storageDiff,
        error: isOk ? void 0 : result.outcome.asErr?.toString()
      };
    },
    catch: (cause) => new ChopsticksExtrinsicError({
      cause,
      operation: "dryRun",
      extrinsic: typeof extrinsic === "string" ? extrinsic : extrinsic.call
    })
  }),
  getBlock: (hashOrNumber) => Effect3.tryPromise({
    try: async () => {
      const block = hashOrNumber === void 0 ? chain.head : typeof hashOrNumber === "number" ? await chain.getBlockAt(hashOrNumber) : await chain.getBlock(hashOrNumber);
      if (!block) return void 0;
      return {
        hash: block.hash,
        number: block.number
      };
    },
    catch: (cause) => new ChopsticksBlockError({
      cause,
      operation: "getBlock",
      blockIdentifier: hashOrNumber
    })
  }),
  setHead: (hashOrNumber) => Effect3.tryPromise({
    try: async () => {
      const block = typeof hashOrNumber === "number" ? await chain.getBlockAt(hashOrNumber) : await chain.getBlock(hashOrNumber);
      if (!block) {
        throw new Error(`Block not found: ${hashOrNumber}`);
      }
      await chain.setHead(block);
    },
    catch: (cause) => new ChopsticksBlockError({
      cause,
      operation: "setHead",
      blockIdentifier: hashOrNumber
    })
  }),
  submitUpwardMessages: (paraId, messages) => Effect3.try({
    try: () => chain.submitUpwardMessages(paraId, messages),
    catch: (cause) => new ChopsticksXcmError({
      cause,
      messageType: "ump",
      paraId
    })
  }),
  submitDownwardMessages: (messages) => Effect3.try({
    try: () => chain.submitDownwardMessages(messages),
    catch: (cause) => new ChopsticksXcmError({
      cause,
      messageType: "dmp"
    })
  }),
  submitHorizontalMessages: (paraId, messages) => Effect3.try({
    try: () => chain.submitHorizontalMessages(paraId, messages),
    catch: (cause) => new ChopsticksXcmError({
      cause,
      messageType: "hrmp",
      paraId
    })
  })
});
async function launchChopsticksEffect(config) {
  const startTime = Date.now();
  logger2.debug(`[T+0ms] Starting chopsticks with endpoint: ${config.endpoint}`);
  const port = config.port ?? 8e3;
  const { logPath, writeStream } = createLogFile(port);
  setChopsticksLogStream(writeStream);
  const program = Effect3.gen(function* () {
    const chopsticksModules = yield* Effect3.promise(() => getChopsticksModules("inherit"));
    const args = prepareConfigForSetup(config);
    logger2.debug(`[T+${Date.now() - startTime}ms] Calling setupWithServer...`);
    const context = yield* Effect3.tryPromise({
      try: () => chopsticksModules.setupWithServer(args),
      catch: (cause) => new ChopsticksSetupError({
        cause,
        endpoint: getEndpointString(config.endpoint),
        block: config.block ?? void 0
      })
    });
    const actualPort = Number.parseInt(context.addr.split(":")[1], 10);
    const chainName = yield* Effect3.promise(() => context.chain.api.getSystemChain());
    logger2.info(`${chainName} RPC listening on ws://${context.addr}`);
    logger2.debug(`[T+${Date.now() - startTime}ms] Chopsticks started at ${context.addr}`);
    logger2.debug(`Log file: ${logPath}`);
    writeLog(writeStream, "info", `Chopsticks started for ${chainName}`);
    writeLog(writeStream, "info", `RPC listening on ws://${context.addr}`);
    writeLog(writeStream, "info", `Endpoint: ${config.endpoint}`);
    if (config.block) {
      writeLog(writeStream, "info", `Block: ${config.block}`);
    }
    const cleanup2 = Effect3.tryPromise({
      try: async () => {
        logger2.debug("Closing chopsticks...");
        writeLog(writeStream, "info", "Shutting down chopsticks...");
        await context.close();
        writeLog(writeStream, "info", "Chopsticks closed");
        setChopsticksLogStream(null);
        writeStream.end();
        logger2.debug("Chopsticks closed");
      },
      catch: (cause) => new ChopsticksCleanupError({ cause })
    }).pipe(
      Effect3.catchAll(
        (error) => Effect3.sync(() => {
          logger2.error(`Failed to cleanly close chopsticks: ${error}`);
          writeLog(writeStream, "error", `Failed to close: ${error}`);
          setChopsticksLogStream(null);
          writeStream.end();
        })
      )
    );
    const serviceMethods = createServiceMethods(context.chain);
    const service2 = {
      chain: context.chain,
      addr: context.addr,
      port: actualPort,
      ...serviceMethods
    };
    return { service: service2, cleanup: cleanup2 };
  });
  const { service, cleanup } = await Effect3.runPromise(program);
  return {
    result: service,
    cleanup: () => Effect3.runPromise(cleanup)
  };
}
var acquireChopsticks = (config) => Effect3.acquireRelease(
  // Acquire: Setup chopsticks (first get modules, then setup)
  Effect3.promise(() => getChopsticksModules("silent")).pipe(
    Effect3.flatMap(
      (modules) => Effect3.tryPromise({
        try: () => modules.setupWithServer(prepareConfigForSetup(config)),
        catch: (cause) => new ChopsticksSetupError({
          cause,
          endpoint: getEndpointString(config.endpoint),
          block: config.block ?? void 0
        })
      })
    ),
    Effect3.tap(
      (context) => Effect3.sync(() => logger2.debug(`Chopsticks started at ${context.addr}`))
    )
  ),
  // Release: Cleanup chopsticks
  (context) => Effect3.tryPromise({
    try: async () => {
      logger2.debug("Closing chopsticks...");
      await context.close();
      logger2.debug("Chopsticks closed");
    },
    catch: (cause) => new ChopsticksCleanupError({ cause })
  }).pipe(
    Effect3.catchAll(
      (error) => Effect3.sync(() => {
        logger2.error(`Failed to cleanly close chopsticks: ${error}`);
      })
    )
  )
);
var ChopsticksServiceLive = Layer.scoped(
  ChopsticksService,
  Effect3.gen(function* () {
    const config = yield* ChopsticksConfigTag;
    const context = yield* acquireChopsticks(config);
    const port = Number.parseInt(context.addr.split(":")[1], 10);
    const serviceMethods = createServiceMethods(context.chain);
    return {
      chain: context.chain,
      addr: context.addr,
      port,
      ...serviceMethods
    };
  })
);

// src/internal/effect/ChopsticksMultiChain.ts
var logger3 = createLogger3({ name: "ChopsticksMultiChain" });
var getEndpointString2 = (endpoint) => {
  if (typeof endpoint === "string") return endpoint;
  if (Array.isArray(endpoint)) return endpoint[0];
  return void 0;
};
var ChopsticksOrchestrationError = class extends Data2.TaggedError("ChopsticksOrchestrationError") {
};
var ChopsticksMultiChainService = class extends Context2.Tag("ChopsticksMultiChainService")() {
};
var createMultiChainService = (relay, parachains) => {
  const chains = /* @__PURE__ */ new Map();
  chains.set("relay", { service: relay, type: "relay" });
  for (const [paraId, service] of parachains) {
    chains.set(`para-${paraId}`, { service, type: "parachain", paraId });
  }
  return {
    relay,
    parachain: (paraId) => parachains.get(paraId),
    chains,
    createBlocksAll: () => Effect4.gen(function* () {
      const results = /* @__PURE__ */ new Map();
      const blockEffects = Array.from(chains.entries()).map(
        ([id, chain]) => chain.service.createBlock().pipe(Effect4.map((result) => [id, result]))
      );
      const blockResults = yield* Effect4.all(blockEffects, { concurrency: "unbounded" });
      for (const [id, result] of blockResults) {
        results.set(id, result);
      }
      return results;
    }),
    sendUmp: (paraId, messages) => Effect4.gen(function* () {
      yield* relay.submitUpwardMessages(paraId, messages);
      logger3.debug(`Sent ${messages.length} UMP messages from para ${paraId} to relay`);
    }),
    sendDmp: (paraId, messages) => Effect4.gen(function* () {
      const para = parachains.get(paraId);
      if (!para) {
        yield* Effect4.fail(
          new ChopsticksXcmError({
            cause: new Error(`Parachain ${paraId} not found`),
            messageType: "dmp",
            paraId
          })
        );
        return;
      }
      yield* para.submitDownwardMessages(messages);
      logger3.debug(`Sent ${messages.length} DMP messages from relay to para ${paraId}`);
    }),
    sendHrmp: (fromParaId, toParaId, messages) => Effect4.gen(function* () {
      const toPara = parachains.get(toParaId);
      if (!toPara) {
        yield* Effect4.fail(
          new ChopsticksXcmError({
            cause: new Error(`Target parachain ${toParaId} not found`),
            messageType: "hrmp",
            paraId: toParaId
          })
        );
        return;
      }
      yield* toPara.submitHorizontalMessages(fromParaId, messages);
      logger3.debug(
        `Sent ${messages.length} HRMP messages from para ${fromParaId} to para ${toParaId}`
      );
    }),
    processXcm: () => Effect4.gen(function* () {
      yield* relay.createBlock();
      for (const para of parachains.values()) {
        yield* para.createBlock();
      }
      logger3.debug("Processed XCM messages across all chains");
    })
  };
};
async function launchMultiChainEffect(config) {
  const cleanups = [];
  try {
    logger3.debug(`Launching relay chain on port ${config.relay.port}`);
    const relayResult = await launchChopsticksEffect(config.relay);
    cleanups.push(relayResult.cleanup);
    const parachains = /* @__PURE__ */ new Map();
    for (const paraConfig of config.parachains) {
      logger3.debug(`Launching parachain ${paraConfig.paraId} on port ${paraConfig.port}`);
      const paraResult = await launchChopsticksEffect(paraConfig);
      cleanups.push(paraResult.cleanup);
      parachains.set(paraConfig.paraId, paraResult.result);
    }
    const service = createMultiChainService(relayResult.result, parachains);
    return {
      service,
      cleanup: async () => {
        logger3.debug("Cleaning up multi-chain setup...");
        for (const cleanupFn of cleanups.reverse()) {
          await cleanupFn();
        }
        logger3.debug("Multi-chain cleanup complete");
      }
    };
  } catch (error) {
    for (const cleanupFn of cleanups.reverse()) {
      try {
        await cleanupFn();
      } catch {
      }
    }
    throw error;
  }
}
var ChopsticksMultiChainLayer = (config) => Layer2.scoped(
  ChopsticksMultiChainService,
  Effect4.gen(function* () {
    const cleanups = [];
    const relayResult = yield* Effect4.tryPromise({
      try: () => launchChopsticksEffect(config.relay),
      catch: (cause) => new ChopsticksSetupError({
        cause,
        endpoint: getEndpointString2(config.relay.endpoint)
      })
    });
    cleanups.push(
      Effect4.tryPromise({
        try: () => relayResult.cleanup(),
        catch: () => void 0
      }).pipe(Effect4.ignore)
    );
    const parachains = /* @__PURE__ */ new Map();
    for (const paraConfig of config.parachains) {
      const paraResult = yield* Effect4.tryPromise({
        try: () => launchChopsticksEffect(paraConfig),
        catch: (cause) => new ChopsticksSetupError({
          cause,
          endpoint: getEndpointString2(paraConfig.endpoint)
        })
      });
      cleanups.push(
        Effect4.tryPromise({
          try: () => paraResult.cleanup(),
          catch: () => void 0
        }).pipe(Effect4.ignore)
      );
      parachains.set(paraConfig.paraId, paraResult.result);
    }
    yield* Effect4.addFinalizer(
      () => Effect4.gen(function* () {
        logger3.debug("Finalizing multi-chain setup...");
        for (const cleanup of cleanups.reverse()) {
          yield* cleanup;
        }
        logger3.debug("Multi-chain finalization complete");
      })
    );
    return createMultiChainService(relayResult.result, parachains);
  })
);
var createPolkadotMoonbeamConfig = (relayPort = 8e3, moonbeamPort = 8001) => ({
  relay: {
    type: "relay",
    endpoint: "wss://rpc.polkadot.io",
    port: relayPort,
    "build-block-mode": "Manual"
  },
  parachains: [
    {
      type: "parachain",
      paraId: 2004,
      // Moonbeam on Polkadot
      endpoint: "wss://wss.api.moonbeam.network",
      port: moonbeamPort,
      "build-block-mode": "Manual"
    }
  ]
});
var createKusamaMoonriverConfig = (relayPort = 8e3, moonriverPort = 8001) => ({
  relay: {
    type: "relay",
    endpoint: "wss://kusama-rpc.polkadot.io",
    port: relayPort,
    "build-block-mode": "Manual"
  },
  parachains: [
    {
      type: "parachain",
      paraId: 2023,
      // Moonriver on Kusama
      endpoint: "wss://wss.api.moonriver.moonbeam.network",
      port: moonriverPort,
      "build-block-mode": "Manual"
    }
  ]
});
export {
  ChopsticksMultiChainLayer,
  ChopsticksMultiChainService,
  ChopsticksOrchestrationError,
  createKusamaMoonriverConfig,
  createPolkadotMoonbeamConfig,
  launchMultiChainEffect
};