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

package/dist/mesh/wrangler.d.ts

@@ -1,29 +0,0 @@
-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>;
-    shutdownHead(): Promise<void>;
-    waitForHeadClose(timeoutMs: 180000): Promise<void>;
-    waitForHeadOpen(commitArgs: {
-        txHash: string;
-        txIndex: number;
-    }, timeoutMs?: number): Promise<void>;
-    getHeadStatus(timeoutMs?: number): Promise<string>;
-    private doCommit;
-    private handleIncoming;
-    private onGreetings;
-}

package/dist/mesh/wrangler.js

@@ -1,277 +0,0 @@
-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 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);
-            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 close!"));
-                }
-            }, timeoutMs);
-            const finalizer = () => clearTimeout(timer);
-            const origResolve = resolve;
-            const origReject = reject;
-            resolve = (v) => {
-                finalizer();
-                origResolve(v);
-            };
-            reject = (e) => {
-                finalizer();
-                origReject(e);
-            };
-        });
-    }
-    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 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}`);
-                }
-        }
-    }
-}