@lerna-labs/hydra-sdk 1.0.0-beta.8 → 2.0.0-beta.1

package/dist/hydra/utxo.js

@@ -1,52 +1,58 @@
-import axios from 'axios';
-export async function getUtxoSet() {
-    const baseUrl = process.env.HYDRA_API_URL;
-    if (!baseUrl) {
-        throw new Error("HYDRA_API_URL is not defined in the environment variables!");
-    }
+import { requireEnv } from '../config.js';
+/**
+ * Fetch the full UTxO set from the Hydra head snapshot.
+ *
+ * Reads `HYDRA_API_URL` from the environment.
+ *
+ * @param options - Query options. Set `includeDatums: true` to include datum/script fields.
+ * @returns All UTxOs currently held in the Hydra head.
+ */
+export async function getUtxoSet(options) {
+    const baseUrl = requireEnv('HYDRA_API_URL');
     const url = `${baseUrl}/snapshot/utxo`;
     try {
-        const response = await axios.get(url);
-        const data = response.data;
+        const response = await fetch(url);
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status} fetching ${url}`);
+        }
+        const data = await response.json();
         const UtxoSet = [];
         for (const [txKey, utxo] of Object.entries(data)) {
-            const [tx_hash, index_str] = txKey.split("#");
+            const [tx_hash, index_str] = txKey.split('#');
             const output_index = parseInt(index_str, 10);
             const amount = Object.entries(utxo.value).map(([unit, quantity]) => ({
                 unit,
                 quantity,
             }));
-            UtxoSet.push({
-                tx_hash,
-                output_index,
-                address: utxo.address,
-                amount,
-            });
+            const parsed = { tx_hash, output_index, address: utxo.address, amount };
+            if (options?.includeDatums) {
+                parsed.datum = utxo.datum ?? null;
+                parsed.datumHash = utxo.datumHash ?? null;
+                parsed.inlineDatum = utxo.inlineDatum ?? null;
+                parsed.referenceScript = utxo.referenceScript ?? null;
+            }
+            UtxoSet.push(parsed);
         }
         return UtxoSet;
     }
     catch (error) {
-        console.error("Error fetching the Hydra Ledger?", error);
+        console.error('Error fetching the Hydra Ledger?', error);
         throw error;
     }
 }
 /**
- * Fetches the full UTxO snapshot and filters by address.
+ * Fetch UTxOs belonging to a specific address from the Hydra head snapshot.
+ *
+ * @param address - Bech32 address to filter by.
+ * @returns UTxOs matching the given address.
  */
-export async function queryUtxoByAddress(address) {
-    console.log(`Querying UTxO by Address: ${address}`);
-    try {
-        const result = [];
-        const data = await getUtxoSet();
-        for (const utxo of data) {
-            if (utxo.address === address) {
-                result.push(utxo);
-            }
+export async function queryUtxoByAddress(address, options) {
+    const result = [];
+    const data = await getUtxoSet(options);
+    for (const utxo of data) {
+        if (utxo.address === address) {
+            result.push(utxo);
         }
-        return result;
-    }
-    catch (error) {
-        console.error('Failed to fetch or parse UTxO snapshot:', error.message);
-        throw error;
     }
+    return result;
 }

package/dist/index.d.ts

@@ -1,7 +1,15 @@
-export * from './mesh/get-admin';
-export * from './mesh/native-script';
-export * from './mesh/wrangler';
-export * from './hydra/utxo';
-export * from './tx3/submit-tx';
-export * from './utils/verify-signature';
-export * from './utils/chunk-string';
+export type { DiskCache, DiskCacheConfig } from './cache/disk-cache.js';
+export { createDiskCache } from './cache/disk-cache.js';
+export { optionalEnv, requireEnv } from './config.js';
+export { HydraMonitor } from './hydra/hydra-monitor.js';
+export type { ConfirmedSnapshot, HeadStatus, HydraHeadInfo, HydraMessage, HydraMonitorOptions, HydraSnapshot, HydraStatus, HydraTransaction, HydraWsMessage, hydraStatus, hydraTransaction, ServerOutput, TimestampedEvent, } from './hydra/messages.js';
+export type { ParsedUtxo, UtxoQueryOptions } 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 { submitTx } from './tx3/submit-tx.js';
+export { chunkString } from './utils/chunk-string.js';
+export { BECH32_DECODE_LIMIT, bufferToAscii, bufferToHex, decodeBech32Address, verifySignature, } from './utils/verify-signature.js';
+export { CommitArgs, UTxORef, Wrangler } from './wrangler.js';

package/dist/index.js

@@ -1,7 +1,11 @@
-export * from './mesh/get-admin';
-export * from './mesh/native-script';
-export * from './mesh/wrangler';
-export * from './hydra/utxo';
-export * from './tx3/submit-tx';
-export * from './utils/verify-signature';
-export * from './utils/chunk-string';
+export { createDiskCache } from './cache/disk-cache.js';
+export { optionalEnv, requireEnv } from './config.js';
+export { HydraMonitor } from './hydra/hydra-monitor.js';
+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 { submitTx } from './tx3/submit-tx.js';
+export { chunkString } from './utils/chunk-string.js';
+export { BECH32_DECODE_LIMIT, bufferToAscii, bufferToHex, decodeBech32Address, verifySignature, } from './utils/verify-signature.js';
+export { Wrangler } from './wrangler.js';

package/dist/ipfs/ipfs.d.ts

@@ -0,0 +1,22 @@
+export interface IpfsConfig {
+    /** Base URL for the Kubo HTTP API (e.g. "http://localhost:5001"). */
+    apiUrl: string;
+}
+export interface PinResult {
+    /** The content-identifier returned by the IPFS node. */
+    cid: string;
+    /** Size in bytes as reported by the IPFS node. */
+    size: number;
+}
+/**
+ * Create an IPFS client bound to the given Kubo API endpoint.
+ *
+ * All operations go through the Kubo HTTP RPC, so the only requirement
+ * is a reachable Kubo node — no additional IPFS libraries are needed.
+ */
+export declare function createIpfsClient(config: IpfsConfig): {
+    pinJson: (filename: string, payload: unknown) => Promise<PinResult>;
+    pinDirectory: (dirPath: string) => Promise<PinResult>;
+    fetchJson: <T = unknown>(cid: string) => Promise<T>;
+};
+export type IpfsClient = ReturnType<typeof createIpfsClient>;

package/dist/ipfs/ipfs.js

@@ -0,0 +1,90 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+/**
+ * Create an IPFS client bound to the given Kubo API endpoint.
+ *
+ * All operations go through the Kubo HTTP RPC, so the only requirement
+ * is a reachable Kubo node — no additional IPFS libraries are needed.
+ */
+export function createIpfsClient(config) {
+    const { apiUrl } = config;
+    /**
+     * Pin a single JSON-serialisable payload and return its CID.
+     *
+     * @param filename - Filename used inside the IPFS object.
+     * @param payload  - Any JSON-serialisable value.
+     */
+    async function pinJson(filename, payload) {
+        const body = JSON.stringify(payload, null, 2);
+        const form = new FormData();
+        form.append('file', new Blob([body], { type: 'application/json' }), filename);
+        const res = await fetch(`${apiUrl}/api/v0/add?pin=true`, {
+            method: 'POST',
+            body: form,
+        });
+        if (!res.ok) {
+            throw new Error(`IPFS pin failed: ${res.status} ${await res.text()}`);
+        }
+        const json = (await res.json());
+        return { cid: json.Hash, size: Number.parseInt(json.Size, 10) };
+    }
+    /**
+     * Pin every file in a directory and wrap them in an IPFS directory object.
+     *
+     * @param dirPath - Absolute path to a local directory.
+     * @returns The CID of the wrapping IPFS directory.
+     */
+    async function pinDirectory(dirPath) {
+        const form = new FormData();
+        const collectFiles = async (rel) => {
+            const out = [];
+            const dirents = await fs.readdir(path.join(dirPath, rel), { withFileTypes: true });
+            for (const dirent of dirents) {
+                const childRel = path.join(rel, dirent.name);
+                if (dirent.isDirectory()) {
+                    out.push(...(await collectFiles(childRel)));
+                }
+                else if (dirent.isFile()) {
+                    out.push(childRel);
+                }
+            }
+            return out;
+        };
+        for (const relPath of await collectFiles('')) {
+            const buf = await fs.readFile(path.join(dirPath, relPath));
+            const content = new Uint8Array(buf).slice().buffer;
+            // Kubo reconstructs the directory tree from entry names — always
+            // use POSIX separators so Windows callers get the same CID.
+            const entryName = relPath.split(path.sep).join('/');
+            form.append('file', new Blob([content]), entryName);
+        }
+        const res = await fetch(`${apiUrl}/api/v0/add?pin=true&wrap-with-directory=true&recursive=true`, {
+            method: 'POST',
+            body: form,
+        });
+        if (!res.ok) {
+            throw new Error(`IPFS directory pin failed: ${res.status} ${await res.text()}`);
+        }
+        // Kubo returns one JSON object per line (ndjson). The last line is the
+        // wrapping directory entry.
+        const text = await res.text();
+        const lines = text.trim().split('\n');
+        const last = JSON.parse(lines[lines.length - 1]);
+        return { cid: last.Hash, size: Number.parseInt(last.Size, 10) };
+    }
+    /**
+     * Fetch a JSON payload from IPFS by CID.
+     *
+     * @param cid - The content identifier to retrieve.
+     */
+    async function fetchJson(cid) {
+        const res = await fetch(`${apiUrl}/api/v0/cat?arg=${cid}`, {
+            method: 'POST',
+        });
+        if (!res.ok) {
+            throw new Error(`IPFS fetch failed: ${res.status} ${await res.text()}`);
+        }
+        return (await res.json());
+    }
+    return { pinJson, pinDirectory, fetchJson };
+}

package/dist/mesh/get-admin.d.ts

@@ -1,2 +1,14 @@
 import { MeshWallet } from '@meshsdk/core';
-export declare function getAdmin(): Promise<MeshWallet>;
+/**
+ * Create and initialize a MeshWallet for the Hydra head admin.
+ *
+ * Reads the Cardano signing key from `HYDRA_ADMIN_KEY_FILE` (preferred)
+ * or falls back to `HYDRA_ADMIN_CARDANO_PK`. Network is selected via `HYDRA_NETWORK`.
+ *
+ * @param blockfrostProjectId - Optional Blockfrost project ID. When provided, the wallet
+ *   is configured with a Blockfrost fetcher and submitter for L1 operations (e.g. preparing
+ *   the Hydra head, querying UTxOs, submitting commit transactions).
+ * @returns An initialized MeshWallet ready for signing transactions.
+ * @throws If no signing key is available or the wallet fails to initialize.
+ */
+export declare function getAdmin(blockfrostProjectId?: string): Promise<MeshWallet>;

package/dist/mesh/get-admin.js

@@ -1,23 +1,53 @@
-import { MeshWallet, } from '@meshsdk/core';
-export async function getAdmin() {
-    const keyCborHex = process.env.HYDRA_ADMIN_CARDANO_PK || null;
+import { readFileSync } from 'node:fs';
+import { BlockfrostProvider, MeshWallet } from '@meshsdk/core';
+import { optionalEnv } from '../config.js';
+/**
+ * Create and initialize a MeshWallet for the Hydra head admin.
+ *
+ * Reads the Cardano signing key from `HYDRA_ADMIN_KEY_FILE` (preferred)
+ * or falls back to `HYDRA_ADMIN_CARDANO_PK`. Network is selected via `HYDRA_NETWORK`.
+ *
+ * @param blockfrostProjectId - Optional Blockfrost project ID. When provided, the wallet
+ *   is configured with a Blockfrost fetcher and submitter for L1 operations (e.g. preparing
+ *   the Hydra head, querying UTxOs, submitting commit transactions).
+ * @returns An initialized MeshWallet ready for signing transactions.
+ * @throws If no signing key is available or the wallet fails to initialize.
+ */
+export async function getAdmin(blockfrostProjectId) {
+    let keyCborHex = null;
+    // Preferred: read the instance's cardano.sk file directly (no secrets in .env)
+    const keyFile = process.env.HYDRA_ADMIN_KEY_FILE;
+    if (keyFile) {
+        const content = JSON.parse(readFileSync(keyFile, 'utf-8'));
+        keyCborHex = content.cborHex ?? content.key?.cborHex ?? null;
+    }
+    // Fallback: cborHex passed via env var (backward compatible)
+    if (!keyCborHex) {
+        keyCborHex = process.env.HYDRA_ADMIN_CARDANO_PK || null;
+    }
     if (!keyCborHex) {
-        throw new Error('Admin signing key is not defined!');
+        throw new Error('Cardano signing key not found. Set HYDRA_ADMIN_KEY_FILE to the instance cardano.sk path, or HYDRA_ADMIN_CARDANO_PK to its cborHex.');
     }
-    let networkId = parseInt(process.env.HYDRA_NETWORK || '0', 10);
+    let networkId = parseInt(optionalEnv('HYDRA_NETWORK', '0'), 10);
     if (networkId < 0) {
         networkId = 0;
     }
     else if (networkId > 1) {
         networkId = 1;
     }
-    const wallet = new MeshWallet({
+    const walletOptions = {
         networkId: networkId,
         key: {
             type: 'cli',
             payment: keyCborHex,
         },
-    });
+    };
+    if (blockfrostProjectId) {
+        const blockfrost = new BlockfrostProvider(blockfrostProjectId);
+        walletOptions.fetcher = blockfrost;
+        walletOptions.submitter = blockfrost;
+    }
+    const wallet = new MeshWallet(walletOptions);
     await wallet.init();
     if (!wallet.addresses.enterpriseAddressBech32) {
         throw new Error('Wallet failed to initialize!');

package/dist/mesh/native-script.d.ts

@@ -1,12 +1,37 @@
 /**
- * Create a multisig address using 'any' policy (AND logic)
- * @param address1 The first address to include in the script (staking or payment)
- * @param address2 The second address to include in the script (staking or payment)
- * @param networkId 0 = testnet, 1 = mainnet
- * @param scriptType
+ * Create a multisig script address from two Cardano addresses.
+ *
+ * @param address1 - First address (bech32) to include in the native script.
+ * @param address2 - Second address (bech32) to include in the native script.
+ * @param networkId - `0` for testnet, `1` for mainnet.
+ * @param scriptType - `"any"` requires one signature, `"all"` requires both.
+ * @returns The script address, serialized CBOR, and script hash.
  */
 export declare function createMultisigAddress(address1: string, address2: string, networkId?: number, scriptType?: 'any' | 'all'): {
     address: string;
     scriptCbor?: string;
     scriptHash?: string;
 };
+/**
+ * Create a native script policy for minting tokens.
+ *
+ * Without options, produces a bare `sig(keyHash)` script suitable for
+ * in-head voter tokens that must remain burnable by the admin.
+ *
+ * When `invalidHereafter` is provided, produces a compound time-bound
+ * script: `all: [sig(keyHash), before(slot)]` — each ballot gets its
+ * own time-bound policy.
+ *
+ * @param address - Address (bech32) whose key hash is the required signer.
+ * @param opts.invalidHereafter - Slot after which minting is no longer possible.
+ * @param opts.networkId - `0` for testnet (default), `1` for mainnet.
+ * @returns The script address, serialized CBOR, and script hash.
+ */
+export declare function createNativeScript(address: string, opts?: {
+    invalidHereafter?: number;
+    networkId?: number;
+}): {
+    address: string;
+    scriptCbor?: string;
+    scriptHash?: string;
+};

package/dist/mesh/native-script.js

@@ -1,10 +1,12 @@
-import { serializeNativeScript, resolveScriptHash, deserializeAddress, } from '@meshsdk/core';
+import { deserializeAddress, resolveScriptHash, serializeNativeScript } from '@meshsdk/core';
 /**
- * Create a multisig address using 'any' policy (AND logic)
- * @param address1 The first address to include in the script (staking or payment)
- * @param address2 The second address to include in the script (staking or payment)
- * @param networkId 0 = testnet, 1 = mainnet
- * @param scriptType
+ * Create a multisig script address from two Cardano addresses.
+ *
+ * @param address1 - First address (bech32) to include in the native script.
+ * @param address2 - Second address (bech32) to include in the native script.
+ * @param networkId - `0` for testnet, `1` for mainnet.
+ * @param scriptType - `"any"` requires one signature, `"all"` requires both.
+ * @returns The script address, serialized CBOR, and script hash.
  */
 export function createMultisigAddress(address1, address2, networkId = 0, scriptType = 'any') {
     const keyHash1 = deserializeAddress(address1).pubKeyHash;
@@ -23,9 +25,35 @@ export function createMultisigAddress(address1, address2, networkId = 0, scriptT
         ],
     };
     const { address, scriptCbor } = serializeNativeScript(script, undefined, networkId);
-    let scriptHash;
-    if (scriptCbor != null) {
-        scriptHash = resolveScriptHash(scriptCbor);
-    }
+    const scriptHash = scriptCbor != null ? resolveScriptHash(scriptCbor) : undefined;
     return { address, scriptCbor, scriptHash };
 }
+/**
+ * Create a native script policy for minting tokens.
+ *
+ * Without options, produces a bare `sig(keyHash)` script suitable for
+ * in-head voter tokens that must remain burnable by the admin.
+ *
+ * When `invalidHereafter` is provided, produces a compound time-bound
+ * script: `all: [sig(keyHash), before(slot)]` — each ballot gets its
+ * own time-bound policy.
+ *
+ * @param address - Address (bech32) whose key hash is the required signer.
+ * @param opts.invalidHereafter - Slot after which minting is no longer possible.
+ * @param opts.networkId - `0` for testnet (default), `1` for mainnet.
+ * @returns The script address, serialized CBOR, and script hash.
+ */
+export function createNativeScript(address, opts) {
+    const networkId = opts?.networkId ?? 0;
+    const keyHash = deserializeAddress(address).pubKeyHash;
+    const sigScript = { type: 'sig', keyHash };
+    const script = opts?.invalidHereafter != null
+        ? {
+            type: 'all',
+            scripts: [sigScript, { type: 'before', slot: opts.invalidHereafter.toString() }],
+        }
+        : sigScript;
+    const { address: scriptAddress, scriptCbor } = serializeNativeScript(script, undefined, networkId);
+    const scriptHash = scriptCbor != null ? resolveScriptHash(scriptCbor) : undefined;
+    return { address: scriptAddress, scriptCbor, scriptHash };
+}

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),
@@ -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,33 @@
-export declare const bufferToHex: (buffer: any) => string;
-export declare const bufferToAscii: (buffer: any) => string;
+import { Buffer } from 'node:buffer';
+/** 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;
+/**
+ * Character limit used for bech32 decoding. The library defaults to 90, which truncates
+ * Cardano base addresses (payment + staking) that are commonly 103+ characters. We raise
+ * the ceiling well above any realistic Cardano encoding (addr, stake, drep, pool, cc_*).
+ */
+export declare const BECH32_DECODE_LIMIT = 1023;
+/**
+ * Decode a Cardano bech32 string (addr, stake, pool, drep, cc_*) with a character
+ * limit high enough to accommodate base addresses that include a staking component.
+ */
+export declare function decodeBech32Address(address: string): {
+    prefix: string;
+    addressBytes: Buffer;
+};
+/**
+ * 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,43 +1,64 @@
+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
+ * Character limit used for bech32 decoding. The library defaults to 90, which truncates
+ * Cardano base addresses (payment + staking) that are commonly 103+ characters. We raise
+ * the ceiling well above any realistic Cardano encoding (addr, stake, drep, pool, cc_*).
+ */
+export const BECH32_DECODE_LIMIT = 1023;
+/**
+ * Decode a Cardano bech32 string (addr, stake, pool, drep, cc_*) with a character
+ * limit high enough to accommodate base addresses that include a staking component.
+ */
+export function decodeBech32Address(address) {
+    const { words, prefix } = bech32.decode(address, BECH32_DECODE_LIMIT);
+    return { prefix, addressBytes: Buffer.from(bech32.fromWords(words)) };
+}
+/**
+ * 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";
-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);
-        const { words } = bech32.decode(signingAddress);
-        const addressBytes = Buffer.from(bech32.fromWords(words));
+        const { prefix, addressBytes } = decodeBech32Address(signingAddress);
         const coseSigKey = cbor.decode(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();
+        // pool1... bech32 encodes the raw 28-byte key hash with no header byte.
+        // All other address types (addr, drep, stake) have a 1-byte header prefix.
+        const addressHex = addressBytes.toString('hex');
+        const address_matches = prefix === 'pool' ? addressHex === publicKeyHash.to_hex() : addressHex.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
- */