@lerna-labs/hydra-sdk 1.0.0-beta.6

package/dist/hydra/utxo.d.ts

@@ -0,0 +1,14 @@
+interface ParsedUtxo {
+    tx_hash: string;
+    output_index: number;
+    address: string;
+    amount: {
+        unit: string;
+        quantity: string;
+    }[];
+}
+/**
+ * Fetches the full UTxO snapshot and filters by address.
+ */
+export declare function queryUtxoByAddress(address: string): Promise<ParsedUtxo[]>;
+export {};

package/dist/hydra/utxo.js

@@ -0,0 +1,40 @@
+import axios from 'axios';
+/**
+ * Fetches the full UTxO snapshot and filters by address.
+ */
+export async function queryUtxoByAddress(address) {
+    console.log(`Querying UTxO by Address: ${address}`);
+    const baseUrl = process.env.HYDRA_API_URL;
+    console.log(`Base Url: ${baseUrl}`);
+    if (!baseUrl) {
+        throw new Error('HYDRA_API_URL is not defined in the environment variables.');
+    }
+    const url = `${baseUrl}/snapshot/utxo`;
+    try {
+        const response = await axios.get(url);
+        const data = response.data;
+        console.log(`Did get data?`, Object.entries(data).length);
+        const result = [];
+        for (const [txKey, utxo] of Object.entries(data)) {
+            if (utxo.address === address) {
+                const [tx_hash, indexStr] = txKey.split('#');
+                const output_index = parseInt(indexStr, 10);
+                const amount = Object.entries(utxo.value).map(([unit, quantity]) => ({
+                    unit,
+                    quantity,
+                }));
+                result.push({
+                    tx_hash,
+                    output_index,
+                    address: utxo.address,
+                    amount,
+                });
+            }
+        }
+        return result;
+    }
+    catch (error) {
+        console.error('Failed to fetch or parse UTxO snapshot:', error.message);
+        throw error;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+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';

package/dist/index.js

@@ -0,0 +1,7 @@
+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';

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

@@ -0,0 +1,2 @@
+import { MeshWallet } from '@meshsdk/core';
+export declare function getAdmin(): Promise<MeshWallet>;

package/dist/mesh/get-admin.js

@@ -0,0 +1,26 @@
+import { MeshWallet, } from '@meshsdk/core';
+export async function getAdmin() {
+    const keyCborHex = process.env.HYDRA_ADMIN_CARDANO_PK || null;
+    if (!keyCborHex) {
+        throw new Error('Admin signing key is not defined!');
+    }
+    let networkId = parseInt(process.env.HYDRA_NETWORK || '0', 10);
+    if (networkId < 0) {
+        networkId = 0;
+    }
+    else if (networkId > 1) {
+        networkId = 1;
+    }
+    const wallet = new MeshWallet({
+        networkId: networkId,
+        key: {
+            type: 'cli',
+            payment: keyCborHex,
+        },
+    });
+    await wallet.init();
+    if (!wallet.addresses.enterpriseAddressBech32) {
+        throw new Error('Wallet failed to initialize!');
+    }
+    return wallet;
+}

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

@@ -0,0 +1,12 @@
+/**
+ * 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
+ */
+export declare function createMultisigAddress(address1: string, address2: string, networkId?: number, scriptType?: 'any' | 'all'): {
+    address: string;
+    scriptCbor?: string;
+    scriptHash?: string;
+};

package/dist/mesh/native-script.js

@@ -0,0 +1,31 @@
+import { serializeNativeScript, resolveScriptHash, deserializeAddress, } 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
+ */
+export function createMultisigAddress(address1, address2, networkId = 0, scriptType = 'any') {
+    const keyHash1 = deserializeAddress(address1).pubKeyHash;
+    const keyHash2 = deserializeAddress(address2).pubKeyHash;
+    const script = {
+        type: scriptType,
+        scripts: [
+            {
+                type: 'sig',
+                keyHash: keyHash1,
+            },
+            {
+                type: 'sig',
+                keyHash: keyHash2,
+            },
+        ],
+    };
+    const { address, scriptCbor } = serializeNativeScript(script, undefined, networkId);
+    let scriptHash;
+    if (scriptCbor != null) {
+        scriptHash = resolveScriptHash(scriptCbor);
+    }
+    return { address, scriptCbor, scriptHash };
+}

package/dist/mesh/wrangler.d.ts

@@ -0,0 +1,28 @@
+import { HydraProvider } from "@meshsdk/hydra";
+export interface CommitArgs {
+    txHash: string;
+    txIndex: number;
+}
+export declare class Wrangler {
+    private readonly BLOCKFROST_KEY;
+    private mode;
+    readonly provider: HydraProvider;
+    private instance;
+    private readonly blockfrost;
+    private readonly url;
+    private readonly wsUrl;
+    constructor(url?: string, wsUrl?: string);
+    private createHydraProvider;
+    private createHydraInstance;
+    connect(): Promise<void>;
+    startHead(txHash: string, txIndex: number): Promise<void>;
+    waitForHeadOpen(commitArgs: {
+        txHash: string;
+        txIndex: number;
+    }, timeoutMs?: number): Promise<void>;
+    getHeadStatus(timeoutMs?: number): Promise<string>;
+    shutdownHead(): Promise<void>;
+    private doCommit;
+    private handleIncoming;
+    private onGreetings;
+}

package/dist/mesh/wrangler.js

@@ -0,0 +1,216 @@
+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");
+export class Wrangler {
+    BLOCKFROST_KEY;
+    mode;
+    provider;
+    instance;
+    blockfrost;
+    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.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,
+        });
+    }
+    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 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();
+            }
+            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);
+            };
+        });
+    }
+    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();
+            }
+            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);
+            };
+        });
+    }
+    async shutdownHead() {
+        this.mode = "shutdown";
+        this.provider.onMessage(msg => this.handleIncoming(msg));
+        await this.provider.connect();
+    }
+    async doCommit(commitArgs) {
+        try {
+            const rawTx = await this.instance.commitFunds(commitArgs.txHash, commitArgs.txIndex);
+            return await this.blockfrost.submitTx(rawTx);
+        }
+        catch (err) {
+            console.error(`Commit error`, err);
+            return false;
+        }
+    }
+    async handleIncoming(message, commitArgs) {
+        if (message.tag === "Greetings") {
+            await this.onGreetings(message.headStatus, commitArgs);
+        }
+        else {
+            switch (this.mode) {
+                case "start":
+                    if (message.tag === "HeadIsInitializing") {
+                        if (commitArgs === undefined) {
+                            console.error("No commit arguments specified... aborting commit!");
+                            return;
+                        }
+                        await this.doCommit(commitArgs);
+                    }
+                    if (message.tag === "HeadIsOpen") {
+                        // Successfully started the head here... close gracefully?
+                    }
+                    break;
+                case "shutdown":
+                    if (message.tag === "ReadyToFanout") {
+                        await this.provider.fanout();
+                    }
+                    break;
+            }
+        }
+    }
+    async onGreetings(status, commitArgs) {
+        switch (this.mode) {
+            case "start":
+                switch (status) {
+                    case "Idle":
+                        console.log("Idle → init()");
+                        await this.provider.init();
+                        break;
+                    case "Initializing":
+                        console.log("Initializing -> commit()");
+                        if (commitArgs === undefined) {
+                            console.error("No commit arguments specified... aborting commit!");
+                            return;
+                        }
+                        await this.doCommit(commitArgs);
+                        break;
+                    case "Open":
+                        console.log("Open → already ready, proceeding");
+                        break;
+                    default:
+                        console.log(`Greetings in start mode, ignoring status: ${status}`);
+                }
+                break;
+            case "shutdown":
+                switch (status) {
+                    case "Open":
+                        console.log("Shutting down: closing head…");
+                        await this.provider.close();
+                        break;
+                    case "FanoutPossible":
+                        console.log("Fanout now possible: fanning out…");
+                        await this.provider.fanout();
+                        break;
+                    default:
+                        console.log(`Greetings in shutdown mode, ignoring status: ${status}`);
+                }
+        }
+    }
+}

