zattera-js 0.1.0

package/dist/browser/index.js

@@ -0,0 +1,2466 @@
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function Pe(e) {
+  return e instanceof Uint8Array || ArrayBuffer.isView(e) && e.constructor.name === "Uint8Array";
+}
+function Kt(e, ...t) {
+  if (!Pe(e))
+    throw new Error("Uint8Array expected");
+  if (t.length > 0 && !t.includes(e.length))
+    throw new Error("Uint8Array expected of length " + t + ", got length=" + e.length);
+}
+function $t(e, t = !0) {
+  if (e.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (t && e.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function Ke(e, t) {
+  Kt(e);
+  const n = t.outputLen;
+  if (e.length < n)
+    throw new Error("digestInto() expects output buffer of length at least " + n);
+}
+function J(...e) {
+  for (let t = 0; t < e.length; t++)
+    e[t].fill(0);
+}
+function Ct(e) {
+  return new DataView(e.buffer, e.byteOffset, e.byteLength);
+}
+function C(e, t) {
+  return e << 32 - t | e >>> t;
+}
+function wt(e, t) {
+  return e << t | e >>> 32 - t >>> 0;
+}
+function Me(e) {
+  if (typeof e != "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(e));
+}
+function ae(e) {
+  return typeof e == "string" && (e = Me(e)), Kt(e), e;
+}
+class Ve {
+}
+function Mt(e) {
+  const t = (s) => e().update(ae(s)).digest(), n = e();
+  return t.outputLen = n.outputLen, t.blockLen = n.blockLen, t.create = () => e(), t;
+}
+function We(e, t, n, s) {
+  if (typeof e.setBigUint64 == "function")
+    return e.setBigUint64(t, n, s);
+  const r = BigInt(32), i = BigInt(4294967295), o = Number(n >> r & i), u = Number(n & i), a = s ? 4 : 0, c = s ? 0 : 4;
+  e.setUint32(t + a, o, s), e.setUint32(t + c, u, s);
+}
+function Le(e, t, n) {
+  return e & t ^ ~e & n;
+}
+function Ye(e, t, n) {
+  return e & t ^ e & n ^ t & n;
+}
+class Vt extends Ve {
+  constructor(t, n, s, r) {
+    super(), this.finished = !1, this.length = 0, this.pos = 0, this.destroyed = !1, this.blockLen = t, this.outputLen = n, this.padOffset = s, this.isLE = r, this.buffer = new Uint8Array(t), this.view = Ct(this.buffer);
+  }
+  update(t) {
+    $t(this), t = ae(t), Kt(t);
+    const { view: n, buffer: s, blockLen: r } = this, i = t.length;
+    for (let o = 0; o < i; ) {
+      const u = Math.min(r - this.pos, i - o);
+      if (u === r) {
+        const a = Ct(t);
+        for (; r <= i - o; o += r)
+          this.process(a, o);
+        continue;
+      }
+      s.set(t.subarray(o, o + u), this.pos), this.pos += u, o += u, this.pos === r && (this.process(n, 0), this.pos = 0);
+    }
+    return this.length += t.length, this.roundClean(), this;
+  }
+  digestInto(t) {
+    $t(this), Ke(t, this), this.finished = !0;
+    const { buffer: n, view: s, blockLen: r, isLE: i } = this;
+    let { pos: o } = this;
+    n[o++] = 128, J(this.buffer.subarray(o)), this.padOffset > r - o && (this.process(s, 0), o = 0);
+    for (let f = o; f < r; f++)
+      n[f] = 0;
+    We(s, r - 8, BigInt(this.length * 8), i), this.process(s, 0);
+    const u = Ct(t), a = this.outputLen;
+    if (a % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const c = a / 4, h = this.get();
+    if (c > h.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let f = 0; f < c; f++)
+      u.setUint32(4 * f, h[f], i);
+  }
+  digest() {
+    const { buffer: t, outputLen: n } = this;
+    this.digestInto(t);
+    const s = t.slice(0, n);
+    return this.destroy(), s;
+  }
+  _cloneInto(t) {
+    t || (t = new this.constructor()), t.set(...this.get());
+    const { blockLen: n, buffer: s, length: r, finished: i, destroyed: o, pos: u } = this;
+    return t.destroyed = o, t.finished = i, t.length = r, t.pos = u, r % n && t.buffer.set(s), t;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+}
+const M = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]), E = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  4089235720,
+  3144134277,
+  2227873595,
+  1013904242,
+  4271175723,
+  2773480762,
+  1595750129,
+  1359893119,
+  2917565137,
+  2600822924,
+  725511199,
+  528734635,
+  4215389547,
+  1541459225,
+  327033209
+]), xt = /* @__PURE__ */ BigInt(2 ** 32 - 1), Zt = /* @__PURE__ */ BigInt(32);
+function je(e, t = !1) {
+  return t ? { h: Number(e & xt), l: Number(e >> Zt & xt) } : { h: Number(e >> Zt & xt) | 0, l: Number(e & xt) | 0 };
+}
+function Ge(e, t = !1) {
+  const n = e.length;
+  let s = new Uint32Array(n), r = new Uint32Array(n);
+  for (let i = 0; i < n; i++) {
+    const { h: o, l: u } = je(e[i], t);
+    [s[i], r[i]] = [o, u];
+  }
+  return [s, r];
+}
+const Xt = (e, t, n) => e >>> n, Qt = (e, t, n) => e << 32 - n | t >>> n, nt = (e, t, n) => e >>> n | t << 32 - n, st = (e, t, n) => e << 32 - n | t >>> n, mt = (e, t, n) => e << 64 - n | t >>> n - 32, At = (e, t, n) => e >>> n - 32 | t << 64 - n;
+function D(e, t, n, s) {
+  const r = (t >>> 0) + (s >>> 0);
+  return { h: e + n + (r / 2 ** 32 | 0) | 0, l: r | 0 };
+}
+const ze = (e, t, n) => (e >>> 0) + (t >>> 0) + (n >>> 0), $e = (e, t, n, s) => t + n + s + (e / 2 ** 32 | 0) | 0, Ze = (e, t, n, s) => (e >>> 0) + (t >>> 0) + (n >>> 0) + (s >>> 0), Xe = (e, t, n, s, r) => t + n + s + r + (e / 2 ** 32 | 0) | 0, Qe = (e, t, n, s, r) => (e >>> 0) + (t >>> 0) + (n >>> 0) + (s >>> 0) + (r >>> 0), Je = (e, t, n, s, r, i) => t + n + s + r + i + (e / 2 ** 32 | 0) | 0, tn = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]), V = /* @__PURE__ */ new Uint32Array(64);
+class en extends Vt {
+  constructor(t = 32) {
+    super(64, t, 8, !1), this.A = M[0] | 0, this.B = M[1] | 0, this.C = M[2] | 0, this.D = M[3] | 0, this.E = M[4] | 0, this.F = M[5] | 0, this.G = M[6] | 0, this.H = M[7] | 0;
+  }
+  get() {
+    const { A: t, B: n, C: s, D: r, E: i, F: o, G: u, H: a } = this;
+    return [t, n, s, r, i, o, u, a];
+  }
+  // prettier-ignore
+  set(t, n, s, r, i, o, u, a) {
+    this.A = t | 0, this.B = n | 0, this.C = s | 0, this.D = r | 0, this.E = i | 0, this.F = o | 0, this.G = u | 0, this.H = a | 0;
+  }
+  process(t, n) {
+    for (let f = 0; f < 16; f++, n += 4)
+      V[f] = t.getUint32(n, !1);
+    for (let f = 16; f < 64; f++) {
+      const l = V[f - 15], d = V[f - 2], y = C(l, 7) ^ C(l, 18) ^ l >>> 3, b = C(d, 17) ^ C(d, 19) ^ d >>> 10;
+      V[f] = b + V[f - 7] + y + V[f - 16] | 0;
+    }
+    let { A: s, B: r, C: i, D: o, E: u, F: a, G: c, H: h } = this;
+    for (let f = 0; f < 64; f++) {
+      const l = C(u, 6) ^ C(u, 11) ^ C(u, 25), d = h + l + Le(u, a, c) + tn[f] + V[f] | 0, b = (C(s, 2) ^ C(s, 13) ^ C(s, 22)) + Ye(s, r, i) | 0;
+      h = c, c = a, a = u, u = o + d | 0, o = i, i = r, r = s, s = d + b | 0;
+    }
+    s = s + this.A | 0, r = r + this.B | 0, i = i + this.C | 0, o = o + this.D | 0, u = u + this.E | 0, a = a + this.F | 0, c = c + this.G | 0, h = h + this.H | 0, this.set(s, r, i, o, u, a, c, h);
+  }
+  roundClean() {
+    J(V);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0), J(this.buffer);
+  }
+}
+const ue = Ge([
+  "0x428a2f98d728ae22",
+  "0x7137449123ef65cd",
+  "0xb5c0fbcfec4d3b2f",
+  "0xe9b5dba58189dbbc",
+  "0x3956c25bf348b538",
+  "0x59f111f1b605d019",
+  "0x923f82a4af194f9b",
+  "0xab1c5ed5da6d8118",
+  "0xd807aa98a3030242",
+  "0x12835b0145706fbe",
+  "0x243185be4ee4b28c",
+  "0x550c7dc3d5ffb4e2",
+  "0x72be5d74f27b896f",
+  "0x80deb1fe3b1696b1",
+  "0x9bdc06a725c71235",
+  "0xc19bf174cf692694",
+  "0xe49b69c19ef14ad2",
+  "0xefbe4786384f25e3",
+  "0x0fc19dc68b8cd5b5",
+  "0x240ca1cc77ac9c65",
+  "0x2de92c6f592b0275",
+  "0x4a7484aa6ea6e483",
+  "0x5cb0a9dcbd41fbd4",
+  "0x76f988da831153b5",
+  "0x983e5152ee66dfab",
+  "0xa831c66d2db43210",
+  "0xb00327c898fb213f",
+  "0xbf597fc7beef0ee4",
+  "0xc6e00bf33da88fc2",
+  "0xd5a79147930aa725",
+  "0x06ca6351e003826f",
+  "0x142929670a0e6e70",
+  "0x27b70a8546d22ffc",
+  "0x2e1b21385c26c926",
+  "0x4d2c6dfc5ac42aed",
+  "0x53380d139d95b3df",
+  "0x650a73548baf63de",
+  "0x766a0abb3c77b2a8",
+  "0x81c2c92e47edaee6",
+  "0x92722c851482353b",
+  "0xa2bfe8a14cf10364",
+  "0xa81a664bbc423001",
+  "0xc24b8b70d0f89791",
+  "0xc76c51a30654be30",
+  "0xd192e819d6ef5218",
+  "0xd69906245565a910",
+  "0xf40e35855771202a",
+  "0x106aa07032bbd1b8",
+  "0x19a4c116b8d2d0c8",
+  "0x1e376c085141ab53",
+  "0x2748774cdf8eeb99",
+  "0x34b0bcb5e19b48a8",
+  "0x391c0cb3c5c95a63",
+  "0x4ed8aa4ae3418acb",
+  "0x5b9cca4f7763e373",
+  "0x682e6ff3d6b2b8a3",
+  "0x748f82ee5defb2fc",
+  "0x78a5636f43172f60",
+  "0x84c87814a1f0ab72",
+  "0x8cc702081a6439ec",
+  "0x90befffa23631e28",
+  "0xa4506cebde82bde9",
+  "0xbef9a3f7b2c67915",
+  "0xc67178f2e372532b",
+  "0xca273eceea26619c",
+  "0xd186b8c721c0c207",
+  "0xeada7dd6cde0eb1e",
+  "0xf57d4f7fee6ed178",
+  "0x06f067aa72176fba",
+  "0x0a637dc5a2c898a6",
+  "0x113f9804bef90dae",
+  "0x1b710b35131c471b",
+  "0x28db77f523047d84",
+  "0x32caab7b40c72493",
+  "0x3c9ebe0a15c9bebc",
+  "0x431d67c49c100d4c",
+  "0x4cc5d4becb3e42b6",
+  "0x597f299cfc657e2a",
+  "0x5fcb6fab3ad6faec",
+  "0x6c44198c4a475817"
+].map((e) => BigInt(e))), nn = ue[0], sn = ue[1], W = /* @__PURE__ */ new Uint32Array(80), L = /* @__PURE__ */ new Uint32Array(80);
+class rn extends Vt {
+  constructor(t = 64) {
+    super(128, t, 16, !1), this.Ah = E[0] | 0, this.Al = E[1] | 0, this.Bh = E[2] | 0, this.Bl = E[3] | 0, this.Ch = E[4] | 0, this.Cl = E[5] | 0, this.Dh = E[6] | 0, this.Dl = E[7] | 0, this.Eh = E[8] | 0, this.El = E[9] | 0, this.Fh = E[10] | 0, this.Fl = E[11] | 0, this.Gh = E[12] | 0, this.Gl = E[13] | 0, this.Hh = E[14] | 0, this.Hl = E[15] | 0;
+  }
+  // prettier-ignore
+  get() {
+    const { Ah: t, Al: n, Bh: s, Bl: r, Ch: i, Cl: o, Dh: u, Dl: a, Eh: c, El: h, Fh: f, Fl: l, Gh: d, Gl: y, Hh: b, Hl: _ } = this;
+    return [t, n, s, r, i, o, u, a, c, h, f, l, d, y, b, _];
+  }
+  // prettier-ignore
+  set(t, n, s, r, i, o, u, a, c, h, f, l, d, y, b, _) {
+    this.Ah = t | 0, this.Al = n | 0, this.Bh = s | 0, this.Bl = r | 0, this.Ch = i | 0, this.Cl = o | 0, this.Dh = u | 0, this.Dl = a | 0, this.Eh = c | 0, this.El = h | 0, this.Fh = f | 0, this.Fl = l | 0, this.Gh = d | 0, this.Gl = y | 0, this.Hh = b | 0, this.Hl = _ | 0;
+  }
+  process(t, n) {
+    for (let p = 0; p < 16; p++, n += 4)
+      W[p] = t.getUint32(n), L[p] = t.getUint32(n += 4);
+    for (let p = 16; p < 80; p++) {
+      const A = W[p - 15] | 0, m = L[p - 15] | 0, F = nt(A, m, 1) ^ nt(A, m, 8) ^ Xt(A, m, 7), at = st(A, m, 1) ^ st(A, m, 8) ^ Qt(A, m, 7), q = W[p - 2] | 0, I = L[p - 2] | 0, _t = nt(q, I, 19) ^ mt(q, I, 61) ^ Xt(q, I, 6), Rt = st(q, I, 19) ^ At(q, I, 61) ^ Qt(q, I, 6), pt = Ze(at, Rt, L[p - 7], L[p - 16]), kt = Xe(pt, F, _t, W[p - 7], W[p - 16]);
+      W[p] = kt | 0, L[p] = pt | 0;
+    }
+    let { Ah: s, Al: r, Bh: i, Bl: o, Ch: u, Cl: a, Dh: c, Dl: h, Eh: f, El: l, Fh: d, Fl: y, Gh: b, Gl: _, Hh: x, Hl: g } = this;
+    for (let p = 0; p < 80; p++) {
+      const A = nt(f, l, 14) ^ nt(f, l, 18) ^ mt(f, l, 41), m = st(f, l, 14) ^ st(f, l, 18) ^ At(f, l, 41), F = f & d ^ ~f & b, at = l & y ^ ~l & _, q = Qe(g, m, at, sn[p], L[p]), I = Je(q, x, A, F, nn[p], W[p]), _t = q | 0, Rt = nt(s, r, 28) ^ mt(s, r, 34) ^ mt(s, r, 39), pt = st(s, r, 28) ^ At(s, r, 34) ^ At(s, r, 39), kt = s & i ^ s & u ^ i & u, Oe = r & o ^ r & a ^ o & a;
+      x = b | 0, g = _ | 0, b = d | 0, _ = y | 0, d = f | 0, y = l | 0, { h: f, l } = D(c | 0, h | 0, I | 0, _t | 0), c = u | 0, h = a | 0, u = i | 0, a = o | 0, i = s | 0, o = r | 0;
+      const zt = ze(_t, pt, Oe);
+      s = $e(zt, I, Rt, kt), r = zt | 0;
+    }
+    ({ h: s, l: r } = D(this.Ah | 0, this.Al | 0, s | 0, r | 0)), { h: i, l: o } = D(this.Bh | 0, this.Bl | 0, i | 0, o | 0), { h: u, l: a } = D(this.Ch | 0, this.Cl | 0, u | 0, a | 0), { h: c, l: h } = D(this.Dh | 0, this.Dl | 0, c | 0, h | 0), { h: f, l } = D(this.Eh | 0, this.El | 0, f | 0, l | 0), { h: d, l: y } = D(this.Fh | 0, this.Fl | 0, d | 0, y | 0), { h: b, l: _ } = D(this.Gh | 0, this.Gl | 0, b | 0, _ | 0), { h: x, l: g } = D(this.Hh | 0, this.Hl | 0, x | 0, g | 0), this.set(s, r, i, o, u, a, c, h, f, l, d, y, b, _, x, g);
+  }
+  roundClean() {
+    J(W, L);
+  }
+  destroy() {
+    J(this.buffer), this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+  }
+}
+const R = /* @__PURE__ */ Mt(() => new en()), fe = /* @__PURE__ */ Mt(() => new rn());
+function on(e) {
+  const t = R(new TextEncoder().encode(e));
+  return Array.from(t).map((n) => n.toString(16).padStart(2, "0")).join("");
+}
+class cs {
+  endpoint;
+  chainId;
+  timeout;
+  retries;
+  requestId;
+  constructor(t) {
+    this.endpoint = t.endpoint, this.chainId = on(t.networkName || "zattera"), this.timeout = t.timeout ?? 3e4, this.retries = t.retries ?? 3, this.requestId = 0;
+  }
+  getNextId() {
+    return ++this.requestId;
+  }
+  /**
+   * Get the configured chain ID
+   */
+  getChainId() {
+    return this.chainId;
+  }
+  /**
+   * Internal method to make JSON-RPC 2.0 requests with retry logic
+   */
+  async request(t, n = {}) {
+    const s = {
+      jsonrpc: "2.0",
+      method: t,
+      params: n,
+      id: this.getNextId()
+    };
+    let r = null;
+    for (let i = 0; i <= this.retries; i++)
+      try {
+        const o = new AbortController(), u = setTimeout(() => o.abort(), this.timeout), a = await fetch(this.endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(s),
+          signal: o.signal
+        });
+        if (clearTimeout(u), !a.ok)
+          throw new Error(`HTTP error! status: ${a.status}`);
+        const c = await a.json();
+        if (c.error)
+          throw new Error(
+            `RPC error ${c.error.code}: ${c.error.message}`
+          );
+        if (c.result === void 0)
+          throw new Error("No result in RPC response");
+        return c.result;
+      } catch (o) {
+        r = o instanceof Error ? o : new Error(String(o)), i < this.retries && await new Promise(
+          (u) => setTimeout(u, 1e3 * Math.pow(2, i))
+        );
+      }
+    throw r ?? new Error("Request failed");
+  }
+  /**
+   * Make batch JSON-RPC requests
+   */
+  async batch(t) {
+    const n = t.map((r) => ({
+      jsonrpc: "2.0",
+      method: r.method,
+      params: r.params ?? {},
+      id: this.getNextId()
+    }));
+    let s = null;
+    for (let r = 0; r <= this.retries; r++)
+      try {
+        const i = new AbortController(), o = setTimeout(() => i.abort(), this.timeout), u = await fetch(this.endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(n),
+          signal: i.signal
+        });
+        if (clearTimeout(o), !u.ok)
+          throw new Error(`HTTP error! status: ${u.status}`);
+        return (await u.json()).map((c) => {
+          if (c.error)
+            throw new Error(
+              `RPC error ${c.error.code}: ${c.error.message}`
+            );
+          if (c.result === void 0)
+            throw new Error("No result in RPC response");
+          return c.result;
+        });
+      } catch (i) {
+        s = i instanceof Error ? i : new Error(String(i)), r < this.retries && await new Promise(
+          (o) => setTimeout(o, 1e3 * Math.pow(2, r))
+        );
+      }
+    throw s ?? new Error("Batch request failed");
+  }
+  // ============================================================================
+  // Generic RPC Call
+  // ============================================================================
+  /**
+   * Generic RPC call method for custom or new API methods
+   */
+  async call(t, n = {}) {
+    return this.request(t, n);
+  }
+  // ============================================================================
+  // Database API - Global Properties
+  // ============================================================================
+  /**
+   * Get compile-time chain configuration constants
+   */
+  async getConfig() {
+    return this.request("database_api.get_config", {});
+  }
+  /**
+   * Get current dynamic global properties (head block, supply, etc.)
+   */
+  async getDynamicGlobalProperties() {
+    return this.request(
+      "database_api.get_dynamic_global_properties",
+      {}
+    );
+  }
+  /**
+   * Get active witness schedule
+   */
+  async getWitnessSchedule() {
+    return this.request(
+      "database_api.get_witness_schedule",
+      {}
+    );
+  }
+  /**
+   * Get hardfork properties and version information
+   */
+  async getHardforkProperties() {
+    return this.request(
+      "database_api.get_hardfork_properties",
+      {}
+    );
+  }
+  /**
+   * Get reward fund details
+   */
+  async getRewardFunds() {
+    return (await this.request("database_api.get_reward_funds", {})).funds;
+  }
+  /**
+   * Get current median price feed
+   */
+  async getCurrentPriceFeed() {
+    return this.request(
+      "database_api.get_current_price_feed",
+      {}
+    );
+  }
+  /**
+   * Get price feed history
+   */
+  async getFeedHistory() {
+    return this.request("database_api.get_feed_history", {});
+  }
+  // ============================================================================
+  // Database API - Witnesses
+  // ============================================================================
+  /**
+   * List witnesses by specified order
+   */
+  async listWitnesses(t) {
+    return (await this.request("database_api.list_witnesses", t)).witnesses;
+  }
+  /**
+   * Find specific witnesses by account names
+   */
+  async findWitnesses(t) {
+    return (await this.request("database_api.find_witnesses", {
+      owners: t
+    })).witnesses;
+  }
+  /**
+   * List witness votes
+   */
+  async listWitnessVotes(t, n, s) {
+    return this.request("database_api.list_witness_votes", {
+      start: t,
+      limit: n,
+      order: s
+    });
+  }
+  /**
+   * Get currently active witnesses
+   */
+  async getActiveWitnesses() {
+    return (await this.request(
+      "database_api.get_active_witnesses",
+      {}
+    )).witnesses;
+  }
+  // ============================================================================
+  // Database API - Accounts
+  // ============================================================================
+  /**
+   * List accounts by specified order
+   */
+  async listAccounts(t) {
+    return (await this.request("database_api.list_accounts", t)).accounts;
+  }
+  /**
+   * Find specific accounts by names
+   */
+  async findAccounts(t) {
+    return (await this.request("database_api.find_accounts", t)).accounts;
+  }
+  /**
+   * List account owner authority change history
+   */
+  async listOwnerHistories(t, n) {
+    return this.request(
+      "database_api.list_owner_histories",
+      { start: t, limit: n }
+    );
+  }
+  /**
+   * Find owner history for specific account
+   */
+  async findOwnerHistories(t) {
+    return this.request(
+      "database_api.find_owner_histories",
+      { owner: t }
+    );
+  }
+  /**
+   * List account recovery requests
+   */
+  async listAccountRecoveryRequests(t, n, s) {
+    return this.request(
+      "database_api.list_account_recovery_requests",
+      { start: t, limit: n, order: s }
+    );
+  }
+  /**
+   * Find account recovery requests
+   */
+  async findAccountRecoveryRequests(t) {
+    return this.request(
+      "database_api.find_account_recovery_requests",
+      { accounts: t }
+    );
+  }
+  /**
+   * List escrows
+   */
+  async listEscrows(t, n, s) {
+    return this.request("database_api.list_escrows", {
+      start: t,
+      limit: n,
+      order: s
+    });
+  }
+  /**
+   * Find escrows
+   */
+  async findEscrows(t) {
+    return this.request("database_api.find_escrows", { from: t });
+  }
+  /**
+   * List vesting delegations
+   */
+  async listVestingDelegations(t, n, s) {
+    return this.request(
+      "database_api.list_vesting_delegations",
+      { start: t, limit: n, order: s }
+    );
+  }
+  /**
+   * Find vesting delegations
+   */
+  async findVestingDelegations(t) {
+    return this.request(
+      "database_api.find_vesting_delegations",
+      { account: t }
+    );
+  }
+  /**
+   * List SBD conversion requests
+   */
+  async listDollarConversionRequests(t, n, s) {
+    return this.request(
+      "database_api.list_dollar_conversion_requests",
+      { start: t, limit: n, order: s }
+    );
+  }
+  /**
+   * Find SBD conversion requests
+   */
+  async findDollarConversionRequests(t) {
+    return this.request(
+      "database_api.find_dollar_conversion_requests",
+      { account: t }
+    );
+  }
+  // ============================================================================
+  // Database API - Comments
+  // ============================================================================
+  /**
+   * List comments by specified order
+   */
+  async listComments(t, n, s) {
+    return this.request("database_api.list_comments", {
+      start: t,
+      limit: n,
+      order: s
+    });
+  }
+  /**
+   * Find specific comments
+   */
+  async findComments(t) {
+    return this.request("database_api.find_comments", {
+      comments: t
+    });
+  }
+  /**
+   * List votes
+   */
+  async listVotes(t, n, s) {
+    return this.request("database_api.list_votes", {
+      start: t,
+      limit: n,
+      order: s
+    });
+  }
+  /**
+   * Find specific votes
+   */
+  async findVotes(t, n) {
+    return this.request("database_api.find_votes", {
+      author: t,
+      permlink: n
+    });
+  }
+  // ============================================================================
+  // Database API - Market
+  // ============================================================================
+  /**
+   * List limit orders
+   */
+  async listLimitOrders(t, n, s) {
+    return this.request("database_api.list_limit_orders", {
+      start: t,
+      limit: n,
+      order: s
+    });
+  }
+  /**
+   * Find limit orders
+   */
+  async findLimitOrders(t) {
+    return this.request("database_api.find_limit_orders", {
+      account: t
+    });
+  }
+  /**
+   * Get current order book
+   */
+  async getOrderBook(t = 50) {
+    return this.request("database_api.get_order_book", {
+      limit: t
+    });
+  }
+  // ============================================================================
+  // Database API - Authority & Validation
+  // ============================================================================
+  /**
+   * Get transaction as hex string
+   */
+  async getTransactionHex(t) {
+    return this.request("database_api.get_transaction_hex", { trx: t });
+  }
+  /**
+   * Get required signatures for transaction
+   */
+  async getRequiredSignatures(t, n) {
+    return this.request(
+      "database_api.get_required_signatures",
+      { trx: t, available_keys: n }
+    );
+  }
+  /**
+   * Get all potential signatures for transaction
+   */
+  async getPotentialSignatures(t) {
+    return this.request(
+      "database_api.get_potential_signatures",
+      { trx: t }
+    );
+  }
+  /**
+   * Verify transaction has required authority
+   */
+  async verifyAuthority(t) {
+    return this.request(
+      "database_api.verify_authority",
+      { trx: t }
+    );
+  }
+  /**
+   * Verify account has authority from signers
+   */
+  async verifyAccountAuthority(t, n) {
+    return this.request(
+      "database_api.verify_account_authority",
+      { account: t, signers: n }
+    );
+  }
+  /**
+   * Verify arbitrary signatures
+   */
+  async verifySignatures(t, n, s, r, i, o) {
+    return this.request(
+      "database_api.verify_signatures",
+      {
+        hash: t,
+        signatures: n,
+        required_owner: s,
+        required_active: r,
+        required_posting: i,
+        required_other: o
+      }
+    );
+  }
+  // ============================================================================
+  // Network Broadcast API
+  // ============================================================================
+  /**
+   * Broadcast transaction to the network
+   */
+  async broadcastTransaction(t, n = -1) {
+    return this.request(
+      "network_broadcast_api.broadcast_transaction",
+      { trx: t, max_block_age: n }
+    );
+  }
+  /**
+   * Broadcast block to the network
+   */
+  async broadcastBlock(t) {
+    return this.request("network_broadcast_api.broadcast_block", {
+      block: t
+    });
+  }
+  // ============================================================================
+  // Block API
+  // ============================================================================
+  /**
+   * Get block header by block number
+   */
+  async getBlockHeader(t) {
+    return (await this.request("block_api.get_block_header", {
+      block_num: t
+    })).header;
+  }
+  /**
+   * Get full block by block number
+   */
+  async getBlock(t) {
+    return (await this.request("block_api.get_block", {
+      block_num: t
+    })).block;
+  }
+  // ============================================================================
+  // Account History API
+  // ============================================================================
+  /**
+   * Get operations in a specific block
+   */
+  async getOpsInBlock(t) {
+    return this.request("account_history_api.get_ops_in_block", t);
+  }
+  /**
+   * Get transaction by ID
+   */
+  async getTransaction(t) {
+    return this.request(
+      "account_history.get_transaction",
+      { id: t }
+    );
+  }
+  /**
+   * Get account operation history
+   */
+  async getAccountHistory(t) {
+    return this.request(
+      "account_history.get_account_history",
+      t
+    );
+  }
+  /**
+   * Enumerate virtual operations in block range
+   */
+  async enumVirtualOps(t, n) {
+    return this.request("account_history_api.enum_virtual_ops", {
+      block_range_begin: t,
+      block_range_end: n
+    });
+  }
+  // ============================================================================
+  // Tags/Discussion API
+  // ============================================================================
+  /**
+   * Get trending tags
+   */
+  async getTrendingTags(t = "", n = 100) {
+    return (await this.request("tags_api.get_trending_tags", {
+      start_tag: t,
+      limit: n
+    })).tags;
+  }
+  /**
+   * Get tags used by author
+   */
+  async getTagsUsedByAuthor(t) {
+    return this.request("tags_api.get_tags_used_by_author", {
+      author: t
+    });
+  }
+  /**
+   * Get single discussion/post
+   */
+  async getDiscussion(t, n) {
+    return this.request("tags_api.get_discussion", {
+      author: t,
+      permlink: n
+    });
+  }
+  /**
+   * Get replies to a post
+   */
+  async getContentReplies(t, n) {
+    return (await this.request("tags_api.get_content_replies", {
+      author: t,
+      permlink: n
+    })).discussions;
+  }
+  /**
+   * Get discussions by trending
+   */
+  async getDiscussionsByTrending(t) {
+    return this.request("tags_api.get_discussions_by_trending", t);
+  }
+  /**
+   * Get discussions by creation time
+   */
+  async getDiscussionsByCreated(t) {
+    return this.request("tags_api.get_discussions_by_created", t);
+  }
+  /**
+   * Get discussions by activity
+   */
+  async getDiscussionsByActive(t) {
+    return this.request("tags_api.get_discussions_by_active", t);
+  }
+  /**
+   * Get discussions by cashout time
+   */
+  async getDiscussionsByCashout(t) {
+    return this.request("tags_api.get_discussions_by_cashout", t);
+  }
+  /**
+   * Get discussions by votes
+   */
+  async getDiscussionsByVotes(t) {
+    return this.request("tags_api.get_discussions_by_votes", t);
+  }
+  /**
+   * Get discussions by children count
+   */
+  async getDiscussionsByChildren(t) {
+    return this.request("tags_api.get_discussions_by_children", t);
+  }
+  /**
+   * Get hot discussions
+   */
+  async getDiscussionsByHot(t) {
+    return this.request("tags_api.get_discussions_by_hot", t);
+  }
+  /**
+   * Get discussions from follower feed
+   */
+  async getDiscussionsByFeed(t) {
+    return this.request("tags_api.get_discussions_by_feed", t);
+  }
+  /**
+   * Get discussions from blog
+   */
+  async getDiscussionsByBlog(t) {
+    return this.request("tags_api.get_discussions_by_blog", t);
+  }
+  /**
+   * Get discussions by comment count
+   */
+  async getDiscussionsByComments(t) {
+    return this.request("tags_api.get_discussions_by_comments", t);
+  }
+  /**
+   * Get promoted discussions
+   */
+  async getDiscussionsByPromoted(t) {
+    return this.request("tags_api.get_discussions_by_promoted", t);
+  }
+  /**
+   * Get active votes on a post
+   */
+  async getActiveVotes(t, n) {
+    return this.request("tags_api.get_active_votes", {
+      author: t,
+      permlink: n
+    });
+  }
+  // ============================================================================
+  // Follow API
+  // ============================================================================
+  /**
+   * Get followers of an account
+   */
+  async getFollowers(t) {
+    return (await this.request("follow_api.get_followers", t)).followers;
+  }
+  /**
+   * Get accounts that an account is following
+   */
+  async getFollowing(t) {
+    return (await this.request("follow_api.get_following", t)).following;
+  }
+  /**
+   * Get follower and following counts
+   */
+  async getFollowCount(t) {
+    return this.request("follow_api.get_follow_count", { account: t });
+  }
+  /**
+   * Get feed entries
+   */
+  async getFeedEntries(t, n = 0, s = 100) {
+    return this.request("follow_api.get_feed_entries", {
+      account: t,
+      start_entry_id: n,
+      limit: s
+    });
+  }
+  /**
+   * Get feed with full comments
+   */
+  async getFeed(t, n = 0, s = 100) {
+    return this.request("follow_api.get_feed", {
+      account: t,
+      start_entry_id: n,
+      limit: s
+    });
+  }
+  /**
+   * Get blog entries
+   */
+  async getBlogEntries(t, n = 0, s = 100) {
+    return this.request("follow_api.get_blog_entries", {
+      account: t,
+      start_entry_id: n,
+      limit: s
+    });
+  }
+  /**
+   * Get blog with full comments
+   */
+  async getBlog(t, n = 0, s = 100) {
+    return this.request("follow_api.get_blog", {
+      account: t,
+      start_entry_id: n,
+      limit: s
+    });
+  }
+  /**
+   * Get account reputation scores
+   */
+  async getAccountReputations(t = "", n = 100) {
+    return this.request("follow_api.get_account_reputations", {
+      account_lower_bound: t,
+      limit: n
+    });
+  }
+  /**
+   * Get accounts that reblogged a post
+   */
+  async getRebloggedBy(t, n) {
+    return this.request("follow_api.get_reblogged_by", {
+      author: t,
+      permlink: n
+    });
+  }
+  /**
+   * Get blog author statistics
+   */
+  async getBlogAuthors(t) {
+    return this.request("follow_api.get_blog_authors", {
+      blog_account: t
+    });
+  }
+  // ============================================================================
+  // Market History API
+  // ============================================================================
+  /**
+   * Get market ticker
+   */
+  async getTicker() {
+    return this.request("market_history_api.get_ticker", {});
+  }
+  /**
+   * Get market volume
+   */
+  async getVolume() {
+    return this.request("market_history_api.get_volume", {});
+  }
+  /**
+   * Get market order book
+   */
+  async getMarketOrderBook(t = 50) {
+    return this.request("market_history_api.get_order_book", {
+      limit: t
+    });
+  }
+  /**
+   * Get trade history
+   */
+  async getTradeHistory(t, n, s = 100) {
+    return this.request("market_history_api.get_trade_history", {
+      start: t,
+      end: n,
+      limit: s
+    });
+  }
+  /**
+   * Get recent trades
+   */
+  async getRecentTrades(t = 100) {
+    return this.request("market_history_api.get_recent_trades", {
+      limit: t
+    });
+  }
+  /**
+   * Get market history buckets
+   */
+  async getMarketHistory(t, n, s) {
+    return this.request(
+      "market_history_api.get_market_history",
+      {
+        bucket_seconds: t,
+        start: n,
+        end: s
+      }
+    );
+  }
+  /**
+   * Get available bucket sizes
+   */
+  async getMarketHistoryBuckets() {
+    return (await this.request(
+      "market_history_api.get_market_history_buckets",
+      {}
+    )).bucket_sizes;
+  }
+  // ============================================================================
+  // Account By Key API
+  // ============================================================================
+  /**
+   * Get accounts that can sign with given public keys
+   */
+  async getKeyReferences(t) {
+    return this.request("account_by_key_api.get_key_references", {
+      keys: t
+    });
+  }
+  // ============================================================================
+  // JSON-RPC Meta API
+  // ============================================================================
+  /**
+   * Get list of all available RPC methods
+   */
+  async getMethods() {
+    return this.request("jsonrpc.get_methods", {});
+  }
+  /**
+   * Get signature (parameters and return type) for an RPC method
+   */
+  async getSignature(t) {
+    return this.request("jsonrpc.get_signature", { method: t });
+  }
+}
+/*! noble-secp256k1 - MIT License (c) 2019 Paul Miller (paulmillr.com) */
+const cn = {
+  p: 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fn,
+  n: 0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141n,
+  b: 7n,
+  Gx: 0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798n,
+  Gy: 0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8n
+}, { p: Z, n: H, Gx: an, Gy: un, b: he } = cn, U = 32, X = 64, B = (e = "") => {
+  throw new Error(e);
+}, le = (e) => typeof e == "bigint", de = (e) => typeof e == "string", fn = (e) => e instanceof Uint8Array || ArrayBuffer.isView(e) && e.constructor.name === "Uint8Array", tt = (e, t) => !fn(e) || typeof t == "number" && t > 0 && e.length !== t ? B("Uint8Array expected") : e, Q = (e) => new Uint8Array(e), hn = (e) => Uint8Array.from(e), ye = (e, t) => e.toString(16).padStart(t, "0"), qt = (e) => Array.from(tt(e)).map((t) => ye(t, 2)).join(""), O = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 }, Jt = (e) => {
+  if (e >= O._0 && e <= O._9)
+    return e - O._0;
+  if (e >= O.A && e <= O.F)
+    return e - (O.A - 10);
+  if (e >= O.a && e <= O.f)
+    return e - (O.a - 10);
+}, Wt = (e) => {
+  const t = "hex invalid";
+  if (!de(e))
+    return B(t);
+  const n = e.length, s = n / 2;
+  if (n % 2)
+    return B(t);
+  const r = Q(s);
+  for (let i = 0, o = 0; i < s; i++, o += 2) {
+    const u = Jt(e.charCodeAt(o)), a = Jt(e.charCodeAt(o + 1));
+    if (u === void 0 || a === void 0)
+      return B(t);
+    r[i] = u * 16 + a;
+  }
+  return r;
+}, k = (e, t) => tt(de(e) ? Wt(e) : hn(tt(e)), t), be = () => globalThis?.crypto, ln = () => be()?.subtle ?? B("crypto.subtle must be defined"), et = (...e) => {
+  const t = Q(e.reduce((s, r) => s + tt(r).length, 0));
+  let n = 0;
+  return e.forEach((s) => {
+    t.set(s, n), n += s.length;
+  }), t;
+}, ge = (e = U) => be().getRandomValues(Q(e)), ot = BigInt, dt = (e, t, n, s = "bad number: out of range") => le(e) && t <= e && e < n ? e : B(s), w = (e, t = Z) => {
+  const n = e % t;
+  return n >= 0n ? n : t + n;
+}, S = (e) => w(e, H), yt = (e, t) => {
+  (e === 0n || t <= 0n) && B("no inverse n=" + e + " mod=" + t);
+  let n = w(e, t), s = t, r = 0n, i = 1n;
+  for (; n !== 0n; ) {
+    const o = s / n, u = s % n, a = r - i * o;
+    s = n, n = u, r = i, i = a;
+  }
+  return s === 1n ? w(r, t) : B("no inverse");
+}, te = (e) => e instanceof v ? e : B("Point expected"), _e = (e) => w(w(e * e) * e + he), ee = (e) => dt(e, 0n, Z), ft = (e) => dt(e, 1n, Z), Ht = (e) => dt(e, 1n, H), Ft = (e) => (e & 1n) === 0n, Et = (e) => Uint8Array.of(e), pe = (e) => Et(Ft(e) ? 2 : 3), dn = (e) => {
+  const t = _e(ft(e));
+  let n = 1n;
+  for (let s = t, r = (Z + 1n) / 4n; r > 0n; r >>= 1n)
+    r & 1n && (n = n * s % Z), s = s * s % Z;
+  return w(n * n) === t ? n : B("sqrt invalid");
+};
+class v {
+  static BASE;
+  static ZERO;
+  px;
+  py;
+  pz;
+  constructor(t, n, s) {
+    this.px = ee(t), this.py = ft(n), this.pz = ee(s), Object.freeze(this);
+  }
+  /** Convert Uint8Array or hex string to Point. */
+  static fromBytes(t) {
+    tt(t);
+    let n;
+    const s = t[0], r = t.subarray(1), i = vt(r, 0, U), o = t.length;
+    if (o === U + 1 && [2, 3].includes(s)) {
+      let u = dn(i);
+      const a = Ft(u);
+      Ft(ot(s)) !== a && (u = w(-u)), n = new v(i, u, 1n);
+    }
+    return o === X + 1 && s === 4 && (n = new v(i, vt(r, U, X), 1n)), n ? n.assertValidity() : B("bad point: not on curve");
+  }
+  /** Equality check: compare points P&Q. */
+  equals(t) {
+    const { px: n, py: s, pz: r } = this, { px: i, py: o, pz: u } = te(t), a = w(n * u), c = w(i * r), h = w(s * u), f = w(o * r);
+    return a === c && h === f;
+  }
+  is0() {
+    return this.equals($);
+  }
+  /** Flip point over y coordinate. */
+  negate() {
+    return new v(this.px, w(-this.py), this.pz);
+  }
+  /** Point doubling: P+P, complete formula. */
+  double() {
+    return this.add(this);
+  }
+  /**
+   * Point addition: P+Q, complete, exception-free formula
+   * (Renes-Costello-Batina, algo 1 of [2015/1060](https://eprint.iacr.org/2015/1060)).
+   * Cost: `12M + 0S + 3*a + 3*b3 + 23add`.
+   */
+  // prettier-ignore
+  add(t) {
+    const { px: n, py: s, pz: r } = this, { px: i, py: o, pz: u } = te(t), a = 0n, c = he;
+    let h = 0n, f = 0n, l = 0n;
+    const d = w(c * 3n);
+    let y = w(n * i), b = w(s * o), _ = w(r * u), x = w(n + s), g = w(i + o);
+    x = w(x * g), g = w(y + b), x = w(x - g), g = w(n + r);
+    let p = w(i + u);
+    return g = w(g * p), p = w(y + _), g = w(g - p), p = w(s + r), h = w(o + u), p = w(p * h), h = w(b + _), p = w(p - h), l = w(a * g), h = w(d * _), l = w(h + l), h = w(b - l), l = w(b + l), f = w(h * l), b = w(y + y), b = w(b + y), _ = w(a * _), g = w(d * g), b = w(b + _), _ = w(y - _), _ = w(a * _), g = w(g + _), y = w(b * g), f = w(f + y), y = w(p * g), h = w(x * h), h = w(h - y), y = w(x * b), l = w(p * l), l = w(l + y), new v(h, f, l);
+  }
+  /**
+   * Point-by-scalar multiplication. Scalar must be in range 1 <= n < CURVE.n.
+   * Uses {@link wNAF} for base point.
+   * Uses fake point to mitigate side-channel leakage.
+   * @param n scalar by which point is multiplied
+   * @param safe safe mode guards against timing attacks; unsafe mode is faster
+   */
+  multiply(t, n = !0) {
+    if (!n && t === 0n)
+      return $;
+    if (Ht(t), t === 1n)
+      return this;
+    if (this.equals(K))
+      return Un(t).p;
+    let s = $, r = K;
+    for (let i = this; t > 0n; i = i.double(), t >>= 1n)
+      t & 1n ? s = s.add(i) : n && (r = r.add(i));
+    return s;
+  }
+  /** Convert point to 2d xy affine point. (X, Y, Z) ∋ (x=X/Z, y=Y/Z) */
+  toAffine() {
+    const { px: t, py: n, pz: s } = this;
+    if (this.equals($))
+      return { x: 0n, y: 0n };
+    if (s === 1n)
+      return { x: t, y: n };
+    const r = yt(s, Z);
+    return w(s * r) !== 1n && B("inverse invalid"), { x: w(t * r), y: w(n * r) };
+  }
+  /** Checks if the point is valid and on-curve. */
+  assertValidity() {
+    const { x: t, y: n } = this.toAffine();
+    return ft(t), ft(n), w(n * n) === _e(t) ? this : B("bad point: not on curve");
+  }
+  /** Converts point to 33/65-byte Uint8Array. */
+  toBytes(t = !0) {
+    const { x: n, y: s } = this.assertValidity().toAffine(), r = z(n);
+    return t ? et(pe(s), r) : et(Et(4), r, z(s));
+  }
+  /** Create 3d xyz point from 2d xy. (0, 0) => (0, 1, 0), not (0, 0, 1) */
+  static fromAffine(t) {
+    const { x: n, y: s } = t;
+    return n === 0n && s === 0n ? $ : new v(n, s, 1n);
+  }
+  toHex(t) {
+    return qt(this.toBytes(t));
+  }
+  static fromPrivateKey(t) {
+    return K.multiply(It(t));
+  }
+  static fromHex(t) {
+    return v.fromBytes(k(t));
+  }
+  get x() {
+    return this.toAffine().x;
+  }
+  get y() {
+    return this.toAffine().y;
+  }
+  toRawBytes(t) {
+    return this.toBytes(t);
+  }
+}
+const K = new v(an, un, 1n), $ = new v(0n, 1n, 0n);
+v.BASE = K;
+v.ZERO = $;
+const we = (e, t, n) => K.multiply(t, !1).add(e.multiply(n, !1)).assertValidity(), bt = (e) => ot("0x" + (qt(e) || "0")), vt = (e, t, n) => bt(e.subarray(t, n)), yn = 2n ** 256n, z = (e) => Wt(ye(dt(e, 0n, yn), X)), It = (e) => {
+  const t = le(e) ? e : bt(k(e, U));
+  return dt(t, 1n, H, "private key invalid 3");
+}, St = (e) => e > H >> 1n, bn = (e, t = !0) => K.multiply(It(e)).toBytes(t);
+let Tt = class ut {
+  r;
+  s;
+  recovery;
+  constructor(t, n, s) {
+    this.r = Ht(t), this.s = Ht(n), s != null && (this.recovery = s), Object.freeze(this);
+  }
+  /** Create signature from 64b compact (r || s) representation. */
+  static fromBytes(t) {
+    tt(t, X);
+    const n = vt(t, 0, U), s = vt(t, U, X);
+    return new ut(n, s);
+  }
+  toBytes() {
+    const { r: t, s: n } = this;
+    return et(z(t), z(n));
+  }
+  /** Copy signature, with newly added recovery bit. */
+  addRecoveryBit(t) {
+    return new ut(this.r, this.s, t);
+  }
+  hasHighS() {
+    return St(this.s);
+  }
+  toCompactRawBytes() {
+    return this.toBytes();
+  }
+  toCompactHex() {
+    return qt(this.toBytes());
+  }
+  recoverPublicKey(t) {
+    return mn(this, t);
+  }
+  static fromCompact(t) {
+    return ut.fromBytes(k(t, X));
+  }
+  assertValidity() {
+    return this;
+  }
+  normalizeS() {
+    const { r: t, s: n, recovery: s } = this;
+    return St(n) ? new ut(t, S(-n), s) : this;
+  }
+};
+const xe = (e) => {
+  const t = e.length * 8 - 256;
+  t > 1024 && B("msg invalid");
+  const n = bt(e);
+  return t > 0 ? n >> ot(t) : n;
+}, Lt = (e) => S(xe(tt(e))), me = { lowS: !0 }, gn = { lowS: !0 }, _n = (e, t, n = me) => {
+  ["der", "recovered", "canonical"].some((l) => l in n) && B("option not supported");
+  let { lowS: s, extraEntropy: r } = n;
+  s == null && (s = !0);
+  const i = z, o = Lt(k(e)), u = i(o), a = It(t), c = [i(a), u];
+  r && c.push(r === !0 ? ge(U) : k(r));
+  const h = o, f = (l) => {
+    const d = xe(l);
+    if (!(1n <= d && d < H))
+      return;
+    const y = K.multiply(d).toAffine(), b = S(y.x);
+    if (b === 0n)
+      return;
+    const _ = yt(d, H), x = S(_ * S(h + S(a * b)));
+    if (x === 0n)
+      return;
+    let g = x, p = (y.x === b ? 0 : 2) | Number(y.y & 1n);
+    return s && St(x) && (g = S(-x), p ^= 1), new Tt(b, g, p);
+  };
+  return { seed: et(...c), k2sig: f };
+}, pn = (e) => {
+  let t = Q(U), n = Q(U), s = 0;
+  const r = Q(0), i = () => {
+    t.fill(1), n.fill(0), s = 0;
+  }, o = 1e3, u = "drbg: tried 1000 values";
+  {
+    const a = (...f) => vn.hmacSha256Async(n, t, ...f), c = async (f = r) => {
+      n = await a(Et(0), f), t = await a(), f.length !== 0 && (n = await a(Et(1), f), t = await a());
+    }, h = async () => (s++ >= o && B(u), t = await a(), t);
+    return async (f, l) => {
+      i(), await c(f);
+      let d;
+      for (; !(d = l(await h())); )
+        await c();
+      return i(), d;
+    };
+  }
+}, wn = async (e, t, n = me) => {
+  const { seed: s, k2sig: r } = _n(e, t, n);
+  return await pn()(s, r);
+}, xn = (e, t, n, s = gn) => {
+  let { lowS: r } = s;
+  r == null && (r = !0), "strict" in s && B("option not supported");
+  let i;
+  const o = e && typeof e == "object" && "r" in e;
+  !o && k(e).length !== X && B("signature must be 64 bytes");
+  try {
+    i = o ? new Tt(e.r, e.s) : Tt.fromCompact(e);
+    const u = Lt(k(t)), a = v.fromBytes(k(n)), { r: c, s: h } = i;
+    if (r && St(h))
+      return !1;
+    const f = yt(h, H), l = S(u * f), d = S(c * f), y = we(a, l, d).toAffine();
+    return S(y.x) === c;
+  } catch {
+    return !1;
+  }
+}, mn = (e, t) => {
+  const { r: n, s, recovery: r } = e;
+  [0, 1, 2, 3].includes(r) || B("recovery id invalid");
+  const i = Lt(k(t, U)), o = r === 2 || r === 3 ? n + H : n;
+  ft(o);
+  const u = pe(ot(r)), a = et(u, z(o)), c = v.fromBytes(a), h = yt(o, H), f = S(-i * h), l = S(s * h);
+  return we(c, f, l);
+}, An = (e, t, n = !0) => v.fromBytes(k(t)).multiply(It(e)).toBytes(n), Bn = (e) => {
+  e = k(e), (e.length < U + 8 || e.length > 1024) && B("expected 40-1024b");
+  const t = w(bt(e), H - 1n);
+  return z(t + 1n);
+}, En = "SHA-256", vn = {
+  hexToBytes: Wt,
+  bytesToHex: qt,
+  concatBytes: et,
+  bytesToNumberBE: bt,
+  numberToBytesBE: z,
+  mod: w,
+  invert: yt,
+  // math utilities
+  hmacSha256Async: async (e, ...t) => {
+    const n = ln(), s = "HMAC", r = await n.importKey("raw", e, { name: s, hash: { name: En } }, !1, ["sign"]);
+    return Q(await n.sign(s, r, et(...t)));
+  },
+  hmacSha256Sync: void 0,
+  // For TypeScript. Actual logic is below
+  hashToPrivateKey: Bn,
+  randomBytes: ge
+}, Ut = 8, Sn = 256, Ae = Math.ceil(Sn / Ut) + 1, Dt = 2 ** (Ut - 1), Tn = () => {
+  const e = [];
+  let t = K, n = t;
+  for (let s = 0; s < Ae; s++) {
+    n = t, e.push(n);
+    for (let r = 1; r < Dt; r++)
+      n = n.add(t), e.push(n);
+    t = n.double();
+  }
+  return e;
+};
+let ne;
+const se = (e, t) => {
+  const n = t.negate();
+  return e ? n : t;
+}, Un = (e) => {
+  const t = ne || (ne = Tn());
+  let n = $, s = K;
+  const r = 2 ** Ut, i = r, o = ot(r - 1), u = ot(Ut);
+  for (let a = 0; a < Ae; a++) {
+    let c = Number(e & o);
+    e >>= u, c > Dt && (c -= i, e += 1n);
+    const h = a * Dt, f = h, l = h + Math.abs(c) - 1, d = a % 2 !== 0, y = c < 0;
+    c === 0 ? s = s.add(se(d, t[f])) : n = n.add(se(y, t[l]));
+  }
+  return { p: n, f: s };
+}, qn = /* @__PURE__ */ Uint8Array.from([
+  7,
+  4,
+  13,
+  1,
+  10,
+  6,
+  15,
+  3,
+  12,
+  0,
+  9,
+  5,
+  2,
+  14,
+  11,
+  8
+]), Be = Uint8Array.from(new Array(16).fill(0).map((e, t) => t)), In = Be.map((e) => (9 * e + 5) % 16), Ee = /* @__PURE__ */ (() => {
+  const n = [[Be], [In]];
+  for (let s = 0; s < 4; s++)
+    for (let r of n)
+      r.push(r[s].map((i) => qn[i]));
+  return n;
+})(), ve = Ee[0], Se = Ee[1], Te = /* @__PURE__ */ [
+  [11, 14, 15, 12, 5, 8, 7, 9, 11, 13, 14, 15, 6, 7, 9, 8],
+  [12, 13, 11, 15, 6, 9, 9, 7, 12, 15, 11, 13, 7, 8, 7, 7],
+  [13, 15, 14, 11, 7, 7, 6, 8, 13, 14, 13, 12, 5, 5, 6, 9],
+  [14, 11, 12, 14, 8, 6, 5, 5, 15, 12, 15, 14, 9, 9, 8, 6],
+  [15, 12, 13, 13, 9, 5, 8, 6, 14, 11, 12, 11, 8, 6, 5, 5]
+].map((e) => Uint8Array.from(e)), Rn = /* @__PURE__ */ ve.map((e, t) => e.map((n) => Te[t][n])), kn = /* @__PURE__ */ Se.map((e, t) => e.map((n) => Te[t][n])), Cn = /* @__PURE__ */ Uint32Array.from([
+  0,
+  1518500249,
+  1859775393,
+  2400959708,
+  2840853838
+]), Nn = /* @__PURE__ */ Uint32Array.from([
+  1352829926,
+  1548603684,
+  1836072691,
+  2053994217,
+  0
+]);
+function re(e, t, n, s) {
+  return e === 0 ? t ^ n ^ s : e === 1 ? t & n | ~t & s : e === 2 ? (t | ~n) ^ s : e === 3 ? t & s | n & ~s : t ^ (n | ~s);
+}
+const Bt = /* @__PURE__ */ new Uint32Array(16);
+class Hn extends Vt {
+  constructor() {
+    super(64, 20, 8, !0), this.h0 = 1732584193, this.h1 = -271733879, this.h2 = -1732584194, this.h3 = 271733878, this.h4 = -1009589776;
+  }
+  get() {
+    const { h0: t, h1: n, h2: s, h3: r, h4: i } = this;
+    return [t, n, s, r, i];
+  }
+  set(t, n, s, r, i) {
+    this.h0 = t | 0, this.h1 = n | 0, this.h2 = s | 0, this.h3 = r | 0, this.h4 = i | 0;
+  }
+  process(t, n) {
+    for (let d = 0; d < 16; d++, n += 4)
+      Bt[d] = t.getUint32(n, !0);
+    let s = this.h0 | 0, r = s, i = this.h1 | 0, o = i, u = this.h2 | 0, a = u, c = this.h3 | 0, h = c, f = this.h4 | 0, l = f;
+    for (let d = 0; d < 5; d++) {
+      const y = 4 - d, b = Cn[d], _ = Nn[d], x = ve[d], g = Se[d], p = Rn[d], A = kn[d];
+      for (let m = 0; m < 16; m++) {
+        const F = wt(s + re(d, i, u, c) + Bt[x[m]] + b, p[m]) + f | 0;
+        s = f, f = c, c = wt(u, 10) | 0, u = i, i = F;
+      }
+      for (let m = 0; m < 16; m++) {
+        const F = wt(r + re(y, o, a, h) + Bt[g[m]] + _, A[m]) + l | 0;
+        r = l, l = h, h = wt(a, 10) | 0, a = o, o = F;
+      }
+    }
+    this.set(this.h1 + u + h | 0, this.h2 + c + l | 0, this.h3 + f + r | 0, this.h4 + s + o | 0, this.h0 + i + a | 0);
+  }
+  roundClean() {
+    J(Bt);
+  }
+  destroy() {
+    this.destroyed = !0, J(this.buffer), this.set(0, 0, 0, 0, 0);
+  }
+}
+const ie = /* @__PURE__ */ Mt(() => new Hn());
+function Fn(e) {
+  if (e.length >= 255)
+    throw new TypeError("Alphabet too long");
+  const t = new Uint8Array(256);
+  for (let c = 0; c < t.length; c++)
+    t[c] = 255;
+  for (let c = 0; c < e.length; c++) {
+    const h = e.charAt(c), f = h.charCodeAt(0);
+    if (t[f] !== 255)
+      throw new TypeError(h + " is ambiguous");
+    t[f] = c;
+  }
+  const n = e.length, s = e.charAt(0), r = Math.log(n) / Math.log(256), i = Math.log(256) / Math.log(n);
+  function o(c) {
+    if (c instanceof Uint8Array || (ArrayBuffer.isView(c) ? c = new Uint8Array(c.buffer, c.byteOffset, c.byteLength) : Array.isArray(c) && (c = Uint8Array.from(c))), !(c instanceof Uint8Array))
+      throw new TypeError("Expected Uint8Array");
+    if (c.length === 0)
+      return "";
+    let h = 0, f = 0, l = 0;
+    const d = c.length;
+    for (; l !== d && c[l] === 0; )
+      l++, h++;
+    const y = (d - l) * i + 1 >>> 0, b = new Uint8Array(y);
+    for (; l !== d; ) {
+      let g = c[l], p = 0;
+      for (let A = y - 1; (g !== 0 || p < f) && A !== -1; A--, p++)
+        g += 256 * b[A] >>> 0, b[A] = g % n >>> 0, g = g / n >>> 0;
+      if (g !== 0)
+        throw new Error("Non-zero carry");
+      f = p, l++;
+    }
+    let _ = y - f;
+    for (; _ !== y && b[_] === 0; )
+      _++;
+    let x = s.repeat(h);
+    for (; _ < y; ++_)
+      x += e.charAt(b[_]);
+    return x;
+  }
+  function u(c) {
+    if (typeof c != "string")
+      throw new TypeError("Expected String");
+    if (c.length === 0)
+      return new Uint8Array();
+    let h = 0, f = 0, l = 0;
+    for (; c[h] === s; )
+      f++, h++;
+    const d = (c.length - h) * r + 1 >>> 0, y = new Uint8Array(d);
+    for (; h < c.length; ) {
+      const g = c.charCodeAt(h);
+      if (g > 255)
+        return;
+      let p = t[g];
+      if (p === 255)
+        return;
+      let A = 0;
+      for (let m = d - 1; (p !== 0 || A < l) && m !== -1; m--, A++)
+        p += n * y[m] >>> 0, y[m] = p % 256 >>> 0, p = p / 256 >>> 0;
+      if (p !== 0)
+        throw new Error("Non-zero carry");
+      l = A, h++;
+    }
+    let b = d - l;
+    for (; b !== d && y[b] === 0; )
+      b++;
+    const _ = new Uint8Array(f + (d - b));
+    let x = f;
+    for (; b !== d; )
+      _[x++] = y[b++];
+    return _;
+  }
+  function a(c) {
+    const h = u(c);
+    if (h)
+      return h;
+    throw new Error("Non-base" + n + " character");
+  }
+  return {
+    encode: o,
+    decodeUnsafe: u,
+    decode: a
+  };
+}
+var Dn = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+const ct = Fn(Dn);
+class T {
+  key;
+  constructor(t) {
+    if (t.length !== 32)
+      throw new Error("Private key must be 32 bytes");
+    this.key = t;
+  }
+  /**
+   * Create PrivateKey from WIF (Wallet Import Format) string
+   */
+  static fromWif(t) {
+    const n = ct.decode(t);
+    if (n[0] !== 128)
+      throw new Error("Invalid WIF version byte");
+    const s = n.slice(1, 33), r = n.slice(33, 37), i = R(n.slice(0, 33)), u = R(i).slice(0, 4);
+    if (!qe(r, u))
+      throw new Error("Invalid WIF checksum");
+    return new T(s);
+  }
+  /**
+   * Create PrivateKey from seed string
+   */
+  static fromSeed(t) {
+    const n = R(new TextEncoder().encode(t));
+    return new T(n);
+  }
+  /**
+   * Generate PrivateKey from account name, password and role
+   */
+  static fromLogin(t, n, s = "active") {
+    const i = (t + s + n).trim().replace(/\s+/g, " ");
+    return T.fromSeed(i);
+  }
+  /**
+   * Convert to WIF format
+   */
+  toWif() {
+    const t = new Uint8Array(33);
+    t[0] = 128, t.set(this.key, 1);
+    const n = R(t), r = R(n).slice(0, 4), i = new Uint8Array(37);
+    return i.set(t), i.set(r, 33), ct.encode(i);
+  }
+  /**
+   * Get the public key
+   */
+  toPublic() {
+    const t = bn(this.key, !0);
+    return new gt(t);
+  }
+  /**
+   * Get raw bytes
+   */
+  toBytes() {
+    return this.key;
+  }
+  /**
+   * Sign a message hash
+   * @param messageHash The message hash to sign
+   * @returns Signature with recovery parameter
+   */
+  async sign(t) {
+    const n = await wn(t, this.key, {
+      lowS: !0
+      // Enforce canonical signatures (prevents malleability)
+    });
+    return new Ue({ signature: n.toCompactRawBytes(), recovery: n.recovery ?? 0 });
+  }
+  /**
+   * Get shared secret with a public key (for ECIES encryption)
+   * @param publicKey The public key to generate shared secret with
+   * @returns Shared secret as Uint8Array
+   */
+  getSharedSecret(t) {
+    return An(this.key, t.toBytes(), !0).slice(1);
+  }
+  /**
+   * Derive child key from offset (hierarchical key derivation)
+   * @param offset Offset string for derivation
+   * @returns New derived PrivateKey
+   */
+  child(t) {
+    const n = R(new TextEncoder().encode(t)), s = BigInt("0x" + Array.from(n).map((c) => c.toString(16).padStart(2, "0")).join("")), r = BigInt("0x" + Array.from(this.key).map((c) => c.toString(16).padStart(2, "0")).join("")), i = BigInt("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141"), u = ((r + s) % i).toString(16).padStart(64, "0"), a = new Uint8Array(32);
+    for (let c = 0; c < 32; c++)
+      a[c] = parseInt(u.slice(c * 2, c * 2 + 2), 16);
+    return new T(a);
+  }
+}
+class gt {
+  key;
+  constructor(t) {
+    if (t.length !== 33)
+      throw new Error("Compressed public key must be 33 bytes");
+    this.key = t;
+  }
+  /**
+   * Create PublicKey from string (e.g., "ZTR...")
+   */
+  static fromString(t, n = "ZTR") {
+    if (!t.startsWith(n))
+      throw new Error(`Public key must start with ${n}`);
+    const s = t.substring(n.length), r = ct.decode(s), i = r.slice(0, 33), o = r.slice(33), a = ie(i).slice(0, 4);
+    if (!qe(o, a))
+      throw new Error("Invalid public key checksum");
+    return new gt(i);
+  }
+  /**
+   * Convert to string format (e.g., "ZTR...")
+   */
+  toString(t = "ZTR") {
+    const n = ie(this.key).slice(0, 4), s = new Uint8Array(37);
+    return s.set(this.key), s.set(n, 33), t + ct.encode(s);
+  }
+  /**
+   * Get raw bytes
+   */
+  toBytes() {
+    return this.key;
+  }
+  /**
+   * Verify a signature
+   */
+  async verify(t, n) {
+    try {
+      return xn(n.toCompact(), t, this.key);
+    } catch {
+      return !1;
+    }
+  }
+  /**
+   * Derive child key from offset (hierarchical key derivation)
+   * Note: This is not implemented for public keys alone, derive from private key instead
+   * @param _offset Offset string for derivation (unused)
+   * @returns Never - throws error
+   */
+  child(t) {
+    throw new Error("PublicKey.child() requires private key derivation");
+  }
+}
+class Ue {
+  sig;
+  recovery;
+  constructor(t) {
+    if (t instanceof Uint8Array) {
+      if (t.length !== 65)
+        throw new Error("Signature must be 65 bytes");
+      const n = t[0];
+      if (n === void 0)
+        throw new Error("Invalid signature: missing recovery byte");
+      this.recovery = n - 27, this.sig = t.slice(1);
+    } else
+      this.sig = t.signature, this.recovery = t.recovery ?? 0;
+  }
+  /**
+   * Get compact signature (65 bytes: recovery + r + s)
+   */
+  toCompact() {
+    return this.sig;
+  }
+  /**
+   * Get full signature with recovery parameter (65 bytes)
+   */
+  toBuffer() {
+    const t = new Uint8Array(65);
+    return t[0] = this.recovery + 27, t.set(this.sig, 1), t;
+  }
+  /**
+   * Recover public key from signature and message hash
+   */
+  async recoverPublicKey(t) {
+    const i = Tt.fromCompact(this.sig).addRecoveryBit(this.recovery).recoverPublicKey(t).toRawBytes(!0);
+    return new gt(i);
+  }
+}
+function qe(e, t) {
+  if (e.length !== t.length) return !1;
+  for (let n = 0; n < e.length; n++)
+    if (e[n] !== t[n]) return !1;
+  return !0;
+}
+function oe(e, t, n = ["owner", "active", "posting", "memo"]) {
+  const s = {};
+  for (const r of n) {
+    const i = T.fromLogin(e, t, r), o = i.toPublic();
+    s[r] = {
+      private: i.toWif(),
+      public: o.toString()
+    };
+  }
+  return s;
+}
+function as(e) {
+  try {
+    return T.fromWif(e), !0;
+  } catch {
+    return !1;
+  }
+}
+function us(e, t = "ZTR") {
+  try {
+    return gt.fromString(e, t), !0;
+  } catch {
+    return !1;
+  }
+}
+class Ie {
+  buffer = [];
+  /**
+   * Write a uint8 (1 byte)
+   */
+  writeUInt8(t) {
+    this.buffer.push(t & 255);
+  }
+  /**
+   * Write a uint16 (2 bytes, little-endian)
+   */
+  writeUInt16(t) {
+    this.buffer.push(t & 255), this.buffer.push(t >> 8 & 255);
+  }
+  /**
+   * Write a uint32 (4 bytes, little-endian)
+   */
+  writeUInt32(t) {
+    this.buffer.push(t & 255), this.buffer.push(t >> 8 & 255), this.buffer.push(t >> 16 & 255), this.buffer.push(t >> 24 & 255);
+  }
+  /**
+   * Write a uint64 (8 bytes, little-endian)
+   */
+  writeUInt64(t) {
+    const n = typeof t == "number" ? BigInt(t) : t;
+    for (let s = 0; s < 8; s++)
+      this.buffer.push(Number(n >> BigInt(s * 8) & BigInt(255)));
+  }
+  /**
+   * Write variable-length integer
+   */
+  writeVarint32(t) {
+    for (; t >= 128; )
+      this.buffer.push(t & 127 | 128), t >>= 7;
+    this.buffer.push(t & 127);
+  }
+  /**
+   * Write a string
+   */
+  writeString(t) {
+    const n = new TextEncoder().encode(t);
+    this.writeVarint32(n.length);
+    for (const s of n)
+      this.buffer.push(s);
+  }
+  /**
+   * Write bytes
+   */
+  writeBytes(t) {
+    for (const n of t)
+      this.buffer.push(n);
+  }
+  /**
+   * Write array with length prefix
+   */
+  writeArray(t, n) {
+    this.writeVarint32(t.length);
+    for (const s of t)
+      n(s);
+  }
+  /**
+   * Get the serialized buffer
+   */
+  toBuffer() {
+    return new Uint8Array(this.buffer);
+  }
+}
+function Yt(e) {
+  const t = new Ie();
+  t.writeUInt16(e.ref_block_num), t.writeUInt32(e.ref_block_prefix);
+  const n = new Date(e.expiration), s = Math.floor(n.getTime() / 1e3);
+  return t.writeUInt32(s), t.writeArray(e.operations, (r) => {
+    On(t, r);
+  }), t.writeArray(e.extensions, (r) => {
+    typeof r == "object" && r !== null && t.writeString(JSON.stringify(r));
+  }), t.toBuffer();
+}
+function On(e, t) {
+  if (!Array.isArray(t) || t.length !== 2)
+    throw new Error("Invalid operation format");
+  const [n, s] = t;
+  if (typeof n == "number")
+    e.writeVarint32(n);
+  else if (typeof n == "string") {
+    const r = Pn(n);
+    e.writeVarint32(r);
+  }
+  Re(e, s);
+}
+function Pn(e) {
+  return {
+    vote: 0,
+    comment: 1,
+    transfer: 2,
+    transfer_to_vesting: 3,
+    withdraw_vesting: 4,
+    limit_order_create: 5,
+    limit_order_cancel: 6,
+    feed_publish: 7,
+    convert: 8,
+    account_create: 9,
+    account_update: 10,
+    witness_update: 11,
+    account_witness_vote: 12,
+    account_witness_proxy: 13
+    // ... more operations
+  }[e] ?? -1;
+}
+function Re(e, t) {
+  if (t != null) {
+    if (typeof t == "string")
+      e.writeString(t);
+    else if (typeof t == "number")
+      e.writeUInt32(t);
+    else if (typeof t == "boolean")
+      e.writeUInt8(t ? 1 : 0);
+    else if (typeof t == "object")
+      for (const n of Object.values(t))
+        Re(e, n);
+  }
+}
+function fs(e) {
+  const t = new Ie(), n = Yt(e);
+  return t.writeBytes(n), e.signatures ? t.writeArray(e.signatures, (s) => {
+    t.writeBytes(s);
+  }) : t.writeVarint32(0), t.toBuffer();
+}
+/*! noble-ciphers - MIT License (c) 2023 Paul Miller (paulmillr.com) */
+function Kn(e) {
+  return e instanceof Uint8Array || ArrayBuffer.isView(e) && e.constructor.name === "Uint8Array";
+}
+function P(e, t, n = "") {
+  const s = Kn(e), r = e?.length, i = t !== void 0;
+  if (!s || i && r !== t) {
+    const o = n && `"${n}" `, u = i ? ` of length ${t}` : "", a = s ? `length=${r}` : `type=${typeof e}`;
+    throw new Error(o + "expected Uint8Array" + u + ", got " + a);
+  }
+  return e;
+}
+function Y(e) {
+  return new Uint32Array(e.buffer, e.byteOffset, Math.floor(e.byteLength / 4));
+}
+function lt(...e) {
+  for (let t = 0; t < e.length; t++)
+    e[t].fill(0);
+}
+const Mn = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+function Vn(e, t) {
+  return e.buffer === t.buffer && // best we can do, may fail with an obscure Proxy
+  e.byteOffset < t.byteOffset + t.byteLength && // a starts before b end
+  t.byteOffset < e.byteOffset + e.byteLength;
+}
+function ke(e, t) {
+  if (Vn(e, t) && e.byteOffset < t.byteOffset)
+    throw new Error("complex overlap of input and output is not supported");
+}
+const Wn = /* @__NO_SIDE_EFFECTS__ */ (e, t) => {
+  function n(s, ...r) {
+    if (P(s, void 0, "key"), !Mn)
+      throw new Error("Non little-endian hardware is not yet supported");
+    if (e.nonceLength !== void 0) {
+      const h = r[0];
+      P(h, e.varSizeNonce ? void 0 : e.nonceLength, "nonce");
+    }
+    const i = e.tagLength;
+    i && r[1] !== void 0 && P(r[1], void 0, "AAD");
+    const o = t(s, ...r), u = (h, f) => {
+      if (f !== void 0) {
+        if (h !== 2)
+          throw new Error("cipher output not supported");
+        P(f, void 0, "output");
+      }
+    };
+    let a = !1;
+    return {
+      encrypt(h, f) {
+        if (a)
+          throw new Error("cannot encrypt() twice with same key + nonce");
+        return a = !0, P(h), u(o.encrypt.length, f), o.encrypt(h, f);
+      },
+      decrypt(h, f) {
+        if (P(h), i && h.length < i)
+          throw new Error('"ciphertext" expected length bigger than tagLength=' + i);
+        return u(o.decrypt.length, f), o.decrypt(h, f);
+      }
+    };
+  }
+  return Object.assign(n, e), n;
+};
+function Ce(e, t, n = !0) {
+  if (t === void 0)
+    return new Uint8Array(e);
+  if (t.length !== e)
+    throw new Error('"output" expected Uint8Array of length ' + e + ", got: " + t.length);
+  if (n && !it(t))
+    throw new Error("invalid output, must be aligned");
+  return t;
+}
+function it(e) {
+  return e.byteOffset % 4 === 0;
+}
+function ht(e) {
+  return Uint8Array.from(e);
+}
+function Ln(e = 32) {
+  const t = typeof globalThis == "object" ? globalThis.crypto : null;
+  if (typeof t?.getRandomValues != "function")
+    throw new Error("crypto.getRandomValues must be defined");
+  return t.getRandomValues(new Uint8Array(e));
+}
+const G = 16, Yn = 283;
+function jn(e) {
+  if (![16, 24, 32].includes(e.length))
+    throw new Error('"aes key" expected Uint8Array of length 16/24/32, got length=' + e.length);
+}
+function jt(e) {
+  return e << 1 ^ Yn & -(e >> 7);
+}
+function rt(e, t) {
+  let n = 0;
+  for (; t > 0; t >>= 1)
+    n ^= e & -(t & 1), e = jt(e);
+  return n;
+}
+const Ot = /* @__PURE__ */ (() => {
+  const e = new Uint8Array(256);
+  for (let n = 0, s = 1; n < 256; n++, s ^= jt(s))
+    e[n] = s;
+  const t = new Uint8Array(256);
+  t[0] = 99;
+  for (let n = 0; n < 255; n++) {
+    let s = e[255 - n];
+    s |= s << 8, t[e[n]] = (s ^ s >> 4 ^ s >> 5 ^ s >> 6 ^ s >> 7 ^ 99) & 255;
+  }
+  return lt(e), t;
+})(), Gn = /* @__PURE__ */ Ot.map((e, t) => Ot.indexOf(t)), zn = (e) => e << 24 | e >>> 8, Nt = (e) => e << 8 | e >>> 24;
+function Ne(e, t) {
+  if (e.length !== 256)
+    throw new Error("Wrong sbox length");
+  const n = new Uint32Array(256).map((c, h) => t(e[h])), s = n.map(Nt), r = s.map(Nt), i = r.map(Nt), o = new Uint32Array(256 * 256), u = new Uint32Array(256 * 256), a = new Uint16Array(256 * 256);
+  for (let c = 0; c < 256; c++)
+    for (let h = 0; h < 256; h++) {
+      const f = c * 256 + h;
+      o[f] = n[c] ^ s[h], u[f] = r[c] ^ i[h], a[f] = e[c] << 8 | e[h];
+    }
+  return { sbox: e, sbox2: a, T0: n, T1: s, T2: r, T3: i, T01: o, T23: u };
+}
+const Gt = /* @__PURE__ */ Ne(Ot, (e) => rt(e, 3) << 24 | e << 16 | e << 8 | rt(e, 2)), He = /* @__PURE__ */ Ne(Gn, (e) => rt(e, 11) << 24 | rt(e, 13) << 16 | rt(e, 9) << 8 | rt(e, 14)), $n = /* @__PURE__ */ (() => {
+  const e = new Uint8Array(16);
+  for (let t = 0, n = 1; t < 16; t++, n = jt(n))
+    e[t] = n;
+  return e;
+})();
+function Fe(e) {
+  P(e);
+  const t = e.length;
+  jn(e);
+  const { sbox2: n } = Gt, s = [];
+  it(e) || s.push(e = ht(e));
+  const r = Y(e), i = r.length, o = (a) => N(n, a, a, a, a), u = new Uint32Array(t + 28);
+  u.set(r);
+  for (let a = i; a < u.length; a++) {
+    let c = u[a - 1];
+    a % i === 0 ? c = o(zn(c)) ^ $n[a / i - 1] : i > 6 && a % i === 4 && (c = o(c)), u[a] = u[a - i] ^ c;
+  }
+  return lt(...s), u;
+}
+function Zn(e) {
+  const t = Fe(e), n = t.slice(), s = t.length, { sbox2: r } = Gt, { T0: i, T1: o, T2: u, T3: a } = He;
+  for (let c = 0; c < s; c += 4)
+    for (let h = 0; h < 4; h++)
+      n[c + h] = t[s - c - 4 + h];
+  lt(t);
+  for (let c = 4; c < s - 4; c++) {
+    const h = n[c], f = N(r, h, h, h, h);
+    n[c] = i[f & 255] ^ o[f >>> 8 & 255] ^ u[f >>> 16 & 255] ^ a[f >>> 24];
+  }
+  return n;
+}
+function j(e, t, n, s, r, i) {
+  return e[n << 8 & 65280 | s >>> 8 & 255] ^ t[r >>> 8 & 65280 | i >>> 24 & 255];
+}
+function N(e, t, n, s, r) {
+  return e[t & 255 | n & 65280] | e[s >>> 16 & 255 | r >>> 16 & 65280] << 16;
+}
+function ce(e, t, n, s, r) {
+  const { sbox2: i, T01: o, T23: u } = Gt;
+  let a = 0;
+  t ^= e[a++], n ^= e[a++], s ^= e[a++], r ^= e[a++];
+  const c = e.length / 4 - 2;
+  for (let y = 0; y < c; y++) {
+    const b = e[a++] ^ j(o, u, t, n, s, r), _ = e[a++] ^ j(o, u, n, s, r, t), x = e[a++] ^ j(o, u, s, r, t, n), g = e[a++] ^ j(o, u, r, t, n, s);
+    t = b, n = _, s = x, r = g;
+  }
+  const h = e[a++] ^ N(i, t, n, s, r), f = e[a++] ^ N(i, n, s, r, t), l = e[a++] ^ N(i, s, r, t, n), d = e[a++] ^ N(i, r, t, n, s);
+  return { s0: h, s1: f, s2: l, s3: d };
+}
+function Xn(e, t, n, s, r) {
+  const { sbox2: i, T01: o, T23: u } = He;
+  let a = 0;
+  t ^= e[a++], n ^= e[a++], s ^= e[a++], r ^= e[a++];
+  const c = e.length / 4 - 2;
+  for (let y = 0; y < c; y++) {
+    const b = e[a++] ^ j(o, u, t, r, s, n), _ = e[a++] ^ j(o, u, n, t, r, s), x = e[a++] ^ j(o, u, s, n, t, r), g = e[a++] ^ j(o, u, r, s, n, t);
+    t = b, n = _, s = x, r = g;
+  }
+  const h = e[a++] ^ N(i, t, r, s, n), f = e[a++] ^ N(i, n, t, r, s), l = e[a++] ^ N(i, s, n, t, r), d = e[a++] ^ N(i, r, s, n, t);
+  return { s0: h, s1: f, s2: l, s3: d };
+}
+function Qn(e) {
+  if (P(e), e.length % G !== 0)
+    throw new Error("aes-(cbc/ecb).decrypt ciphertext should consist of blocks with size " + G);
+}
+function Jn(e, t, n) {
+  P(e);
+  let s = e.length;
+  const r = s % G;
+  if (!t && r !== 0)
+    throw new Error("aec/(cbc-ecb): unpadded plaintext with disabled padding");
+  it(e) || (e = ht(e));
+  const i = Y(e);
+  if (t) {
+    let u = G - r;
+    u || (u = G), s = s + u;
+  }
+  n = Ce(s, n), ke(e, n);
+  const o = Y(n);
+  return { b: i, o, out: n };
+}
+function ts(e, t) {
+  if (!t)
+    return e;
+  const n = e.length;
+  if (!n)
+    throw new Error("aes/pcks5: empty ciphertext not allowed");
+  const s = e[n - 1];
+  if (s <= 0 || s > 16)
+    throw new Error("aes/pcks5: wrong padding");
+  const r = e.subarray(0, -s);
+  for (let i = 0; i < s; i++)
+    if (e[n - i - 1] !== s)
+      throw new Error("aes/pcks5: wrong padding");
+  return r;
+}
+function es(e) {
+  const t = new Uint8Array(16), n = Y(t);
+  t.set(e);
+  const s = G - e.length;
+  for (let r = G - s; r < G; r++)
+    t[r] = s;
+  return n;
+}
+const De = /* @__PURE__ */ Wn({ blockSize: 16, nonceLength: 16 }, function(t, n, s = {}) {
+  const r = !s.disablePadding;
+  return {
+    encrypt(i, o) {
+      const u = Fe(t), { b: a, o: c, out: h } = Jn(i, r, o);
+      let f = n;
+      const l = [u];
+      it(f) || l.push(f = ht(f));
+      const d = Y(f);
+      let y = d[0], b = d[1], _ = d[2], x = d[3], g = 0;
+      for (; g + 4 <= a.length; )
+        y ^= a[g + 0], b ^= a[g + 1], _ ^= a[g + 2], x ^= a[g + 3], { s0: y, s1: b, s2: _, s3: x } = ce(u, y, b, _, x), c[g++] = y, c[g++] = b, c[g++] = _, c[g++] = x;
+      if (r) {
+        const p = es(i.subarray(g * 4));
+        y ^= p[0], b ^= p[1], _ ^= p[2], x ^= p[3], { s0: y, s1: b, s2: _, s3: x } = ce(u, y, b, _, x), c[g++] = y, c[g++] = b, c[g++] = _, c[g++] = x;
+      }
+      return lt(...l), h;
+    },
+    decrypt(i, o) {
+      Qn(i);
+      const u = Zn(t);
+      let a = n;
+      const c = [u];
+      it(a) || c.push(a = ht(a));
+      const h = Y(a);
+      o = Ce(i.length, o), it(i) || c.push(i = ht(i)), ke(i, o);
+      const f = Y(i), l = Y(o);
+      let d = h[0], y = h[1], b = h[2], _ = h[3];
+      for (let x = 0; x + 4 <= f.length; ) {
+        const g = d, p = y, A = b, m = _;
+        d = f[x + 0], y = f[x + 1], b = f[x + 2], _ = f[x + 3];
+        const { s0: F, s1: at, s2: q, s3: I } = Xn(u, d, y, b, _);
+        l[x++] = F ^ g, l[x++] = at ^ p, l[x++] = q ^ A, l[x++] = I ^ m;
+      }
+      return lt(...c), ts(o, r);
+    }
+  };
+});
+function ns(e = 8) {
+  return Ln(e);
+}
+function hs(e, t, n, s) {
+  n.startsWith("#") || (n = "#" + n);
+  const r = n.slice(1), i = new TextEncoder().encode(r), o = s ?? ns(8), u = e.getSharedSecret(t), a = new Uint8Array(o.length + u.length);
+  a.set(o), a.set(u, o.length);
+  const c = fe(a), h = c.slice(0, 16), f = c.slice(16, 48), d = De(f, h).encrypt(i), b = R(f).slice(0, 4), _ = new Uint8Array(o.length + b.length + d.length);
+  return _.set(o, 0), _.set(b, o.length), _.set(d, o.length + b.length), "#" + ct.encode(_);
+}
+function ls(e, t) {
+  if (!t.startsWith("#"))
+    return t;
+  throw new Error("decodeMemo requires sender public key - use decodeMemoWithKey instead");
+}
+function ds(e, t, n) {
+  if (!n.startsWith("#"))
+    return n;
+  try {
+    const s = ct.decode(n.slice(1)), r = s.slice(0, 8), i = s.slice(8, 12), o = s.slice(12), u = e.getSharedSecret(t), a = new Uint8Array(r.length + u.length);
+    a.set(r), a.set(u, r.length);
+    const c = fe(a), h = c.slice(0, 16), f = c.slice(16, 48), d = R(f).slice(0, 4);
+    let y = !0;
+    for (let g = 0; g < 4; g++)
+      if (i[g] !== d[g]) {
+        y = !1;
+        break;
+      }
+    if (!y)
+      throw new Error("Invalid memo checksum");
+    const _ = De(f, h).decrypt(o);
+    return "#" + new TextDecoder().decode(_);
+  } catch (s) {
+    throw new Error(`Failed to decode memo: ${s instanceof Error ? s.message : String(s)}`);
+  }
+}
+async function ss(e, t, n) {
+  const s = Yt(e), r = Pt(n), i = new Uint8Array(r.length + s.length);
+  i.set(r), i.set(s, r.length);
+  const o = R(i), u = [];
+  for (const a of t) {
+    const h = await (typeof a == "string" ? T.fromWif(a) : a).sign(o);
+    u.push(rs(h.toBuffer()));
+  }
+  return {
+    ...e,
+    signatures: u
+  };
+}
+async function ys(e, t) {
+  const { signatures: n, ...s } = e, r = Yt(s), i = Pt(t), o = new Uint8Array(i.length + r.length);
+  o.set(i), o.set(r, i.length);
+  const u = R(o), a = [];
+  for (const c of n) {
+    const h = Pt(c), l = await new Ue(h).recoverPublicKey(u);
+    a.push(l);
+  }
+  return a;
+}
+function bs(e, t, n, s) {
+  const r = typeof n == "string" ? n : n.toISOString().split(".")[0] ?? "";
+  return {
+    ref_block_num: e & 65535,
+    // Ensure it's within uint16 range
+    ref_block_prefix: t >>> 0,
+    // Ensure it's uint32
+    expiration: r,
+    operations: s,
+    extensions: []
+  };
+}
+function Pt(e) {
+  const t = e.startsWith("0x") ? e.slice(2) : e, n = new Uint8Array(t.length / 2);
+  for (let s = 0; s < t.length; s += 2)
+    n[s / 2] = parseInt(t.slice(s, s + 2), 16);
+  return n;
+}
+function rs(e) {
+  return Array.from(e).map((t) => t.toString(16).padStart(2, "0")).join("");
+}
+const gs = {
+  /**
+   * Generate all role keys from account name and password
+   * @param name Account name
+   * @param password Password
+   * @param roles Array of role names (default: ['owner', 'active', 'posting', 'memo'])
+   * @returns Object mapping roles to private WIF keys and public keys
+   *
+   * @example
+   * ```typescript
+   * const keys = Auth.getPrivateKeys('alice', 'password123');
+   * console.log(keys.active); // WIF private key
+   * console.log(keys.activePubkey); // ZTR... public key
+   * ```
+   */
+  getPrivateKeys(e, t, n = ["owner", "active", "posting", "memo"]) {
+    const s = {}, r = oe(e, t, n);
+    for (const i of n) {
+      const o = r[i];
+      o && (s[i] = o.private, s[`${i}Pubkey`] = o.public);
+    }
+    return s;
+  },
+  /**
+   * Generate public keys only from account name and password
+   * @param name Account name
+   * @param password Password
+   * @param roles Array of role names
+   * @returns Object mapping roles to public keys
+   */
+  generateKeys(e, t, n = ["owner", "active", "posting", "memo"]) {
+    const s = oe(e, t, n), r = {};
+    for (const i of n) {
+      const o = s[i];
+      o && (r[i] = o.public);
+    }
+    return r;
+  },
+  /**
+   * Convert account credentials to WIF format for a specific role
+   * @param name Account name
+   * @param password Password
+   * @param role Role name (e.g., 'active', 'posting')
+   * @returns WIF private key
+   */
+  toWif(e, t, n = "active") {
+    return T.fromLogin(e, t, n).toWif();
+  },
+  /**
+   * Convert WIF private key to public key
+   * @param privateWif WIF format private key
+   * @param addressPrefix Address prefix (default: 'ZTR')
+   * @returns Public key string
+   */
+  wifToPublic(e, t = "ZTR") {
+    return T.fromWif(e).toPublic().toString(t);
+  },
+  /**
+   * Check if a WIF key is valid
+   * @param privateWif WIF format private key
+   * @returns true if valid, false otherwise
+   */
+  isWif(e) {
+    try {
+      return T.fromWif(e), !0;
+    } catch {
+      return !1;
+    }
+  },
+  /**
+   * Sign a transaction with private keys
+   * @param tx Transaction to sign
+   * @param keys Array of WIF private keys
+   * @param chainId Chain ID
+   * @returns Signed transaction
+   */
+  signTransaction(e, t, n) {
+    return ss(e, t, n);
+  },
+  /**
+   * Verify account credentials against authorities
+   * @param name Account name
+   * @param password Password
+   * @param auths Authority public keys to verify against
+   * @param role Role to check (default: 'active')
+   * @returns true if credentials match, false otherwise
+   */
+  verify(e, t, n, s = "active") {
+    const i = T.fromLogin(e, t, s).toPublic().toString("ZTR"), o = n[s];
+    return o ? o.includes(i) : !1;
+  }
+};
+var is = /* @__PURE__ */ ((e) => (e[e.PARSE_ERROR = -32700] = "PARSE_ERROR", e[e.INVALID_REQUEST = -32600] = "INVALID_REQUEST", e[e.METHOD_NOT_FOUND = -32601] = "METHOD_NOT_FOUND", e[e.INVALID_PARAMS = -32602] = "INVALID_PARAMS", e[e.INTERNAL_ERROR = -32603] = "INTERNAL_ERROR", e[e.SERVER_ERROR = -32e3] = "SERVER_ERROR", e[e.NO_PARAMS = -32001] = "NO_PARAMS", e[e.PARSE_PARAMS_ERROR = -32002] = "PARSE_PARAMS_ERROR", e[e.ERROR_DURING_CALL = -32003] = "ERROR_DURING_CALL", e))(is || {}), os = /* @__PURE__ */ ((e) => (e.BY_NAME = "by_name", e.BY_PROXY = "by_proxy", e.BY_NEXT_VESTING_WITHDRAWAL = "by_next_vesting_withdrawal", e.BY_ACCOUNT = "by_account", e.BY_EXPIRATION = "by_expiration", e.BY_EFFECTIVE_DATE = "by_effective_date", e.BY_VOTE = "by_vote", e.BY_ACCOUNT_WITNESS = "by_account_witness", e.BY_WITNESS_ACCOUNT = "by_witness_account", e.BY_FROM_ID = "by_from_id", e.BY_RATIFICATION_DEADLINE = "by_ratification_deadline", e.BY_WITHDRAW_ROUTE = "by_withdraw_route", e.BY_DESTINATION = "by_destination", e.BY_COMPLETE_FROM_ID = "by_complete_from_id", e.BY_TO_COMPLETE = "by_to_complete", e.BY_DELEGATION = "by_delegation", e.BY_ACCOUNT_EXPIRATION = "by_account_expiration", e.BY_CONVERSION_DATE = "by_conversion_date", e.BY_CASHOUT_TIME = "by_cashout_time", e.BY_PERMLINK = "by_permlink", e.BY_ROOT = "by_root", e.BY_PARENT = "by_parent", e.BY_LAST_UPDATE = "by_last_update", e.BY_AUTHOR_LAST_UPDATE = "by_author_last_update", e.BY_COMMENT_VOTER = "by_comment_voter", e.BY_VOTER_COMMENT = "by_voter_comment", e.BY_PRICE = "by_price", e.BY_ACCOUNT_CREATION = "by_account_creation", e))(os || {});
+export {
+  gs as Auth,
+  is as JsonRpcErrorCode,
+  os as ListOrder,
+  T as PrivateKey,
+  gt as PublicKey,
+  Ue as Signature,
+  Ie as TransactionSerializer,
+  cs as ZatteraClient,
+  bs as createTransaction,
+  ls as decodeMemo,
+  ds as decodeMemoWithKey,
+  hs as encodeMemo,
+  on as generateChainId,
+  oe as generateKeys,
+  us as isPublicKey,
+  as as isWif,
+  fs as serializeSignedTransaction,
+  Yt as serializeTransaction,
+  ss as signTransaction,
+  ys as verifyTransactionSignatures
+};
+//# sourceMappingURL=index.js.map