@lerna-labs/hydra-sdk 1.0.0-beta.13 → 1.0.0-beta.14

package/dist/mesh/wrangler.js

@@ -1,10 +1,22 @@
-import { HydraInstance, HydraProvider } from "@meshsdk/hydra";
-import { BlockfrostProvider } from "@meshsdk/core";
-const BLOCKFROST_KEY = process.env.BLOCKFROST_API_KEY;
-if (!BLOCKFROST_KEY)
-    throw new Error("BLOCKFROST_API_KEY not set");
+import { BlockfrostProvider } from '@meshsdk/core';
+import { HydraInstance, HydraProvider } from '@meshsdk/hydra';
+import { requireEnv } from '../config.js';
+/**
+ * High-level controller for Hydra head lifecycle operations.
+ *
+ * Wraps `HydraProvider` and `HydraInstance` to provide a simplified API
+ * for initializing, opening, and closing a Hydra head.
+ *
+ * @example
+ * ```ts
+ * const wrangler = new Wrangler("http://localhost:4001");
+ * await wrangler.waitForHeadOpen({
+ *   utxos: [{ txHash: "abc...", outputIndex: 0 }],
+ *   blueprintTx: { type: "Tx ConwayEra", cborHex: "...", description: "" },
+ * });
+ * ```
+ */
 export class Wrangler {
-    BLOCKFROST_KEY;
     mode;
     provider;
     instance;
@@ -12,10 +24,9 @@ export class Wrangler {
     url;
     wsUrl;
     constructor(url, wsUrl) {
-        this.url = url || process.env.HYDRA_API_URL;
-        this.wsUrl = wsUrl || process.env.HYDRA_WS_URL;
-        this.BLOCKFROST_KEY = process.env.BLOCKFROST_API_KEY;
-        this.blockfrost = new BlockfrostProvider(this.BLOCKFROST_KEY);
+        this.url = url || requireEnv('HYDRA_API_URL');
+        this.wsUrl = wsUrl || requireEnv('HYDRA_WS_URL');
+        this.blockfrost = new BlockfrostProvider(requireEnv('BLOCKFROST_API_KEY'));
         this.provider = this.createHydraProvider();
         this.instance = this.createHydraInstance();
     }
@@ -29,207 +40,243 @@ export class Wrangler {
             submitter: this.provider,
         });
     }