package/dist/test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/test.js

@@ -0,0 +1,66 @@
+import * as dotenv from 'dotenv';
+dotenv.config({ path: '.local.env' });
+import { BlockfrostProvider, MeshTxBuilder, MeshWallet } from '@meshsdk/core';
+import { Wrangler } from './mesh/wrangler';
+(async () => {
+    const admin_wallet = new MeshWallet({
+        networkId: parseInt(process.env.HYDRA_NETWORK_ID || '0', 10),
+        key: {
+            type: 'cli',
+            payment: process.env.HYDRA_ADMIN_CARDANO_PK,
+        },
+    });
+    await admin_wallet.init();
+    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 utxo = await blockfrostProvider.fetchAddressUTxOs(admin_address);
+    if (utxo.length < 3) {
+        console.log(utxo);
+        const unsigned_tx = await new MeshTxBuilder({
+            fetcher: blockfrostProvider,
+        })
+            .txOut(admin_address, [
+            {
+                unit: 'lovelace',
+                quantity: '5000000',
+            },
+        ])
+            .txOut(admin_address, [
+            {
+                unit: 'lovelace',
+                quantity: '5000000',
+            },
+        ])
+            .txOut(admin_address, [
+            {
+                unit: 'lovelace',
+                quantity: '5000000',
+            },
+        ])
+            .txOut(admin_address, [
+            {
+                unit: 'lovelace',
+                quantity: '5000000',
+            },
+        ])
+            .txOut(admin_address, [
+            {
+                unit: 'lovelace',
+                quantity: '5000000',
+            },
+        ])
+            .changeAddress(admin_address)
+            .selectUtxosFrom(utxo)
+            .complete();
+        const signed = await admin_wallet.signTx(unsigned_tx);
+        await blockfrostProvider.submitTx(signed);
+        console.log('Just created some seed utxo... give it a minute!');
+        return;
+    }
+    const wrangler = new Wrangler();
+    // await wrangler.startHead(txHash, txIndex);
+    await wrangler.shutdownHead();
+})();

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

