@no-witness-labs/midday-sdk 0.2.4 → 0.2.5

package/dist/Client.d.ts

@@ -3,26 +3,31 @@
  *
  * ## API Design
  *
- * This module uses a **module-function pattern**:
+ * This module uses a **Client-centric hub pattern** following the Effect hybrid 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
+ * - **Effect is source of truth**: All logic in Effect functions
+ * - **Client is the hub**: All operations flow from the client
+ * - **Two interfaces**: `.effect.method()` for Effect users, `.method()` for Promise users
+ * - **Effects call Effects, Promises call Promises**: Never mix execution models
  *
  * ### 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');
+ * // Promise user - simple flow
+ * const client = await Midday.Client.create(config);
+ * const contract = await client.loadContract({ path: './contracts/counter' });
+ * await contract.deploy();
+ * await contract.call('increment');
+ * const state = await contract.ledgerState();
+ *
+ * // Effect user - compositional
+ * const program = Effect.gen(function* () {
+ *   const client = yield* Midday.Client.effect.create(config);
+ *   const contract = yield* client.effect.loadContract({ path: './contracts/counter' });
+ *   yield* contract.effect.deploy();
+ *   yield* contract.effect.call('increment');
+ *   const state = yield* contract.effect.ledgerState();
+ * });
  * ```
  *
  * @since 0.1.0
@@ -31,7 +36,7 @@
 import { Context, Effect, Layer } from 'effect';
 import type { ZKConfigProvider, PrivateStateProvider } from '@midnight-ntwrk/midnight-js-types';
 import type { NetworkConfig } from './Config.js';
-import type { ContractProviders, StorageConfig } from './Providers.js';
+import type { BaseProviders, ContractProviders, StorageConfig } from './Providers.js';
 import type { WalletContext } from './Wallet.js';
 import type { WalletConnection } from './wallet/connector.js';
 declare const ClientError_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 & {
@@ -75,8 +80,6 @@ export interface ClientConfig {
     networkConfig?: NetworkConfig;
     /** Wallet seed (required for non-local networks) */
     seed?: string;
-    /** ZK configuration provider (required) */
-    zkConfigProvider: ZKConfigProvider<string>;
     /** Private state provider (required) */
     privateStateProvider: PrivateStateProvider;
     /** Storage configuration */
@@ -87,14 +90,25 @@ export interface ClientConfig {
 /**
  * Options for loading a contract.
  *
+ * Exactly one of these must be provided:
+ * - `module` + `zkConfig`: Direct module and zkConfig (works everywhere)
+ * - `path`: Load from filesystem path (Node.js only)
+ * - `moduleUrl` + `zkConfigBaseUrl`: Load from URLs (browser)
+ *
  * @since 0.2.0
  * @category model
  */
-export interface ContractFromOptions {
-    /** Contract module (required in browser) */
+export interface LoadContractOptions {
+    /** Contract module */
     module?: ContractModule;
-    /** URL to fetch ZK config from (for HttpZkConfigProvider) */
-    zkConfigUrl?: string;
+    /** ZK configuration provider for this contract */
+    zkConfig?: ZKConfigProvider<string>;
+    /** Filesystem path to contract directory (auto-loads module + zkConfig) */
+    path?: string;
+    /** URL to contract module JS file */
+    moduleUrl?: string;
+    /** Base URL for ZK artifacts */
+    zkConfigBaseUrl?: string;
     /** Witnesses for the contract */
     witnesses?: Record<string, unknown>;
     /** Override privateStateId (defaults to contract name) */
@@ -165,84 +179,166 @@ export interface CallResult {
     status: string;
 }
 /**
- * Represents a Midnight client.
+ * A Midnight client handle with convenience methods.
  *
- * This is plain data - use module functions to operate on it.
- *
- * @since 0.2.0
+ * @since 0.5.0
  * @category model
  */
-export interface MidnightClient {
-    /** Raw wallet context for advanced use (null if using wallet connector) */
-    readonly wallet: WalletContext | null;
+export interface MiddayClient {
     /** Network configuration */
     readonly networkConfig: NetworkConfig;
-    /** Contract providers */
-    readonly providers: ContractProviders;
-    /** Whether logging is enabled (for backwards compatibility) */
-    readonly logging: boolean;
+    /** Base providers (for advanced use - no zkConfig) */
+    readonly providers: BaseProviders;
+    /** Raw wallet context (null if using wallet connector) */
+    readonly wallet: WalletContext | null;
+    /**
+     * Load a contract module. Returns a Contract in "loaded" state.
+     * Call `deploy()` or `join()` on it to connect to the network.
+     *
+     * @example
+     * ```typescript
+     * // Load from path (Node.js)
+     * const contract = await client.loadContract({ path: './contracts/counter' });
+     *
+     * // Load with direct module + zkConfig
+     * const contract = await client.loadContract({ module, zkConfig });
+     *
+     * // Load from URLs (browser)
+     * const contract = await client.loadContract({
+     *   moduleUrl: 'https://example.com/contract.js',
+     *   zkConfigBaseUrl: 'https://example.com/zk'
+     * });
+     * ```
+     */
+    loadContract(options: LoadContractOptions): Promise<Contract>;
+    /**
+     * Wait for a transaction to be finalized.
+     */
+    waitForTx(txHash: string): Promise<FinalizedTxData>;
+    /** Effect versions of client methods */
+    readonly effect: {
+        loadContract(options: LoadContractOptions): Effect.Effect<Contract, ClientError>;
+        waitForTx(txHash: string): Effect.Effect<FinalizedTxData, ClientError>;
+    };
 }
 /**
- * Represents a contract builder for deploying or joining contracts.
- *
- * This is plain data - use module functions to operate on it.
+ * Contract state: either "loaded" (pre-deploy) or "deployed" (connected to network).
  *
- * @since 0.2.0
+ * @since 0.6.0
  * @category model
  */
-export interface ContractBuilder {
-    /** The loaded contract module */
-    readonly module: LoadedContractModule;
-    /** Contract providers */
-    readonly providers: ContractProviders;
-    /** Whether logging is enabled */
-    readonly logging: boolean;
-}
+export type ContractState = 'loaded' | 'deployed';
 /**
- * Represents a connected contract.
+ * A contract handle that manages the full lifecycle: load → deploy/join → call.
  *
- * This is plain data - use module functions to operate on it.
+ * The contract has two states:
+ * - **loaded**: Contract module loaded, ready for deploy() or join()
+ * - **deployed**: Connected to network, ready for call() and ledgerState()
  *
- * @since 0.2.0
+ * @since 0.5.0
  * @category model
  */
-export interface ConnectedContract {
-    /** The deployed contract address */
-    readonly address: string;
-    /** The underlying contract instance */
-    readonly instance: unknown;
-    /** The loaded module (for ledger access) */
+export interface Contract {
+    /** Current state of the contract */
+    readonly state: ContractState;
+    /** The deployed contract address (undefined until deployed/joined) */
+    readonly address: string | undefined;
+    /** The loaded contract module */
     readonly module: LoadedContractModule;
-    /** Raw providers */
+    /** Contract providers (for advanced use) */
     readonly providers: ContractProviders;
-    /** Whether logging is enabled */
-    readonly logging: boolean;
+    /**
+     * Deploy a new contract instance.
+     * Transitions state from "loaded" to "deployed".
+     *
+     * @throws {ContractError} If already deployed
+     * @example
+     * ```typescript
+     * await contract.deploy();
+     * console.log(contract.address); // Now available
+     * ```
+     */
+    deploy(options?: DeployOptions): Promise<void>;
+    /**
+     * Join an existing contract at an address.
+     * Transitions state from "loaded" to "deployed".
+     *
+     * @throws {ContractError} If already deployed
+     * @example
+     * ```typescript
+     * await contract.join('0x...');
+     * ```
+     */
+    join(address: string, options?: JoinOptions): Promise<void>;
+    /**
+     * Call a contract action.
+     *
+     * @throws {ContractError} If not deployed
+     * @example
+     * ```typescript
+     * const result = await contract.call('increment', 5n);
+     * ```
+     */
+    call(action: string, ...args: unknown[]): Promise<CallResult>;
+    /**
+     * Get raw contract state.
+     *
+     * @throws {ContractError} If not deployed
+     */
+    getState(): Promise<unknown>;
+    /**
+     * Get raw contract state at a specific block height.
+     *
+     * @throws {ContractError} If not deployed
+     */
+    getStateAt(blockHeight: number): Promise<unknown>;
+    /**
+     * Get parsed ledger state.
+     *
+     * @throws {ContractError} If not deployed
+     * @example
+     * ```typescript
+     * const state = await contract.ledgerState() as MyContractLedger;
+     * ```
+     */
+    ledgerState(): Promise<unknown>;
+    /**
+     * Get parsed ledger state at a specific block height.
+     *
+     * @throws {ContractError} If not deployed
+     */
+    ledgerStateAt(blockHeight: number): Promise<unknown>;
+    /** Effect versions of contract methods */
+    readonly effect: {
+        deploy(options?: DeployOptions): Effect.Effect<void, ContractError>;
+        join(address: string, options?: JoinOptions): Effect.Effect<void, ContractError>;
+        call(action: string, ...args: unknown[]): Effect.Effect<CallResult, ContractError>;
+        getState(): Effect.Effect<unknown, ContractError>;
+        getStateAt(blockHeight: number): Effect.Effect<unknown, ContractError>;
+        ledgerState(): Effect.Effect<unknown, ContractError>;
+        ledgerStateAt(blockHeight: number): Effect.Effect<unknown, ContractError>;
+    };
 }
-declare function createEffect(config: ClientConfig): Effect.Effect<MidnightClient, ClientError>;
-declare function fromWalletEffect(connection: WalletConnection, config: {
-    zkConfigProvider: ZKConfigProvider<string>;
-    privateStateProvider: PrivateStateProvider;
-    logging?: boolean;
-}): Effect.Effect<MidnightClient, ClientError>;
-declare function contractFromEffect(client: MidnightClient, options: ContractFromOptions): Effect.Effect<ContractBuilder, ClientError>;
-declare function waitForTxEffect(client: MidnightClient, txHash: string): Effect.Effect<FinalizedTxData, ClientError>;
 /**
- * Create a Midnight client for interacting with contracts using a seed.
+ * Create a Midnight client for interacting with contracts.
  *
  * @example
  * ```typescript
