moonwall 1.0.0-dev.0

package/dist/services/chopsticks/ChopsticksMultiChain.js

@@ -0,0 +1,282 @@
+/**
+ * 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, Data, Effect, Layer } from "effect";
+import { createLogger } from "../../util/index.js";
+import { ChopsticksSetupError, ChopsticksXcmError, } from "./ChopsticksService.js";
+import { launchChopsticksEffect } from "./launchChopsticksEffect.js";
+const logger = createLogger({ name: "ChopsticksMultiChain" });
+/**
+ * Extract a single endpoint string from the config.
+ * The ChopsticksConfig endpoint can be a string, array of strings, or undefined.
+ */
+const getEndpointString = (endpoint) => {
+    if (typeof endpoint === "string")
+        return endpoint;
+    if (Array.isArray(endpoint))
+        return endpoint[0];
+    return undefined;
+};
+// =============================================================================
+// Error Types
+// =============================================================================
+/**
+ * Error thrown when multi-chain orchestration fails
+ */
+export class ChopsticksOrchestrationError extends Data.TaggedError("ChopsticksOrchestrationError") {
+}
+/**
+ * Service tag for multi-chain orchestration
+ */
+export class ChopsticksMultiChainService extends Context.Tag("ChopsticksMultiChainService")() {
+}
+// =============================================================================
+// Implementation
+// =============================================================================
+/**
+ * Create the multi-chain service implementation
+ */
+const createMultiChainService = (relay, parachains) => {
+    const chains = new Map();
+    // Add relay chain
+    chains.set("relay", { service: relay, type: "relay" });
+    // Add parachains
+    for (const [paraId, service] of parachains) {
+        chains.set(`para-${paraId}`, { service, type: "parachain", paraId });
+    }
+    return {
+        relay,
+        parachain: (paraId) => parachains.get(paraId),
+        chains,
+        createBlocksAll: () => Effect.gen(function* () {
+            const results = new Map();
+            // Create blocks on all chains in parallel
+            const blockEffects = Array.from(chains.entries()).map(([id, chain]) => chain.service.createBlock().pipe(Effect.map((result) => [id, result])));
+            const blockResults = yield* Effect.all(blockEffects, { concurrency: "unbounded" });
+            for (const [id, result] of blockResults) {
+                results.set(id, result);
+            }
+            return results;
+        }),
+        sendUmp: (paraId, messages) => Effect.gen(function* () {
+            // UMP: Submit upward messages FROM parachain TO relay
+            // The messages are submitted to the relay chain
+            yield* relay.submitUpwardMessages(paraId, messages);
+            logger.debug(`Sent ${messages.length} UMP messages from para ${paraId} to relay`);
+        }),
+        sendDmp: (paraId, messages) => Effect.gen(function* () {
+            const para = parachains.get(paraId);
+            if (!para) {
+                yield* Effect.fail(new ChopsticksXcmError({
+                    cause: new Error(`Parachain ${paraId} not found`),
+                    messageType: "dmp",
+                    paraId,
+                }));
+                return;
+            }
+            // DMP: Submit downward messages FROM relay TO parachain
+            // The messages are submitted to the parachain
+            yield* para.submitDownwardMessages(messages);
+            logger.debug(`Sent ${messages.length} DMP messages from relay to para ${paraId}`);
+        }),
+        sendHrmp: (fromParaId, toParaId, messages) => Effect.gen(function* () {
+            const toPara = parachains.get(toParaId);
+            if (!toPara) {
+                yield* Effect.fail(new ChopsticksXcmError({
+                    cause: new Error(`Target parachain ${toParaId} not found`),
+                    messageType: "hrmp",
+                    paraId: toParaId,
+                }));
+                return;
+            }
+            // HRMP: Submit horizontal messages FROM one parachain TO another
+            // The messages are submitted to the receiving parachain
+            yield* toPara.submitHorizontalMessages(fromParaId, messages);
+            logger.debug(`Sent ${messages.length} HRMP messages from para ${fromParaId} to para ${toParaId}`);
+        }),
+        processXcm: () => Effect.gen(function* () {
+            // Create blocks on all chains to process pending XCM messages
+            // First create block on relay, then on parachains
+            yield* relay.createBlock();
+            for (const para of parachains.values()) {
+                yield* para.createBlock();
+            }
+            logger.debug("Processed XCM messages across all chains");
+        }),
+    };
+};
+// =============================================================================
+// Launch Functions
+// =============================================================================
+/**
+ * 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 async function launchMultiChainEffect(config) {
+    const cleanups = [];
+    try {
+        // Launch relay chain
+        logger.debug(`Launching relay chain on port ${config.relay.port}`);
+        const relayResult = await launchChopsticksEffect(config.relay);
+        cleanups.push(relayResult.cleanup);
+        // Launch parachains
+        const parachains = new Map();
+        for (const paraConfig of config.parachains) {
+            logger.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 () => {
+                logger.debug("Cleaning up multi-chain setup...");
+                // Cleanup in reverse order (parachains first, then relay)
+                for (const cleanupFn of cleanups.reverse()) {
+                    await cleanupFn();
+                }
+                logger.debug("Multi-chain cleanup complete");
+            },
+        };
+    }
+    catch (error) {
+        // If any launch fails, cleanup what was started
+        for (const cleanupFn of cleanups.reverse()) {
+            try {
+                await cleanupFn();
+            }
+            catch {
+                // Ignore cleanup errors during error handling
+            }
+        }
+        throw error;
+    }
+}
+/**
+ * Create a Layer for multi-chain setup
+ *
+ * @param config - Multi-chain configuration
+ * @returns Layer providing ChopsticksMultiChainService
+ */
+export const ChopsticksMultiChainLayer = (config) => Layer.scoped(ChopsticksMultiChainService, Effect.gen(function* () {
+    const cleanups = [];
+    // Launch relay chain
+    const relayResult = yield* Effect.tryPromise({
+        try: () => launchChopsticksEffect(config.relay),
+        catch: (cause) => new ChopsticksSetupError({
+            cause,
+            endpoint: getEndpointString(config.relay.endpoint),
+        }),
+    });
+    cleanups.push(Effect.tryPromise({
+        try: () => relayResult.cleanup(),
+        catch: () => undefined,
+    }).pipe(Effect.ignore));
+    // Launch parachains
+    const parachains = new Map();
+    for (const paraConfig of config.parachains) {
+        const paraResult = yield* Effect.tryPromise({
+            try: () => launchChopsticksEffect(paraConfig),
+            catch: (cause) => new ChopsticksSetupError({
+                cause,
+                endpoint: getEndpointString(paraConfig.endpoint),
+            }),
+        });
+        cleanups.push(Effect.tryPromise({
+            try: () => paraResult.cleanup(),
+            catch: () => undefined,
+        }).pipe(Effect.ignore));
+        parachains.set(paraConfig.paraId, paraResult.result);
+    }
+    // Register cleanup with scope finalizer
+    yield* Effect.addFinalizer(() => Effect.gen(function* () {
+        logger.debug("Finalizing multi-chain setup...");
+        for (const cleanup of cleanups.reverse()) {
+            yield* cleanup;
+        }
+        logger.debug("Multi-chain finalization complete");
+    }));
+    return createMultiChainService(relayResult.result, parachains);
+}));
+/**
+ * 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 const createPolkadotMoonbeamConfig = (relayPort = 8000, 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",
+        },
+    ],
+});
+/**
+ * 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 const createKusamaMoonriverConfig = (relayPort = 8000, 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",
+        },
+    ],
+});

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

@@ -0,0 +1,313 @@
+/**
+ * Effect-based Chopsticks Service for programmatic blockchain fork management
+ *
+ * This service provides a type-safe, Effect-based interface to @acala-network/chopsticks,
+ * replacing the previous CLI-subprocess approach with direct programmatic control.
+ *
+ * The configuration type (ChopsticksConfig) is imported directly from @acala-network/chopsticks
+ * to ensure it stays in sync with upstream changes and supports all config options like rpc-timeout.
+ */
+import { Context, Effect } from "effect";
+import type { Blockchain, BuildBlockMode, fetchConfig } from "@acala-network/chopsticks";
+import type { HexString } from "@polkadot/util/types";
+/**
+ * The ChopsticksConfig type, derived from the fetchConfig return type.
+ *
+ * This ensures our type stays in sync with upstream chopsticks changes.
+ * The config uses kebab-case keys as defined by chopsticks (e.g., 'rpc-timeout',
+ * 'build-block-mode', 'mock-signature-host').
+ */
+export type ChopsticksConfig = Awaited<ReturnType<typeof fetchConfig>>;
+declare const ChopsticksSetupError_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: "ChopsticksSetupError";
+} & Readonly<A>;
+/**
+ * Error thrown when chopsticks setup/initialization fails
+ */
+export declare class ChopsticksSetupError extends ChopsticksSetupError_base<{
+    readonly cause: unknown;
+    readonly endpoint?: string;
+    readonly block?: string | number;
+}> {
+}
+declare const ChopsticksBlockError_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: "ChopsticksBlockError";
+} & Readonly<A>;
+/**
+ * Error thrown when block creation fails
+ */
+export declare class ChopsticksBlockError extends ChopsticksBlockError_base<{
+    readonly cause: unknown;
+    readonly operation: "newBlock" | "setHead" | "getBlock";
+    readonly blockIdentifier?: string | number;
+}> {
+}
+declare const ChopsticksStorageError_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: "ChopsticksStorageError";
+} & Readonly<A>;
+/**
+ * Error thrown when storage operations fail
+ */
+export declare class ChopsticksStorageError extends ChopsticksStorageError_base<{
+    readonly cause: unknown;
+    readonly module: string;
+    readonly method: string;
+}> {
+}
+declare const ChopsticksExtrinsicError_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: "ChopsticksExtrinsicError";
+} & Readonly<A>;
+/**
+ * Error thrown when extrinsic operations fail
+ */
+export declare class ChopsticksExtrinsicError extends ChopsticksExtrinsicError_base<{
+    readonly cause: unknown;
+    readonly operation: "submit" | "dryRun" | "validate";
+    readonly extrinsic?: string;
+}> {
+}
+declare const ChopsticksXcmError_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: "ChopsticksXcmError";
+} & Readonly<A>;
+/**
+ * Error thrown when XCM message operations fail
+ */
+export declare class ChopsticksXcmError extends ChopsticksXcmError_base<{
+    readonly cause: unknown;
+    readonly messageType: "ump" | "dmp" | "hrmp";
+    readonly paraId?: number;
+}> {
+}
+declare const ChopsticksCleanupError_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: "ChopsticksCleanupError";
+} & Readonly<A>;
+/**
+ * Error thrown when chopsticks cleanup/shutdown fails
+ */
+export declare class ChopsticksCleanupError extends ChopsticksCleanupError_base<{
+    readonly cause: unknown;
+}> {
+}
+/**
+ * Union type of all chopsticks errors for exhaustive handling
+ */
+export type ChopsticksError = ChopsticksSetupError | ChopsticksBlockError | ChopsticksStorageError | ChopsticksExtrinsicError | ChopsticksXcmError | ChopsticksCleanupError;
+/**
+ * Result from creating a new block
+ */
+export interface BlockCreationResult {
+    /** The created block */
+    readonly block: {
+        readonly hash: HexString;
+        readonly number: number;
+    };
+}
+/**
+ * Parameters for creating a new block
+ */
+export interface BlockCreationParams {
+    /** Number of blocks to create */
+    readonly count?: number;
+    /** Target block number to create up to */
+    readonly to?: number;
+    /** Transactions to include */
+    readonly transactions?: HexString[];
+    /** UMP messages to include */
+    readonly ump?: Record<number, HexString[]>;
+    /** DMP messages to include */
+    readonly dmp?: Array<{
+        sentAt: number;
+        msg: HexString;
+    }>;
+    /** HRMP messages to include */
+    readonly hrmp?: Record<number, Array<{
+        sentAt: number;
+        data: HexString;
+    }>>;
+}
+/**
+ * Result from dry-running an extrinsic
+ */
+export interface DryRunResult {
+    /** Whether the extrinsic would succeed */
+    readonly success: boolean;
+    /** Storage changes that would occur */
+    readonly storageDiff: Array<[HexString, HexString | null]>;
+    /** Any error message if failed */
+    readonly error?: string;
+}
+declare const ChopsticksService_base: Context.TagClass<ChopsticksService, "ChopsticksService", {
+    /**
+     * Direct access to the underlying Blockchain instance.
+     * Use this for advanced operations not covered by the service methods.
+     */
+    readonly chain: Blockchain;
+    /**
+     * The WebSocket address the chopsticks server is listening on
+     */
+    readonly addr: string;
+    /**
+     * The port the chopsticks server is listening on
+     */
+    readonly port: number;
+    /**
+     * Create one or more new blocks
+     *
+     * @param params - Optional block creation parameters
+     * @returns The created block information
+     */
+    readonly createBlock: (params?: BlockCreationParams) => Effect.Effect<BlockCreationResult, ChopsticksBlockError>;
+    /**
+     * Set storage values directly
+     *
+     * @param params - Storage modification parameters
+     */
+    readonly setStorage: (params: {
+        module: string;
+        method: string;
+        params: unknown[];
+    }) => Effect.Effect<void, ChopsticksStorageError>;
+    /**
+     * Submit an extrinsic to the transaction pool
+     *
+     * @param extrinsic - The encoded extrinsic
+     * @returns The extrinsic hash
+     */
+    readonly submitExtrinsic: (extrinsic: HexString) => Effect.Effect<HexString, ChopsticksExtrinsicError>;
+    /**
+     * Dry-run an extrinsic without submitting it
+     *
+     * @param extrinsic - The encoded extrinsic or call data with address
+     * @param at - Optional block hash to dry-run at
+     * @returns The dry-run result
+     */
+    readonly dryRunExtrinsic: (extrinsic: HexString | {
+        call: HexString;
+        address: string;
+    }, at?: HexString) => Effect.Effect<DryRunResult, ChopsticksExtrinsicError>;
+    /**
+     * Get a block by hash or number
+     *
+     * @param hashOrNumber - Block hash or number (defaults to head)
+     */
+    readonly getBlock: (hashOrNumber?: HexString | number) => Effect.Effect<{
+        hash: HexString;
+        number: number;
+    } | undefined, ChopsticksBlockError>;
+    /**
+     * Set the head of the chain to a specific block
+     *
+     * @param hashOrNumber - Block hash or number to set as head
+     */
+    readonly setHead: (hashOrNumber: HexString | number) => Effect.Effect<void, ChopsticksBlockError>;
+    /**
+     * Submit upward messages (parachain → relay chain)
+     *
+     * @param paraId - The parachain ID
+     * @param messages - Array of encoded UMP messages
+     */
+    readonly submitUpwardMessages: (paraId: number, messages: HexString[]) => Effect.Effect<void, ChopsticksXcmError>;
+    /**
+     * Submit downward messages (relay chain → parachain)
+     *
+     * @param messages - Array of DMP messages
+     */
+    readonly submitDownwardMessages: (messages: Array<{
+        sentAt: number;
+        msg: HexString;
+    }>) => Effect.Effect<void, ChopsticksXcmError>;
+    /**
+     * Submit horizontal messages (parachain → parachain)
+     *
+     * @param paraId - The source parachain ID
+     * @param messages - Array of HRMP messages
+     */
+    readonly submitHorizontalMessages: (paraId: number, messages: Array<{
+        sentAt: number;
+        data: HexString;
+    }>) => Effect.Effect<void, ChopsticksXcmError>;
+}>;
+/**
+ * ChopsticksService provides programmatic access to a chopsticks blockchain fork.
+ *
+ * This service wraps the @acala-network/chopsticks library and exposes its
+ * functionality through Effect-based methods with proper error handling.
+ *
+ * @example
+ * ```typescript
+ * const program = Effect.gen(function* () {
+ *   const chopsticks = yield* ChopsticksService;
+ *
+ *   // Create a new block
+ *   const block = yield* chopsticks.createBlock();
+ *   console.log(`Created block #${block.block.number}`);
+ *
+ *   // Modify storage
+ *   yield* chopsticks.setStorage({
+ *     module: "System",
+ *     method: "Account",
+ *     params: [[address, { data: { free: "1000000000000" } }]]
+ *   });
+ * });
+ * ```
+ */
+export declare class ChopsticksService extends ChopsticksService_base {
+}
+declare const ChopsticksConfigTag_base: Context.TagClass<ChopsticksConfigTag, "ChopsticksConfig", {
+    port: number;
+    'build-block-mode': BuildBlockMode;
+    addr?: string | undefined;
+    host?: string | undefined;
+    endpoint?: string | string[] | undefined;
+    block?: string | number | null | undefined;
+    'import-storage'?: any;
+    'allow-unresolved-imports'?: boolean | undefined;
+    'mock-signature-host'?: boolean | undefined;
+    'max-memory-block-count'?: number | undefined;
+    db?: string | undefined;
+    'save-blocks'?: boolean | undefined;
+    'wasm-override'?: string | undefined;
+    genesis?: string | {
+        name: string;
+        id: string;
+        properties: {
+            ss58Format?: number | undefined;
+            tokenDecimals?: number | number[] | undefined;
+            tokenSymbol?: string | string[] | undefined;
+        };
+        genesis: {
+            raw: {
+                top: Record<string, string>;
+            };
+        };
+    } | undefined;
+    'chain-spec'?: string | {
+        name: string;
+        id: string;
+        properties: {
+            ss58Format?: number | undefined;
+            tokenDecimals?: number | number[] | undefined;
+            tokenSymbol?: string | string[] | undefined;
+        };
+        genesis: {
+            raw: {
+                top: Record<string, string>;
+            };
+        };
+    } | undefined;
+    timestamp?: number | undefined;
+    'registered-types'?: any;
+    'runtime-log-level'?: number | undefined;
+    'offchain-worker'?: boolean | undefined;
+    resume?: number | boolean | `0x${string}` | undefined;
+    'process-queued-messages'?: boolean | undefined;
+    'prefetch-storages'?: any;
+    'rpc-timeout'?: number | undefined;
+}>;
+/**
+ * Configuration service tag for dependency injection
+ */
+export declare class ChopsticksConfigTag extends ChopsticksConfigTag_base {
+}
+export {};
+//# sourceMappingURL=ChopsticksService.d.ts.map

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

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

