@no-witness-labs/midday-sdk 0.2.0 → 0.2.2

package/dist/Client.js

@@ -1,160 +1,276 @@
 /**
  * High-level client for interacting with Midnight Network contracts.
  *
- * Provides a simple API for deploying, joining, and calling contracts.
+ * ## API Design
+ *
+ * This module uses a **module-function pattern**:
+ *
+ * - **Stateless**: Functions operate on Client/Contract data
+ * - **Module functions**: `Client.contractFrom(client, options)`, `Contract.deploy(builder)`
+ * - **Data-oriented**: Client/Contract are plain data, not instances with methods
+ *
+ * ### Usage Patterns
+ *
+ * ```typescript
+ * // Promise user
+ * const client = await Client.create(config);
+ * const builder = await Client.contractFrom(client, { module });
+ * const contract = await ContractBuilder.deploy(builder);
+ * const result = await Contract.call(contract, 'increment');
+ *
+ * // Effect user
+ * const client = yield* Client.effect.create(config);
+ * const builder = yield* Client.effect.contractFrom(client, { module });
+ * const contract = yield* ContractBuilder.effect.deploy(builder);
+ * const result = yield* Contract.effect.call(contract, 'increment');
+ * ```
  *
  * @since 0.1.0
  * @module
  */
-import * as path from 'path';
-import * as fs from 'fs';
-import { fileURLToPath } from 'url';
+import { Context, Data, Effect, Layer } from 'effect';
 import { deployContract, findDeployedContract } from '@midnight-ntwrk/midnight-js-contracts';
-import pino from 'pino';
-import { build as buildPretty } from 'pino-pretty';
 import * as Config from './Config.js';
 import * as Wallet from './Wallet.js';
 import * as Providers from './Providers.js';
+import { createWalletProviders } from './wallet/provider.js';
+import { runEffectPromise } from './utils/effect-runtime.js';
 // =============================================================================
-// Path Resolution
+// Errors
 // =============================================================================