-    async connect() {
-        return await this.provider.connect();
-    }
-    async startHead(txHash, txIndex) {
-        this.mode = "start";
-        this.provider.onMessage(msg => this.handleIncoming(msg, { txHash, txIndex }));
-        await this.provider.connect();
-    }
-    async shutdownHead() {
-        this.mode = "shutdown";
-        this.provider.onMessage(msg => this.handleIncoming(msg));
-        await this.provider.connect();
-    }
-    async waitForHeadClose(timeoutMs) {
-        this.mode = "shutdown";
-        return new Promise(async (resolve, reject) => {
-            let settled = false;
-            const handle = async (message) => {
-                try {
-                    console.log("Message received: ", message.tag, message);
-                    switch (message.tag) {
-                        case "HeadIsClosed":
-                        case "HeadIsFinalized":
-                            if (settled)
-                                return;
-                            settled = true;
-                            resolve();
-                            break;
-                        case "ReadyToFanout":
-                            if (settled)
-                                return;
-                            await this.provider.fanout();
-                            break;
-                        case "Greetings":
-                            await this.onGreetings(message.headStatus);
-                            break;
-                    }
-                }
-                catch (err) {
-                    if (!settled) {
-                        settled = true;
-                        reject(err);
-                    }
-                }
-            };
-            this.provider.onMessage(handle);
+    /**
+     * 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.
+     *
+     * @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.
+     */
+    async connectWithRetry(maxAttempts = 5, baseDelayMs = 1000) {
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
             try {
-                await this.provider.connect();
+                const connected = await this.provider.isConnected();
+                if (connected)
+                    return;
+                throw new Error('isConnected() returned false');
             }
             catch (err) {
-                if (!settled) {
-                    settled = true;
-                    return reject(new Error("Failed to connect to Hydra provider: " + String(err)));
+                if (attempt === maxAttempts - 1) {
+                    throw new Error(`Failed to connect after ${maxAttempts} attempts: ${String(err)}`);
                 }
+                const delay = Math.min(baseDelayMs * 2 ** attempt, 30_000);
+                await new Promise((r) => setTimeout(r, delay));
             }
-            const timer = setTimeout(() => {
-                if (!settled) {
-                    settled = true;
-                    reject(new Error("Timeout waiting for head to close!"));
-                }
-            }, timeoutMs);
-            const finalizer = () => clearTimeout(timer);
-            const origResolve = resolve;
-            const origReject = reject;
-            resolve = (v) => {
-                finalizer();
-                origResolve(v);
-            };
-            reject = (e) => {
-                finalizer();
-                origReject(e);
+        }
+    }
+    /**
+     * Shared helper for promise-based methods that wait for a specific
+     * Hydra message. Handles connection, timeout, and settlement in one place.
+     */
+    awaitMessage(handler, timeoutMs, timeoutMessage) {
+        return new Promise((resolve, reject) => {
+            let settled = false;
+            const settle = (fn, value) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                fn(value);
             };
+            this.provider.onMessage((message) => {
+                handler(message, (value) => settle(resolve, value), (reason) => settle(reject, reason));
+            });
+            const timer = setTimeout(() => settle(reject, new Error(timeoutMessage)), timeoutMs);
+            this.connectWithRetry().catch((err) => settle(reject, new Error(`Failed to connect: ${String(err)}`)));
         });
     }
+    /** Connect the underlying HydraProvider WebSocket with retry logic. */
+    async connect() {
+        return await this.connectWithRetry();
+    }
+    /** Disconnect the underlying HydraProvider WebSocket. */
+    async disconnect(timeout) {
+        return this.provider.disconnect(timeout);
+    }
+    /** Return the current HydraProvider connection/head status. */
+    getStatus() {
+        return this.provider.getStatus();
+    }
+    /** Register a callback for HydraProvider status changes. */
+    onStatusChange(callback) {
+        return this.provider.onStatusChange(callback);
+    }
+    /** Begin the head-opening sequence: init, commit, and listen for state changes. */
+    async startHead(commitArgs) {
+        this.mode = 'start';
+        this.provider.onMessage((msg) => this.handleIncoming(msg, commitArgs));
+        await this.connectWithRetry();
+    }
+    /** Begin the head-closing sequence: close, fanout, and finalize. */
+    async shutdownHead() {
+        this.mode = 'shutdown';
+        this.provider.onMessage((msg) => this.handleIncoming(msg));
+        await this.connectWithRetry();
+    }
+    /**
+     * Wait for the Hydra head to fully close and finalize.
+     * @param timeoutMs - Maximum time to wait in milliseconds.
+     */
+    async waitForHeadClose(timeoutMs = 180000) {
+        this.mode = 'shutdown';
+        return this.awaitMessage((message, resolve, reject) => {
+            switch (message.tag) {
+                case 'HeadIsClosed':
+                case 'HeadIsFinalized':
+                    resolve();
+                    break;
+                case 'ReadyToFanout':
+                    this.provider.fanout();
+                    break;
+                case 'Greetings':
+                    this.onGreetings(message.headStatus).catch((err) => reject(new Error(`Greetings handler failed: ${String(err)}`)));
+                    break;
+            }
+        }, timeoutMs, 'Timeout waiting for head to close!');
+    }
+    /**
+     * Wait for the Hydra head to reach the `Open` state.
+     * @param commitArgs - UTxO to commit into the head during initialization.
+     * @param timeoutMs - Maximum time to wait in milliseconds.
+     */
     async waitForHeadOpen(commitArgs, timeoutMs = 180000) {
-        this.mode = "start";
-        return new Promise(async (resolve, reject) => {
-            let settled = false;
-            const handle = async (message) => {
-                try {
-                    if (message.tag === "HeadIsOpen") {
-                        if (settled)
-                            return;
-                        settled = true;
-                        resolve();
-                    }
-                    else if (message.tag === "HeadIsInitializing") {
-                        if (!commitArgs)
-                            return;
-                        await this.doCommit(commitArgs);
-                    }
-                    else if (message.tag === "Greetings") {
-                        await this.onGreetings(message.headStatus, commitArgs);
-                    }
-                }
-                catch (err) {
-                    if (!settled) {
-                        settled = true;
-                        reject(err);
-                    }
-                }
-            };
-            this.provider.onMessage(handle);
-            try {
-                await this.provider.connect();
+        this.mode = 'start';
+        return this.awaitMessage((message, resolve, reject) => {
+            if (message.tag === 'HeadIsOpen') {
+                resolve();
             }
-            catch (err) {
-                if (!settled) {
-                    settled = true;
-                    return reject(new Error("Failed to connect to Hydra provider: " + String(err)));
-                }
+            else if (message.tag === 'HeadIsInitializing') {
+                if (!commitArgs)
+                    return;
+                this.doCommit(commitArgs).catch((err) => reject(new Error(`Commit failed: ${String(err)}`)));
             }
-            const timer = setTimeout(() => {
-                if (!settled) {
-                    settled = true;
-                    reject(new Error("Timeout waiting for head to open"));
-                }
-            }, timeoutMs);
-            const finalizer = () => clearTimeout(timer);
-            const origResolve = resolve;
-            const origReject = reject;
-            resolve = (v) => {
-                finalizer();
-                origResolve(v);
-            };
-            reject = (e) => {
-                finalizer();
-                origReject(e);
-            };
-        });
+            else if (message.tag === 'Greetings') {
+                this.onGreetings(message.headStatus, commitArgs).catch((err) => reject(new Error(`Greetings handler failed: ${String(err)}`)));
+            }
+        }, timeoutMs, 'Timeout waiting for head to open');
     }
+    /**
+     * Query the current Hydra head status via a `Greetings` message.
+     * @param timeoutMs - Maximum time to wait for the status response.
+     * @returns The head status string (e.g. `"Idle"`, `"Open"`, `"Closed"`).
+     */
     async getHeadStatus(timeoutMs = 5000) {
-        return new Promise(async (resolve, reject) => {
-            let settled = false;
-            const handle = (message) => {
-                if (settled)
-                    return;
-                if (message.tag === "Greetings") {
-                    settled = true;
-                    resolve(message.headStatus);
-                }
-            };
-            this.provider.onMessage(handle);
-            try {
-                await this.provider.connect();
+        return this.awaitMessage((message, resolve, _reject) => {
+            if (message.tag === 'Greetings') {
+                resolve(message.headStatus);
             }
-            catch (err) {
-                if (!settled) {
-                    settled = true;
-                    return reject(new Error("Failed to connect to Hydra provider: " + String(err)));
-                }
-            }
-            const timer = setTimeout(() => {
-                if (!settled) {
-                    settled = true;
-                    reject(new Error("Timeout waiting for head to open"));
-                }
-            }, timeoutMs);
-            const finalizer = () => clearTimeout(timer);
-            const origResolve = resolve;
-            const origReject = reject;
-            resolve = (v) => {
-                finalizer();
-                origResolve(v);
-            };
-            reject = (e) => {
-                finalizer();
-                origReject(e);
-            };
-        });
+        }, timeoutMs, 'Timeout waiting for head status');
     }
     async doCommit(commitArgs) {
-        try {
-            const rawTx = await this.instance.commitFunds(commitArgs.txHash, commitArgs.txIndex);
-            return await this.blockfrost.submitTx(rawTx);
+        let rawTx;
+        if (commitArgs.blueprintTx) {
+            rawTx = await this.instance.commitBlueprintUTxOs(commitArgs.utxos, commitArgs.blueprintTx);
+        }
+        else if (commitArgs.utxos.length === 0) {
+            rawTx = await this.instance.commitEmpty();
+        }
+        else if (commitArgs.utxos.length === 1) {
+            const { txHash, outputIndex } = commitArgs.utxos[0];
+            rawTx = await this.instance.commitFunds(txHash, outputIndex);
+        }
+        else {
+            throw new Error('Multiple UTxOs without a blueprintTx require a blueprint transaction');
+        }
+        return await this.blockfrost.submitTx(rawTx);
+    }
+    /**
+     * 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).
+     *
+     * Resolves on `DecommitApproved` — L1 settlement happens asynchronously.
+     *
+     * @param transaction - The decommit transaction (CBOR-encoded).
+     * @param timeoutMs - Maximum time to wait for approval (default 60s).
+     */
+    async decommit(transaction, timeoutMs = 60000) {
+        const status = await this.getHeadStatus();
+        if (status !== 'Open') {
+            throw new Error(`Cannot decommit: head is "${status}", expected "Open"`);
+        }
+        const result = this.awaitMessage((message, resolve, reject) => {
+            if (message.tag === 'DecommitApproved') {
+                resolve();
+            }
+            else if (message.tag === 'DecommitInvalid') {
+                reject(new Error(`Decommit invalid: ${JSON.stringify(message.decommitInvalidReason)}`));
+            }
+        }, timeoutMs, 'Timeout waiting for decommit approval');
+        await this.provider.publishDecommit(transaction);
+        return result;
+    }
+    /**
+     * Incrementally commit funds into an already-open Hydra head.
+     *
+     * Only single-UTxO commits are supported (MeshJS limitation).
+     * The raw L1 transaction is submitted to Blockfrost automatically.
+     *
+     * Resolves on `CommitFinalized`.
+     *
+     * @param commitArgs - Single UTxO (with optional blueprint) to commit.
+     * @param timeoutMs - Maximum time to wait for finalization (default 120s).
+     */
+    async incrementalCommit(commitArgs, timeoutMs = 120000) {
+        const status = await this.getHeadStatus();
+        if (status !== 'Open') {
+            throw new Error(`Cannot incrementally commit: head is "${status}", expected "Open"`);
+        }
+        await this.doIncrementalCommit(commitArgs);
+        return this.awaitMessage((message, resolve, _reject) => {
+            if (message.tag === 'CommitFinalized') {
+                resolve();
+            }
+        }, timeoutMs, 'Timeout waiting for incremental commit finalization');
+    }
+    async doIncrementalCommit(commitArgs) {
+        if (commitArgs.utxos.length !== 1) {
+            throw new Error('Incremental commit requires exactly one UTxO');
         }
-        catch (err) {
-            console.error(`Commit error`, err);
-            return false;
+        const { txHash, outputIndex } = commitArgs.utxos[0];
+        let rawTx;
+        if (commitArgs.blueprintTx) {
+            rawTx = await this.instance.incrementalBlueprintCommit(txHash, outputIndex, commitArgs.blueprintTx);
         }
+        else {
+            rawTx = await this.instance.incrementalCommitFunds(txHash, outputIndex);
+        }
+        return await this.blockfrost.submitTx(rawTx);
     }
     async handleIncoming(message, commitArgs) {
-        if (message.tag === "Greetings") {
+        if (message.tag === 'Greetings') {
             await this.onGreetings(message.headStatus, commitArgs);
         }
         else {
             switch (this.mode) {
-                case "start":
-                    if (message.tag === "HeadIsInitializing") {
+                case 'start':
+                    if (message.tag === 'HeadIsInitializing') {
                         if (commitArgs === undefined) {
-                            console.error("No commit arguments specified... aborting commit!");
+                            console.error('No commit arguments specified... aborting commit!');
                             return;
                         }
-                        await this.doCommit(commitArgs);
+                        try {
+                            await this.doCommit(commitArgs);
+                        }
+                        catch (err) {
+                            console.error('Commit failed during startHead:', err);
+                        }
                     }
-                    if (message.tag === "HeadIsOpen") {
+                    if (message.tag === 'HeadIsOpen') {
                         // Successfully started the head here... close gracefully?
                     }
                     break;
-                case "shutdown":
-                    if (message.tag === "ReadyToFanout") {
+                case 'shutdown':
+                    if (message.tag === 'ReadyToFanout') {
                         await this.provider.fanout();
                     }
                     break;
@@ -238,35 +285,35 @@ export class Wrangler {
     }
     async onGreetings(status, commitArgs) {
         switch (this.mode) {
-            case "start":
+            case 'start':
                 switch (status) {
-                    case "Idle":
-                        console.log("Idle → init()");
+                    case 'Idle':
+                        console.log('Idle → init()');
                         await this.provider.init();
                         break;
-                    case "Initializing":
-                        console.log("Initializing -> commit()");
+                    case 'Initializing':
+                        console.log('Initializing -> commit()');
                         if (commitArgs === undefined) {
-                            console.error("No commit arguments specified... aborting commit!");
+                            console.error('No commit arguments specified... aborting commit!');
                             return;
                         }
                         await this.doCommit(commitArgs);
                         break;
-                    case "Open":
-                        console.log("Open → already ready, proceeding");
+                    case 'Open':
+                        console.log('Open → already ready, proceeding');
                         break;
                     default:
                         console.log(`Greetings in start mode, ignoring status: ${status}`);
                 }
                 break;
-            case "shutdown":
+            case 'shutdown':
                 switch (status) {
-                    case "Open":
-                        console.log("Shutting down: closing head…");
+                    case 'Open':
+                        console.log('Shutting down: closing head…');
                         await this.provider.close();
                         break;
-                    case "FanoutPossible":
-                        console.log("Fanout now possible: fanning out…");
+                    case 'FanoutPossible':
+                        console.log('Fanout now possible: fanning out…');
                         await this.provider.fanout();
                         break;
                     default:

package/dist/test.js

@@ -14,8 +14,8 @@ import { Wrangler } from './mesh/wrangler';
     const admin_address = admin_wallet.addresses.enterpriseAddressBech32;
     console.log(`Admin address: ${admin_address}`);
     const blockfrostProvider = new BlockfrostProvider(process.env.BLOCKFROST_API_KEY);
-    const txHash = 'a000003f633d9b2efcc18dedefaf60623e3132c8b05a5751ac08d3bf6f505d54';
-    const txIndex = 3;
+    const _txHash = 'a000003f633d9b2efcc18dedefaf60623e3132c8b05a5751ac08d3bf6f505d54';
+    const _txIndex = 3;
     const utxo = await blockfrostProvider.fetchAddressUTxOs(admin_address);
     if (utxo.length < 3) {
         console.log(utxo);

package/dist/tx3/submit-tx.d.ts

@@ -1 +1,9 @@
+/**
+ * Submit a transaction to a TRP endpoint via JSON-RPC.
+ *
+ * @param submit_endpoint - URL of the TRP submit endpoint.
+ * @param payload - Hex-encoded transaction payload.
+ * @param id - JSON-RPC request identifier.
+ * @returns The fetch Response from the TRP endpoint.
+ */
 export declare function submitTx(submit_endpoint: string, payload: string, id: string): Promise<Response>;

package/dist/tx3/submit-tx.js

@@ -1,3 +1,11 @@
+/**
+ * Submit a transaction to a TRP endpoint via JSON-RPC.
+ *
+ * @param submit_endpoint - URL of the TRP submit endpoint.
+ * @param payload - Hex-encoded transaction payload.
+ * @param id - JSON-RPC request identifier.
+ * @returns The fetch Response from the TRP endpoint.
+ */
 export async function submitTx(submit_endpoint, payload, id) {
     return await fetch(submit_endpoint, {
         method: 'POST',

package/dist/utils/chunk-string.d.ts

@@ -1 +1,8 @@
+/**
+ * Split a string into fixed-size chunks.
+ *
+ * @param str - The string to split.
+ * @param size - Maximum character count per chunk.
+ * @returns Array of string chunks.
+ */
 export declare function chunkString(str: string, size: number): string[];

package/dist/utils/chunk-string.js

@@ -1,3 +1,10 @@
+/**
+ * Split a string into fixed-size chunks.
+ *
+ * @param str - The string to split.
+ * @param size - Maximum character count per chunk.
+ * @returns Array of string chunks.
+ */
 export function chunkString(str, size) {
     const chunks = [];
     for (let i = 0; i < str.length; i += size) {

package/dist/utils/verify-signature.d.ts

@@ -1,10 +1,18 @@
-export declare const bufferToHex: (buffer: any) => string;
-export declare const bufferToAscii: (buffer: any) => string;
+/** Convert a buffer-like value to a hex string. */
+export declare const bufferToHex: (buffer: Uint8Array | string) => string;
+/** Convert a buffer-like value to an ASCII string. */
+export declare const bufferToAscii: (buffer: Uint8Array | string) => string;
+/**
+ * Verify a CIP-30 COSE_Sign1 signature against an expected message and address.
+ *
+ * @param signature - Hex-encoded COSE_Sign1 signature bytes.
+ * @param message - The original plaintext message that was signed.
+ * @param signingAddress - Bech32 address of the expected signer.
+ * @param signatureKey - Hex-encoded COSE key containing the public key.
+ * @returns Validation result with `isValid`, chunked signature metadata, and public key hex.
+ */
 export declare function verifySignature(signature: string, message: string, signingAddress: string, signatureKey: string): {
     isValid: boolean;
     sigMeta: string[];
     pubKeyHex: string;
 };
-/**
- * End Signature Validation Stuff
- */

package/dist/utils/verify-signature.js

@@ -1,17 +1,25 @@
+import { Buffer } from 'node:buffer';
+import { COSESign1 } from '@emurgo/cardano-message-signing-nodejs';
+import * as CSL from '@emurgo/cardano-serialization-lib-nodejs';
+import { bech32 } from 'bech32';
+import { default as cbor } from 'cbor';
+import { chunkString } from './chunk-string.js';
+/** Convert a buffer-like value to a hex string. */
+export const bufferToHex = (buffer) => Buffer.from(buffer).toString('hex');
+/** Convert a buffer-like value to an ASCII string. */
+export const bufferToAscii = (buffer) => Buffer.from(buffer).toString('ascii');
 /**
- * Signature Validation Stuff
+ * Verify a CIP-30 COSE_Sign1 signature against an expected message and address.
+ *
+ * @param signature - Hex-encoded COSE_Sign1 signature bytes.
+ * @param message - The original plaintext message that was signed.
+ * @param signingAddress - Bech32 address of the expected signer.
+ * @param signatureKey - Hex-encoded COSE key containing the public key.
+ * @returns Validation result with `isValid`, chunked signature metadata, and public key hex.
  */
-import * as CSL from "@emurgo/cardano-serialization-lib-nodejs";
-import { COSESign1 } from "@emurgo/cardano-message-signing-nodejs";
-import { Buffer } from "buffer";
-import { default as cbor } from "cbor";
-import { chunkString } from "./chunk-string.js";
-import { bech32 } from "bech32";
-export const bufferToHex = (buffer) => Buffer.from(buffer).toString("hex");
-export const bufferToAscii = (buffer) => Buffer.from(buffer).toString("ascii");
 export function verifySignature(signature, message, signingAddress, signatureKey) {
     try {
-        const coseSign1 = COSESign1.from_bytes(Buffer.from(signature, "hex"));
+        const coseSign1 = COSESign1.from_bytes(Buffer.from(signature, 'hex'));
         const signatureBytes = coseSign1.signature();
         const [, , , payload1] = cbor.decode(bufferToHex(coseSign1.signed_data().to_bytes()));
         const signaturePayloadAscii = bufferToAscii(payload1);
@@ -21,23 +29,20 @@ export function verifySignature(signature, message, signingAddress, signatureKey
         const cosePublicKey = coseSigKey.get(-2);
         const sigKey = CSL.PublicKey.from_bytes(cosePublicKey);
         const publicKeyHash = sigKey.hash();
-        const address_matches = addressBytes.toString("hex").slice(2) === publicKeyHash.to_hex();
+        const address_matches = addressBytes.toString('hex').slice(2) === publicKeyHash.to_hex();
         const sig = CSL.Ed25519Signature.from_bytes(signatureBytes);
         const validates = sigKey.verify(coseSign1.signed_data().to_bytes(), sig);
         const message_matches = signaturePayloadAscii === message;
         const isValid = validates && message_matches && address_matches;
         const sigMeta = chunkString(sig.to_hex(), 64);
         if (!isValid) {
-            console.log("Failed to validate signature!");
+            console.log('Failed to validate signature!');
             console.log(isValid, validates, message_matches, address_matches);
         }
         return { isValid, sigMeta, pubKeyHex: sigKey.to_hex() };
     }
     catch (error) {
-        console.error(`Error during signature validation:`, error);
+        console.error(`Error during signature validation:`, String(error));
         return { isValid: false, sigMeta: [], pubKeyHex: '' };
     }
 }
-/**
- * End Signature Validation Stuff
- */