@lerna-labs/hydra-sdk 1.0.0-beta.17 → 1.0.0-beta.18

package/dist/hydra/hydra-http-client.d.ts

@@ -0,0 +1,28 @@
+import type { CommitBlueprintPayload, HydraTransaction, HydraUTxOEntry, HydraUTxOs } from './types.js';
+/**
+ * HTTP client for the Hydra node REST API.
+ *
+ * Uses native `fetch` (Node 18+). Accepts 200 and 202 as success responses.
+ */
+export declare class HydraHttpClient {
+    private readonly baseUrl;
+    constructor(baseUrl: string);
+    /**
+     * Build a commit transaction.
+     *
+     * `POST /commit` — returns the unsigned L1 transaction CBOR hex.
+     */
+    buildCommit(payload: HydraUTxOs | CommitBlueprintPayload | Record<string, never>): Promise<string>;
+    /**
+     * Publish a decommit transaction.
+     *
+     * `POST /decommit` — submits the decommit request to the Hydra node.
+     */
+    publishDecommit(transaction: HydraTransaction): Promise<unknown>;
+    /** Fetch the current UTxO snapshot. `GET /snapshot/utxo` */
+    getSnapshotUtxo(): Promise<Record<string, HydraUTxOEntry>>;
+    /** Fetch protocol parameters. `GET /protocol-parameters` */
+    getProtocolParameters(): Promise<unknown>;
+    private post;
+    private get;
+}

package/dist/hydra/hydra-http-client.js