-function findProjectRoot(startDir = process.cwd()) {
-    let current = startDir;
-    while (current !== path.dirname(current)) {
-        if (fs.existsSync(path.join(current, 'package.json'))) {
-            return current;
-        }
-        current = path.dirname(current);
-    }
-    throw new Error('Could not find project root (no package.json found)');
+/**
+ * Error during client initialization or operation.
+ *
+ * @since 0.3.0
+ * @category errors
+ */
+export class ClientError extends Data.TaggedError('ClientError') {
 }
-function resolvePath(basePath, options) {
-    if (path.isAbsolute(basePath)) {
-        return basePath;
-    }
-    const from = options?.from ?? 'cwd';
-    if (from === 'cwd') {
-        return path.resolve(process.cwd(), basePath);
-    }
-    if (from === 'project') {
-        const projectRoot = findProjectRoot();
-        return path.resolve(projectRoot, basePath);
-    }
-    // Assume it's an import.meta.url
-    const callerDir = path.dirname(fileURLToPath(from));
-    return path.resolve(callerDir, basePath);
+/**
+ * Error during contract deployment or calls.
+ *
+ * @since 0.3.0
+ * @category errors
+ */
+export class ContractError extends Data.TaggedError('ContractError') {
 }
 // =============================================================================
-// Logger
+// Logger Factory
 // =============================================================================
 function createLogger(enabled) {
     if (!enabled) {
-        return pino.default({ level: 'silent' });
+        return {
+            info: () => { },
+            warn: () => { },
+            error: () => { },
+            debug: () => { },
+        };
     }
-    const pretty = buildPretty({ colorize: true, sync: true });
-    return pino.default({ level: 'info' }, pretty);
+    return {
+        info: (message) => console.log(`[INFO] ${message}`),
+        warn: (message) => console.warn(`[WARN] ${message}`),
+        error: (message) => console.error(`[ERROR] ${message}`),
+        debug: (message) => console.debug(`[DEBUG] ${message}`),
+    };
 }
 // =============================================================================
-// Client Implementation
+// Client - Internal Effect Implementations
 // =============================================================================
-/**
- * Create a Midnight client for interacting with contracts
- *
- * @example
- * ```typescript
- * import * as Midday from '@no-witness-labs/midday-sdk';
- *
- * // Simple - local network with dev wallet
- * const client = await Midday.Client.create();
- *
- * // Custom seed
- * const client = await Midday.Client.create({
- *   seed: 'your-64-char-hex-seed'
- * });
- *
- * // Custom network endpoints via env vars or config
- * const client = await Midday.Client.create({
- *   networkConfig: {
- *     networkId: 'testnet',
- *     indexer: 'https://indexer.testnet.midnight.network/graphql',
- *     indexerWS: 'wss://indexer.testnet.midnight.network/graphql/ws',
- *     node: 'wss://node.testnet.midnight.network',
- *     proofServer: 'https://proof.testnet.midnight.network',
- *   }
- * });
- *
- * // Load and deploy a contract
- * const counter = await (await client.contractFrom('build/simple-counter')).deploy();
- *
- * // Call actions
- * await counter.call('increment');
- *
- * // Read state
- * const state = await counter.ledgerState();
- * console.log(state.counter);
- *
- * // Join existing contract
- * const existing = await (await client.contractFrom('build/simple-counter')).join(address);
- * ```
- */
-export async function create(config = {}) {
-    const { network = 'local', networkConfig: customNetworkConfig, seed, storage, logging = true } = config;
-    const logger = createLogger(logging);
-    // Resolve network configuration
-    const networkConfig = customNetworkConfig ?? Config.getNetworkConfig(network);
-    // Resolve seed (use dev wallet only for local network)
-    const walletSeed = seed ?? (network === 'local' ? Config.DEV_WALLET_SEED : undefined);
-    if (!walletSeed) {
-        throw new Error('Wallet seed is required for non-local networks. Provide via config.seed or MIDNIGHT_WALLET_SEED env var.');
-    }
-    // Initialize wallet
-    logger.info('Initializing wallet...');
-    const walletContext = await Wallet.init(walletSeed, networkConfig);
-    await Wallet.waitForSync(walletContext);
-    logger.info('Wallet synced');
-    return {
-        wallet: walletContext,
-        networkConfig,
-        logger,
-        async contractFrom(basePath, options) {
-            const zkConfigPath = resolvePath(basePath, options);
-            if (!fs.existsSync(zkConfigPath)) {
-                throw new Error(`Contract path not found: ${zkConfigPath}`);
-            }
-            const contractPath = path.join(zkConfigPath, 'contract', 'index.js');
-            if (!fs.existsSync(contractPath)) {
-                throw new Error(`Contract module not found: ${contractPath}`);
+function createEffect(config) {
+    return Effect.gen(function* () {
+        const { network = 'local', networkConfig: customNetworkConfig, seed, zkConfigProvider, privateStateProvider, storage, logging = true, } = config;
+        const logger = createLogger(logging);
+        // Resolve network configuration
+        const networkConfig = customNetworkConfig ?? Config.getNetworkConfig(network);
+        // Resolve seed (use dev wallet only for local network)
+        const walletSeed = seed ?? (network === 'local' ? Config.DEV_WALLET_SEED : undefined);
+        if (!walletSeed) {
+            return yield* Effect.fail(new ClientError({
+                cause: new Error('Missing seed'),
+                message: 'Wallet seed is required for non-local networks. Provide via config.seed.',
+            }));
+        }
+        // Initialize wallet
+        logger.info('Initializing wallet...');
+        const walletContext = yield* Wallet.effect.init(walletSeed, networkConfig).pipe(Effect.mapError((e) => new ClientError({
+            cause: e,
+            message: `Failed to initialize wallet: ${e.message}`,
+        })));
+        yield* Wallet.effect.waitForSync(walletContext).pipe(Effect.mapError((e) => new ClientError({
+            cause: e,
+            message: `Failed to sync wallet: ${e.message}`,
+        })));
+        logger.info('Wallet synced');
+        const providerOptions = {
+            networkConfig,
+            zkConfigProvider,
+            privateStateProvider,
+            storageConfig: storage,
+        };
+        const providers = Providers.create(walletContext, providerOptions);
+        return {
+            wallet: walletContext,
+            networkConfig,
+            logger,
+            providers,
+        };
+    });
+}
+function fromWalletEffect(connection, config) {
+    return Effect.try({
+        try: () => {
+            const { zkConfigProvider, privateStateProvider, logging = true } = config;
+            const logger = createLogger(logging);
+            // Create network config from wallet configuration
+            const networkConfig = {
+                networkId: connection.config.networkId,
+                indexer: connection.config.indexerUri,
+                indexerWS: connection.config.indexerWsUri,
+                node: connection.config.substrateNodeUri,
+                proofServer: connection.config.proverServerUri ?? '',
+            };
+            // Create wallet providers from connection
+            const { walletProvider, midnightProvider } = createWalletProviders(connection.wallet, connection.addresses);
+            const providerOptions = {
+                networkConfig,
+                zkConfigProvider,
+                privateStateProvider,
+            };
+            // Create providers using the wallet providers
+            const providers = Providers.createFromWalletProviders(walletProvider, midnightProvider, providerOptions);
+            logger.info('Connected to wallet');
+            return {
+                wallet: null,
+                networkConfig,
+                logger,
+                providers,
+            };
+        },
+        catch: (cause) => new ClientError({
+            cause,
+            message: `Failed to create client from wallet: ${cause instanceof Error ? cause.message : String(cause)}`,
+        }),
+    });
+}
+function contractFromEffect(client, options) {
+    return Effect.try({
+        try: () => {
+            if (!options.module) {
+                throw new Error('Contract module is required. Import and pass the contract module.');
             }
-            const contractModule = await import(contractPath);
             const module = {
-                Contract: contractModule.Contract,
-                ledger: contractModule.ledger,
-                zkConfigPath,
-                privateStateId: options?.privateStateId ?? path.basename(zkConfigPath),
-                witnesses: options?.witnesses ?? {},
+                Contract: options.module.Contract,
+                ledger: options.module.ledger,
+                privateStateId: options.privateStateId ?? 'contract',
+                witnesses: options.witnesses ?? {},
+            };
+            return {
+                module,
+                providers: client.providers,
+                logger: client.logger,
             };
-            const providers = Providers.create(walletContext, zkConfigPath, networkConfig, storage);
-            return createContractBuilder(module, providers, logger);
         },
-        async waitForTx(txHash) {
-            const providers = Providers.create(walletContext, process.cwd(), networkConfig, storage);
-            const data = await providers.publicDataProvider.watchForTxData(txHash);
+        catch: (cause) => new ClientError({
+            cause,
+            message: `Failed to load contract: ${cause instanceof Error ? cause.message : String(cause)}`,
+        }),
+    });
+}
+function waitForTxEffect(client, txHash) {
+    return Effect.tryPromise({
+        try: async () => {
+            const data = await client.providers.publicDataProvider.watchForTxData(txHash);
             return {
                 txHash: data.txHash,
                 blockHeight: data.blockHeight,
                 blockHash: data.blockHash,
             };
         },
-    };
+        catch: (cause) => new ClientError({
+            cause,
+            message: `Failed to wait for transaction: ${cause instanceof Error ? cause.message : String(cause)}`,
+        }),
+    });
 }
 // =============================================================================
-// Contract Builder
+// Client - Promise API
 // =============================================================================
-function createContractBuilder(module, providers, logger) {
-    return {
-        module,
-        async deploy(options) {
+/**
+ * Create a Midnight client for interacting with contracts using a seed.
+ *
+ * @example
+ * ```typescript
+ * const client = await Client.create({
+ *   seed: 'your-64-char-hex-seed',
+ *   networkConfig: Config.NETWORKS.local,
+ *   zkConfigProvider,
+ *   privateStateProvider,
+ * });
+ * ```
+ *
+ * @since 0.2.0
+ * @category constructors
+ */
+export async function create(config) {
+    return runEffectPromise(createEffect(config));
+}
+/**
+ * Create a Midnight client from a connected wallet (browser).
+ *
+ * @since 0.2.0
+ * @category constructors
+ */
+export async function fromWallet(connection, config) {
+    return runEffectPromise(fromWalletEffect(connection, config));
+}
+/**
+ * Load a contract module for a client.
+ *
+ * @example
+ * ```typescript
+ * const builder = await Client.contractFrom(client, {
+ *   module: await import('./contracts/counter/index.js'),
+ * });
+ * ```
+ *
+ * @since 0.2.0
+ * @category operations
+ */
+export async function contractFrom(client, options) {
+    return runEffectPromise(contractFromEffect(client, options));
+}
+/**
+ * Wait for a transaction to be finalized.
+ *
+ * @since 0.2.0
+ * @category operations
+ */
+export async function waitForTx(client, txHash) {
+    return runEffectPromise(waitForTxEffect(client, txHash));
+}
+/**
+ * Raw Effect APIs for advanced users.
+ *
+ * @example
+ * ```typescript
+ * const client = yield* Client.effect.create(config);
+ * const builder = yield* Client.effect.contractFrom(client, { module });
+ * ```
+ *
+ * @since 0.2.0
+ * @category effect
+ */
+export const effect = {
+    create: createEffect,
+    fromWallet: fromWalletEffect,
+    contractFrom: contractFromEffect,
+    waitForTx: waitForTxEffect,
+};
+function deployEffect(builder, options) {
+    return Effect.tryPromise({
+        try: async () => {
             const { initialPrivateState = {} } = options ?? {};
+            const { module, providers, logger } = builder;
             logger.info('Deploying contract...');
             const ContractClass = module.Contract;
             const contract = new ContractClass(module.witnesses);
@@ -164,12 +280,28 @@ function createContractBuilder(module, providers, logger) {
                 privateStateId: module.privateStateId,
                 initialPrivateState,
             });
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const address = deployed.deployTxData.public.contractAddress;
             logger.info(`Contract deployed at: ${address}`);
-            return createConnectedContract(address, deployed, module, providers, logger);
+            return {
+                address,
+                instance: deployed,
+                module,
+                providers,
+                logger,
+            };
         },
-        async join(address, options) {
+        catch: (cause) => new ContractError({
+            cause,
+            message: `Failed to deploy contract: ${cause instanceof Error ? cause.message : String(cause)}`,
+        }),
+    });
+}
+function joinEffect(builder, address, options) {
+    return Effect.tryPromise({
+        try: async () => {
             const { initialPrivateState = {} } = options ?? {};
+            const { module, providers, logger } = builder;
             logger.info(`Joining contract at ${address}...`);
             const ContractClass = module.Contract;
             const contract = new ContractClass(module.witnesses);
@@ -181,18 +313,76 @@ function createContractBuilder(module, providers, logger) {
                 initialPrivateState,
             });
             logger.info('Contract joined');
-            return createConnectedContract(address, deployed, module, providers, logger);
+            return {
+                address,
+                instance: deployed,
+                module,
+                providers,
+                logger,
+            };
         },
-    };
+        catch: (cause) => new ContractError({
+            cause,
+            message: `Failed to join contract at ${address}: ${cause instanceof Error ? cause.message : String(cause)}`,
+        }),
+    });
 }
-function createConnectedContract(address, instance, module, providers, logger) {
-    return {
-        address,
-        instance,
-        module,
-        providers,
-        logger,
-        async call(action, ...args) {
+// =============================================================================
+// ContractBuilder - Promise API & Effect Namespace
+// =============================================================================
+/**
+ * ContractBuilder module functions.
+ *
+ * @since 0.2.0
+ * @category ContractBuilder
+ */
+export const ContractBuilder = {
+    /**
+     * Deploy a new contract instance.
+     *
+     * @example
+     * ```typescript
+     * const contract = await ContractBuilder.deploy(builder);
+     * ```
+     *
+     * @since 0.2.0
+     * @category lifecycle
+     */
+    deploy: async (builder, options) => {
+        return runEffectPromise(deployEffect(builder, options));
+    },
+    /**
+     * Join an existing contract.
+     *
+     * @example
+     * ```typescript
+     * const contract = await ContractBuilder.join(builder, '0x...');
+     * ```
+     *
+     * @since 0.2.0
+     * @category lifecycle
+     */
+    join: async (builder, address, options) => {
+        return runEffectPromise(joinEffect(builder, address, options));
+    },
+    /**
+     * Raw Effect APIs for ContractBuilder.
+     *
+     * @since 0.2.0
+     * @category effect
+     */
+    effect: {
+        deploy: deployEffect,
+        join: joinEffect,
+    },
+};
+// =============================================================================
+// Contract - Internal Effect Implementations
+// =============================================================================
+function callEffect(contract, action, ...args) {
+    return Effect.tryPromise({
+        try: async () => {
+            const { instance, logger } = contract;
             logger.info(`Calling ${action}()...`);
             const deployed = instance;
             const callTx = deployed.callTx;
@@ -209,14 +399,32 @@ function createConnectedContract(address, instance, module, providers, logger) {
                 status: txData.public.status,
             };
         },
-        async state() {
+        catch: (cause) => new ContractError({
+            cause,
+            message: `Failed to call ${action}: ${cause instanceof Error ? cause.message : String(cause)}`,
+        }),
+    });
+}
+function stateEffect(contract) {
+    return Effect.tryPromise({
+        try: async () => {
+            const { address, providers } = contract;
             const contractState = await providers.publicDataProvider.queryContractState(address);
             if (!contractState) {
                 throw new Error(`Contract state not found at ${address}`);
             }
             return contractState.data;
         },
-        async stateAt(blockHeight) {
+        catch: (cause) => new ContractError({
+            cause,
+            message: `Failed to query contract state: ${cause instanceof Error ? cause.message : String(cause)}`,
+        }),
+    });
+}
+function stateAtEffect(contract, blockHeight) {
+    return Effect.tryPromise({
+        try: async () => {
+            const { address, providers } = contract;
             const contractState = await providers.publicDataProvider.queryContractState(address, {
                 type: 'blockHeight',
                 blockHeight,
@@ -226,14 +434,271 @@ function createConnectedContract(address, instance, module, providers, logger) {
             }
             return contractState.data;
         },
-        async ledgerState() {
-            const data = await this.state();
-            return module.ledger(data);
-        },
-        async ledgerStateAt(blockHeight) {
-            const data = await this.stateAt(blockHeight);
-            return module.ledger(data);
-        },
-    };
+        catch: (cause) => new ContractError({
+            cause,
+            message: `Failed to query contract state at block ${blockHeight}: ${cause instanceof Error ? cause.message : String(cause)}`,
+        }),
+    });
+}
+function ledgerStateEffect(contract) {
+    return stateEffect(contract).pipe(Effect.map((data) => contract.module.ledger(data)));
+}
+function ledgerStateAtEffect(contract, blockHeight) {
+    return stateAtEffect(contract, blockHeight).pipe(Effect.map((data) => contract.module.ledger(data)));
+}
+// =============================================================================
+// Contract - Promise API & Effect Namespace
+// =============================================================================
+/**
+ * Contract module functions.
+ *
+ * @since 0.2.0
+ * @category Contract
+ */
+export const Contract = {
+    /**
+     * Call a contract action.
+     *
+     * @example
+     * ```typescript
+     * const result = await Contract.call(contract, 'increment');
+     * ```
+     *
+     * @since 0.2.0
+     * @category operations
+     */
+    call: async (contract, action, ...args) => {
+        return runEffectPromise(callEffect(contract, action, ...args));
+    },
+    /**
+     * Get contract state.
+     *
+     * @since 0.2.0
+     * @category inspection
+     */
+    state: async (contract) => {
+        return runEffectPromise(stateEffect(contract));
+    },
+    /**
+     * Get contract state at a specific block height.
+     *
+     * @since 0.2.0
+     * @category inspection
+     */
+    stateAt: async (contract, blockHeight) => {
+        return runEffectPromise(stateAtEffect(contract, blockHeight));
+    },
+    /**
+     * Get ledger state (parsed through ledger function).
+     *
+     * @since 0.2.0
+     * @category inspection
+     */
+    ledgerState: async (contract) => {
+        return runEffectPromise(ledgerStateEffect(contract));
+    },
+    /**
+     * Get ledger state at a specific block height.
+     *
+     * @since 0.2.0
+     * @category inspection
+     */
+    ledgerStateAt: async (contract, blockHeight) => {
+        return runEffectPromise(ledgerStateAtEffect(contract, blockHeight));
+    },
+    /**
+     * Raw Effect APIs for Contract.
+     *
+     * @since 0.2.0
+     * @category effect
+     */
+    effect: {
+        call: callEffect,
+        state: stateEffect,
+        stateAt: stateAtEffect,
+        ledgerState: ledgerStateEffect,
+        ledgerStateAt: ledgerStateAtEffect,
+    },
+};
+/**
+ * Context.Tag for ClientService dependency injection.
+ *
+ * @example
+ * ```typescript
+ * const program = Effect.gen(function* () {
+ *   const clientService = yield* ClientService;
+ *   const client = yield* clientService.create(config);
+ *   return client;
+ * });
+ *
+ * Effect.runPromise(program.pipe(Effect.provide(ClientLive)));
+ * ```
+ *
+ * @since 0.2.0
+ * @category service
+ */
+export class ClientService extends Context.Tag('ClientService')() {
+}
+/**
+ * Context.Tag for ContractBuilderService dependency injection.
+ *
+ * @since 0.2.0
+ * @category service
+ */
+export class ContractBuilderService extends Context.Tag('ContractBuilderService')() {
+}
+/**
+ * Context.Tag for ContractService dependency injection.
+ *
+ * @since 0.2.0
+ * @category service
+ */
+export class ContractService extends Context.Tag('ContractService')() {
+}
+// =============================================================================
+// Effect DI - Live Layers
+// =============================================================================
+/**
+ * Live Layer for ClientService.
+ *
+ * @since 0.2.0
+ * @category layer
+ */
+export const ClientLive = Layer.succeed(ClientService, {
+    create: createEffect,
+    fromWallet: fromWalletEffect,
+    contractFrom: contractFromEffect,
+    waitForTx: waitForTxEffect,
+});
+/**
+ * Live Layer for ContractBuilderService.
+ *
+ * @since 0.2.0
+ * @category layer
+ */
+export const ContractBuilderLive = Layer.succeed(ContractBuilderService, {
+    deploy: deployEffect,
+    join: joinEffect,
+});
+/**
+ * Live Layer for ContractService.
+ *
+ * @since 0.2.0
+ * @category layer
+ */
+export const ContractLive = Layer.succeed(ContractService, {
+    call: callEffect,
+    state: stateEffect,
+    stateAt: stateAtEffect,
+    ledgerState: ledgerStateEffect,
+    ledgerStateAt: ledgerStateAtEffect,
+});
+// =============================================================================
+// Layer Factories
+// =============================================================================
+/**
+ * Create a Layer providing all Client-related factory services.
+ *
+ * Use this when you want to create clients on-demand within your Effect programs.
+ * For pre-initialized clients, use `Client.layer(config)` instead.
+ *
+ * @example
+ * ```typescript
+ * import { Effect } from 'effect';
+ * import * as Midday from '@no-witness-labs/midday-sdk';
+ *
+ * const program = Effect.gen(function* () {
+ *   const clientService = yield* Midday.ClientService;
+ *   const client = yield* clientService.create(config);
+ *   return client;
+ * });
+ *
+ * await Effect.runPromise(program.pipe(Effect.provide(Midday.Client.services())));
+ * ```
+ *
+ * @since 0.3.0
+ * @category layer
+ */
+export function services() {
+    return Layer.mergeAll(ClientLive, ContractBuilderLive, ContractLive);
+}
+// =============================================================================
+// Pre-configured Client Layer
+// =============================================================================
+/**
+ * Context.Tag for a pre-initialized MidnightClient.
+ *
+ * Use with `Client.layer(config)` for dependency injection of a configured client.
+ *
+ * @since 0.3.0
+ * @category service
+ */
+export class MidnightClientService extends Context.Tag('MidnightClientService')() {
+}
+/**
+ * Create a Layer that provides a pre-initialized MidnightClient.
+ *
+ * This is the recommended way to inject a client into Effect programs
+ * when you have a known configuration at startup. Follows the same pattern
+ * as `Cluster.layer(config)`.
+ *
+ * @example
+ * ```typescript
+ * import { Effect } from 'effect';
+ * import * as Midday from '@no-witness-labs/midday-sdk';
+ *
+ * const clientLayer = Midday.Client.layer({
+ *   seed: 'your-64-char-hex-seed',
+ *   networkConfig: Midday.Config.NETWORKS.local,
+ *   zkConfigProvider: new Midday.HttpZkConfigProvider('http://localhost:3000/zk'),
+ *   privateStateProvider: Midday.inMemoryPrivateStateProvider(),
+ * });
+ *
+ * const program = Effect.gen(function* () {
+ *   const client = yield* Midday.MidnightClientService;
+ *   const builder = yield* Midday.Client.effect.contractFrom(client, { module });
+ *   return builder;
+ * });
+ *
+ * await Effect.runPromise(program.pipe(Effect.provide(clientLayer)));
+ * ```
+ *
+ * @since 0.3.0
+ * @category layer
+ */
+export function layer(config) {
+    return Layer.effect(MidnightClientService, createEffect(config));
+}
+/**
+ * Create a Layer that provides a pre-initialized MidnightClient from a wallet connection.
+ *
+ * Use this for browser environments with Lace wallet integration.
+ *
+ * @example
+ * ```typescript
+ * import { Effect } from 'effect';
+ * import * as Midday from '@no-witness-labs/midday-sdk';
+ *
+ * // After connecting wallet
+ * const connection = await Midday.connectWallet('testnet');
+ *
+ * const clientLayer = Midday.Client.layerFromWallet(connection, {
+ *   zkConfigProvider: new Midday.HttpZkConfigProvider('https://cdn.example.com/zk'),
+ *   privateStateProvider: Midday.indexedDBPrivateStateProvider({ privateStateStoreName: 'my-app' }),
+ * });
+ *
+ * const program = Effect.gen(function* () {
+ *   const client = yield* Midday.MidnightClientService;
+ *   // Use client...
+ * });
+ *
+ * await Effect.runPromise(program.pipe(Effect.provide(clientLayer)));
+ * ```
+ *
+ * @since 0.3.0
+ * @category layer
+ */
+export function layerFromWallet(connection, config) {
+    return Layer.effect(MidnightClientService, fromWalletEffect(connection, config));
 }
 //# sourceMappingURL=Client.js.map