package/dist/services/chopsticks/ChopsticksService.js

@@ -0,0 +1,77 @@
+/**
+ * Effect-based Chopsticks Service for programmatic blockchain fork management
+ *
+ * This service provides a type-safe, Effect-based interface to @acala-network/chopsticks,
+ * replacing the previous CLI-subprocess approach with direct programmatic control.
+ *
+ * The configuration type (ChopsticksConfig) is imported directly from @acala-network/chopsticks
+ * to ensure it stays in sync with upstream changes and supports all config options like rpc-timeout.
+ */
+import { Context, Data } from "effect";
+// =============================================================================
+// Error Types
+// =============================================================================
+/**
+ * Error thrown when chopsticks setup/initialization fails
+ */
+export class ChopsticksSetupError extends Data.TaggedError("ChopsticksSetupError") {
+}
+/**
+ * Error thrown when block creation fails
+ */
+export class ChopsticksBlockError extends Data.TaggedError("ChopsticksBlockError") {
+}
+/**
+ * Error thrown when storage operations fail
+ */
+export class ChopsticksStorageError extends Data.TaggedError("ChopsticksStorageError") {
+}
+/**
+ * Error thrown when extrinsic operations fail
+ */
+export class ChopsticksExtrinsicError extends Data.TaggedError("ChopsticksExtrinsicError") {
+}
+/**
+ * Error thrown when XCM message operations fail
+ */
+export class ChopsticksXcmError extends Data.TaggedError("ChopsticksXcmError") {
+}
+/**
+ * Error thrown when chopsticks cleanup/shutdown fails
+ */
+export class ChopsticksCleanupError extends Data.TaggedError("ChopsticksCleanupError") {
+}
+// =============================================================================
+// Service Definition
+// =============================================================================
+/**
+ * ChopsticksService provides programmatic access to a chopsticks blockchain fork.
+ *
+ * This service wraps the @acala-network/chopsticks library and exposes its
+ * functionality through Effect-based methods with proper error handling.
+ *
+ * @example
+ * ```typescript
+ * const program = Effect.gen(function* () {
+ *   const chopsticks = yield* ChopsticksService;
+ *
+ *   // Create a new block
+ *   const block = yield* chopsticks.createBlock();
+ *   console.log(`Created block #${block.block.number}`);
+ *
+ *   // Modify storage
+ *   yield* chopsticks.setStorage({
+ *     module: "System",
+ *     method: "Account",
+ *     params: [[address, { data: { free: "1000000000000" } }]]
+ *   });
+ * });
+ * ```
+ */
+export class ChopsticksService extends Context.Tag("ChopsticksService")() {
+}
+/**
+ * Configuration service tag for dependency injection
+ */
+export class ChopsticksConfigTag extends Context.Tag("ChopsticksConfig")() {
+}