@@ -0,0 +1 @@
+export declare function submitTx(submit_endpoint: string, payload: string, id: string): Promise<Response>;

package/dist/tx3/submit-tx.js

@@ -0,0 +1,20 @@
+export async function submitTx(submit_endpoint, payload, id) {
+    return await fetch(submit_endpoint, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            jsonrpc: '2.0',
+            method: 'trp.submit',
+            params: {
+                tx: {
+                    payload,
+                    encoding: 'hex',
+                    version: 'v1alpha6',
+                },
+            },
+            id,
+        }),
+    });
+}

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

@@ -0,0 +1 @@
+export declare function chunkString(str: string, size: number): string[];

package/dist/utils/chunk-string.js

@@ -0,0 +1,7 @@
+export function chunkString(str, size) {
+    const chunks = [];
+    for (let i = 0; i < str.length; i += size) {
+        chunks.push(str.slice(i, i + size));
+    }
+    return chunks;
+}

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

@@ -0,0 +1,10 @@
+export declare const bufferToHex: (buffer: any) => string;
+export declare const bufferToAscii: (buffer: any) => string;
+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

@@ -0,0 +1,43 @@
+/**
+ * Signature Validation Stuff
+ */
+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 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 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();
+        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(isValid, validates, message_matches, address_matches);
+        }
+        return { isValid, sigMeta, pubKeyHex: sigKey.to_hex() };
+    }
+    catch (error) {
+        console.error(`Error during signature validation:`, error);
+        return { isValid: false, sigMeta: [], pubKeyHex: '' };
+    }
+}
+/**
+ * End Signature Validation Stuff
+ */

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@lerna-labs/hydra-sdk",
+  "version": "1.0.0-beta.6",
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./*": "./dist/*"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run build"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true,
+    "tag": "beta"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {},
+  "devDependencies": {},
+  "homepage": "https://github.com/Lerna-Labs/hydra-sdk#readme",
+  "bugs": {
+    "url": "https://github.com/Lerna-Labs/hydra-sdk/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Lerna-Labs/hydra-sdk",
+    "directory": "packages/core"
+  }
+}