- * const client = await Client.create({
+ * const client = await Midday.Client.create({
  *   seed: 'your-64-char-hex-seed',
- *   networkConfig: Config.NETWORKS.local,
- *   zkConfigProvider,
+ *   networkConfig: Midday.Config.NETWORKS.local,
  *   privateStateProvider,
  * });
+ *
+ * const contract = await client.loadContract({ path: './contracts/counter' });
+ * await contract.deploy();
+ * await contract.call('increment');
  * ```
  *
  * @since 0.2.0
  * @category constructors
  */
-export declare function create(config: ClientConfig): Promise<MidnightClient>;
+export declare function create(config: ClientConfig): Promise<MiddayClient>;
 /**
  * Create a Midnight client from a connected wallet (browser).
  *
@@ -250,235 +346,118 @@ export declare function create(config: ClientConfig): Promise<MidnightClient>;
  * @category constructors
  */
 export declare function fromWallet(connection: WalletConnection, config: {
-    zkConfigProvider: ZKConfigProvider<string>;
     privateStateProvider: PrivateStateProvider;
     logging?: boolean;
-}): Promise<MidnightClient>;
+}): Promise<MiddayClient>;
 /**
- * Load a contract module for a client.
+ * Raw Effect APIs for advanced users who want to compose Effects.
  *
  * @example
  * ```typescript
- * const builder = await Client.contractFrom(client, {
- *   module: await import('./contracts/counter/index.js'),
+ * const program = Effect.gen(function* () {
+ *   const client = yield* Midday.Client.effect.create(config);
+ *   const contract = yield* client.effect.loadContract({ module });
+ *   yield* contract.effect.deploy();
+ *   yield* contract.effect.call('increment');
  * });
  * ```
  *
  * @since 0.2.0
- * @category operations
- */
-export declare function contractFrom(client: MidnightClient, options: ContractFromOptions): Promise<ContractBuilder>;
-/**
- * Wait for a transaction to be finalized.
- *
- * @since 0.2.0
- * @category operations
- */
-export declare function waitForTx(client: MidnightClient, txHash: string): Promise<FinalizedTxData>;
-/**
- * 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 declare const effect: {
-    create: typeof createEffect;
-    fromWallet: typeof fromWalletEffect;
-    contractFrom: typeof contractFromEffect;
-    waitForTx: typeof waitForTxEffect;
-};
-declare function deployEffect(builder: ContractBuilder, options?: DeployOptions): Effect.Effect<ConnectedContract, ContractError>;
-declare function joinEffect(builder: ContractBuilder, address: string, options?: JoinOptions): Effect.Effect<ConnectedContract, ContractError>;
-/**
- * ContractBuilder module functions.
- *
- * @since 0.2.0
- * @category ContractBuilder
- */
-export declare const ContractBuilder: {
     /**
-     * Deploy a new contract instance.
-     *
-     * @example
-     * ```typescript
-     * const contract = await ContractBuilder.deploy(builder);
-     * ```
-     *
-     * @since 0.2.0
-     * @category lifecycle
+     * Create a client (Effect version).
      */
-    deploy: (builder: ContractBuilder, options?: DeployOptions) => Promise<ConnectedContract>;
+    create: (config: ClientConfig) => Effect.Effect<MiddayClient, ClientError>;
     /**
-     * Join an existing contract.
-     *
-     * @example
-     * ```typescript
-     * const contract = await ContractBuilder.join(builder, '0x...');
-     * ```
-     *
-     * @since 0.2.0
-     * @category lifecycle
+     * Create a client from wallet (Effect version).
      */
-    join: (builder: ContractBuilder, address: string, options?: JoinOptions) => Promise<ConnectedContract>;
-    /**
-     * Raw Effect APIs for ContractBuilder.
-     *
-     * @since 0.2.0
-     * @category effect
-     */
-    effect: {
-        deploy: typeof deployEffect;
-        join: typeof joinEffect;
-    };
+    fromWallet: (connection: WalletConnection, config: {
+        privateStateProvider: PrivateStateProvider;
+        logging?: boolean;
+    }) => Effect.Effect<MiddayClient, ClientError>;
 };
-declare function callEffect(contract: ConnectedContract, action: string, ...args: unknown[]): Effect.Effect<CallResult, ContractError>;
-declare function stateEffect(contract: ConnectedContract): Effect.Effect<unknown, ContractError>;
-declare function stateAtEffect(contract: ConnectedContract, blockHeight: number): Effect.Effect<unknown, ContractError>;
-declare function ledgerStateEffect(contract: ConnectedContract): Effect.Effect<unknown, ContractError>;
-declare function ledgerStateAtEffect(contract: ConnectedContract, blockHeight: number): Effect.Effect<unknown, ContractError>;
 /**
- * Contract module functions.
+ * Result of loading a contract from a path.
  *
- * @since 0.2.0
- * @category Contract
+ * @since 0.4.0
+ * @category model
  */
-export declare const Contract: {
-    /**
-     * Call a contract action.
-     *
-     * @example
-     * ```typescript
-     * const result = await Contract.call(contract, 'increment');
-     * ```
-     *
-     * @since 0.2.0
-     * @category operations
-     */
-    call: (contract: ConnectedContract, action: string, ...args: unknown[]) => Promise<CallResult>;
-    /**
-     * Get contract state.
-     *
-     * @since 0.2.0
-     * @category inspection
-     */
-    state: (contract: ConnectedContract) => Promise<unknown>;
-    /**
-     * Get contract state at a specific block height.
-     *
-     * @since 0.2.0
-     * @category inspection
-     */
-    stateAt: (contract: ConnectedContract, blockHeight: number) => Promise<unknown>;
-    /**
-     * Get ledger state (parsed through ledger function).
-     *
-     * @since 0.2.0
-     * @category inspection
-     */
-    ledgerState: (contract: ConnectedContract) => Promise<unknown>;
-    /**
-     * Get ledger state at a specific block height.
-     *
-     * @since 0.2.0
-     * @category inspection
-     */
-    ledgerStateAt: (contract: ConnectedContract, blockHeight: number) => Promise<unknown>;
-    /**
-     * Raw Effect APIs for Contract.
-     *
-     * @since 0.2.0
-     * @category effect
-     */
-    effect: {
-        call: typeof callEffect;
-        state: typeof stateEffect;
-        stateAt: typeof stateAtEffect;
-        ledgerState: typeof ledgerStateEffect;
-        ledgerStateAt: typeof ledgerStateAtEffect;
-    };
-};
+export interface ContractLoadResult<T = ContractModule> {
+    /** The contract module with TypeScript types. */
+    readonly module: T;
+    /** ZK config provider for circuit artifacts. */
+    readonly zkConfig: ZKConfigProvider<string>;
+}
 /**
- * Service interface for Client operations.
+ * Options for loading a contract.
  *
- * @since 0.2.0
- * @category service
+ * @since 0.4.0
+ * @category model
  */
-export interface ClientServiceImpl {
-    readonly create: (config: ClientConfig) => Effect.Effect<MidnightClient, ClientError>;
-    readonly fromWallet: (connection: WalletConnection, config: {
-        zkConfigProvider: ZKConfigProvider<string>;
-        privateStateProvider: PrivateStateProvider;
-        logging?: boolean;
-    }) => Effect.Effect<MidnightClient, ClientError>;
-    readonly contractFrom: (client: MidnightClient, options: ContractFromOptions) => Effect.Effect<ContractBuilder, ClientError>;
-    readonly waitForTx: (client: MidnightClient, txHash: string) => Effect.Effect<FinalizedTxData, ClientError>;
+export interface ContractLoadOptions {
+    /** Subdirectory within the contract path where the compiled module lives. @default 'contract' */
+    readonly moduleSubdir?: string;
+    /** Module entry point filename. @default 'index.js' */
+    readonly moduleEntry?: string;
 }
-declare const ClientService_base: Context.TagClass<ClientService, "ClientService", ClientServiceImpl>;
 /**
- * Context.Tag for ClientService dependency injection.
+ * Load a Compact contract from a directory path.
+ *
+ * Note: Prefer using `client.loadContract({ path })` which handles this automatically.
+ * This function is useful when you need to load the module before creating a client.
+ *
+ * @param contractPath - Absolute path to the contract directory
+ * @param options - Optional loading configuration
+ * @returns Promise resolving to the contract module and ZK config provider
  *
  * @example
  * ```typescript
- * const program = Effect.gen(function* () {
- *   const clientService = yield* ClientService;
- *   const client = yield* clientService.create(config);
- *   return client;
- * });
+ * // Preferred: let loadContract handle it
+ * const contract = await client.loadContract({ path: contractPath });
  *
- * Effect.runPromise(program.pipe(Effect.provide(ClientLive)));
+ * // Alternative: load separately (useful for pre-loading)
+ * const { module, zkConfig } = await Midday.Client.loadContractModule(contractPath);
+ * const contract = await client.loadContract({ module, zkConfig });
  * ```
  *
- * @since 0.2.0
- * @category service
+ * @since 0.4.0
+ * @category loading
  */
-export declare class ClientService extends ClientService_base {
-}
+export declare function loadContractModule<T = ContractModule>(contractPath: string, options?: ContractLoadOptions): Promise<ContractLoadResult<T>>;
 /**
- * Service interface for ContractBuilder operations.
+ * Load a contract from URLs (browser environments).
  *
- * @since 0.2.0
- * @category service
- */
-export interface ContractBuilderServiceImpl {
-    readonly deploy: (builder: ContractBuilder, options?: DeployOptions) => Effect.Effect<ConnectedContract, ContractError>;
-    readonly join: (builder: ContractBuilder, address: string, options?: JoinOptions) => Effect.Effect<ConnectedContract, ContractError>;
-}
-declare const ContractBuilderService_base: Context.TagClass<ContractBuilderService, "ContractBuilderService", ContractBuilderServiceImpl>;
-/**
- * Context.Tag for ContractBuilderService dependency injection.
+ * @param moduleUrl - URL to the contract module
+ * @param zkConfigBaseUrl - Base URL for ZK artifacts
+ * @returns Promise resolving to the contract module and ZK config provider
  *
- * @since 0.2.0
- * @category service
+ * @since 0.4.0
+ * @category loading
  */
-export declare class ContractBuilderService extends ContractBuilderService_base {
-}
+export declare function loadContractModuleFromUrl<T = ContractModule>(moduleUrl: string, zkConfigBaseUrl: string): Promise<ContractLoadResult<T>>;
 /**
- * Service interface for Contract operations.
+ * Service interface for Client operations.
  *
  * @since 0.2.0
  * @category service
  */
-export interface ContractServiceImpl {
-    readonly call: (contract: ConnectedContract, action: string, ...args: unknown[]) => Effect.Effect<CallResult, ContractError>;
-    readonly state: (contract: ConnectedContract) => Effect.Effect<unknown, ContractError>;
-    readonly stateAt: (contract: ConnectedContract, blockHeight: number) => Effect.Effect<unknown, ContractError>;
-    readonly ledgerState: (contract: ConnectedContract) => Effect.Effect<unknown, ContractError>;
-    readonly ledgerStateAt: (contract: ConnectedContract, blockHeight: number) => Effect.Effect<unknown, ContractError>;
+export interface ClientServiceImpl {
+    readonly create: (config: ClientConfig) => Effect.Effect<MiddayClient, ClientError>;
+    readonly fromWallet: (connection: WalletConnection, config: {
+        privateStateProvider: PrivateStateProvider;
+        logging?: boolean;
+    }) => Effect.Effect<MiddayClient, ClientError>;
 }
-declare const ContractService_base: Context.TagClass<ContractService, "ContractService", ContractServiceImpl>;
+declare const ClientService_base: Context.TagClass<ClientService, "ClientService", ClientServiceImpl>;
 /**
- * Context.Tag for ContractService dependency injection.
+ * Context.Tag for ClientService dependency injection.
  *
  * @since 0.2.0
  * @category service
  */
-export declare class ContractService extends ContractService_base {
+export declare class ClientService extends ClientService_base {
 }
 /**
  * Live Layer for ClientService.
@@ -487,77 +466,30 @@ export declare class ContractService extends ContractService_base {
  * @category layer
  */
 export declare const ClientLive: Layer.Layer<ClientService>;
+declare const MiddayClientService_base: Context.TagClass<MiddayClientService, "MiddayClientService", MiddayClient>;
 /**
- * Live Layer for ContractBuilderService.
- *
- * @since 0.2.0
- * @category layer
- */
-export declare const ContractBuilderLive: Layer.Layer<ContractBuilderService>;
-/**
- * Live Layer for ContractService.
- *
- * @since 0.2.0
- * @category layer
- */
-export declare const ContractLive: Layer.Layer<ContractService>;
-/**
- * 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 declare function services(): Layer.Layer<ClientService | ContractBuilderService | ContractService>;
-declare const MidnightClientService_base: Context.TagClass<MidnightClientService, "MidnightClientService", MidnightClient>;
-/**
- * Context.Tag for a pre-initialized MidnightClient.
- *
- * Use with `Client.layer(config)` for dependency injection of a configured client.
+ * Context.Tag for a pre-initialized MiddayClient.
  *
  * @since 0.3.0
  * @category service
  */
-export declare class MidnightClientService extends MidnightClientService_base {
+export declare class MiddayClientService extends MiddayClientService_base {
 }
 /**
- * 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)`.
+ * Create a Layer that provides a pre-initialized MiddayClient.
  *
  * @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(),
+ *   zkConfigProvider,
+ *   privateStateProvider,
  * });
  *
  * const program = Effect.gen(function* () {
- *   const client = yield* Midday.MidnightClientService;
- *   const builder = yield* Midday.Client.effect.contractFrom(client, { module });
+ *   const client = yield* Midday.MiddayClientService;
+ *   const builder = yield* client.effect.loadContract({ module });
  *   return builder;
  * });
  *
@@ -567,32 +499,9 @@ export declare class MidnightClientService extends MidnightClientService_base {
  * @since 0.3.0
  * @category layer
  */
-export declare function layer(config: ClientConfig): Layer.Layer<MidnightClientService, ClientError>;
+export declare function layer(config: ClientConfig): Layer.Layer<MiddayClientService, ClientError>;
 /**
- * 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)));
- * ```
+ * Create a Layer that provides a pre-initialized MiddayClient from a wallet connection.
  *
  * @since 0.3.0
  * @category layer
@@ -601,6 +510,13 @@ export declare function layerFromWallet(connection: WalletConnection, config: {
     zkConfigProvider: ZKConfigProvider<string>;
     privateStateProvider: PrivateStateProvider;
     logging?: boolean;
-}): Layer.Layer<MidnightClientService, ClientError>;
+}): Layer.Layer<MiddayClientService, ClientError>;
+/**
+ * Create a Layer providing all Client-related services.
+ *
+ * @since 0.3.0
+ * @category layer
+ */
+export declare function services(): Layer.Layer<ClientService>;
 export {};
 //# sourceMappingURL=Client.d.ts.map