zeldhash-miner 0.1.0

package/dist/index.js

@@ -0,0 +1,775 @@
+var o = /* @__PURE__ */ ((s) => (s.INVALID_ADDRESS = "INVALID_ADDRESS", s.UNSUPPORTED_ADDRESS_TYPE = "UNSUPPORTED_ADDRESS_TYPE", s.INSUFFICIENT_FUNDS = "INSUFFICIENT_FUNDS", s.NO_CHANGE_OUTPUT = "NO_CHANGE_OUTPUT", s.MULTIPLE_CHANGE_OUTPUTS = "MULTIPLE_CHANGE_OUTPUTS", s.INVALID_INPUT = "INVALID_INPUT", s.WEBGPU_NOT_AVAILABLE = "WEBGPU_NOT_AVAILABLE", s.WORKER_ERROR = "WORKER_ERROR", s.MINING_ABORTED = "MINING_ABORTED", s.DUST_OUTPUT = "DUST_OUTPUT", s))(o || {});
+const $ = (s) => s instanceof Error ? s.message : String(s);
+class _ extends Error {
+  code;
+  details;
+  constructor(t, e, r) {
+    super(e), this.name = "ZeldMinerError", this.code = t, this.details = r;
+  }
+}
+const M = (s, t = o.WORKER_ERROR, e) => {
+  if (s instanceof _)
+    return s;
+  const r = $(s);
+  return new _(t, r, e);
+}, u = (s, t, e) => new _(s, t, e), k = (s) => {
+  const t = BigInt(Number.MAX_SAFE_INTEGER);
+  return s > t ? Number.MAX_SAFE_INTEGER : s < -t ? -Number.MAX_SAFE_INTEGER : Number(s);
+};
+class C {
+  mode;
+  batchSize;
+  workerCount;
+  listeners;
+  workers = [];
+  readyPromise;
+  abortHandler;
+  stride;
+  cleanupExternalAbort = () => {
+    this.externalAbort && (this.externalAbort.removeEventListener("abort", this.abortHandler), this.externalAbort = void 0);
+  };
+  running = !1;
+  paused = !1;
+  startedAt = null;
+  txInputs;
+  txOutputs;
+  txNetwork;
+  satsPerVbyte;
+  template;
+  targetZeros;
+  startNonce = 0n;
+  txDistribution;
+  externalAbort;
+  terminated = !1;
+  constructor(t) {
+    this.mode = t.mode, this.batchSize = t.batchSize, this.workerCount = this.mode === "gpu" ? 1 : Math.max(1, t.workerThreads), this.stride = this.mode === "gpu" ? BigInt(this.batchSize) : BigInt(this.batchSize) * BigInt(this.workerCount), this.listeners = {
+      ready: /* @__PURE__ */ new Set(),
+      progress: /* @__PURE__ */ new Set(),
+      found: /* @__PURE__ */ new Set(),
+      error: /* @__PURE__ */ new Set(),
+      stopped: /* @__PURE__ */ new Set()
+    }, this.abortHandler = () => this.stop(), this.readyPromise = this.spawnWorkers();
+  }
+  on(t, e) {
+    this.listeners[t].add(e);
+  }
+  off(t, e) {
+    this.listeners[t].delete(e);
+  }
+  emit(t, e) {
+    this.listeners[t].forEach((r) => r(e));
+  }
+  async spawnWorkers() {
+    const t = [];
+    for (let e = 0; e < this.workerCount; e += 1) {
+      const r = new Worker(new URL(
+        /* @vite-ignore */
+        "/worker.js",
+        import.meta.url
+      ), {
+        type: "module",
+        /* @vite-ignore */
+        name: `zeldminer-worker-${e}`
+      }), n = {
+        worker: r,
+        hashesProcessed: 0n,
+        hashRate: 0,
+        nextNonce: 0n,
+        processedBase: 0n
+      };
+      this.workers.push(n), t.push(
+        new Promise((a) => {
+          const h = (c) => {
+            c.data.type === "ready" && (r.removeEventListener("message", h), a());
+          };
+          r.addEventListener("message", h);
+        })
+      ), r.addEventListener(
+        "message",
+        (a) => this.handleWorkerMessage(n, a.data)
+      );
+      const i = { type: "init", mode: this.mode };
+      r.postMessage(i);
+    }
+    await Promise.all(t), this.emit("ready", void 0);
+  }
+  handleWorkerMessage(t, e) {
+    switch (e.type) {
+      case "ready":
+        break;
+      case "progress":
+        t.hashesProcessed = t.processedBase + e.hashesProcessed, t.hashRate = e.hashRate, t.lastNonce = e.lastNonce ?? t.lastNonce, this.emitProgress();
+        break;
+      case "batch_complete":
+        t.lastNonce = e.lastNonce, t.nextNonce = this.computeNextNonce(e.lastNonce);
+        break;
+      case "found":
+        t.hashesProcessed = t.processedBase + (e.hashesProcessed ?? t.hashesProcessed), t.hashRate = e.hashRate ?? t.hashRate, t.lastNonce = e.lastNonce ?? t.lastNonce;
+        const r = this.workers.reduce(
+          (h, c) => h + c.hashesProcessed,
+          0n
+        ), n = this.startedAt ? performance.now() - this.startedAt : 0, i = n > 0 ? k(r) / (n / 1e3) : 0, a = {
+          ...e.result,
+          attempts: r,
+          duration: n,
+          hashRate: i
+        };
+        this.running = !1, this.paused = !1, this.terminateWorkers(), this.cleanupExternalAbort(), this.emit("found", a);
+        break;
+      case "error":
+        this.running = !1, this.paused = !1, this.terminateWorkers(), this.cleanupExternalAbort(), this.emit(
+          "error",
+          new _(
+            e.code ?? o.WORKER_ERROR,
+            e.message,
+            {
+              workerId: e.workerId,
+              ...e.details ?? {}
+            }
+          )
+        );
+        break;
+    }
+  }
+  emitProgress() {
+    if (!this.running) return;
+    const t = this.workers.reduce(
+      (i, a) => i + a.hashesProcessed,
+      0n
+    ), e = this.startedAt ? performance.now() - this.startedAt : 0, r = e > 0 ? k(t) / (e / 1e3) : 0, n = {
+      hashesProcessed: t,
+      hashRate: r,
+      elapsedMs: e
+    };
+    this.emit("progress", n);
+  }
+  computeNextNonce(t) {
+    const e = this.stride - BigInt(this.batchSize);
+    return t + 1n + e;
+  }
+  stopWorkers() {
+    this.terminated || this.workers.forEach(
+      (t) => t.worker.postMessage({ type: "stop" })
+    );
+  }
+  terminateWorkers() {
+    this.terminated || (this.stopWorkers(), this.workers.forEach((t) => {
+      try {
+        t.worker.terminate(), t.terminated = !0;
+      } catch {
+      }
+    }), this.terminated = !0);
+  }
+  async start(t) {
+    if (await this.readyPromise, this.stopWorkers(), this.running = !0, this.paused = !1, this.startedAt = performance.now(), this.txInputs = t.inputs, this.txOutputs = t.outputs, this.txNetwork = t.network === "signet" ? "testnet" : t.network, this.satsPerVbyte = t.satsPerVbyte, this.template = t.template, this.targetZeros = t.targetZeros, this.startNonce = t.startNonce ?? 0n, this.txDistribution = t.distribution, this.externalAbort && this.externalAbort !== t.signal && this.cleanupExternalAbort(), t.signal && (this.externalAbort = t.signal, t.signal.addEventListener("abort", this.abortHandler, { once: !0 })), !this.template || !this.txInputs || !this.txOutputs || this.targetZeros === void 0 || this.satsPerVbyte === void 0 || !this.txNetwork)
+      throw new Error("Mining parameters are missing");
+    const e = this.txInputs, r = this.txOutputs, n = this.txNetwork, i = this.satsPerVbyte, a = this.template, h = this.targetZeros, c = this.txDistribution, p = this.stride;
+    this.workers.forEach((l, d) => {
+      l.processedBase = 0n, l.hashesProcessed = 0n, l.hashRate = 0, l.lastNonce = void 0;
+      const m = this.startNonce + BigInt(d) * BigInt(this.batchSize);
+      l.nextNonce = m;
+      const w = {
+        type: "mine",
+        inputs: e,
+        outputs: r,
+        network: n,
+        satsPerVbyte: i,
+        template: a,
+        startNonce: m,
+        batchSize: this.batchSize,
+        targetZeros: h,
+        nonceStep: p,
+        distribution: c
+      };
+      l.worker.postMessage(w);
+    });
+  }
+  pause() {
+    this.running && (this.running = !1, this.paused = !0, this.stopWorkers());
+  }
+  async resume() {
+    if (!this.paused || !this.template || !this.txInputs || !this.txOutputs || this.targetZeros === void 0 || this.satsPerVbyte === void 0 || !this.txNetwork)
+      return;
+    await this.readyPromise, this.running = !0, this.paused = !1, this.startedAt || (this.startedAt = performance.now());
+    const t = this.txInputs, e = this.txOutputs, r = this.txNetwork, n = this.satsPerVbyte, i = this.template, a = this.targetZeros, h = this.txDistribution, c = this.stride;
+    this.workers.forEach((p, l) => {
+      p.processedBase = p.hashesProcessed, p.hashRate = 0;
+      const d = p.nextNonce || this.startNonce + BigInt(l) * BigInt(this.batchSize), m = {
+        type: "mine",
+        inputs: t,
+        outputs: e,
+        network: r,
+        satsPerVbyte: n,
+        template: i,
+        startNonce: d,
+        batchSize: this.batchSize,
+        targetZeros: a,
+        nonceStep: c,
+        distribution: h
+      };
+      p.worker.postMessage(m);
+    });
+  }
+  stop() {
+    !this.running && !this.paused || (this.running = !1, this.paused = !1, this.terminateWorkers(), this.cleanupExternalAbort(), this.emit("stopped", void 0));
+  }
+}
+const q = {};
+let P = null, N = null, D = !1;
+const Z = () => {
+  if (D) return;
+  D = !0;
+  const s = globalThis.GPUAdapter?.prototype, t = s?.requestDevice;
+  !s || typeof t != "function" || (s.requestDevice = function(r) {
+    if (r?.requiredLimits && typeof this.limits == "object") {
+      const n = r.requiredLimits, i = this.limits;
+      for (const a of Object.keys(n))
+        (!(a in i) || i[a] === void 0) && delete n[a];
+    }
+    return t.call(this, r);
+  });
+}, S = (s) => s.endsWith("/") ? s : `${s}/`, A = (s) => {
+  const t = s.trim();
+  return t && (typeof window < "u" && typeof window.location?.origin == "string" ? S(new URL(t, window.location.origin).href) : S(new URL(t, import.meta.url).href));
+}, H = () => {
+  const s = globalThis.__ZELDMINER_WASM_BASE__;
+  if (typeof s == "string" && s.trim())
+    return A(s);
+  const t = q?.VITE_ZELDMINER_WASM_BASE;
+  if (typeof t == "string" && t.trim())
+    return A(t);
+  const e = "/";
+  return e.trim() ? A(`${S(e.trim())}wasm/`) : A("/wasm/");
+}, W = H(), L = `${W}zeldhash_miner_wasm.js`, X = `${W}zeldhash_miner_wasm_bg.wasm`, v = (s) => s instanceof Error ? s.message : String(s), K = async () => {
+  Z();
+  let s;
+  try {
+    s = await import(
+      /* @vite-ignore */
+      L
+    );
+  } catch (r) {
+    throw new Error(
+      `Failed to import WASM bundle (${L}). Did you run ./scripts/build-wasm.sh? (${v(r)})`
+    );
+  }
+  const t = s.default;
+  if (typeof t != "function")
+    throw new Error("WASM init function is missing from the bundle.");
+  try {
+    const r = new URL(X, import.meta.url);
+    await t(r);
+  } catch (r) {
+    throw new Error(
+      `Failed to initialize WASM bundle: ${v(r)}`
+    );
+  }
+  const e = s;
+  try {
+    e.init_panic_hook?.();
+  } catch {
+  }
+  return e;
+}, j = async () => P || (N || (N = K().then((s) => (P = s, s)).catch((s) => {
+  throw N = null, s;
+})), N), E = (1n << 64n) - 1n, z = (s) => {
+  if (s < 0n)
+    throw new Error("nonce must be non-negative");
+  if (s === 0n) return 1;
+  let t = 0, e = s;
+  for (; e > 0n; )
+    t += 1, e >>= 8n;
+  return t;
+}, F = (s) => {
+  if (s < 0n)
+    throw new Error("nonce must be non-negative");
+  if (s <= 23n) return 1;
+  if (s <= 0xffn) return 2;
+  if (s <= 0xffffn) return 3;
+  if (s <= 0xffffffffn) return 5;
+  if (s <= E) return 9;
+  throw new Error("nonce range exceeds u64");
+}, Y = (s) => {
+  if (!Number.isInteger(s) || s <= 0 || s > 8)
+    throw new Error("nonceLength must be between 1 and 8");
+  return (1n << BigInt(s * 8)) - 1n;
+}, J = (s) => {
+  switch (s) {
+    case 1:
+      return 23n;
+    case 2:
+      return 0xffn;
+    case 3:
+      return 0xffffn;
+    case 5:
+      return 0xffffffffn;
+    case 9:
+      return E;
+    default:
+      throw new Error("cbor nonceLength must be one of 1, 2, 3, 5, 9");
+  }
+}, Q = (s, t) => {
+  if (s < 0n)
+    throw new Error("startNonce must be non-negative");
+  if (!Number.isInteger(t) || t <= 0)
+    throw new Error("batchSize must be a positive integer");
+  const e = s + BigInt(t - 1);
+  if (e > E)
+    throw new Error("nonce range exceeds u64");
+  const r = [];
+  let n = s;
+  for (; n <= e; ) {
+    const i = z(n), a = Y(i), h = e < a ? e : a, c = h - n + 1n;
+    if (c > BigInt(Number.MAX_SAFE_INTEGER))
+      throw new Error("segment size exceeds safe integer range");
+    if (r.push({
+      start: n,
+      size: Number(c),
+      nonceLength: i
+    }), h === e)
+      break;
+    n = h + 1n;
+  }
+  return r;
+}, tt = (s, t) => {
+  if (s < 0n)
+    throw new Error("startNonce must be non-negative");
+  if (!Number.isInteger(t) || t <= 0)
+    throw new Error("batchSize must be a positive integer");
+  const e = s + BigInt(t - 1);
+  if (e > E)
+    throw new Error("nonce range exceeds u64");
+  const r = [];
+  let n = s;
+  for (; n <= e; ) {
+    const i = F(n), a = J(i), h = e < a ? e : a, c = h - n + 1n;
+    if (c > BigInt(Number.MAX_SAFE_INTEGER))
+      throw new Error("segment size exceeds safe integer range");
+    if (r.push({
+      start: n,
+      size: Number(c),
+      nonceLength: i
+    }), h === e)
+      break;
+    n = h + 1n;
+  }
+  return r;
+}, et = /^[0-9a-fA-F]{64}$/, st = /^[0-9a-fA-F]+$/, T = (1n << 64n) - 1n, rt = 4294967295, nt = (s) => s === "p2tr" ? 330 : s === "p2wpkh" ? 310 : 546, it = (s) => s instanceof Error ? s.message : String(s), x = (s, t) => t.some((e) => s.includes(e)), O = (s, t, e) => {
+  const r = it(s), n = r.toLowerCase();
+  throw x(n, ["insufficient funds", "insufficient_funds"]) ? u(
+    o.INSUFFICIENT_FUNDS,
+    "Insufficient funds for outputs and fee",
+    { ...e, cause: r }
+  ) : x(n, ["change would be dust", "output amount below dust limit", "dust"]) ? u(
+    o.DUST_OUTPUT,
+    "Change would be dust",
+    { ...e, cause: r }
+  ) : M(s, o.WORKER_ERROR, {
+    ...e,
+    context: t
+  });
+}, y = (s) => s === "signet" ? "testnet" : s;
+class ot {
+  network;
+  satsPerVbyte;
+  constructor(t, e) {
+    if (!Number.isFinite(e) || e <= 0)
+      throw u(
+        o.INVALID_INPUT,
+        "satsPerVbyte must be a positive number",
+        { field: "satsPerVbyte" }
+      );
+    this.network = t, this.satsPerVbyte = e;
+  }
+  async getWasm() {
+    return j();
+  }
+  assertNonceRange(t, e, r) {
+    if (t < 0n || t > T)
+      throw u(
+        o.INVALID_INPUT,
+        "startNonce must be between 0 and 2^64 - 1",
+        { startNonce: t }
+      );
+    if (!Number.isInteger(e) || e <= 0 || e > rt)
+      throw u(
+        o.INVALID_INPUT,
+        "batchSize must be a positive 32-bit integer",
+        { batchSize: e }
+      );
+    const n = t + BigInt(e - 1);
+    if (n > T)
+      throw u(
+        o.INVALID_INPUT,
+        "nonce range exceeds u64",
+        { startNonce: t, batchSize: e }
+      );
+    const i = r ? F : z, a = i(t), h = i(n);
+    if (a !== h) {
+      const c = r ? "CBOR length" : "byte-length";
+      throw u(
+        o.INVALID_INPUT,
+        `nonce range crosses ${c} boundary; reduce batch size`,
+        { startNonce: t, batchSize: e }
+      );
+    }
+    return a;
+  }
+  cloneInputs(t) {
+    return t.map((e) => ({ ...e }));
+  }
+  cloneOutputs(t) {
+    return t.map((e) => ({ ...e }));
+  }
+  validateInputs(t) {
+    if (!Array.isArray(t) || t.length === 0)
+      throw u(
+        o.INVALID_INPUT,
+        "At least one input is required"
+      );
+    t.forEach((e, r) => {
+      if (!et.test(e.txid))
+        throw u(
+          o.INVALID_INPUT,
+          `inputs[${r}].txid must be a 64-character hex`,
+          { index: r }
+        );
+      if (!Number.isInteger(e.vout) || e.vout < 0)
+        throw u(
+          o.INVALID_INPUT,
+          `inputs[${r}].vout must be a non-negative integer`,
+          { index: r }
+        );
+      if (!Number.isInteger(e.amount) || e.amount <= 0)
+        throw u(
+          o.INVALID_INPUT,
+          `inputs[${r}].amount must be a positive integer`,
+          { index: r }
+        );
+      if (typeof e.scriptPubKey != "string" || e.scriptPubKey.length === 0 || e.scriptPubKey.length % 2 !== 0 || !st.test(e.scriptPubKey))
+        throw u(
+          o.INVALID_INPUT,
+          `inputs[${r}].scriptPubKey must be valid hex`,
+          { index: r }
+        );
+    });
+  }
+  validateAddressResult(t, e, r) {
+    if (!t.ok) {
+      const n = t.error ?? "invalid address", a = n.toLowerCase().includes("unsupported") ? o.UNSUPPORTED_ADDRESS_TYPE : o.INVALID_ADDRESS;
+      throw u(
+        a,
+        `outputs[${e}].address is invalid (${n})`,
+        { index: e }
+      );
+    }
+    if (t.network && t.network !== r && !(t.network === "testnet" && r === "signet"))
+      throw u(
+        o.INVALID_ADDRESS,
+        `outputs[${e}].address network mismatch`,
+        { index: e }
+      );
+    if (t.addressType && t.addressType !== "p2tr" && t.addressType !== "p2wpkh")
+      throw u(
+        o.UNSUPPORTED_ADDRESS_TYPE,
+        `outputs[${e}].address uses an unsupported type`,
+        { index: e, addressType: t.addressType }
+      );
+  }
+  async validateOutputs(t) {
+    if (!Array.isArray(t) || t.length === 0)
+      throw u(
+        o.INVALID_INPUT,
+        "At least one output is required"
+      );
+    const e = t.filter((i) => i.change).length;
+    if (e !== 1) {
+      const i = e === 0 ? o.NO_CHANGE_OUTPUT : o.MULTIPLE_CHANGE_OUTPUTS;
+      throw u(
+        i,
+        "Exactly one change output is required",
+        { changeCount: e }
+      );
+    }
+    const r = await this.getWasm(), n = y(this.network);
+    t.forEach((i, a) => {
+      const h = r.validate_address(i.address, n);
+      this.validateAddressResult(h, a, n);
+      const c = nt(h.addressType);
+      if (i.change) {
+        if (i.amount !== void 0 && (!Number.isInteger(i.amount) || i.amount < 0))
+          throw u(
+            o.INVALID_INPUT,
+            `outputs[${a}].amount must be a non-negative integer when provided`,
+            { index: a }
+          );
+      } else if (!Number.isInteger(i.amount) || i.amount < c)
+        throw u(
+          o.DUST_OUTPUT,
+          `outputs[${a}].amount must be at least ${c} sats`,
+          { index: a, addressType: h.addressType }
+        );
+    });
+  }
+  validateDistribution(t, e) {
+    if (e !== void 0) {
+      if (!Array.isArray(e))
+        throw u(
+          o.INVALID_INPUT,
+          "distribution must be an array of bigint values"
+        );
+      if (e.length !== t.length)
+        throw u(
+          o.INVALID_INPUT,
+          "distribution length must match number of outputs",
+          { expected: t.length, actual: e.length }
+        );
+      return e.map((r, n) => {
+        if (typeof r != "bigint")
+          throw u(
+            o.INVALID_INPUT,
+            "distribution values must be bigint",
+            { index: n }
+          );
+        if (r < 0n)
+          throw u(
+            o.INVALID_INPUT,
+            "distribution values must be non-negative",
+            { index: n }
+          );
+        return r;
+      });
+    }
+  }
+  async buildMiningTemplate(t) {
+    const { inputs: e, outputs: r, startNonce: n, batchSize: i, distribution: a } = t;
+    this.validateInputs(e), await this.validateOutputs(r);
+    const h = this.validateDistribution(r, a), c = Array.isArray(h), p = this.assertNonceRange(n, i, c), l = await this.getWasm();
+    try {
+      const d = l.build_mining_template(
+        this.cloneInputs(e),
+        this.cloneOutputs(r),
+        y(this.network),
+        BigInt(this.satsPerVbyte),
+        n,
+        i,
+        h ?? null
+      );
+      if (!d || !(d.prefix instanceof Uint8Array) || !(d.suffix instanceof Uint8Array))
+        throw u(
+          o.WORKER_ERROR,
+          "WASM returned an invalid mining template"
+        );
+      const m = d.useCborNonce ?? c;
+      return { ...d, nonceLength: p, useCborNonce: m };
+    } catch (d) {
+      throw O(d, "build_mining_template", {
+        startNonce: n,
+        batchSize: i,
+        distribution: h
+      });
+    }
+  }
+  async buildPsbt(t) {
+    const { inputs: e, outputs: r, nonce: n, distribution: i } = t;
+    this.validateInputs(e), await this.validateOutputs(r);
+    const a = this.validateDistribution(r, i);
+    if (n < 0n || n > T)
+      throw u(
+        o.INVALID_INPUT,
+        "nonce must be between 0 and 2^64 - 1",
+        { nonce: n }
+      );
+    const h = await this.getWasm();
+    try {
+      return h.build_psbt(
+        this.cloneInputs(e),
+        this.cloneOutputs(r),
+        y(this.network),
+        BigInt(this.satsPerVbyte),
+        n,
+        a ?? null
+      );
+    } catch (c) {
+      throw O(c, "build_psbt", { nonce: n, distribution: a });
+    }
+  }
+}
+const V = 1, B = 32;
+class at {
+  options;
+  builder;
+  coordinator = null;
+  listeners;
+  state = "idle";
+  stopRequested = !1;
+  constructor(t) {
+    this.options = this.validateOptions(t), this.builder = new ot(t.network, t.satsPerVbyte), this.listeners = {
+      progress: /* @__PURE__ */ new Set(),
+      found: /* @__PURE__ */ new Set(),
+      error: /* @__PURE__ */ new Set(),
+      stopped: /* @__PURE__ */ new Set()
+    };
+  }
+  on(t, e) {
+    this.listeners[t].add(e);
+  }
+  off(t, e) {
+    this.listeners[t].delete(e);
+  }
+  emit(t, e) {
+    this.listeners[t].forEach((r) => r(e));
+  }
+  validateOptions(t) {
+    if (!Number.isInteger(t.batchSize) || t.batchSize <= 0)
+      throw u(
+        o.INVALID_INPUT,
+        "batchSize must be a positive integer",
+        { field: "batchSize" }
+      );
+    if (!Number.isInteger(t.workerThreads) || t.workerThreads <= 0)
+      throw u(
+        o.INVALID_INPUT,
+        "workerThreads must be a positive integer",
+        { field: "workerThreads" }
+      );
+    if (!Number.isFinite(t.satsPerVbyte) || t.satsPerVbyte <= 0)
+      throw u(
+        o.INVALID_INPUT,
+        "satsPerVbyte must be a positive number",
+        { field: "satsPerVbyte" }
+      );
+    return t;
+  }
+  async selectBackend() {
+    if (!this.options.useWebGPU || typeof navigator > "u") return "cpu";
+    const t = navigator.gpu;
+    return (typeof t?.requestAdapter == "function" ? await t.requestAdapter() : null) ? "gpu" : "cpu";
+  }
+  clearCoordinatorHandlers(t, e) {
+    e.progress && t.off("progress", e.progress), e.found && t.off("found", e.found), e.error && t.off("error", e.error), e.stopped && t.off("stopped", e.stopped);
+  }
+  async mineTransaction(t) {
+    if (this.state === "running")
+      throw u(
+        o.INVALID_INPUT,
+        "Mining is already in progress"
+      );
+    if (!Number.isInteger(t.targetZeros) || t.targetZeros < V || t.targetZeros > B)
+      throw u(
+        o.INVALID_INPUT,
+        `targetZeros must be an integer between ${V} and ${B}`,
+        { targetZeros: t.targetZeros }
+      );
+    const e = t.startNonce ?? 0n, r = t.batchSize ?? this.options.batchSize;
+    if (!Number.isInteger(r) || r <= 0)
+      throw u(
+        o.INVALID_INPUT,
+        "batchSize must be a positive integer",
+        { batchSize: r }
+      );
+    if (t.signal?.aborted)
+      throw u(
+        o.MINING_ABORTED,
+        "Abort signal already triggered"
+      );
+    const n = t.distribution, i = !!(n && n.length > 0);
+    let a = r;
+    try {
+      const [d] = i ? tt(e, r) : Q(e, r);
+      if (!d)
+        throw u(
+          o.INVALID_INPUT,
+          "Failed to compute nonce segments",
+          { startNonce: e, batchSize: r }
+        );
+      a = d.size;
+    } catch (d) {
+      throw u(
+        o.INVALID_INPUT,
+        d instanceof Error ? d.message : String(d),
+        { startNonce: e, batchSize: r }
+      );
+    }
+    const h = await this.selectBackend(), c = await this.builder.buildMiningTemplate({
+      inputs: t.inputs,
+      outputs: t.outputs,
+      startNonce: e,
+      batchSize: a,
+      distribution: n
+    }), p = this.options.network === "signet" ? "testnet" : this.options.network, l = new C({
+      mode: h,
+      batchSize: r,
+      workerThreads: this.options.workerThreads
+    });
+    return this.coordinator = l, this.state = "running", this.stopRequested = !1, new Promise((d, m) => {
+      let w = !1;
+      const R = () => {
+        this.clearCoordinatorHandlers(l, g), this.coordinator === l && (this.coordinator = null), this.state = "idle", this.stopRequested = !1;
+      }, G = (f) => {
+        w || (w = !0, R(), d(f));
+      }, I = (f) => {
+        if (w) return;
+        w = !0;
+        const b = M(f);
+        R(), this.emit("error", b), m(b);
+      }, g = {};
+      g.progress = (f) => {
+        this.emit("progress", f);
+      }, g.found = async (f) => {
+        try {
+          const b = await this.builder.buildPsbt({
+            inputs: t.inputs,
+            outputs: t.outputs,
+            nonce: f.nonce,
+            distribution: n
+          }), U = { ...f, psbt: b };
+          this.emit("found", U), G(U);
+        } catch (b) {
+          I(b);
+        }
+      }, g.error = (f) => {
+        I(f);
+      }, g.stopped = () => {
+        if (w) return;
+        const f = this.stopRequested ? u(
+          o.MINING_ABORTED,
+          "Mining stopped by caller"
+        ) : u(
+          o.MINING_ABORTED,
+          "Mining halted"
+        );
+        this.emit("stopped", void 0), I(f);
+      }, l.on("progress", g.progress), l.on("found", g.found), l.on("error", g.error), l.on("stopped", g.stopped), l.start({
+        inputs: t.inputs,
+        outputs: t.outputs,
+        network: p,
+        satsPerVbyte: this.options.satsPerVbyte,
+        template: c,
+        targetZeros: t.targetZeros,
+        startNonce: e,
+        signal: t.signal,
+        distribution: n
+      }).catch(I);
+    });
+  }
+  stop() {
+    this.coordinator && (this.stopRequested = !0, this.coordinator.stop());
+  }
+  pause() {
+    this.state !== "running" || !this.coordinator || (this.state = "paused", this.coordinator.pause());
+  }
+  async resume() {
+    this.state !== "paused" || !this.coordinator || (this.state = "running", await this.coordinator.resume());
+  }
+}
+export {
+  C as MiningCoordinator,
+  ot as TransactionBuilder,
+  at as ZeldMiner,
+  _ as ZeldMinerError,
+  o as ZeldMinerErrorCode,
+  u as createMinerError,
+  M as toZeldMinerError
+};
+//# sourceMappingURL=index.js.map