@hazae41/networker/dist/cjs/mods/worker/index.cjs

Generate Network secrets in a worker

'use strict';

var box = require('@hazae41/box');
var future = require('@hazae41/future');
var jsonrpc = require('@hazae41/jsonrpc');
var index = require('../../libs/disworker/index.cjs');
var index$1 = require('../data/index.cjs');

function _using_ctx() {
    var _disposeSuppressedError = typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed) {
        var err = new Error();
        err.name = "SuppressedError";
        err.suppressed = suppressed;
        err.error = error;
        return err;
    }, empty = {}, stack = [];
    function using(isAwait, value) {
        if (value != null) {
            if (Object(value) !== value) {
                throw new TypeError("using declarations can only be used with objects, functions, null, or undefined.");
            }
            if (isAwait) {
                var dispose = value[Symbol.asyncDispose || Symbol.for("Symbol.asyncDispose")];
            }
            if (dispose == null) {
                dispose = value[Symbol.dispose || Symbol.for("Symbol.dispose")];
            }
            if (typeof dispose !== "function") {
                throw new TypeError(`Property [Symbol.dispose] is not a function.`);
            }
            stack.push({
                v: value,
                d: dispose,
                a: isAwait
            });
        } else if (isAwait) {
            stack.push({
                d: value,
                a: isAwait
            });
        }
        return value;
    }
    return {
        e: empty,
        u: using.bind(null, false),
        a: using.bind(null, true),
        d: function() {
            var error = this.e;
            function next() {
                while(resource = stack.pop()){
                    try {
                        var resource, disposalResult = resource.d && resource.d.call(resource.v);
                        if (resource.a) {
                            return Promise.resolve(disposalResult).then(next, err);
                        }
                    } catch (e) {
                        return err(e);
                    }
                }
                if (error !== empty) throw error;
            }
            function err(e) {
                error = error !== empty ? new _disposeSuppressedError(error, e) : e;
                return next();
            }
            return next();
        }
    };
}
class NetWorker extends index.DisWorker {
    worker = new Worker(index$1.data, {
        type: "module"
    });
    counter = new jsonrpc.RpcCounter();
    async requestOrThrow(prerequest) {
        try {
            var _usingCtx = _using_ctx();
            const stack = _usingCtx.u(new box.Stack());
            const request = this.counter.prepare(prerequest);
            const future$1 = new future.Future();
            const onMessage = (e)=>{
                if (e.data.id !== request.id) return;
                future$1.resolve(jsonrpc.RpcResponse.from(e.data));
            };
            this.worker.addEventListener("message", onMessage, {
                passive: true
            });
            stack.push(new box.Deferred(()=>this.worker.removeEventListener("message", onMessage)));
            const onError = ()=>future$1.reject(new Error("Errored"));
            this.worker.addEventListener("error", onError, {
                passive: true
            });
            stack.push(new box.Deferred(()=>this.worker.removeEventListener("error", onError)));
            const onMessageError = (cause)=>future$1.reject(new Error("Errored", {
                    cause
                }));
            this.worker.addEventListener("messageerror", onMessageError, {
                passive: true
            });
            stack.push(new box.Deferred(()=>this.worker.removeEventListener("messageerror", onMessageError)));
            this.worker.postMessage(request);
            return await future$1.promise;
        } catch (_) {
            _usingCtx.e = _;
        } finally{
            _usingCtx.d();
        }
    }
    async createOrThrow(params) {
        const uuid = await this.requestOrThrow({
            method: "net_create",
            params: [
                params
            ]
        }).then((r)=>r.getOrThrow());
        return new NetMixin(this, uuid);
    }
}
class NetMixin {
    worker;
    uuid;
    constructor(worker, uuid){
        this.worker = worker;
        this.uuid = uuid;
    }
    async [Symbol.asyncDispose]() {
        await this.worker.requestOrThrow({
            method: "net_destroy",
            params: [
                this.uuid
            ]
        }).then((r)=>r.getOrThrow());
    }
    async generateOrThrow(minimumZeroHex) {
        return await this.worker.requestOrThrow({
            method: "net_generate",
            params: [
                this.uuid,
                minimumZeroHex
            ]
        }).then((r)=>r.getOrThrow());
    }
    async verifyProofOrThrow(proofZeroHex) {
        return await this.worker.requestOrThrow({
            method: "net_verify_proof",
            params: [
                this.uuid,
                proofZeroHex
            ]
        }).then((r)=>r.getOrThrow());
    }
    async verifySecretOrThrow(secretZeroHex) {
        return await this.worker.requestOrThrow({
            method: "net_verify_secret",
            params: [
                this.uuid,
                secretZeroHex
            ]
        }).then((r)=>r.getOrThrow());
    }
    async verifyProofsOrThrow(proofsZeroHexArray) {
        return await this.worker.requestOrThrow({
            method: "net_verify_proofs",
            params: [
                this.uuid,
                proofsZeroHexArray
            ]
        }).then((r)=>r.getOrThrow());
    }
    async verifySecretsOrThrow(secretsZeroHexArray) {
        return await this.worker.requestOrThrow({
            method: "net_verify_secrets",
            params: [
                this.uuid,
                secretsZeroHexArray
            ]
        }).then((r)=>r.getOrThrow());
    }
}

exports.NetMixin = NetMixin;
exports.NetWorker = NetWorker;
//# sourceMappingURL=index.cjs.map