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

package/dist/Client.js

@@ -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
@@ -55,11 +60,11 @@ export class ClientError extends Data.TaggedError('ClientError') {
 export class ContractError extends Data.TaggedError('ContractError') {
 }
 // =============================================================================
-// Client - Internal Effect Implementations
+// Effect Implementations (Source of Truth)
 // =============================================================================
-function createEffect(config) {
+function createClientDataEffect(config) {
     return Effect.gen(function* () {
-        const { network = 'local', networkConfig: customNetworkConfig, seed, zkConfigProvider, privateStateProvider, storage, logging = true, } = config;
+        const { network = 'local', networkConfig: customNetworkConfig, seed, privateStateProvider, storage, logging = true, } = config;
         // Resolve network configuration
         const networkConfig = customNetworkConfig ?? Config.getNetworkConfig(network);
         // Resolve seed (use dev wallet only for local network)
@@ -81,13 +86,13 @@ function createEffect(config) {
             message: `Failed to sync wallet: ${e.message}`,
         })));
         yield* Effect.logDebug('Wallet synced');
+        // Create base providers (no zkConfig - that's per-contract)
         const providerOptions = {
             networkConfig,
-            zkConfigProvider,
             privateStateProvider,
             storageConfig: storage,
         };
-        const providers = Providers.create(walletContext, providerOptions);
+        const providers = Providers.createBase(walletContext, providerOptions);
         return {
             wallet: walletContext,
             networkConfig,
@@ -96,9 +101,9 @@ function createEffect(config) {
         };
     });
 }