@@ -0,0 +1,56 @@
+/**
+ * HTTP client for the Hydra node REST API.
+ *
+ * Uses native `fetch` (Node 18+). Accepts 200 and 202 as success responses.
+ */
+export class HydraHttpClient {
+    baseUrl;
+    constructor(baseUrl) {
+        this.baseUrl = baseUrl.replace(/\/+$/, '');
+    }
+    /**
+     * Build a commit transaction.
+     *
+     * `POST /commit` — returns the unsigned L1 transaction CBOR hex.
+     */
+    async buildCommit(payload) {
+        const response = await this.post('/commit', payload);
+        return response.cborHex;
+    }
+    /**
+     * Publish a decommit transaction.
+     *
+     * `POST /decommit` — submits the decommit request to the Hydra node.
+     */
+    async publishDecommit(transaction) {
+        return this.post('/decommit', { tag: 'Decommit', transaction });
+    }
+    /** Fetch the current UTxO snapshot. `GET /snapshot/utxo` */
+    async getSnapshotUtxo() {
+        return this.get('/snapshot/utxo');
+    }
+    /** Fetch protocol parameters. `GET /protocol-parameters` */
+    async getProtocolParameters() {
+        return this.get('/protocol-parameters');
+    }
+    async post(path, payload) {
+        const response = await fetch(`${this.baseUrl}${path}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(payload),
+        });
+        if (!response.ok && response.status !== 202) {
+            const body = await response.text().catch(() => '');
+            throw new Error(`Hydra HTTP ${response.status} on POST ${path}: ${body}`);
+        }
+        return response.json();
+    }
+    async get(path) {
+        const response = await fetch(`${this.baseUrl}${path}`);
+        if (!response.ok && response.status !== 202) {
+            const body = await response.text().catch(() => '');
+            throw new Error(`Hydra HTTP ${response.status} on GET ${path}: ${body}`);
+        }
+        return response.json();
+    }
+}

package/dist/hydra/hydra-websocket.d.ts

@@ -0,0 +1,41 @@
+import { EventEmitter } from 'node:events';
+import type { ClientInput, ConnectionState, HydraStatus } from './types.js';
+/**
+ * Thin WebSocket wrapper for the Hydra node.
+ *
+ * Uses `EventEmitter` for multi-listener message dispatch (no single-callback
+ * overwrite). Emits:
+ *
+ * - `'message'`  — `(msg: HydraWsMessage)` for every incoming message
+ * - `'status'`   — `(status: HydraStatus)` on head-status changes
+ * - `'error'`    — `(err: Error)`
+ * - `'close'`    — `()`
+ */
+export declare class HydraWebSocket extends EventEmitter {
+    private ws;
+    private readonly url;
+    private _status;
+    private _connectionState;
+    constructor(wsUrl: string);
+    /** Current connection state. */
+    get connectionState(): ConnectionState;
+    /** Open the WebSocket connection. Resolves when the socket is open. */
+    connect(): Promise<void>;
+    /**
+     * Connect and wait for the Greetings message from the Hydra node.
+     *
+     * Unlike `HydraProvider.isConnected()`, this does NOT overwrite existing
+     * message handlers — it uses a one-time EventEmitter listener.
+     */
+    waitForGreetings(timeoutMs?: number): Promise<boolean>;
+    /** Close the WebSocket. */
+    disconnect(timeoutMs?: number): Promise<void>;
+    /** Send a ClientInput message as JSON over the WebSocket. */
+    send(message: ClientInput): void;
+    /** Current Hydra head status derived from messages. */
+    getStatus(): HydraStatus;
+    /** Register a status-change listener. Returns current status. */
+    onStatusChange(callback: (status: HydraStatus) => void): HydraStatus;
+    private handleMessage;
+    private updateStatus;
+}

package/dist/hydra/hydra-websocket.js

@@ -0,0 +1,159 @@
+import { EventEmitter } from 'node:events';
+import WebSocket from 'ws';
+const HEAD_STATUS_TO_HYDRA = {
+    Idle: 'IDLE',
+    Initializing: 'INITIALIZING',
+    Open: 'OPEN',
+    Closed: 'CLOSED',
+    FanoutPossible: 'FANOUT_POSSIBLE',
+    Final: 'FINAL',
+};
+const TAG_TO_HYDRA = {
+    HeadIsInitializing: 'INITIALIZING',
+    HeadIsOpen: 'OPEN',
+    HeadIsClosed: 'CLOSED',
+    ReadyToFanout: 'FANOUT_POSSIBLE',
+    HeadIsFinalized: 'FINAL',
+};
+/**
+ * Thin WebSocket wrapper for the Hydra node.
+ *
+ * Uses `EventEmitter` for multi-listener message dispatch (no single-callback
+ * overwrite). Emits:
+ *
+ * - `'message'`  — `(msg: HydraWsMessage)` for every incoming message
+ * - `'status'`   — `(status: HydraStatus)` on head-status changes
+ * - `'error'`    — `(err: Error)`
+ * - `'close'`    — `()`
+ */
+export class HydraWebSocket extends EventEmitter {
+    ws = null;
+    url;
+    _status = 'IDLE';
+    _connectionState = 'IDLE';
+    constructor(wsUrl) {
+        super();
+        this.url = wsUrl;
+    }
+    /** Current connection state. */
+    get connectionState() {
+        return this._connectionState;
+    }
+    /** Open the WebSocket connection. Resolves when the socket is open. */
+    async connect() {
+        if (this.ws?.readyState === WebSocket.OPEN)
+            return;
+        return new Promise((resolve, reject) => {
+            const ws = new WebSocket(this.url);
+            ws.on('open', () => {
+                this.ws = ws;
+                this._connectionState = 'CONNECTING';
+                resolve();
+            });
+            ws.on('message', (data) => {
+                try {
+                    const msg = JSON.parse(data.toString());
+                    this.handleMessage(msg);
+                }
+                catch {
+                    // Ignore non-JSON messages
+                }
+            });
+            ws.on('error', (err) => {
+                this._connectionState = 'FAILED';
+                this.emit('error', err);
+                reject(new Error(`WebSocket error: ${err.message}`));
+            });
+            ws.on('close', () => {
+                this._connectionState = 'DISCONNECTED';
+                this.ws = null;
+                this.emit('close');
+            });
+        });
+    }
+    /**
+     * Connect and wait for the Greetings message from the Hydra node.
+     *
+     * Unlike `HydraProvider.isConnected()`, this does NOT overwrite existing
+     * message handlers — it uses a one-time EventEmitter listener.
+     */
+    async waitForGreetings(timeoutMs = 30_000) {
+        if (this._connectionState === 'CONNECTED')
+            return true;
+        await this.connect();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.removeListener('message', onMsg);
+                this._connectionState = 'FAILED';
+                reject(new Error('Connection timed out: no Greetings from Hydra node'));
+            }, timeoutMs);
+            const onMsg = (msg) => {
+                if (msg.tag === 'Greetings') {
+                    clearTimeout(timer);
+                    this.removeListener('message', onMsg);
+                    this._connectionState = 'CONNECTED';
+                    resolve(true);
+                }
+            };
+            this.on('message', onMsg);
+        });
+    }
+    /** Close the WebSocket. */
+    async disconnect(timeoutMs = 5000) {
+        if (!this.ws || this.ws.readyState === WebSocket.CLOSED) {
+            this._connectionState = 'DISCONNECTED';
+            return;
+        }
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                this.ws?.terminate();
+                this._connectionState = 'DISCONNECTED';
+                this.ws = null;
+                resolve();
+            }, timeoutMs);
+            this.ws.on('close', () => {
+                clearTimeout(timer);
+                this._connectionState = 'DISCONNECTED';
+                this.ws = null;
+                resolve();
+            });
+            this.ws.close();
+        });
+    }
+    /** Send a ClientInput message as JSON over the WebSocket. */
+    send(message) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new Error('WebSocket is not connected');
+        }
+        this.ws.send(JSON.stringify(message));
+    }
+    /** Current Hydra head status derived from messages. */
+    getStatus() {
+        return this._status;
+    }
+    /** Register a status-change listener. Returns current status. */
+    onStatusChange(callback) {
+        this.on('status', callback);
+        return this._status;
+    }
+    handleMessage(msg) {
+        this.emit('message', msg);
+        // Update status from Greetings headStatus
+        if (msg.tag === 'Greetings' && 'headStatus' in msg) {
+            const mapped = HEAD_STATUS_TO_HYDRA[msg.headStatus];
+            if (mapped)
+                this.updateStatus(mapped);
+            return;
+        }
+        // Update status from state transition messages
+        const mapped = TAG_TO_HYDRA[msg.tag];
+        if (mapped)
+            this.updateStatus(mapped);
+    }
+    updateStatus(newStatus) {
+        if (this._status !== newStatus) {
+            this._status = newStatus;
+            this.emit('status', newStatus);
+        }
+    }
+}

package/dist/hydra/messages.d.ts

@@ -1,5 +1,5 @@
 /**
- * Re-exported Hydra WebSocket message types from `@meshsdk/hydra`.
+ * Re-exported Hydra WebSocket message types.
  *
  * `ServerOutput` is a discriminated union (on `.tag`) of all possible messages
  * the Hydra node can send over its WebSocket API. Use `Extract` to narrow:
@@ -7,25 +7,8 @@
  * @example
  * ```ts
  * function handleOpen(msg: HydraMessage<"HeadIsOpen">) {
- *   console.log(msg.headId, msg.utxo);
+ *   console.log(msg.tag);
  * }
  * ```
  */
-export type { ClientInput, ClientMessage, ConnectionState, ServerOutput } from '@meshsdk/hydra';
-import type { ClientMessage, ServerOutput } from '@meshsdk/hydra';
-/** Any message received via the Hydra WebSocket (server output or client echo). */
-export type HydraWsMessage = ServerOutput | ClientMessage;
-/**
- * Extract a specific message type from the `ServerOutput` union by its `tag`.
- *
- * @example
- * ```ts
- * type Greetings = HydraMessage<"Greetings">;
- * // { tag: "Greetings"; me: { vkey: string }; headStatus: HeadStatus; ... }
- * ```
- */
-export type HydraMessage<T extends ServerOutput['tag']> = Extract<ServerOutput, {
-    tag: T;
-}>;
-/** Possible Hydra head states as reported in the `Greetings` message. */
-export type HeadStatus = 'Idle' | 'Initializing' | 'Open' | 'Closed' | 'FanoutPossible' | 'Final';
+export type { ClientInput, ClientMessage, ConnectionState, HeadStatus, HydraMessage, HydraStatus, HydraTransaction, HydraWsMessage, hydraStatus, hydraTransaction, ServerOutput, } from './types.js';

package/dist/hydra/types.d.ts

@@ -0,0 +1,196 @@
+/** A Cardano transaction in Hydra's wire format. */
+export type HydraTransaction = {
+    type: 'Tx ConwayEra' | 'Unwitnessed Tx ConwayEra' | 'Witnessed Tx ConwayEra';
+    description: string;
+    cborHex: string;
+    txId?: string;
+};
+/** @deprecated Use HydraTransaction */
+export type hydraTransaction = HydraTransaction;
+/** Hydra's nested asset value format: `{ lovelace: N, policyId: { assetNameHex: N } }`. */
+export type HydraAssets = {
+    lovelace: number;
+} & {
+    [policyId: string]: number | {
+        [assetNameHex: string]: number;
+    };
+};
+export interface HydraReferenceScript {
+    script: {
+        cborHex: string;
+        description: string;
+        type: string | null;
+    };
+    scriptLanguage: string;
+}
+/** A single UTxO entry in Hydra's wire format. */
+export interface HydraUTxOEntry {
+    address: string;
+    datum: string | null;
+    inlineDatum: object | null;
+    inlineDatumRaw: string | null;
+    inlineDatumhash: string | null;
+    referenceScript: HydraReferenceScript | null;
+    value: HydraAssets;
+}
+/** A set of UTxOs keyed by `"txHash#outputIndex"`. */
+export type HydraUTxOs = {
+    [txRef: string]: HydraUTxOEntry;
+};
+/** Payload for blueprint-based commits. */
+export interface CommitBlueprintPayload {
+    blueprintTx: HydraTransaction;
+    utxo: HydraUTxOs;
+}
+/** Possible Hydra head states as reported in the `Greetings` message (mixed-case). */
+export type HeadStatus = 'Idle' | 'Initializing' | 'Open' | 'Closed' | 'FanoutPossible' | 'Final';
+/** Hydra status values (uppercase, as used by HydraProvider status tracking). */
+export type HydraStatus = 'IDLE' | 'INITIALIZING' | 'OPEN' | 'CLOSED' | 'FANOUT_POSSIBLE' | 'FINAL';
+/** @deprecated Use HydraStatus */
+export type hydraStatus = HydraStatus;
+/** Connection state of the WebSocket. */
+export type ConnectionState = 'IDLE' | 'CONNECTING' | 'CONNECTED' | 'FAILED' | 'DISCONNECTED';
+/** Messages that can be sent to the Hydra node over WebSocket. */
+export type ClientInput = {
+    tag: 'Init';
+} | {
+    tag: 'Abort';
+} | {
+    tag: 'NewTx';
+    transaction: HydraTransaction;
+} | {
+    tag: 'Close';
+} | {
+    tag: 'Contest';
+} | {
+    tag: 'Fanout';
+} | {
+    tag: 'Decommit';
+    transaction: HydraTransaction;
+} | {
+    tag: 'Recover';
+    recoverTxId: string;
+};
+/** Greetings message received on initial WebSocket connection. */
+export interface GreetingsMessage {
+    tag: 'Greetings';
+    me: {
+        vkey: string;
+    };
+    headStatus: HeadStatus;
+    hydraHeadId?: string;
+    snapshotUtxo?: HydraUTxOs;
+    hydraNodeVersion?: string;
+    env?: Record<string, unknown>;
+    networkInfo?: Record<string, unknown>;
+}
+export interface HeadIsInitializingMessage {
+    tag: 'HeadIsInitializing';
+    headId: string;
+    parties: {
+        vkey: string;
+    }[];
+    [key: string]: unknown;
+}
+export interface CommittedMessage {
+    tag: 'Committed';
+    party: {
+        vkey: string;
+    };
+    utxo: HydraUTxOs;
+    [key: string]: unknown;
+}
+export interface HeadIsOpenMessage {
+    tag: 'HeadIsOpen';
+    utxo: HydraUTxOs;
+    [key: string]: unknown;
+}
+export interface HeadIsClosedMessage {
+    tag: 'HeadIsClosed';
+    [key: string]: unknown;
+}
+export interface HeadIsContestedMessage {
+    tag: 'HeadIsContested';
+    [key: string]: unknown;
+}
+export interface ReadyToFanoutMessage {
+    tag: 'ReadyToFanout';
+    [key: string]: unknown;
+}
+export interface HeadIsAbortedMessage {
+    tag: 'HeadIsAborted';
+    [key: string]: unknown;
+}
+export interface HeadIsFinalizedMessage {
+    tag: 'HeadIsFinalized';
+    [key: string]: unknown;
+}
+export interface TxValidMessage {
+    tag: 'TxValid';
+    transaction: HydraTransaction;
+    [key: string]: unknown;
+}
+export interface TxInvalidMessage {
+    tag: 'TxInvalid';
+    transaction: HydraTransaction;
+    validationError: {
+        reason: string;
+    };
+    [key: string]: unknown;
+}
+export interface SnapshotConfirmedMessage {
+    tag: 'SnapshotConfirmed';
+    [key: string]: unknown;
+}
+export interface DecommitApprovedMessage {
+    tag: 'DecommitApproved';
+    [key: string]: unknown;
+}
+export interface DecommitInvalidMessage {
+    tag: 'DecommitInvalid';
+    decommitInvalidReason: unknown;
+    [key: string]: unknown;
+}
+export interface DecommitFinalizedMessage {
+    tag: 'DecommitFinalized';
+    [key: string]: unknown;
+}
+export interface CommitFinalizedMessage {
+    tag: 'CommitFinalized';
+    [key: string]: unknown;
+}
+export interface CommitApprovedMessage {
+    tag: 'CommitApproved';
+    [key: string]: unknown;
+}
+export interface CommandFailedMessage {
+    tag: 'CommandFailed';
+    clientInput: ClientInput;
+    [key: string]: unknown;
+}
+export interface PostTxOnChainFailedMessage {
+    tag: 'PostTxOnChainFailed';
+    [key: string]: unknown;
+}
+/** Catch-all for message types not explicitly defined above. */
+export interface UnknownMessage {
+    tag: string;
+    [key: string]: unknown;
+}
+/** All possible messages the Hydra node can send over its WebSocket API. */
+export type ServerOutput = GreetingsMessage | HeadIsInitializingMessage | CommittedMessage | HeadIsOpenMessage | HeadIsClosedMessage | HeadIsContestedMessage | ReadyToFanoutMessage | HeadIsAbortedMessage | HeadIsFinalizedMessage | TxValidMessage | TxInvalidMessage | SnapshotConfirmedMessage | DecommitApprovedMessage | DecommitInvalidMessage | DecommitFinalizedMessage | CommitFinalizedMessage | CommitApprovedMessage | CommandFailedMessage | PostTxOnChainFailedMessage | UnknownMessage;
+/** Client echo messages (errors, command failures). */
+export type ClientMessage = CommandFailedMessage | PostTxOnChainFailedMessage;
+/** Any message received via the Hydra WebSocket. */
+export type HydraWsMessage = ServerOutput | ClientMessage;
+/**
+ * Extract a specific message type from the `ServerOutput` union by its `tag`.
+ *
+ * @example
+ * ```ts
+ * type Greetings = HydraMessage<"Greetings">;
+ * ```
+ */
+export type HydraMessage<T extends ServerOutput['tag']> = Extract<ServerOutput, {
+    tag: T;
+}>;

package/dist/hydra/types.js

@@ -0,0 +1,2 @@
+// ── Hydra Transaction ────────────────────────────────────────────────
+export {};

package/dist/hydra/utxo-conversion.d.ts

@@ -0,0 +1,10 @@
+import type { Asset, UTxO } from '@meshsdk/common';
+import type { HydraAssets, HydraUTxOEntry, HydraUTxOs } from './types.js';
+/** Convert MeshSDK `Asset[]` to Hydra's nested value format. */
+export declare function toHydraAssets(assets: Asset[]): HydraAssets;
+/** Convert Hydra's nested value format back to MeshSDK `Asset[]`. */
+export declare function fromHydraAssets(assetsObj: HydraAssets): Asset[];
+/** Convert a single MeshSDK UTxO to Hydra wire format. */
+export declare function toHydraUTxO(utxo: UTxO): HydraUTxOEntry;
+/** Convert multiple MeshSDK UTxOs to Hydra wire format (keyed by `"txHash#outputIndex"`). */
+export declare function toHydraUTxOs(utxos: UTxO[]): HydraUTxOs;

package/dist/hydra/utxo-conversion.js

@@ -0,0 +1,111 @@
+import { fromScriptRef, parseDatumCbor } from '@meshsdk/core-cst';
+// ── Asset Conversion ─────────────────────────────────────────────────
+/** Convert MeshSDK `Asset[]` to Hydra's nested value format. */
+export function toHydraAssets(assets) {
+    return assets.reduce((acc, asset) => {
+        if (asset.unit === '' || asset.unit === 'lovelace') {
+            acc.lovelace += Number(asset.quantity);
+        }
+        else {
+            const policyId = asset.unit.slice(0, 56);
+            const assetNameHex = asset.unit.slice(56) || '';
+            if (!acc[policyId] || typeof acc[policyId] === 'number') {
+                acc[policyId] = {};
+            }
+            const policy = acc[policyId];
+            policy[assetNameHex] = (policy[assetNameHex] ?? 0) + Number(asset.quantity);
+        }
+        return acc;
+    }, { lovelace: 0 });
+}
+/** Convert Hydra's nested value format back to MeshSDK `Asset[]`. */
+export function fromHydraAssets(assetsObj) {
+    const result = [];
+    if (assetsObj.lovelace && assetsObj.lovelace > 0) {
+        result.push({ unit: 'lovelace', quantity: String(assetsObj.lovelace) });
+    }
+    for (const [policyId, assets] of Object.entries(assetsObj)) {
+        if (policyId === 'lovelace')
+            continue;
+        if (typeof assets !== 'object')
+            continue;
+        for (const [assetNameHex, quantity] of Object.entries(assets)) {
+            result.push({ unit: policyId + assetNameHex, quantity: String(quantity) });
+        }
+    }
+    return result;
+}
+// ── Reference Script Conversion ──────────────────────────────────────
+function resolveReferenceScript(scriptRef) {
+    if (!scriptRef)
+        return null;
+    const scriptInstance = fromScriptRef(scriptRef);
+    if (!scriptInstance)
+        return null;
+    let scriptType = 'Unknown';
+    let scriptLanguage = null;
+    if ('code' in scriptInstance) {
+        switch (scriptInstance.version) {
+            case 'V1':
+                scriptType = 'PlutusScriptV1';
+                scriptLanguage = 'PlutusScriptLanguage PlutusScriptV1';
+                break;
+            case 'V2':
+                scriptType = 'PlutusScriptV2';
+                scriptLanguage = 'PlutusScriptLanguage PlutusScriptV2';
+                break;
+            case 'V3':
+                scriptType = 'PlutusScriptV3';
+                scriptLanguage = 'PlutusScriptLanguage PlutusScriptV3';
+                break;
+        }
+    }
+    else {
+        scriptType = 'SimpleScript';
+        scriptLanguage = 'NativeScriptLanguage SimpleScript';
+    }
+    if (!scriptLanguage || scriptType === 'Unknown')
+        return null;
+    return {
+        script: {
+            cborHex: scriptRef,
+            description: '',
+            type: scriptType,
+        },
+        scriptLanguage,
+    };
+}
+// ── Datum Resolution ─────────────────────────────────────────────────
+function resolvePlutusData(datumCbor) {
+    const data = parseDatumCbor(datumCbor);
+    function normalize(value) {
+        if (typeof value === 'bigint') {
+            return value <= Number.MAX_SAFE_INTEGER && value >= Number.MIN_SAFE_INTEGER ? Number(value) : value.toString();
+        }
+        if (Array.isArray(value)) {
+            return value.map(normalize);
+        }
+        if (value && typeof value === 'object') {
+            return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, normalize(v)]));
+        }
+        return value;
+    }
+    return { inlineDatum: normalize(data) };
+}
+// ── UTxO Conversion ──────────────────────────────────────────────────
+/** Convert a single MeshSDK UTxO to Hydra wire format. */
+export function toHydraUTxO(utxo) {
+    return {
+        address: utxo.output.address,
+        datum: null,
+        inlineDatum: utxo.output.plutusData ? resolvePlutusData(utxo.output.plutusData).inlineDatum : null,
+        inlineDatumRaw: utxo.output.plutusData ?? null,
+        inlineDatumhash: utxo.output.dataHash ?? null,
+        referenceScript: utxo.output.scriptRef ? resolveReferenceScript(utxo.output.scriptRef) : null,
+        value: toHydraAssets(utxo.output.amount),
+    };
+}
+/** Convert multiple MeshSDK UTxOs to Hydra wire format (keyed by `"txHash#outputIndex"`). */
+export function toHydraUTxOs(utxos) {
+    return Object.fromEntries(utxos.map((utxo) => [`${utxo.input.txHash}#${utxo.input.outputIndex}`, toHydraUTxO(utxo)]));
+}

package/dist/index.d.ts

@@ -1,14 +1,14 @@
 export type { DiskCache, DiskCacheConfig } from './cache/disk-cache.js';
 export { createDiskCache } from './cache/disk-cache.js';
 export { optionalEnv, requireEnv } from './config.js';
-export type { HeadStatus, HydraMessage, HydraWsMessage, ServerOutput } from './hydra/messages.js';
+export type { HeadStatus, HydraMessage, HydraStatus, HydraTransaction, HydraWsMessage, hydraStatus, hydraTransaction, ServerOutput, } from './hydra/messages.js';
 export type { ParsedUtxo } from './hydra/utxo.js';
 export { getUtxoSet, queryUtxoByAddress } from './hydra/utxo.js';
 export type { IpfsClient, IpfsConfig, PinResult } from './ipfs/ipfs.js';
 export { createIpfsClient } from './ipfs/ipfs.js';
 export { getAdmin } from './mesh/get-admin.js';
 export { createMultisigAddress, createNativeScript } from './mesh/native-script.js';
-export { CommitArgs, UTxORef, Wrangler } from './mesh/wrangler.js';
 export { submitTx } from './tx3/submit-tx.js';
 export { chunkString } from './utils/chunk-string.js';
 export { bufferToAscii, bufferToHex, verifySignature } from './utils/verify-signature.js';
+export { CommitArgs, UTxORef, Wrangler } from './wrangler.js';

package/dist/index.js

@@ -4,7 +4,7 @@ export { getUtxoSet, queryUtxoByAddress } from './hydra/utxo.js';
 export { createIpfsClient } from './ipfs/ipfs.js';
 export { getAdmin } from './mesh/get-admin.js';
 export { createMultisigAddress, createNativeScript } from './mesh/native-script.js';
-export { Wrangler } from './mesh/wrangler.js';
 export { submitTx } from './tx3/submit-tx.js';
 export { chunkString } from './utils/chunk-string.js';
 export { bufferToAscii, bufferToHex, verifySignature } from './utils/verify-signature.js';
+export { Wrangler } from './wrangler.js';

package/dist/test.js

@@ -1,7 +1,7 @@
 import * as dotenv from 'dotenv';
 dotenv.config({ path: '.local.env' });
 import { BlockfrostProvider, MeshTxBuilder, MeshWallet } from '@meshsdk/core';
-import { Wrangler } from './mesh/wrangler';
+import { Wrangler } from './wrangler.js';
 (async () => {
     const admin_wallet = new MeshWallet({
         networkId: parseInt(process.env.HYDRA_NETWORK_ID || '0', 10),

package/dist/{mesh/wrangler.d.ts → wrangler.d.ts}

@@ -1,6 +1,6 @@
-import type { hydraStatus, hydraTransaction } from '@meshsdk/hydra';
-import { HydraProvider } from '@meshsdk/hydra';
-import type { HeadStatus } from '../hydra/messages.js';
+import { HydraHttpClient } from './hydra/hydra-http-client.js';
+import { HydraWebSocket } from './hydra/hydra-websocket.js';
+import type { HeadStatus, HydraStatus, HydraTransaction } from './hydra/types.js';
 /** UTxO reference for committing funds into a Hydra head. */
 export interface UTxORef {
     /** Transaction hash containing the UTxO. */
@@ -13,17 +13,17 @@ export interface CommitArgs {
     /** One or more UTxO references to commit. */
     utxos: UTxORef[];
     /** Blueprint transaction that spends the committed UTxOs (CBOR-encoded, unsigned). Optional — omit for simple ADA-only commits. */
-    blueprintTx?: hydraTransaction;
+    blueprintTx?: HydraTransaction;
 }
 /**
  * High-level controller for Hydra head lifecycle operations.
  *
- * Wraps `HydraProvider` and `HydraInstance` to provide a simplified API
+ * Wraps `HydraWebSocket` and `HydraHttpClient` to provide a simplified API
  * for initializing, opening, and closing a Hydra head.
  *
  * @example
  * ```ts
- * const wrangler = new Wrangler("http://localhost:4001");
+ * const wrangler = new Wrangler("http://localhost:4001", "ws://localhost:4001");
  * await wrangler.waitForHeadOpen({
  *   utxos: [{ txHash: "abc...", outputIndex: 0 }],
  *   blueprintTx: { type: "Tx ConwayEra", cborHex: "...", description: "" },
@@ -32,20 +32,15 @@ export interface CommitArgs {
  */
 export declare class Wrangler {
     private mode;
-    readonly provider: HydraProvider;
-    private instance;
+    readonly ws: HydraWebSocket;
+    readonly http: HydraHttpClient;
     private readonly blockfrost;
-    private readonly url;
-    private readonly wsUrl;
     constructor(url?: string, wsUrl?: string);
-    private createHydraProvider;
-    private createHydraInstance;
     /**
      * Connect to the Hydra node with exponential-backoff retry.
      *
-     * Uses `HydraProvider.isConnected()` which establishes the WebSocket
-     * **and** waits for the Hydra `Greetings` handshake, unlike the raw
-     * `connect()` which only opens the socket.
+     * Uses `HydraWebSocket.waitForGreetings()` which establishes the WebSocket
+     * **and** waits for the Hydra `Greetings` handshake.
      *
      * @param maxAttempts - Maximum number of connection attempts (default 5).
      * @param baseDelayMs - Initial retry delay in milliseconds (default 1000). Doubles each attempt, capped at 30 s.
@@ -54,16 +49,19 @@ export declare class Wrangler {
     /**
      * Shared helper for promise-based methods that wait for a specific
      * Hydra message. Handles connection, timeout, and settlement in one place.
+     *
+     * Uses EventEmitter `on`/`removeListener` for multi-listener support,
+     * avoiding the single-callback overwrite bug in HydraProvider.
      */
     private awaitMessage;
-    /** Connect the underlying HydraProvider WebSocket with retry logic. */
+    /** Connect the underlying WebSocket with retry logic. */
     connect(): Promise<void>;
-    /** Disconnect the underlying HydraProvider WebSocket. */
+    /** Disconnect the underlying WebSocket. */
     disconnect(timeout?: number): Promise<void>;
-    /** Return the current HydraProvider connection/head status. */
-    getStatus(): hydraStatus;
-    /** Register a callback for HydraProvider status changes. */
-    onStatusChange(callback: (status: hydraStatus) => void): hydraStatus;
+    /** Return the current Hydra head status (uppercase). */
+    getStatus(): HydraStatus;
+    /** Register a callback for head status changes. */
+    onStatusChange(callback: (status: HydraStatus) => void): HydraStatus;
     /** Begin the head-opening sequence: init, commit, and listen for state changes. */
     startHead(commitArgs: CommitArgs): Promise<void>;
     /** Begin the head-closing sequence: close, fanout, and finalize. */
@@ -89,16 +87,13 @@ export declare class Wrangler {
     /**
      * Decommit funds from an open Hydra head back to L1.
      *
-     * Posts the decommit transaction via `provider.publishDecommit()` (HTTP POST)
-     * instead of `provider.decommit()` to avoid overwriting the Wrangler's
-     * `onMessage` handler (single-callback replacement pattern).
-     *
+     * Posts the decommit transaction via HTTP to avoid overwriting message handlers.
      * Resolves on `DecommitApproved` — L1 settlement happens asynchronously.
      *
      * @param transaction - The decommit transaction (CBOR-encoded).
      * @param timeoutMs - Maximum time to wait for approval (default 60s).
      */
-    decommit(transaction: hydraTransaction, timeoutMs?: number): Promise<void>;
+    decommit(transaction: HydraTransaction, timeoutMs?: number): Promise<void>;
     /**
      * Incrementally commit funds into an already-open Hydra head.
      *
@@ -112,6 +107,7 @@ export declare class Wrangler {
      */
     incrementalCommit(commitArgs: CommitArgs, timeoutMs?: number): Promise<void>;
     private doIncrementalCommit;
+    private fetchUtxos;
     private handleIncoming;
     private onGreetings;
 }

package/dist/{mesh/wrangler.js → wrangler.js}

@@ -1,15 +1,17 @@
 import { BlockfrostProvider } from '@meshsdk/core';
-import { HydraInstance, HydraProvider } from '@meshsdk/hydra';
-import { requireEnv } from '../config.js';
+import { requireEnv } from './config.js';
+import { HydraHttpClient } from './hydra/hydra-http-client.js';
+import { HydraWebSocket } from './hydra/hydra-websocket.js';
+import { toHydraUTxO, toHydraUTxOs } from './hydra/utxo-conversion.js';
 /**
  * High-level controller for Hydra head lifecycle operations.
  *
- * Wraps `HydraProvider` and `HydraInstance` to provide a simplified API
+ * Wraps `HydraWebSocket` and `HydraHttpClient` to provide a simplified API
  * for initializing, opening, and closing a Hydra head.
  *
  * @example
  * ```ts
- * const wrangler = new Wrangler("http://localhost:4001");
+ * const wrangler = new Wrangler("http://localhost:4001", "ws://localhost:4001");
  * await wrangler.waitForHeadOpen({
  *   utxos: [{ txHash: "abc...", outputIndex: 0 }],
  *   blueprintTx: { type: "Tx ConwayEra", cborHex: "...", description: "" },
@@ -18,34 +20,21 @@ import { requireEnv } from '../config.js';
  */
 export class Wrangler {
     mode;
-    provider;
-    instance;
+    ws;
+    http;
     blockfrost;
-    url;
-    wsUrl;
     constructor(url, wsUrl) {
-        this.url = url || requireEnv('HYDRA_API_URL');
-        this.wsUrl = wsUrl || requireEnv('HYDRA_WS_URL');
+        const httpUrl = url || requireEnv('HYDRA_API_URL');
+        const socketUrl = wsUrl || requireEnv('HYDRA_WS_URL');
         this.blockfrost = new BlockfrostProvider(requireEnv('BLOCKFROST_API_KEY'));
-        this.provider = this.createHydraProvider();
-        this.instance = this.createHydraInstance();
-    }
-    createHydraProvider() {
-        return new HydraProvider({ httpUrl: this.url, history: false });
-    }
-    createHydraInstance() {
-        return new HydraInstance({
-            provider: this.provider,
-            fetcher: this.blockfrost,
-            submitter: this.provider,
-        });
+        this.ws = new HydraWebSocket(socketUrl);
+        this.http = new HydraHttpClient(httpUrl);
     }
     /**
      * Connect to the Hydra node with exponential-backoff retry.
      *
-     * Uses `HydraProvider.isConnected()` which establishes the WebSocket
-     * **and** waits for the Hydra `Greetings` handshake, unlike the raw
-     * `connect()` which only opens the socket.
+     * Uses `HydraWebSocket.waitForGreetings()` which establishes the WebSocket
+     * **and** waits for the Hydra `Greetings` handshake.
      *
      * @param maxAttempts - Maximum number of connection attempts (default 5).
      * @param baseDelayMs - Initial retry delay in milliseconds (default 1000). Doubles each attempt, capped at 30 s.
@@ -53,10 +42,10 @@ export class Wrangler {
     async connectWithRetry(maxAttempts = 5, baseDelayMs = 1000) {
         for (let attempt = 0; attempt < maxAttempts; attempt++) {
             try {
-                const connected = await this.provider.isConnected();
+                const connected = await this.ws.waitForGreetings();
                 if (connected)
                     return;
-                throw new Error('isConnected() returned false');
+                throw new Error('waitForGreetings() returned false');
             }
             catch (err) {
                 if (attempt === maxAttempts - 1) {
@@ -70,6 +59,9 @@ export class Wrangler {
     /**
      * Shared helper for promise-based methods that wait for a specific
      * Hydra message. Handles connection, timeout, and settlement in one place.
+     *
+     * Uses EventEmitter `on`/`removeListener` for multi-listener support,
+     * avoiding the single-callback overwrite bug in HydraProvider.
      */
     awaitMessage(handler, timeoutMs, timeoutMessage) {
         return new Promise((resolve, reject) => {
@@ -79,50 +71,47 @@ export class Wrangler {
                     return;
                 settled = true;
                 clearTimeout(timer);
+                this.ws.removeListener('message', onMsg);
                 fn(value);
             };
             const timer = setTimeout(() => settle(reject, new Error(timeoutMessage)), timeoutMs);
-            // Connect first, then register the message handler. HydraProvider.isConnected()
-            // internally calls onMessage() (single-callback replacement), which would overwrite
-            // any handler set beforehand. By connecting first, isConnected() consumes the
-            // Greetings message via its own handler. Once connected, we register our handler —
-            // onMessage() replays the _messageQueue, so the Greetings is re-delivered to us.
+            const onMsg = (message) => {
+                handler(message, (value) => settle(resolve, value), (reason) => settle(reject, reason));
+            };
             this.connectWithRetry()
                 .then(() => {
-                this.provider.onMessage((message) => {
-                    handler(message, (value) => settle(resolve, value), (reason) => settle(reject, reason));
-                });
+                this.ws.on('message', onMsg);
             })
                 .catch((err) => settle(reject, new Error(`Failed to connect: ${String(err)}`)));
         });
     }
-    /** Connect the underlying HydraProvider WebSocket with retry logic. */
+    /** Connect the underlying WebSocket with retry logic. */
     async connect() {
         return await this.connectWithRetry();
     }
-    /** Disconnect the underlying HydraProvider WebSocket. */
+    /** Disconnect the underlying WebSocket. */
     async disconnect(timeout) {
-        return this.provider.disconnect(timeout);
+        return this.ws.disconnect(timeout);
     }
-    /** Return the current HydraProvider connection/head status. */
+    /** Return the current Hydra head status (uppercase). */
     getStatus() {
-        return this.provider.getStatus();
+        return this.ws.getStatus();
     }
-    /** Register a callback for HydraProvider status changes. */
+    /** Register a callback for head status changes. */
     onStatusChange(callback) {
-        return this.provider.onStatusChange(callback);
+        return this.ws.onStatusChange(callback);
     }
     /** Begin the head-opening sequence: init, commit, and listen for state changes. */
     async startHead(commitArgs) {
         this.mode = 'start';
         await this.connectWithRetry();
-        this.provider.onMessage((msg) => this.handleIncoming(msg, commitArgs));
+        this.ws.on('message', (msg) => this.handleIncoming(msg, commitArgs));
     }
     /** Begin the head-closing sequence: close, fanout, and finalize. */
     async shutdownHead() {
         this.mode = 'shutdown';
         await this.connectWithRetry();
-        this.provider.onMessage((msg) => this.handleIncoming(msg));
+        this.ws.on('message', (msg) => this.handleIncoming(msg));
     }
     /**
      * Wait for the Hydra head to fully close and finalize.
@@ -137,7 +126,7 @@ export class Wrangler {
                     resolve();
                     break;
                 case 'ReadyToFanout':
-                    this.provider.fanout();
+                    this.ws.send({ tag: 'Fanout' });
                     break;
                 case 'Greetings':
                     this.onGreetings(message.headStatus).catch((err) => reject(new Error(`Greetings handler failed: ${String(err)}`)));
@@ -179,29 +168,32 @@ export class Wrangler {
         }, timeoutMs, 'Timeout waiting for head status');
     }
     async doCommit(commitArgs) {
-        let rawTx;
+        let cborHex;
         if (commitArgs.blueprintTx) {
-            rawTx = await this.instance.commitBlueprintUTxOs(commitArgs.utxos, commitArgs.blueprintTx);
+            const utxos = await this.fetchUtxos(commitArgs.utxos);
+            const hydraUtxos = toHydraUTxOs(utxos);
+            cborHex = await this.http.buildCommit({ blueprintTx: commitArgs.blueprintTx, utxo: hydraUtxos });
         }
         else if (commitArgs.utxos.length === 0) {
-            rawTx = await this.instance.commitEmpty();
+            cborHex = await this.http.buildCommit({});
         }
         else if (commitArgs.utxos.length === 1) {
             const { txHash, outputIndex } = commitArgs.utxos[0];
-            rawTx = await this.instance.commitFunds(txHash, outputIndex);
+            const utxos = await this.blockfrost.fetchUTxOs(txHash, outputIndex);
+            if (!utxos[0])
+                throw new Error('UTxO not found');
+            const hydraUtxo = toHydraUTxO(utxos[0]);
+            cborHex = await this.http.buildCommit({ [`${txHash}#${outputIndex}`]: hydraUtxo });
         }
         else {
             throw new Error('Multiple UTxOs without a blueprintTx require a blueprint transaction');
         }
-        return await this.blockfrost.submitTx(rawTx);
+        return await this.blockfrost.submitTx(cborHex);
     }
     /**
      * Decommit funds from an open Hydra head back to L1.
      *
-     * Posts the decommit transaction via `provider.publishDecommit()` (HTTP POST)
-     * instead of `provider.decommit()` to avoid overwriting the Wrangler's
-     * `onMessage` handler (single-callback replacement pattern).
-     *
+     * Posts the decommit transaction via HTTP to avoid overwriting message handlers.
      * Resolves on `DecommitApproved` — L1 settlement happens asynchronously.
      *
      * @param transaction - The decommit transaction (CBOR-encoded).
@@ -220,7 +212,7 @@ export class Wrangler {
                 reject(new Error(`Decommit invalid: ${JSON.stringify(message.decommitInvalidReason)}`));
             }
         }, timeoutMs, 'Timeout waiting for decommit approval');
-        await this.provider.publishDecommit(transaction);
+        await this.http.publishDecommit(transaction);
         return result;
     }
     /**
@@ -251,14 +243,32 @@ export class Wrangler {
             throw new Error('Incremental commit requires exactly one UTxO');
         }
         const { txHash, outputIndex } = commitArgs.utxos[0];
-        let rawTx;
+        const utxos = await this.blockfrost.fetchUTxOs(txHash, outputIndex);
+        if (!utxos[0])
+            throw new Error('UTxO not found');
+        const hydraUtxo = toHydraUTxO(utxos[0]);
+        let cborHex;
         if (commitArgs.blueprintTx) {
-            rawTx = await this.instance.incrementalBlueprintCommit(txHash, outputIndex, commitArgs.blueprintTx);
+            cborHex = await this.http.buildCommit({
+                blueprintTx: commitArgs.blueprintTx,
+                utxo: { [`${txHash}#${outputIndex}`]: hydraUtxo },
+            });
         }
         else {
-            rawTx = await this.instance.incrementalCommitFunds(txHash, outputIndex);
+            cborHex = await this.http.buildCommit({ [`${txHash}#${outputIndex}`]: hydraUtxo });
+        }
+        return await this.blockfrost.submitTx(cborHex);
+    }
+    async fetchUtxos(utxoRefs) {
+        const results = [];
+        for (const { txHash, outputIndex } of utxoRefs) {
+            const utxos = await this.blockfrost.fetchUTxOs(txHash, outputIndex);
+            if (!utxos.length) {
+                throw new Error(`UTxO not found for ${txHash}#${outputIndex}`);
+            }
+            results.push(...utxos);
         }
-        return await this.blockfrost.submitTx(rawTx);
+        return results;
     }
     async handleIncoming(message, commitArgs) {
         if (message.tag === 'Greetings') {
@@ -285,7 +295,7 @@ export class Wrangler {
                     break;
                 case 'shutdown':
                     if (message.tag === 'ReadyToFanout') {
-                        await this.provider.fanout();
+                        this.ws.send({ tag: 'Fanout' });
                     }
                     break;
             }
@@ -297,7 +307,7 @@ export class Wrangler {
                 switch (status) {
                     case 'Idle':
                         console.log('Idle → init()');
-                        await this.provider.init();
+                        this.ws.send({ tag: 'Init' });
                         break;
                     case 'Initializing':
                         console.log('Initializing -> commit()');
@@ -318,11 +328,11 @@ export class Wrangler {
                 switch (status) {
                     case 'Open':
                         console.log('Shutting down: closing head…');
-                        await this.provider.close();
+                        this.ws.send({ tag: 'Close' });
                         break;
                     case 'FanoutPossible':
                         console.log('Fanout now possible: fanning out…');
-                        await this.provider.fanout();
+                        this.ws.send({ tag: 'Fanout' });
                         break;
                     default:
                         console.log(`Greetings in shutdown mode, ignoring status: ${status}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lerna-labs/hydra-sdk",
-  "version": "1.0.0-beta.17",
+  "version": "1.0.0-beta.18",
   "description": "TypeScript SDK for managing Cardano Hydra Heads — lifecycle, UTxO queries, wallet management, transaction submission, and signature verification",
   "keywords": [
     "cardano",
@@ -42,10 +42,13 @@
     "@emurgo/cardano-message-signing-nodejs": "^1.1.0",
     "@emurgo/cardano-serialization-lib-nodejs": "^15.0.3",
     "@meshsdk/core": "1.9.0-beta.99",
-    "@meshsdk/hydra": "1.9.0-beta.99",
-    "axios": "^1.11.0"
+    "@meshsdk/core-cst": "1.9.0-beta.99",
+    "axios": "^1.11.0",
+    "ws": "^8.18.3"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.18.1"
   },
-  "devDependencies": {},
   "homepage": "https://github.com/Lerna-Labs/hydra-sdk#readme",
   "bugs": {
     "url": "https://github.com/Lerna-Labs/hydra-sdk/issues"