-function fromWalletEffect(connection, config) {
+function fromWalletDataEffect(connection, config) {
     return Effect.gen(function* () {
-        const { zkConfigProvider, privateStateProvider, logging = true } = config;
+        const { privateStateProvider, logging = true } = config;
         // Create network config from wallet configuration
         const networkConfig = {
             networkId: connection.config.networkId,
@@ -109,13 +114,13 @@ function fromWalletEffect(connection, config) {
         };
         // Create wallet providers from connection
         const { walletProvider, midnightProvider } = createWalletProviders(connection.wallet, connection.addresses);
+        // Create base providers (no zkConfig - that's per-contract)
         const providerOptions = {
             networkConfig,
-            zkConfigProvider,
             privateStateProvider,
         };
         // Create providers using the wallet providers
-        const providers = Providers.createFromWalletProviders(walletProvider, midnightProvider, providerOptions);
+        const providers = Providers.createBaseFromWalletProviders(walletProvider, midnightProvider, providerOptions);
         yield* Effect.logDebug('Connected to wallet');
         return {
             wallet: null,
@@ -128,22 +133,57 @@ function fromWalletEffect(connection, config) {
         message: `Failed to create client from wallet: ${defect instanceof Error ? defect.message : String(defect)}`,
     }))));
 }
-function contractFromEffect(client, options) {
-    return Effect.try({
-        try: () => {
-            if (!options.module) {
-                throw new Error('Contract module is required. Import and pass the contract module.');
+function loadContractEffect(clientData, options) {
+    return Effect.tryPromise({
+        try: async () => {
+            let module;
+            let zkConfig;
+            // Determine loading method
+            if (options.path) {
+                // Path-based loading (Node.js)
+                // eslint-disable-next-line @typescript-eslint/no-require-imports
+                const { join } = require('path');
+                // eslint-disable-next-line @typescript-eslint/no-require-imports
+                const { NodeZkConfigProvider } = require('@midnight-ntwrk/midnight-js-node-zk-config-provider');
+                const modulePath = join(options.path, 'contract', 'index.js');
+                module = await import(modulePath);
+                zkConfig = new NodeZkConfigProvider(options.path);
+            }
+            else if (options.moduleUrl && options.zkConfigBaseUrl) {
+                // URL-based loading (browser)
+                // eslint-disable-next-line @typescript-eslint/no-require-imports
+                const { HttpZkConfigProvider } = require('./providers/HttpZkConfigProvider.js');
+                module = await import(/* webpackIgnore: true */ options.moduleUrl);
+                zkConfig = new HttpZkConfigProvider(options.zkConfigBaseUrl);
+            }
+            else if (options.module && options.zkConfig) {
+                // Direct loading
+                module = options.module;
+                zkConfig = options.zkConfig;
             }
-            const module = {
-                Contract: options.module.Contract,
-                ledger: options.module.ledger,
+            else {
+                throw new Error('Contract loading requires one of: ' +
+                    '(1) module + zkConfig, ' +
+                    '(2) path (Node.js), or ' +
+                    '(3) moduleUrl + zkConfigBaseUrl (browser)');
+            }
+            const loadedModule = {
+                Contract: module.Contract,
+                ledger: module.ledger,
                 privateStateId: options.privateStateId ?? 'contract',
                 witnesses: options.witnesses ?? {},
             };
+            // Create full providers with zkConfig for this contract
+            const providers = {
+                ...clientData.providers,
+                zkConfigProvider: zkConfig,
+            };
             return {
-                module,
-                providers: client.providers,
-                logging: client.logging,
+                module: loadedModule,
+                providers,
+                logging: clientData.logging,
+                address: undefined,
+                instance: undefined,
             };
         },
         catch: (cause) => new ClientError({
@@ -152,10 +192,10 @@ function contractFromEffect(client, options) {
         }),
     });
 }
-function waitForTxEffect(client, txHash) {
+function waitForTxEffect(clientData, txHash) {
     return Effect.tryPromise({
         try: async () => {
-            const data = await client.providers.publicDataProvider.watchForTxData(txHash);
+            const data = await clientData.providers.publicDataProvider.watchForTxData(txHash);
             return {
                 txHash: data.txHash,
                 blockHeight: data.blockHeight,
@@ -168,86 +208,17 @@ function waitForTxEffect(client, txHash) {
         }),
     });
 }
-// =============================================================================
-// Client - Promise API
-// =============================================================================
-/**
- * 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) {
-    const logging = config.logging ?? true;
-    return runEffectWithLogging(createEffect(config), logging);
-}
-/**
- * Create a Midnight client from a connected wallet (browser).
- *
- * @since 0.2.0
- * @category constructors
- */
-export async function fromWallet(connection, config) {
-    const logging = config.logging ?? true;
-    return runEffectWithLogging(fromWalletEffect(connection, config), logging);
-}
-/**
- * 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 runEffectWithLogging(contractFromEffect(client, options), client.logging);
-}
-/**
- * Wait for a transaction to be finalized.
- *
- * @since 0.2.0
- * @category operations
- */
-export async function waitForTx(client, txHash) {
-    return runEffectWithLogging(waitForTxEffect(client, txHash), client.logging);
-}
-/**
- * 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) {
+function deployContractEffect(contractData, options) {
     return Effect.gen(function* () {
+        // State machine check
+        if (contractData.address !== undefined) {
+            return yield* Effect.fail(new ContractError({
+                cause: new Error('Already deployed'),
+                message: `Contract already deployed at ${contractData.address}. Cannot deploy again.`,
+            }));
+        }
         const { initialPrivateState = {} } = options ?? {};
-        const { module, providers, logging } = builder;
+        const { module, providers, logging } = contractData;
         yield* Effect.logDebug('Deploying contract...');
         const ContractClass = module.Contract;
         const contract = new ContractClass(module.witnesses);
@@ -277,10 +248,17 @@ function deployEffect(builder, options) {
         };
     });
 }
-function joinEffect(builder, address, options) {
+function joinContractEffect(contractData, address, options) {
     return Effect.gen(function* () {
+        // State machine check
+        if (contractData.address !== undefined) {
+            return yield* Effect.fail(new ContractError({
+                cause: new Error('Already deployed'),
+                message: `Contract already connected at ${contractData.address}. Cannot join another.`,
+            }));
+        }
         const { initialPrivateState = {} } = options ?? {};
-        const { module, providers, logging } = builder;
+        const { module, providers, logging } = contractData;
         yield* Effect.logDebug(`Joining contract at ${address}...`);
         const ContractClass = module.Contract;
         const contract = new ContractClass(module.witnesses);
@@ -309,61 +287,16 @@ function joinEffect(builder, address, options) {
         };
     });
 }
-// =============================================================================
-// 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 runEffectWithLogging(deployEffect(builder, options), builder.logging);
-    },
-    /**
-     * 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 runEffectWithLogging(joinEffect(builder, address, options), builder.logging);
-    },
-    /**
-     * 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) {
+function callContractEffect(contractData, action, ...args) {
     return Effect.gen(function* () {
-        const { instance } = contract;
+        // State machine check
+        if (contractData.instance === undefined) {
+            return yield* Effect.fail(new ContractError({
+                cause: new Error('Not deployed'),
+                message: `Contract not deployed. Call deploy() or join() first.`,
+            }));
+        }
+        const { instance } = contractData;
         yield* Effect.logDebug(`Calling ${action}()...`);
         const deployed = instance;
         const callTx = deployed.callTx;
@@ -390,10 +323,17 @@ function callEffect(contract, action, ...args) {
         };
     });
 }
-function stateEffect(contract) {
+function contractStateEffect(contractData) {
+    if (contractData.address === undefined) {
+        return Effect.fail(new ContractError({
+            cause: new Error('Not deployed'),
+            message: `Contract not deployed. Call deploy() or join() first.`,
+        }));
+    }
+    const address = contractData.address;
     return Effect.tryPromise({
         try: async () => {
-            const { address, providers } = contract;
+            const { providers } = contractData;
             const contractState = await providers.publicDataProvider.queryContractState(address);
             if (!contractState) {
                 throw new Error(`Contract state not found at ${address}`);
@@ -406,10 +346,17 @@ function stateEffect(contract) {
         }),
     });
 }
-function stateAtEffect(contract, blockHeight) {
+function contractStateAtEffect(contractData, blockHeight) {
+    if (contractData.address === undefined) {
+        return Effect.fail(new ContractError({
+            cause: new Error('Not deployed'),
+            message: `Contract not deployed. Call deploy() or join() first.`,
+        }));
+    }
+    const address = contractData.address;
     return Effect.tryPromise({
         try: async () => {
-            const { address, providers } = contract;
+            const { providers } = contractData;
             const contractState = await providers.publicDataProvider.queryContractState(address, {
                 type: 'blockHeight',
                 blockHeight,
@@ -425,223 +372,249 @@ function stateAtEffect(contract, blockHeight) {
         }),
     });
 }
-function ledgerStateEffect(contract) {
-    return stateEffect(contract).pipe(Effect.map((data) => contract.module.ledger(data)));
+function ledgerStateEffect(contractData) {
+    return contractStateEffect(contractData).pipe(Effect.map((data) => contractData.module.ledger(data)));
 }
-function ledgerStateAtEffect(contract, blockHeight) {
-    return stateAtEffect(contract, blockHeight).pipe(Effect.map((data) => contract.module.ledger(data)));
+function ledgerStateAtEffect(contractData, blockHeight) {
+    return contractStateAtEffect(contractData, blockHeight).pipe(Effect.map((data) => contractData.module.ledger(data)));
 }
 // =============================================================================
-// Contract - Promise API & Effect Namespace
+// Handle Factories (Create handles with methods from data)
 // =============================================================================
 /**
- * Contract module functions.
- *
- * @since 0.2.0
- * @category Contract
+ * Create a stateful Contract handle from internal data.
+ * The contract maintains mutable state internally for simplicity.
+ * @internal
  */
-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 runEffectWithLogging(callEffect(contract, action, ...args), contract.logging);
-    },
-    /**
-     * Get contract state.
-     *
-     * @since 0.2.0
-     * @category inspection
-     */
-    state: async (contract) => {
-        return runEffectWithLogging(stateEffect(contract), contract.logging);
-    },
-    /**
-     * Get contract state at a specific block height.
-     *
-     * @since 0.2.0
-     * @category inspection
-     */
-    stateAt: async (contract, blockHeight) => {
-        return runEffectWithLogging(stateAtEffect(contract, blockHeight), contract.logging);
-    },
-    /**
-     * Get ledger state (parsed through ledger function).
-     *
-     * @since 0.2.0
-     * @category inspection
-     */
-    ledgerState: async (contract) => {
-        return runEffectWithLogging(ledgerStateEffect(contract), contract.logging);
-    },
-    /**
-     * Get ledger state at a specific block height.
-     *
-     * @since 0.2.0
-     * @category inspection
-     */
-    ledgerStateAt: async (contract, blockHeight) => {
-        return runEffectWithLogging(ledgerStateAtEffect(contract, blockHeight), contract.logging);
-    },
-    /**
-     * Raw Effect APIs for Contract.
-     *
-     * @since 0.2.0
-     * @category effect
-     */
-    effect: {
-        call: callEffect,
-        state: stateEffect,
-        stateAt: stateAtEffect,
-        ledgerState: ledgerStateEffect,
-        ledgerStateAt: ledgerStateAtEffect,
-    },
-};
+function createContractHandle(initialData) {
+    // Mutable state - the contract data can change via deploy/join
+    let data = initialData;
+    const handle = {
+        // Computed state property
+        get state() {
+            return data.address !== undefined ? 'deployed' : 'loaded';
+        },
+        // Data accessors
+        get address() {
+            return data.address;
+        },
+        get module() {
+            return data.module;
+        },
+        get providers() {
+            return data.providers;
+        },
+        // Lifecycle methods
+        deploy: async (options) => {
+            const newData = await runEffectWithLogging(deployContractEffect(data, options), data.logging);
+            data = newData; // Update internal state
+        },
+        join: async (address, options) => {
+            const newData = await runEffectWithLogging(joinContractEffect(data, address, options), data.logging);
+            data = newData; // Update internal state
+        },
+        // Contract methods
+        call: (action, ...args) => runEffectWithLogging(callContractEffect(data, action, ...args), data.logging),
+        getState: () => runEffectWithLogging(contractStateEffect(data), data.logging),
+        getStateAt: (blockHeight) => runEffectWithLogging(contractStateAtEffect(data, blockHeight), data.logging),
+        ledgerState: () => runEffectWithLogging(ledgerStateEffect(data), data.logging),
+        ledgerStateAt: (blockHeight) => runEffectWithLogging(ledgerStateAtEffect(data, blockHeight), data.logging),
+        // Effect API
+        effect: {
+            deploy: (options) => deployContractEffect(data, options).pipe(Effect.tap((newData) => Effect.sync(() => { data = newData; }))),
+            join: (address, options) => joinContractEffect(data, address, options).pipe(Effect.tap((newData) => Effect.sync(() => { data = newData; }))),
+            call: (action, ...args) => callContractEffect(data, action, ...args),
+            getState: () => contractStateEffect(data),
+            getStateAt: (blockHeight) => contractStateAtEffect(data, blockHeight),
+            ledgerState: () => ledgerStateEffect(data),
+            ledgerStateAt: (blockHeight) => ledgerStateAtEffect(data, blockHeight),
+        },
+    };
+    return handle;
+}
 /**
- * Context.Tag for ClientService dependency injection.
+ * Create a MiddayClient handle from internal data.
+ * @internal
+ */
+function createClientHandle(data) {
+    return {
+        // Data accessors
+        networkConfig: data.networkConfig,
+        providers: data.providers,
+        wallet: data.wallet,
+        // Promise API - returns Contract directly (new API)
+        loadContract: async (options) => {
+            const contractData = await runEffectWithLogging(loadContractEffect(data, options), data.logging);
+            return createContractHandle(contractData);
+        },
+        waitForTx: (txHash) => runEffectWithLogging(waitForTxEffect(data, txHash), data.logging),
+        // Effect API
+        effect: {
+            loadContract: (options) => loadContractEffect(data, options).pipe(Effect.map((contractData) => createContractHandle(contractData))),
+            waitForTx: (txHash) => waitForTxEffect(data, txHash),
+        },
+    };
+}
+// =============================================================================
+// Module - Public API
+// =============================================================================
+/**
+ * Create a Midnight client for interacting with contracts.
  *
  * @example
  * ```typescript
- * const program = Effect.gen(function* () {
- *   const clientService = yield* ClientService;
- *   const client = yield* clientService.create(config);
- *   return client;
+ * const client = await Midday.Client.create({
+ *   seed: 'your-64-char-hex-seed',
+ *   networkConfig: Midday.Config.NETWORKS.local,
+ *   privateStateProvider,
  * });
  *
- * Effect.runPromise(program.pipe(Effect.provide(ClientLive)));
+ * const contract = await client.loadContract({ path: './contracts/counter' });
+ * await contract.deploy();
+ * await contract.call('increment');
  * ```
  *
  * @since 0.2.0
- * @category service
+ * @category constructors
  */
-export class ClientService extends Context.Tag('ClientService')() {
+export async function create(config) {
+    const logging = config.logging ?? true;
+    const data = await runEffectWithLogging(createClientDataEffect(config), logging);
+    return createClientHandle(data);
 }
 /**
- * Context.Tag for ContractBuilderService dependency injection.
+ * Create a Midnight client from a connected wallet (browser).
  *
  * @since 0.2.0
- * @category service
+ * @category constructors
  */
-export class ContractBuilderService extends Context.Tag('ContractBuilderService')() {
+export async function fromWallet(connection, config) {
+    const logging = config.logging ?? true;
+    const data = await runEffectWithLogging(fromWalletDataEffect(connection, config), logging);
+    return createClientHandle(data);
 }
 /**
- * Context.Tag for ContractService dependency injection.
+ * Raw Effect APIs for advanced users who want to compose Effects.
+ *
+ * @example
+ * ```typescript
+ * 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 service
+ * @category effect
  */
-export class ContractService extends Context.Tag('ContractService')() {
-}
-// =============================================================================
-// Effect DI - Live Layers
-// =============================================================================
+export const effect = {
+    /**
+     * Create a client (Effect version).
+     */
+    create: (config) => createClientDataEffect(config).pipe(Effect.map(createClientHandle)),
+    /**
+     * Create a client from wallet (Effect version).
+     */
+    fromWallet: (connection, config) => fromWalletDataEffect(connection, config).pipe(Effect.map(createClientHandle)),
+};
 /**
- * Live Layer for ClientService.
+ * Load a Compact contract from a directory path.
  *
- * @since 0.2.0
- * @category layer
+ * 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
+ * // Preferred: let loadContract handle it
+ * const contract = await client.loadContract({ path: contractPath });
+ *
+ * // Alternative: load separately (useful for pre-loading)
+ * const { module, zkConfig } = await Midday.Client.loadContractModule(contractPath);
+ * const contract = await client.loadContract({ module, zkConfig });
+ * ```
+ *
+ * @since 0.4.0
+ * @category loading
  */
-export const ClientLive = Layer.succeed(ClientService, {
-    create: createEffect,
-    fromWallet: fromWalletEffect,
-    contractFrom: contractFromEffect,
-    waitForTx: waitForTxEffect,
-});
+export async function loadContractModule(contractPath, options = {}) {
+    const { moduleSubdir = 'contract', moduleEntry = 'index.js' } = options;
+    // Dynamic imports to avoid bundling Node.js code in browser
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { join } = require('path');
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { NodeZkConfigProvider } = require('@midnight-ntwrk/midnight-js-node-zk-config-provider');
+    const modulePath = join(contractPath, moduleSubdir, moduleEntry);
+    const module = (await import(modulePath));
+    const zkConfig = new NodeZkConfigProvider(contractPath);
+    return { module, zkConfig };
+}
 /**
- * Live Layer for ContractBuilderService.
+ * Load a contract from URLs (browser environments).
  *
- * @since 0.2.0
- * @category layer
+ * @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.4.0
+ * @category loading
  */
-export const ContractBuilderLive = Layer.succeed(ContractBuilderService, {
-    deploy: deployEffect,
-    join: joinEffect,
-});
+export async function loadContractModuleFromUrl(moduleUrl, zkConfigBaseUrl) {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const { HttpZkConfigProvider } = require('./providers/HttpZkConfigProvider.js');
+    const module = (await import(/* webpackIgnore: true */ moduleUrl));
+    const zkConfig = new HttpZkConfigProvider(zkConfigBaseUrl);
+    return { module, zkConfig };
+}
 /**
- * Live Layer for ContractService.
+ * Context.Tag for ClientService dependency injection.
  *
  * @since 0.2.0
- * @category layer
+ * @category service
  */
-export const ContractLive = Layer.succeed(ContractService, {
-    call: callEffect,
-    state: stateEffect,
-    stateAt: stateAtEffect,
-    ledgerState: ledgerStateEffect,
-    ledgerStateAt: ledgerStateAtEffect,
-});
-// =============================================================================
-// Layer Factories
-// =============================================================================
+export class ClientService extends Context.Tag('ClientService')() {
+}
 /**
- * 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())));
- * ```
+ * Live Layer for ClientService.
  *
- * @since 0.3.0
+ * @since 0.2.0
  * @category layer
  */
-export function services() {
-    return Layer.mergeAll(ClientLive, ContractBuilderLive, ContractLive);
-}
+export const ClientLive = Layer.succeed(ClientService, {
+    create: effect.create,
+    fromWallet: effect.fromWallet,
+});
 // =============================================================================
 // Pre-configured Client Layer
 // =============================================================================
 /**
- * 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 class MidnightClientService extends Context.Tag('MidnightClientService')() {
+export class MiddayClientService extends Context.Tag('MiddayClientService')() {
 }
 /**
- * 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;
  * });
  *
@@ -652,38 +625,24 @@ export class MidnightClientService extends Context.Tag('MidnightClientService')(
  * @category layer
  */
 export function layer(config) {
-    return Layer.effect(MidnightClientService, createEffect(config));
+    return Layer.effect(MiddayClientService, effect.create(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)));
- * ```
+ * Create a Layer that provides a pre-initialized MiddayClient from a wallet connection.
  *
  * @since 0.3.0
  * @category layer
  */
 export function layerFromWallet(connection, config) {
-    return Layer.effect(MidnightClientService, fromWalletEffect(connection, config));
+    return Layer.effect(MiddayClientService, effect.fromWallet(connection, config));
+}
+/**
+ * Create a Layer providing all Client-related services.
+ *
+ * @since 0.3.0
+ * @category layer
+ */
+export function services() {
+    return ClientLive;
 }
 //# sourceMappingURL=Client.js.map