@fastnear/api 0.9.9 → 0.9.10

package/dist/umd/browser.global.js

@@ -1,5 +1,5 @@
-/* ⋈ 🏃🏻💨 FastNear API - IIFE/UMD (@fastnear/api version 0.9.8) */
-/* https://www.npmjs.com/package/@fastnear/api/v/0.9.8 */
+/* ⋈ 🏃🏻💨 FastNear API - IIFE/UMD (@fastnear/api version 0.9.10) */
+/* https://www.npmjs.com/package/@fastnear/api/v/0.9.10 */
 "use strict";
 var near = (() => {
   var __defProp = Object.defineProperty;
@@ -581,16 +581,29 @@ var near = (() => {
     txToJsonStringified: () => txToJsonStringified
   });
 
-  // ../../node_modules/@noble/hashes/esm/_assert.js
+  // ../utils/node_modules/@noble/hashes/utils.js
   function isBytes(a) {
     return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
   }
   __name(isBytes, "isBytes");
-  function abytes(b, ...lengths) {
-    if (!isBytes(b))
-      throw new Error("Uint8Array expected");
-    if (lengths.length > 0 && !lengths.includes(b.length))
-      throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
+  function anumber(n, title = "") {
+    if (!Number.isSafeInteger(n) || n < 0) {
+      const prefix = title && `"${title}" `;
+      throw new Error(`${prefix}expected integer >= 0, got ${n}`);
+    }
+  }
+  __name(anumber, "anumber");
+  function abytes(value, length, title = "") {
+    const bytes = isBytes(value);
+    const len = value?.length;
+    const needsLen = length !== void 0;
+    if (!bytes || needsLen && len !== length) {
+      const prefix = title && `"${title}" `;
+      const ofLen = needsLen ? ` of length ${length}` : "";
+      const got = bytes ? `length=${len}` : `type=${typeof value}`;
+      throw new Error(prefix + "expected Uint8Array" + ofLen + ", got " + got);
+    }
+    return value;
   }
   __name(abytes, "abytes");
   function aexists(instance, checkFinished = true) {
@@ -601,18 +614,19 @@ var near = (() => {
   }
   __name(aexists, "aexists");
   function aoutput(out, instance) {
-    abytes(out);
+    abytes(out, void 0, "digestInto() output");
     const min = instance.outputLen;
     if (out.length < min) {
-      throw new Error("digestInto() expects output buffer of length at least " + min);
+      throw new Error('"digestInto() output" expected to be of length >=' + min);
     }
   }
   __name(aoutput, "aoutput");
-
-  // ../../node_modules/@noble/hashes/esm/crypto.js
-  var crypto2 = typeof globalThis === "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
-
-  // ../../node_modules/@noble/hashes/esm/utils.js
+  function clean(...arrays) {
+    for (let i = 0; i < arrays.length; i++) {
+      arrays[i].fill(0);
+    }
+  }
+  __name(clean, "clean");
   function createView(arr) {
     return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
   }
@@ -621,62 +635,93 @@ var near = (() => {
     return word << 32 - shift | word >>> shift;
   }
   __name(rotr, "rotr");
-  function utf8ToBytes(str) {
-    if (typeof str !== "string")
-      throw new Error("utf8ToBytes expected string, got " + typeof str);
-    return new Uint8Array(new TextEncoder().encode(str));
+  var hasHexBuiltin = /* @__PURE__ */ (() => (
+    // @ts-ignore
+    typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function"
+  ))();
+  var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
+  function bytesToHex(bytes) {
+    abytes(bytes);
+    if (hasHexBuiltin)
+      return bytes.toHex();
+    let hex = "";
+    for (let i = 0; i < bytes.length; i++) {
+      hex += hexes[bytes[i]];
+    }
+    return hex;
   }
-  __name(utf8ToBytes, "utf8ToBytes");
-  function toBytes(data) {
-    if (typeof data === "string")
-      data = utf8ToBytes(data);
-    abytes(data);
-    return data;
+  __name(bytesToHex, "bytesToHex");
+  var asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
+  function asciiToBase16(ch) {
+    if (ch >= asciis._0 && ch <= asciis._9)
+      return ch - asciis._0;
+    if (ch >= asciis.A && ch <= asciis.F)
+      return ch - (asciis.A - 10);
+    if (ch >= asciis.a && ch <= asciis.f)
+      return ch - (asciis.a - 10);
+    return;
   }
-  __name(toBytes, "toBytes");
-  var Hash = class {
-    static {
-      __name(this, "Hash");
+  __name(asciiToBase16, "asciiToBase16");
+  function hexToBytes(hex) {
+    if (typeof hex !== "string")
+      throw new Error("hex string expected, got " + typeof hex);
+    if (hasHexBuiltin)
+      return Uint8Array.fromHex(hex);
+    const hl = hex.length;
+    const al = hl / 2;
+    if (hl % 2)
+      throw new Error("hex string expected, got unpadded hex of length " + hl);
+    const array = new Uint8Array(al);
+    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
+      const n1 = asciiToBase16(hex.charCodeAt(hi));
+      const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
+      if (n1 === void 0 || n2 === void 0) {
+        const char = hex[hi] + hex[hi + 1];
+        throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
+      }
+      array[ai] = n1 * 16 + n2;
     }
-    // Safe version that clones internal state
-    clone() {
-      return this._cloneInto();
+    return array;
+  }
+  __name(hexToBytes, "hexToBytes");
+  function concatBytes(...arrays) {
+    let sum = 0;
+    for (let i = 0; i < arrays.length; i++) {
+      const a = arrays[i];
+      abytes(a);
+      sum += a.length;
     }
-  };
-  function wrapConstructor(hashCons) {
-    const hashC = /* @__PURE__ */ __name((msg) => hashCons().update(toBytes(msg)).digest(), "hashC");
-    const tmp = hashCons();
+    const res = new Uint8Array(sum);
+    for (let i = 0, pad = 0; i < arrays.length; i++) {
+      const a = arrays[i];
+      res.set(a, pad);
+      pad += a.length;
+    }
+    return res;
+  }
+  __name(concatBytes, "concatBytes");
+  function createHasher(hashCons, info = {}) {
+    const hashC = /* @__PURE__ */ __name((msg, opts) => hashCons(opts).update(msg).digest(), "hashC");
+    const tmp = hashCons(void 0);
     hashC.outputLen = tmp.outputLen;
     hashC.blockLen = tmp.blockLen;
-    hashC.create = () => hashCons();
-    return hashC;
+    hashC.create = (opts) => hashCons(opts);
+    Object.assign(hashC, info);
+    return Object.freeze(hashC);
   }
-  __name(wrapConstructor, "wrapConstructor");
+  __name(createHasher, "createHasher");
   function randomBytes(bytesLength = 32) {
-    if (crypto2 && typeof crypto2.getRandomValues === "function") {
-      return crypto2.getRandomValues(new Uint8Array(bytesLength));
-    }
-    if (crypto2 && typeof crypto2.randomBytes === "function") {
-      return crypto2.randomBytes(bytesLength);
-    }
-    throw new Error("crypto.getRandomValues must be defined");
+    const cr = typeof globalThis === "object" ? globalThis.crypto : null;
+    if (typeof cr?.getRandomValues !== "function")
+      throw new Error("crypto.getRandomValues must be defined");
+    return cr.getRandomValues(new Uint8Array(bytesLength));
   }
   __name(randomBytes, "randomBytes");
+  var oidNist = /* @__PURE__ */ __name((suffix) => ({
+    oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, suffix])
+  }), "oidNist");
 
-  // ../../node_modules/@noble/hashes/esm/_md.js
-  function setBigUint64(view2, byteOffset, value, isLE) {
-    if (typeof view2.setBigUint64 === "function")
-      return view2.setBigUint64(byteOffset, value, isLE);
-    const _32n2 = BigInt(32);
-    const _u32_max = BigInt(4294967295);
-    const wh = Number(value >> _32n2 & _u32_max);
-    const wl = Number(value & _u32_max);
-    const h = isLE ? 4 : 0;
-    const l = isLE ? 0 : 4;
-    view2.setUint32(byteOffset + h, wh, isLE);
-    view2.setUint32(byteOffset + l, wl, isLE);
-  }
-  __name(setBigUint64, "setBigUint64");
+  // ../utils/node_modules/@noble/hashes/_md.js
   function Chi(a, b, c) {
     return a & b ^ ~a & c;
   }
@@ -685,27 +730,33 @@ var near = (() => {
     return a & b ^ a & c ^ b & c;
   }
   __name(Maj, "Maj");
-  var HashMD = class extends Hash {
+  var HashMD = class {
     static {
       __name(this, "HashMD");
     }
+    blockLen;
+    outputLen;
+    padOffset;
+    isLE;
+    // For partial updates less than block size
+    buffer;
+    view;
+    finished = false;
+    length = 0;
+    pos = 0;
+    destroyed = false;
     constructor(blockLen, outputLen, padOffset, isLE) {
-      super();
       this.blockLen = blockLen;
       this.outputLen = outputLen;
       this.padOffset = padOffset;
       this.isLE = isLE;
-      this.finished = false;
-      this.length = 0;
-      this.pos = 0;
-      this.destroyed = false;
       this.buffer = new Uint8Array(blockLen);
       this.view = createView(this.buffer);
     }
     update(data) {
       aexists(this);
+      abytes(data);
       const { view: view2, buffer, blockLen } = this;
-      data = toBytes(data);
       const len = data.length;
       for (let pos = 0; pos < len; ) {
         const take = Math.min(blockLen - this.pos, len - pos);
@@ -734,19 +785,19 @@ var near = (() => {
       const { buffer, view: view2, blockLen, isLE } = this;
       let { pos } = this;
       buffer[pos++] = 128;
-      this.buffer.subarray(pos).fill(0);
+      clean(this.buffer.subarray(pos));
       if (this.padOffset > blockLen - pos) {
         this.process(view2, 0);
         pos = 0;
       }
       for (let i = pos; i < blockLen; i++)
         buffer[i] = 0;
-      setBigUint64(view2, blockLen - 8, BigInt(this.length * 8), isLE);
+      view2.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);
       this.process(view2, 0);
       const oview = createView(out);
       const len = this.outputLen;
       if (len % 4)
-        throw new Error("_sha2: outputLen should be aligned to 32bit");
+        throw new Error("_sha2: outputLen must be aligned to 32bit");
       const outLen = len / 4;
       const state2 = this.get();
       if (outLen > state2.length)
@@ -762,20 +813,51 @@ var near = (() => {
       return res;
     }
     _cloneInto(to) {
-      to || (to = new this.constructor());
+      to ||= new this.constructor();
       to.set(...this.get());
       const { blockLen, buffer, length, finished, destroyed, pos } = this;
+      to.destroyed = destroyed;
+      to.finished = finished;
       to.length = length;
       to.pos = pos;
-      to.finished = finished;
-      to.destroyed = destroyed;
       if (length % blockLen)
         to.buffer.set(buffer);
       return to;
     }
+    clone() {
+      return this._cloneInto();
+    }
   };
+  var SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]);
+  var SHA512_IV = /* @__PURE__ */ Uint32Array.from([
+    1779033703,
+    4089235720,
+    3144134277,
+    2227873595,
+    1013904242,
+    4271175723,
+    2773480762,
+    1595750129,
+    1359893119,
+    2917565137,
+    2600822924,
+    725511199,
+    528734635,
+    4215389547,
+    1541459225,
+    327033209
+  ]);
 
-  // ../../node_modules/@noble/hashes/esm/_u64.js
+  // ../utils/node_modules/@noble/hashes/_u64.js
   var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
   var _32n = /* @__PURE__ */ BigInt(32);
   function fromBig(n, le = false) {
@@ -785,28 +867,22 @@ var near = (() => {
   }
   __name(fromBig, "fromBig");
   function split(lst, le = false) {
-    let Ah = new Uint32Array(lst.length);
-    let Al = new Uint32Array(lst.length);
-    for (let i = 0; i < lst.length; i++) {
+    const len = lst.length;
+    let Ah = new Uint32Array(len);
+    let Al = new Uint32Array(len);
+    for (let i = 0; i < len; i++) {
       const { h, l } = fromBig(lst[i], le);
       [Ah[i], Al[i]] = [h, l];
     }
     return [Ah, Al];
   }
   __name(split, "split");
-  var toBig = /* @__PURE__ */ __name((h, l) => BigInt(h >>> 0) << _32n | BigInt(l >>> 0), "toBig");
   var shrSH = /* @__PURE__ */ __name((h, _l, s) => h >>> s, "shrSH");
   var shrSL = /* @__PURE__ */ __name((h, l, s) => h << 32 - s | l >>> s, "shrSL");
   var rotrSH = /* @__PURE__ */ __name((h, l, s) => h >>> s | l << 32 - s, "rotrSH");
   var rotrSL = /* @__PURE__ */ __name((h, l, s) => h << 32 - s | l >>> s, "rotrSL");
   var rotrBH = /* @__PURE__ */ __name((h, l, s) => h << 64 - s | l >>> s - 32, "rotrBH");
   var rotrBL = /* @__PURE__ */ __name((h, l, s) => h >>> s - 32 | l << 64 - s, "rotrBL");
-  var rotr32H = /* @__PURE__ */ __name((_h, l) => l, "rotr32H");
-  var rotr32L = /* @__PURE__ */ __name((h, _l) => h, "rotr32L");
-  var rotlSH = /* @__PURE__ */ __name((h, l, s) => h << s | l >>> 32 - s, "rotlSH");
-  var rotlSL = /* @__PURE__ */ __name((h, l, s) => l << s | h >>> 32 - s, "rotlSL");
-  var rotlBH = /* @__PURE__ */ __name((h, l, s) => l << s - 32 | h >>> 64 - s, "rotlBH");
-  var rotlBL = /* @__PURE__ */ __name((h, l, s) => h << s - 32 | l >>> 64 - s, "rotlBL");
   function add(Ah, Al, Bh, Bl) {
     const l = (Al >>> 0) + (Bl >>> 0);
     return { h: Ah + Bh + (l / 2 ** 32 | 0) | 0, l: l | 0 };
@@ -818,34 +894,159 @@ var near = (() => {
   var add4H = /* @__PURE__ */ __name((low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0, "add4H");
   var add5L = /* @__PURE__ */ __name((Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0), "add5L");
   var add5H = /* @__PURE__ */ __name((low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0, "add5H");
-  var u64 = {
-    fromBig,
-    split,
-    toBig,
-    shrSH,
-    shrSL,
-    rotrSH,
-    rotrSL,
-    rotrBH,
-    rotrBL,
-    rotr32H,
-    rotr32L,
-    rotlSH,
-    rotlSL,
-    rotlBH,
-    rotlBL,
-    add,
-    add3L,
-    add3H,
-    add4L,
-    add4H,
-    add5H,
-    add5L
-  };
-  var u64_default = u64;
 
-  // ../../node_modules/@noble/hashes/esm/sha512.js
-  var [SHA512_Kh, SHA512_Kl] = /* @__PURE__ */ (() => u64_default.split([
+  // ../utils/node_modules/@noble/hashes/sha2.js
+  var SHA256_K = /* @__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
+  ]);
+  var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+  var SHA2_32B = class extends HashMD {
+    static {
+      __name(this, "SHA2_32B");
+    }
+    constructor(outputLen) {
+      super(64, outputLen, 8, false);
+    }
+    get() {
+      const { A, B, C, D, E, F, G, H } = this;
+      return [A, B, C, D, E, F, G, H];
+    }
+    // prettier-ignore
+    set(A, B, C, D, E, F, G, H) {
+      this.A = A | 0;
+      this.B = B | 0;
+      this.C = C | 0;
+      this.D = D | 0;
+      this.E = E | 0;
+      this.F = F | 0;
+      this.G = G | 0;
+      this.H = H | 0;
+    }
+    process(view2, offset) {
+      for (let i = 0; i < 16; i++, offset += 4)
+        SHA256_W[i] = view2.getUint32(offset, false);
+      for (let i = 16; i < 64; i++) {
+        const W15 = SHA256_W[i - 15];
+        const W2 = SHA256_W[i - 2];
+        const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
+        const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
+        SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
+      }
+      let { A, B, C, D, E, F, G, H } = this;
+      for (let i = 0; i < 64; i++) {
+        const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+        const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+        const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+        const T2 = sigma0 + Maj(A, B, C) | 0;
+        H = G;
+        G = F;
+        F = E;
+        E = D + T1 | 0;
+        D = C;
+        C = B;
+        B = A;
+        A = T1 + T2 | 0;
+      }
+      A = A + this.A | 0;
+      B = B + this.B | 0;
+      C = C + this.C | 0;
+      D = D + this.D | 0;
+      E = E + this.E | 0;
+      F = F + this.F | 0;
+      G = G + this.G | 0;
+      H = H + this.H | 0;
+      this.set(A, B, C, D, E, F, G, H);
+    }
+    roundClean() {
+      clean(SHA256_W);
+    }
+    destroy() {
+      this.set(0, 0, 0, 0, 0, 0, 0, 0);
+      clean(this.buffer);
+    }
+  };
+  var _SHA256 = class extends SHA2_32B {
+    static {
+      __name(this, "_SHA256");
+    }
+    // We cannot use array here since array allows indexing by variable
+    // which means optimizer/compiler cannot use registers.
+    A = SHA256_IV[0] | 0;
+    B = SHA256_IV[1] | 0;
+    C = SHA256_IV[2] | 0;
+    D = SHA256_IV[3] | 0;
+    E = SHA256_IV[4] | 0;
+    F = SHA256_IV[5] | 0;
+    G = SHA256_IV[6] | 0;
+    H = SHA256_IV[7] | 0;
+    constructor() {
+      super(32);
+    }
+  };
+  var K512 = /* @__PURE__ */ (() => split([
     "0x428a2f98d728ae22",
     "0x7137449123ef65cd",
     "0xb5c0fbcfec4d3b2f",
@@ -927,30 +1128,16 @@ var near = (() => {
     "0x5fcb6fab3ad6faec",
     "0x6c44198c4a475817"
   ].map((n) => BigInt(n))))();
+  var SHA512_Kh = /* @__PURE__ */ (() => K512[0])();
+  var SHA512_Kl = /* @__PURE__ */ (() => K512[1])();
   var SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
   var SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
-  var SHA512 = class extends HashMD {
+  var SHA2_64B = class extends HashMD {
     static {
-      __name(this, "SHA512");
+      __name(this, "SHA2_64B");
     }
-    constructor() {
-      super(128, 64, 16, false);
-      this.Ah = 1779033703 | 0;
-      this.Al = 4089235720 | 0;
-      this.Bh = 3144134277 | 0;
-      this.Bl = 2227873595 | 0;
-      this.Ch = 1013904242 | 0;
-      this.Cl = 4271175723 | 0;
-      this.Dh = 2773480762 | 0;
-      this.Dl = 1595750129 | 0;
-      this.Eh = 1359893119 | 0;
-      this.El = 2917565137 | 0;
-      this.Fh = 2600822924 | 0;
-      this.Fl = 725511199 | 0;
-      this.Gh = 528734635 | 0;
-      this.Gl = 4215389547 | 0;
-      this.Hh = 1541459225 | 0;
-      this.Hl = 327033209 | 0;
+    constructor(outputLen) {
+      super(128, outputLen, 16, false);
     }
     // prettier-ignore
     get() {
@@ -984,28 +1171,28 @@ var near = (() => {
       for (let i = 16; i < 80; i++) {
         const W15h = SHA512_W_H[i - 15] | 0;
         const W15l = SHA512_W_L[i - 15] | 0;
-        const s0h = u64_default.rotrSH(W15h, W15l, 1) ^ u64_default.rotrSH(W15h, W15l, 8) ^ u64_default.shrSH(W15h, W15l, 7);
-        const s0l = u64_default.rotrSL(W15h, W15l, 1) ^ u64_default.rotrSL(W15h, W15l, 8) ^ u64_default.shrSL(W15h, W15l, 7);
+        const s0h = rotrSH(W15h, W15l, 1) ^ rotrSH(W15h, W15l, 8) ^ shrSH(W15h, W15l, 7);
+        const s0l = rotrSL(W15h, W15l, 1) ^ rotrSL(W15h, W15l, 8) ^ shrSL(W15h, W15l, 7);
         const W2h = SHA512_W_H[i - 2] | 0;
         const W2l = SHA512_W_L[i - 2] | 0;
-        const s1h = u64_default.rotrSH(W2h, W2l, 19) ^ u64_default.rotrBH(W2h, W2l, 61) ^ u64_default.shrSH(W2h, W2l, 6);
-        const s1l = u64_default.rotrSL(W2h, W2l, 19) ^ u64_default.rotrBL(W2h, W2l, 61) ^ u64_default.shrSL(W2h, W2l, 6);
-        const SUMl = u64_default.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
-        const SUMh = u64_default.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
+        const s1h = rotrSH(W2h, W2l, 19) ^ rotrBH(W2h, W2l, 61) ^ shrSH(W2h, W2l, 6);
+        const s1l = rotrSL(W2h, W2l, 19) ^ rotrBL(W2h, W2l, 61) ^ shrSL(W2h, W2l, 6);
+        const SUMl = add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
+        const SUMh = add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
         SHA512_W_H[i] = SUMh | 0;
         SHA512_W_L[i] = SUMl | 0;
       }
       let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
       for (let i = 0; i < 80; i++) {
-        const sigma1h = u64_default.rotrSH(Eh, El, 14) ^ u64_default.rotrSH(Eh, El, 18) ^ u64_default.rotrBH(Eh, El, 41);
-        const sigma1l = u64_default.rotrSL(Eh, El, 14) ^ u64_default.rotrSL(Eh, El, 18) ^ u64_default.rotrBL(Eh, El, 41);
+        const sigma1h = rotrSH(Eh, El, 14) ^ rotrSH(Eh, El, 18) ^ rotrBH(Eh, El, 41);
+        const sigma1l = rotrSL(Eh, El, 14) ^ rotrSL(Eh, El, 18) ^ rotrBL(Eh, El, 41);
         const CHIh = Eh & Fh ^ ~Eh & Gh;
         const CHIl = El & Fl ^ ~El & Gl;
-        const T1ll = u64_default.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
-        const T1h = u64_default.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
+        const T1ll = add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
+        const T1h = add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
         const T1l = T1ll | 0;
-        const sigma0h = u64_default.rotrSH(Ah, Al, 28) ^ u64_default.rotrBH(Ah, Al, 34) ^ u64_default.rotrBH(Ah, Al, 39);
-        const sigma0l = u64_default.rotrSL(Ah, Al, 28) ^ u64_default.rotrBL(Ah, Al, 34) ^ u64_default.rotrBL(Ah, Al, 39);
+        const sigma0h = rotrSH(Ah, Al, 28) ^ rotrBH(Ah, Al, 34) ^ rotrBH(Ah, Al, 39);
+        const sigma0l = rotrSL(Ah, Al, 28) ^ rotrBL(Ah, Al, 34) ^ rotrBL(Ah, Al, 39);
         const MAJh = Ah & Bh ^ Ah & Ch ^ Bh & Ch;
         const MAJl = Al & Bl ^ Al & Cl ^ Bl & Cl;
         Hh = Gh | 0;
@@ -1014,155 +1201,119 @@ var near = (() => {
         Gl = Fl | 0;
         Fh = Eh | 0;
         Fl = El | 0;
-        ({ h: Eh, l: El } = u64_default.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
+        ({ h: Eh, l: El } = add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
         Dh = Ch | 0;
         Dl = Cl | 0;
         Ch = Bh | 0;
         Cl = Bl | 0;
         Bh = Ah | 0;
         Bl = Al | 0;
-        const All = u64_default.add3L(T1l, sigma0l, MAJl);
-        Ah = u64_default.add3H(All, T1h, sigma0h, MAJh);
+        const All = add3L(T1l, sigma0l, MAJl);
+        Ah = add3H(All, T1h, sigma0h, MAJh);
         Al = All | 0;
       }
-      ({ h: Ah, l: Al } = u64_default.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
-      ({ h: Bh, l: Bl } = u64_default.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
-      ({ h: Ch, l: Cl } = u64_default.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
-      ({ h: Dh, l: Dl } = u64_default.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
-      ({ h: Eh, l: El } = u64_default.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
-      ({ h: Fh, l: Fl } = u64_default.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
-      ({ h: Gh, l: Gl } = u64_default.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
-      ({ h: Hh, l: Hl } = u64_default.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
+      ({ h: Ah, l: Al } = add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
+      ({ h: Bh, l: Bl } = add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
+      ({ h: Ch, l: Cl } = add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
+      ({ h: Dh, l: Dl } = add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
+      ({ h: Eh, l: El } = add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
+      ({ h: Fh, l: Fl } = add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
+      ({ h: Gh, l: Gl } = add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
+      ({ h: Hh, l: Hl } = add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
       this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
     }
     roundClean() {
-      SHA512_W_H.fill(0);
-      SHA512_W_L.fill(0);
+      clean(SHA512_W_H, SHA512_W_L);
     }
     destroy() {
-      this.buffer.fill(0);
+      clean(this.buffer);
       this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
     }
   };
-  var sha512 = /* @__PURE__ */ wrapConstructor(() => new SHA512());
+  var _SHA512 = class extends SHA2_64B {
+    static {
+      __name(this, "_SHA512");
+    }
+    Ah = SHA512_IV[0] | 0;
+    Al = SHA512_IV[1] | 0;
+    Bh = SHA512_IV[2] | 0;
+    Bl = SHA512_IV[3] | 0;
+    Ch = SHA512_IV[4] | 0;
+    Cl = SHA512_IV[5] | 0;
+    Dh = SHA512_IV[6] | 0;
+    Dl = SHA512_IV[7] | 0;
+    Eh = SHA512_IV[8] | 0;
+    El = SHA512_IV[9] | 0;
+    Fh = SHA512_IV[10] | 0;
+    Fl = SHA512_IV[11] | 0;
+    Gh = SHA512_IV[12] | 0;
+    Gl = SHA512_IV[13] | 0;
+    Hh = SHA512_IV[14] | 0;
+    Hl = SHA512_IV[15] | 0;
+    constructor() {
+      super(64);
+    }
+  };
+  var sha256 = /* @__PURE__ */ createHasher(
+    () => new _SHA256(),
+    /* @__PURE__ */ oidNist(1)
+  );
+  var sha512 = /* @__PURE__ */ createHasher(
+    () => new _SHA512(),
+    /* @__PURE__ */ oidNist(3)
+  );
 
-  // ../../node_modules/@noble/curves/esm/abstract/utils.js
+  // ../utils/node_modules/@noble/curves/utils.js
   var _0n = /* @__PURE__ */ BigInt(0);
   var _1n = /* @__PURE__ */ BigInt(1);
-  var _2n = /* @__PURE__ */ BigInt(2);
-  function isBytes2(a) {
-    return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
-  }
-  __name(isBytes2, "isBytes");
-  function abytes2(item) {
-    if (!isBytes2(item))
-      throw new Error("Uint8Array expected");
-  }
-  __name(abytes2, "abytes");
-  function abool(title, value) {
-    if (typeof value !== "boolean")
-      throw new Error(title + " boolean expected, got " + value);
+  function abool(value, title = "") {
+    if (typeof value !== "boolean") {
+      const prefix = title && `"${title}" `;
+      throw new Error(prefix + "expected boolean, got type=" + typeof value);
+    }
+    return value;
   }
   __name(abool, "abool");
-  var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
-  function bytesToHex(bytes) {
-    abytes2(bytes);
-    let hex = "";
-    for (let i = 0; i < bytes.length; i++) {
-      hex += hexes[bytes[i]];
-    }
-    return hex;
+  function abignumber(n) {
+    if (typeof n === "bigint") {
+      if (!isPosBig(n))
+        throw new Error("positive bigint expected, got " + n);
+    } else
+      anumber(n);
+    return n;
   }
-  __name(bytesToHex, "bytesToHex");
+  __name(abignumber, "abignumber");
   function hexToNumber(hex) {
     if (typeof hex !== "string")
       throw new Error("hex string expected, got " + typeof hex);
     return hex === "" ? _0n : BigInt("0x" + hex);
   }
   __name(hexToNumber, "hexToNumber");
-  var asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 };
-  function asciiToBase16(ch) {
-    if (ch >= asciis._0 && ch <= asciis._9)
-      return ch - asciis._0;
-    if (ch >= asciis.A && ch <= asciis.F)
-      return ch - (asciis.A - 10);
-    if (ch >= asciis.a && ch <= asciis.f)
-      return ch - (asciis.a - 10);
-    return;
-  }
-  __name(asciiToBase16, "asciiToBase16");
-  function hexToBytes(hex) {
-    if (typeof hex !== "string")
-      throw new Error("hex string expected, got " + typeof hex);
-    const hl = hex.length;
-    const al = hl / 2;
-    if (hl % 2)
-      throw new Error("hex string expected, got unpadded hex of length " + hl);
-    const array = new Uint8Array(al);
-    for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {
-      const n1 = asciiToBase16(hex.charCodeAt(hi));
-      const n2 = asciiToBase16(hex.charCodeAt(hi + 1));
-      if (n1 === void 0 || n2 === void 0) {
-        const char = hex[hi] + hex[hi + 1];
-        throw new Error('hex string expected, got non-hex character "' + char + '" at index ' + hi);
-      }
-      array[ai] = n1 * 16 + n2;
-    }
-    return array;
-  }
-  __name(hexToBytes, "hexToBytes");
-  function bytesToNumberBE(bytes) {
-    return hexToNumber(bytesToHex(bytes));
+  function bytesToNumberBE(bytes) {
+    return hexToNumber(bytesToHex(bytes));
   }
   __name(bytesToNumberBE, "bytesToNumberBE");
   function bytesToNumberLE(bytes) {
-    abytes2(bytes);
-    return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));
+    return hexToNumber(bytesToHex(copyBytes(abytes(bytes)).reverse()));
   }
   __name(bytesToNumberLE, "bytesToNumberLE");
   function numberToBytesBE(n, len) {
-    return hexToBytes(n.toString(16).padStart(len * 2, "0"));
+    anumber(len);
+    n = abignumber(n);
+    const res = hexToBytes(n.toString(16).padStart(len * 2, "0"));
+    if (res.length !== len)
+      throw new Error("number too large");
+    return res;
   }
   __name(numberToBytesBE, "numberToBytesBE");
   function numberToBytesLE(n, len) {
     return numberToBytesBE(n, len).reverse();
   }
   __name(numberToBytesLE, "numberToBytesLE");
-  function ensureBytes(title, hex, expectedLength) {
-    let res;
-    if (typeof hex === "string") {
-      try {
-        res = hexToBytes(hex);
-      } catch (e) {
-        throw new Error(title + " must be hex string or Uint8Array, cause: " + e);
-      }
-    } else if (isBytes2(hex)) {
-      res = Uint8Array.from(hex);
-    } else {
-      throw new Error(title + " must be hex string or Uint8Array");
-    }
-    const len = res.length;
-    if (typeof expectedLength === "number" && len !== expectedLength)
-      throw new Error(title + " of length " + expectedLength + " expected, got " + len);
-    return res;
-  }
-  __name(ensureBytes, "ensureBytes");
-  function concatBytes(...arrays) {
-    let sum = 0;
-    for (let i = 0; i < arrays.length; i++) {
-      const a = arrays[i];
-      abytes2(a);
-      sum += a.length;
-    }
-    const res = new Uint8Array(sum);
-    for (let i = 0, pad = 0; i < arrays.length; i++) {
-      const a = arrays[i];
-      res.set(a, pad);
-      pad += a.length;
-    }
-    return res;
+  function copyBytes(bytes) {
+    return Uint8Array.from(bytes);
   }
-  __name(concatBytes, "concatBytes");
+  __name(copyBytes, "copyBytes");
   var isPosBig = /* @__PURE__ */ __name((n) => typeof n === "bigint" && _0n <= n, "isPosBig");
   function inRange(n, min, max) {
     return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
@@ -1173,42 +1324,22 @@ var near = (() => {
       throw new Error("expected valid " + title + ": " + min + " <= n < " + max + ", got " + n);
   }
   __name(aInRange, "aInRange");
-  function bitLen(n) {
-    let len;
-    for (len = 0; n > _0n; n >>= _1n, len += 1)
-      ;
-    return len;
-  }
-  __name(bitLen, "bitLen");
-  var bitMask = /* @__PURE__ */ __name((n) => (_2n << BigInt(n - 1)) - _1n, "bitMask");
-  var validatorFns = {
-    bigint: /* @__PURE__ */ __name((val) => typeof val === "bigint", "bigint"),
-    function: /* @__PURE__ */ __name((val) => typeof val === "function", "function"),
-    boolean: /* @__PURE__ */ __name((val) => typeof val === "boolean", "boolean"),
-    string: /* @__PURE__ */ __name((val) => typeof val === "string", "string"),
-    stringOrUint8Array: /* @__PURE__ */ __name((val) => typeof val === "string" || isBytes2(val), "stringOrUint8Array"),
-    isSafeInteger: /* @__PURE__ */ __name((val) => Number.isSafeInteger(val), "isSafeInteger"),
-    array: /* @__PURE__ */ __name((val) => Array.isArray(val), "array"),
-    field: /* @__PURE__ */ __name((val, object) => object.Fp.isValid(val), "field"),
-    hash: /* @__PURE__ */ __name((val) => typeof val === "function" && Number.isSafeInteger(val.outputLen), "hash")
-  };
-  function validateObject(object, validators, optValidators = {}) {
-    const checkField = /* @__PURE__ */ __name((fieldName, type, isOptional) => {
-      const checkVal = validatorFns[type];
-      if (typeof checkVal !== "function")
-        throw new Error("invalid validator function");
+  var bitMask = /* @__PURE__ */ __name((n) => (_1n << BigInt(n)) - _1n, "bitMask");
+  function validateObject(object, fields = {}, optFields = {}) {
+    if (!object || typeof object !== "object")
+      throw new Error("expected valid options object");
+    function checkField(fieldName, expectedType, isOpt) {
       const val = object[fieldName];
-      if (isOptional && val === void 0)
+      if (isOpt && val === void 0)
         return;
-      if (!checkVal(val, object)) {
-        throw new Error("param " + String(fieldName) + " is invalid. Expected " + type + ", got " + val);
-      }
-    }, "checkField");
-    for (const [fieldName, type] of Object.entries(validators))
-      checkField(fieldName, type, false);
-    for (const [fieldName, type] of Object.entries(optValidators))
-      checkField(fieldName, type, true);
-    return object;
+      const current = typeof val;
+      if (current !== expectedType || val === null)
+        throw new Error(`param "${fieldName}" is invalid: expected ${expectedType}, got ${current}`);
+    }
+    __name(checkField, "checkField");
+    const iter = /* @__PURE__ */ __name((f, isOpt) => Object.entries(f).forEach(([k, v]) => checkField(k, v, isOpt)), "iter");
+    iter(fields, false);
+    iter(optFields, true);
   }
   __name(validateObject, "validateObject");
   function memoized(fn) {
@@ -1224,13 +1355,14 @@ var near = (() => {
   }
   __name(memoized, "memoized");
 
-  // ../../node_modules/@noble/curves/esm/abstract/modular.js
-  var _0n2 = BigInt(0);
-  var _1n2 = BigInt(1);
-  var _2n2 = /* @__PURE__ */ BigInt(2);
+  // ../utils/node_modules/@noble/curves/abstract/modular.js
+  var _0n2 = /* @__PURE__ */ BigInt(0);
+  var _1n2 = /* @__PURE__ */ BigInt(1);
+  var _2n = /* @__PURE__ */ BigInt(2);
   var _3n = /* @__PURE__ */ BigInt(3);
   var _4n = /* @__PURE__ */ BigInt(4);
   var _5n = /* @__PURE__ */ BigInt(5);
+  var _7n = /* @__PURE__ */ BigInt(7);
   var _8n = /* @__PURE__ */ BigInt(8);
   var _9n = /* @__PURE__ */ BigInt(9);
   var _16n = /* @__PURE__ */ BigInt(16);
@@ -1239,23 +1371,6 @@ var near = (() => {
     return result >= _0n2 ? result : b + result;
   }
   __name(mod, "mod");
-  function pow(num, power, modulo) {
-    if (power < _0n2)
-      throw new Error("invalid exponent, negatives unsupported");
-    if (modulo <= _0n2)
-      throw new Error("invalid modulus");
-    if (modulo === _1n2)
-      return _0n2;
-    let res = _1n2;
-    while (power > _0n2) {
-      if (power & _1n2)
-        res = res * num % modulo;
-      num = num * num % modulo;
-      power >>= _1n2;
-    }
-    return res;
-  }
-  __name(pow, "pow");
   function pow2(x, power, modulo) {
     let res = x;
     while (power-- > _0n2) {
@@ -1286,76 +1401,109 @@ var near = (() => {
     return mod(x, modulo);
   }
   __name(invert, "invert");
+  function assertIsSquare(Fp, root, n) {
+    if (!Fp.eql(Fp.sqr(root), n))
+      throw new Error("Cannot find square root");
+  }
+  __name(assertIsSquare, "assertIsSquare");
+  function sqrt3mod4(Fp, n) {
+    const p1div4 = (Fp.ORDER + _1n2) / _4n;
+    const root = Fp.pow(n, p1div4);
+    assertIsSquare(Fp, root, n);
+    return root;
+  }
+  __name(sqrt3mod4, "sqrt3mod4");
+  function sqrt5mod8(Fp, n) {
+    const p5div8 = (Fp.ORDER - _5n) / _8n;
+    const n2 = Fp.mul(n, _2n);
+    const v = Fp.pow(n2, p5div8);
+    const nv = Fp.mul(n, v);
+    const i = Fp.mul(Fp.mul(nv, _2n), v);
+    const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));
+    assertIsSquare(Fp, root, n);
+    return root;
+  }
+  __name(sqrt5mod8, "sqrt5mod8");
+  function sqrt9mod16(P2) {
+    const Fp_ = Field(P2);
+    const tn = tonelliShanks(P2);
+    const c1 = tn(Fp_, Fp_.neg(Fp_.ONE));
+    const c2 = tn(Fp_, c1);
+    const c3 = tn(Fp_, Fp_.neg(c1));
+    const c4 = (P2 + _7n) / _16n;
+    return (Fp, n) => {
+      let tv1 = Fp.pow(n, c4);
+      let tv2 = Fp.mul(tv1, c1);
+      const tv3 = Fp.mul(tv1, c2);
+      const tv4 = Fp.mul(tv1, c3);
+      const e1 = Fp.eql(Fp.sqr(tv2), n);
+      const e2 = Fp.eql(Fp.sqr(tv3), n);
+      tv1 = Fp.cmov(tv1, tv2, e1);
+      tv2 = Fp.cmov(tv4, tv3, e2);
+      const e3 = Fp.eql(Fp.sqr(tv2), n);
+      const root = Fp.cmov(tv1, tv2, e3);
+      assertIsSquare(Fp, root, n);
+      return root;
+    };
+  }
+  __name(sqrt9mod16, "sqrt9mod16");
   function tonelliShanks(P2) {
-    const legendreC = (P2 - _1n2) / _2n2;
-    let Q, S, Z;
-    for (Q = P2 - _1n2, S = 0; Q % _2n2 === _0n2; Q /= _2n2, S++)
-      ;
-    for (Z = _2n2; Z < P2 && pow(Z, legendreC, P2) !== P2 - _1n2; Z++) {
-      if (Z > 1e3)
-        throw new Error("Cannot find square root: likely non-prime P");
-    }
-    if (S === 1) {
-      const p1div4 = (P2 + _1n2) / _4n;
-      return /* @__PURE__ */ __name(function tonelliFast(Fp2, n) {
-        const root = Fp2.pow(n, p1div4);
-        if (!Fp2.eql(Fp2.sqr(root), n))
-          throw new Error("Cannot find square root");
-        return root;
-      }, "tonelliFast");
-    }
-    const Q1div2 = (Q + _1n2) / _2n2;
-    return /* @__PURE__ */ __name(function tonelliSlow(Fp2, n) {
-      if (Fp2.pow(n, legendreC) === Fp2.neg(Fp2.ONE))
+    if (P2 < _3n)
+      throw new Error("sqrt is not defined for small field");
+    let Q = P2 - _1n2;
+    let S = 0;
+    while (Q % _2n === _0n2) {
+      Q /= _2n;
+      S++;
+    }
+    let Z = _2n;
+    const _Fp = Field(P2);
+    while (FpLegendre(_Fp, Z) === 1) {
+      if (Z++ > 1e3)
+        throw new Error("Cannot find square root: probably non-prime P");
+    }
+    if (S === 1)
+      return sqrt3mod4;
+    let cc = _Fp.pow(Z, Q);
+    const Q1div2 = (Q + _1n2) / _2n;
+    return /* @__PURE__ */ __name(function tonelliSlow(Fp, n) {
+      if (Fp.is0(n))
+        return n;
+      if (FpLegendre(Fp, n) !== 1)
         throw new Error("Cannot find square root");
-      let r = S;
-      let g = Fp2.pow(Fp2.mul(Fp2.ONE, Z), Q);
-      let x = Fp2.pow(n, Q1div2);
-      let b = Fp2.pow(n, Q);
-      while (!Fp2.eql(b, Fp2.ONE)) {
-        if (Fp2.eql(b, Fp2.ZERO))
-          return Fp2.ZERO;
-        let m = 1;
-        for (let t2 = Fp2.sqr(b); m < r; m++) {
-          if (Fp2.eql(t2, Fp2.ONE))
-            break;
-          t2 = Fp2.sqr(t2);
+      let M = S;
+      let c = Fp.mul(Fp.ONE, cc);
+      let t = Fp.pow(n, Q);
+      let R = Fp.pow(n, Q1div2);
+      while (!Fp.eql(t, Fp.ONE)) {
+        if (Fp.is0(t))
+          return Fp.ZERO;
+        let i = 1;
+        let t_tmp = Fp.sqr(t);
+        while (!Fp.eql(t_tmp, Fp.ONE)) {
+          i++;
+          t_tmp = Fp.sqr(t_tmp);
+          if (i === M)
+            throw new Error("Cannot find square root");
         }
-        const ge = Fp2.pow(g, _1n2 << BigInt(r - m - 1));
-        g = Fp2.sqr(ge);
-        x = Fp2.mul(x, ge);
-        b = Fp2.mul(b, g);
-        r = m;
+        const exponent = _1n2 << BigInt(M - i - 1);
+        const b = Fp.pow(c, exponent);
+        M = i;
+        c = Fp.sqr(b);
+        t = Fp.mul(t, c);
+        R = Fp.mul(R, b);
       }
-      return x;
+      return R;
     }, "tonelliSlow");
   }
   __name(tonelliShanks, "tonelliShanks");
   function FpSqrt(P2) {
-    if (P2 % _4n === _3n) {
-      const p1div4 = (P2 + _1n2) / _4n;
-      return /* @__PURE__ */ __name(function sqrt3mod4(Fp2, n) {
-        const root = Fp2.pow(n, p1div4);
-        if (!Fp2.eql(Fp2.sqr(root), n))
-          throw new Error("Cannot find square root");
-        return root;
-      }, "sqrt3mod4");
-    }
-    if (P2 % _8n === _5n) {
-      const c1 = (P2 - _5n) / _8n;
-      return /* @__PURE__ */ __name(function sqrt5mod8(Fp2, n) {
-        const n2 = Fp2.mul(n, _2n2);
-        const v = Fp2.pow(n2, c1);
-        const nv = Fp2.mul(n, v);
-        const i = Fp2.mul(Fp2.mul(nv, _2n2), v);
-        const root = Fp2.mul(nv, Fp2.sub(i, Fp2.ONE));
-        if (!Fp2.eql(Fp2.sqr(root), n))
-          throw new Error("Cannot find square root");
-        return root;
-      }, "sqrt5mod8");
-    }
-    if (P2 % _16n === _9n) {
-    }
+    if (P2 % _4n === _3n)
+      return sqrt3mod4;
+    if (P2 % _8n === _5n)
+      return sqrt5mod8;
+    if (P2 % _16n === _9n)
+      return sqrt9mod16(P2);
     return tonelliShanks(P2);
   }
   __name(FpSqrt, "FpSqrt");
@@ -1382,422 +1530,506 @@ var near = (() => {
   function validateField(field) {
     const initial = {
       ORDER: "bigint",
-      MASK: "bigint",
-      BYTES: "isSafeInteger",
-      BITS: "isSafeInteger"
+      BYTES: "number",
+      BITS: "number"
     };
     const opts = FIELD_FIELDS.reduce((map, val) => {
       map[val] = "function";
       return map;
     }, initial);
-    return validateObject(field, opts);
+    validateObject(field, opts);
+    return field;
   }
   __name(validateField, "validateField");
-  function FpPow(f, num, power) {
+  function FpPow(Fp, num, power) {
     if (power < _0n2)
       throw new Error("invalid exponent, negatives unsupported");
     if (power === _0n2)
-      return f.ONE;
+      return Fp.ONE;
     if (power === _1n2)
       return num;
-    let p = f.ONE;
+    let p = Fp.ONE;
     let d = num;
     while (power > _0n2) {
       if (power & _1n2)
-        p = f.mul(p, d);
-      d = f.sqr(d);
+        p = Fp.mul(p, d);
+      d = Fp.sqr(d);
       power >>= _1n2;
     }
     return p;
   }
   __name(FpPow, "FpPow");
-  function FpInvertBatch(f, nums) {
-    const tmp = new Array(nums.length);
-    const lastMultiplied = nums.reduce((acc, num, i) => {
-      if (f.is0(num))
+  function FpInvertBatch(Fp, nums, passZero = false) {
+    const inverted = new Array(nums.length).fill(passZero ? Fp.ZERO : void 0);
+    const multipliedAcc = nums.reduce((acc, num, i) => {
+      if (Fp.is0(num))
         return acc;
-      tmp[i] = acc;
-      return f.mul(acc, num);
-    }, f.ONE);
-    const inverted = f.inv(lastMultiplied);
+      inverted[i] = acc;
+      return Fp.mul(acc, num);
+    }, Fp.ONE);
+    const invertedAcc = Fp.inv(multipliedAcc);
     nums.reduceRight((acc, num, i) => {
-      if (f.is0(num))
+      if (Fp.is0(num))
         return acc;
-      tmp[i] = f.mul(acc, tmp[i]);
-      return f.mul(acc, num);
-    }, inverted);
-    return tmp;
+      inverted[i] = Fp.mul(acc, inverted[i]);
+      return Fp.mul(acc, num);
+    }, invertedAcc);
+    return inverted;
   }
   __name(FpInvertBatch, "FpInvertBatch");
+  function FpLegendre(Fp, n) {
+    const p1mod2 = (Fp.ORDER - _1n2) / _2n;
+    const powered = Fp.pow(n, p1mod2);
+    const yes = Fp.eql(powered, Fp.ONE);
+    const zero = Fp.eql(powered, Fp.ZERO);
+    const no = Fp.eql(powered, Fp.neg(Fp.ONE));
+    if (!yes && !zero && !no)
+      throw new Error("invalid Legendre symbol result");
+    return yes ? 1 : zero ? 0 : -1;
+  }
+  __name(FpLegendre, "FpLegendre");
   function nLength(n, nBitLength) {
+    if (nBitLength !== void 0)
+      anumber(nBitLength);
     const _nBitLength = nBitLength !== void 0 ? nBitLength : n.toString(2).length;
     const nByteLength = Math.ceil(_nBitLength / 8);
     return { nBitLength: _nBitLength, nByteLength };
   }
   __name(nLength, "nLength");
-  function Field(ORDER, bitLen2, isLE = false, redef = {}) {
-    if (ORDER <= _0n2)
-      throw new Error("invalid field: expected ORDER > 0, got " + ORDER);
-    const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen2);
-    if (BYTES > 2048)
-      throw new Error("invalid field: expected ORDER of <= 2048 bytes");
-    let sqrtP;
-    const f = Object.freeze({
-      ORDER,
-      isLE,
-      BITS,
-      BYTES,
-      MASK: bitMask(BITS),
-      ZERO: _0n2,
-      ONE: _1n2,
-      create: /* @__PURE__ */ __name((num) => mod(num, ORDER), "create"),
-      isValid: /* @__PURE__ */ __name((num) => {
-        if (typeof num !== "bigint")
-          throw new Error("invalid field element: expected bigint, got " + typeof num);
-        return _0n2 <= num && num < ORDER;
-      }, "isValid"),
-      is0: /* @__PURE__ */ __name((num) => num === _0n2, "is0"),
-      isOdd: /* @__PURE__ */ __name((num) => (num & _1n2) === _1n2, "isOdd"),
-      neg: /* @__PURE__ */ __name((num) => mod(-num, ORDER), "neg"),
-      eql: /* @__PURE__ */ __name((lhs, rhs) => lhs === rhs, "eql"),
-      sqr: /* @__PURE__ */ __name((num) => mod(num * num, ORDER), "sqr"),
-      add: /* @__PURE__ */ __name((lhs, rhs) => mod(lhs + rhs, ORDER), "add"),
-      sub: /* @__PURE__ */ __name((lhs, rhs) => mod(lhs - rhs, ORDER), "sub"),
-      mul: /* @__PURE__ */ __name((lhs, rhs) => mod(lhs * rhs, ORDER), "mul"),
-      pow: /* @__PURE__ */ __name((num, power) => FpPow(f, num, power), "pow"),
-      div: /* @__PURE__ */ __name((lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER), "div"),
-      // Same as above, but doesn't normalize
-      sqrN: /* @__PURE__ */ __name((num) => num * num, "sqrN"),
-      addN: /* @__PURE__ */ __name((lhs, rhs) => lhs + rhs, "addN"),
-      subN: /* @__PURE__ */ __name((lhs, rhs) => lhs - rhs, "subN"),
-      mulN: /* @__PURE__ */ __name((lhs, rhs) => lhs * rhs, "mulN"),
-      inv: /* @__PURE__ */ __name((num) => invert(num, ORDER), "inv"),
-      sqrt: redef.sqrt || ((n) => {
-        if (!sqrtP)
-          sqrtP = FpSqrt(ORDER);
-        return sqrtP(f, n);
-      }),
-      invertBatch: /* @__PURE__ */ __name((lst) => FpInvertBatch(f, lst), "invertBatch"),
-      // TODO: do we really need constant cmov?
-      // We don't have const-time bigints anyway, so probably will be not very useful
-      cmov: /* @__PURE__ */ __name((a, b, c) => c ? b : a, "cmov"),
-      toBytes: /* @__PURE__ */ __name((num) => isLE ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES), "toBytes"),
-      fromBytes: /* @__PURE__ */ __name((bytes) => {
-        if (bytes.length !== BYTES)
-          throw new Error("Field.fromBytes: expected " + BYTES + " bytes, got " + bytes.length);
-        return isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);
-      }, "fromBytes")
-    });
-    return Object.freeze(f);
+  var _Field = class {
+    static {
+      __name(this, "_Field");
+    }
+    ORDER;
+    BITS;
+    BYTES;
+    isLE;
+    ZERO = _0n2;
+    ONE = _1n2;
+    _lengths;
+    _sqrt;
+    // cached sqrt
+    _mod;
+    constructor(ORDER, opts = {}) {
+      if (ORDER <= _0n2)
+        throw new Error("invalid field: expected ORDER > 0, got " + ORDER);
+      let _nbitLength = void 0;
+      this.isLE = false;
+      if (opts != null && typeof opts === "object") {
+        if (typeof opts.BITS === "number")
+          _nbitLength = opts.BITS;
+        if (typeof opts.sqrt === "function")
+          this.sqrt = opts.sqrt;
+        if (typeof opts.isLE === "boolean")
+          this.isLE = opts.isLE;
+        if (opts.allowedLengths)
+          this._lengths = opts.allowedLengths?.slice();
+        if (typeof opts.modFromBytes === "boolean")
+          this._mod = opts.modFromBytes;
+      }
+      const { nBitLength, nByteLength } = nLength(ORDER, _nbitLength);
+      if (nByteLength > 2048)
+        throw new Error("invalid field: expected ORDER of <= 2048 bytes");
+      this.ORDER = ORDER;
+      this.BITS = nBitLength;
+      this.BYTES = nByteLength;
+      this._sqrt = void 0;
+      Object.preventExtensions(this);
+    }
+    create(num) {
+      return mod(num, this.ORDER);
+    }
+    isValid(num) {
+      if (typeof num !== "bigint")
+        throw new Error("invalid field element: expected bigint, got " + typeof num);
+      return _0n2 <= num && num < this.ORDER;
+    }
+    is0(num) {
+      return num === _0n2;
+    }
+    // is valid and invertible
+    isValidNot0(num) {
+      return !this.is0(num) && this.isValid(num);
+    }
+    isOdd(num) {
+      return (num & _1n2) === _1n2;
+    }
+    neg(num) {
+      return mod(-num, this.ORDER);
+    }
+    eql(lhs, rhs) {
+      return lhs === rhs;
+    }
+    sqr(num) {
+      return mod(num * num, this.ORDER);
+    }
+    add(lhs, rhs) {
+      return mod(lhs + rhs, this.ORDER);
+    }
+    sub(lhs, rhs) {
+      return mod(lhs - rhs, this.ORDER);
+    }
+    mul(lhs, rhs) {
+      return mod(lhs * rhs, this.ORDER);
+    }
+    pow(num, power) {
+      return FpPow(this, num, power);
+    }
+    div(lhs, rhs) {
+      return mod(lhs * invert(rhs, this.ORDER), this.ORDER);
+    }
+    // Same as above, but doesn't normalize
+    sqrN(num) {
+      return num * num;
+    }
+    addN(lhs, rhs) {
+      return lhs + rhs;
+    }
+    subN(lhs, rhs) {
+      return lhs - rhs;
+    }
+    mulN(lhs, rhs) {
+      return lhs * rhs;
+    }
+    inv(num) {
+      return invert(num, this.ORDER);
+    }
+    sqrt(num) {
+      if (!this._sqrt)
+        this._sqrt = FpSqrt(this.ORDER);
+      return this._sqrt(this, num);
+    }
+    toBytes(num) {
+      return this.isLE ? numberToBytesLE(num, this.BYTES) : numberToBytesBE(num, this.BYTES);
+    }
+    fromBytes(bytes, skipValidation = false) {
+      abytes(bytes);
+      const { _lengths: allowedLengths, BYTES, isLE, ORDER, _mod: modFromBytes } = this;
+      if (allowedLengths) {
+        if (!allowedLengths.includes(bytes.length) || bytes.length > BYTES) {
+          throw new Error("Field.fromBytes: expected " + allowedLengths + " bytes, got " + bytes.length);
+        }
+        const padded = new Uint8Array(BYTES);
+        padded.set(bytes, isLE ? 0 : padded.length - bytes.length);
+        bytes = padded;
+      }
+      if (bytes.length !== BYTES)
+        throw new Error("Field.fromBytes: expected " + BYTES + " bytes, got " + bytes.length);
+      let scalar = isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);
+      if (modFromBytes)
+        scalar = mod(scalar, ORDER);
+      if (!skipValidation) {
+        if (!this.isValid(scalar))
+          throw new Error("invalid field element: outside of range 0..ORDER");
+      }
+      return scalar;
+    }
+    // TODO: we don't need it here, move out to separate fn
+    invertBatch(lst) {
+      return FpInvertBatch(this, lst);
+    }
+    // We can't move this out because Fp6, Fp12 implement it
+    // and it's unclear what to return in there.
+    cmov(a, b, condition) {
+      return condition ? b : a;
+    }
+  };
+  function Field(ORDER, opts = {}) {
+    return new _Field(ORDER, opts);
   }
   __name(Field, "Field");
 
-  // ../../node_modules/@noble/curves/esm/abstract/curve.js
-  var _0n3 = BigInt(0);
-  var _1n3 = BigInt(1);
-  function constTimeNegate(condition, item) {
+  // ../utils/node_modules/@noble/curves/abstract/curve.js
+  var _0n3 = /* @__PURE__ */ BigInt(0);
+  var _1n3 = /* @__PURE__ */ BigInt(1);
+  function negateCt(condition, item) {
     const neg = item.negate();
     return condition ? neg : item;
   }
-  __name(constTimeNegate, "constTimeNegate");
+  __name(negateCt, "negateCt");
+  function normalizeZ(c, points) {
+    const invertedZs = FpInvertBatch(c.Fp, points.map((p) => p.Z));
+    return points.map((p, i) => c.fromAffine(p.toAffine(invertedZs[i])));
+  }
+  __name(normalizeZ, "normalizeZ");
   function validateW(W, bits) {
     if (!Number.isSafeInteger(W) || W <= 0 || W > bits)
       throw new Error("invalid window size, expected [1.." + bits + "], got W=" + W);
   }
   __name(validateW, "validateW");
-  function calcWOpts(W, bits) {
-    validateW(W, bits);
-    const windows = Math.ceil(bits / W) + 1;
+  function calcWOpts(W, scalarBits) {
+    validateW(W, scalarBits);
+    const windows = Math.ceil(scalarBits / W) + 1;
     const windowSize = 2 ** (W - 1);
-    return { windows, windowSize };
+    const maxNumber = 2 ** W;
+    const mask = bitMask(W);
+    const shiftBy = BigInt(W);
+    return { windows, windowSize, mask, maxNumber, shiftBy };
   }
   __name(calcWOpts, "calcWOpts");
-  function validateMSMPoints(points, c) {
-    if (!Array.isArray(points))
-      throw new Error("array expected");
-    points.forEach((p, i) => {
-      if (!(p instanceof c))
-        throw new Error("invalid point at index " + i);
-    });
+  function calcOffsets(n, window, wOpts) {
+    const { windowSize, mask, maxNumber, shiftBy } = wOpts;
+    let wbits = Number(n & mask);
+    let nextN = n >> shiftBy;
+    if (wbits > windowSize) {
+      wbits -= maxNumber;
+      nextN += _1n3;
+    }
+    const offsetStart = window * windowSize;
+    const offset = offsetStart + Math.abs(wbits) - 1;
+    const isZero = wbits === 0;
+    const isNeg = wbits < 0;
+    const isNegF = window % 2 !== 0;
+    const offsetF = offsetStart;
+    return { nextN, offset, isZero, isNeg, isNegF, offsetF };
   }
-  __name(validateMSMPoints, "validateMSMPoints");
-  function validateMSMScalars(scalars, field) {
-    if (!Array.isArray(scalars))
-      throw new Error("array of scalars expected");
-    scalars.forEach((s, i) => {
-      if (!field.isValid(s))
-        throw new Error("invalid scalar at index " + i);
-    });
-  }
-  __name(validateMSMScalars, "validateMSMScalars");
+  __name(calcOffsets, "calcOffsets");
   var pointPrecomputes = /* @__PURE__ */ new WeakMap();
   var pointWindowSizes = /* @__PURE__ */ new WeakMap();
   function getW(P2) {
     return pointWindowSizes.get(P2) || 1;
   }
   __name(getW, "getW");
-  function wNAF(c, bits) {
-    return {
-      constTimeNegate,
-      hasPrecomputes(elm) {
-        return getW(elm) !== 1;
-      },
-      // non-const time multiplication ladder
-      unsafeLadder(elm, n, p = c.ZERO) {
-        let d = elm;
-        while (n > _0n3) {
-          if (n & _1n3)
-            p = p.add(d);
-          d = d.double();
-          n >>= _1n3;
-        }
-        return p;
-      },
-      /**
-       * Creates a wNAF precomputation window. Used for caching.
-       * Default window size is set by `utils.precompute()` and is equal to 8.
-       * Number of precomputed points depends on the curve size:
-       * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
-       * - 𝑊 is the window size
-       * - 𝑛 is the bitlength of the curve order.
-       * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
-       * @param elm Point instance
-       * @param W window size
-       * @returns precomputed point tables flattened to a single array
-       */
-      precomputeWindow(elm, W) {
-        const { windows, windowSize } = calcWOpts(W, bits);
-        const points = [];
-        let p = elm;
-        let base = p;
-        for (let window = 0; window < windows; window++) {
-          base = p;
+  function assert0(n) {
+    if (n !== _0n3)
+      throw new Error("invalid wNAF");
+  }
+  __name(assert0, "assert0");
+  var wNAF = class {
+    static {
+      __name(this, "wNAF");
+    }
+    BASE;
+    ZERO;
+    Fn;
+    bits;
+    // Parametrized with a given Point class (not individual point)
+    constructor(Point, bits) {
+      this.BASE = Point.BASE;
+      this.ZERO = Point.ZERO;
+      this.Fn = Point.Fn;
+      this.bits = bits;
+    }
+    // non-const time multiplication ladder
+    _unsafeLadder(elm, n, p = this.ZERO) {
+      let d = elm;
+      while (n > _0n3) {
+        if (n & _1n3)
+          p = p.add(d);
+        d = d.double();
+        n >>= _1n3;
+      }
+      return p;
+    }
+    /**
+     * Creates a wNAF precomputation window. Used for caching.
+     * Default window size is set by `utils.precompute()` and is equal to 8.
+     * Number of precomputed points depends on the curve size:
+     * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
+     * - 𝑊 is the window size
+     * - 𝑛 is the bitlength of the curve order.
+     * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
+     * @param point Point instance
+     * @param W window size
+     * @returns precomputed point tables flattened to a single array
+     */
+    precomputeWindow(point, W) {
+      const { windows, windowSize } = calcWOpts(W, this.bits);
+      const points = [];
+      let p = point;
+      let base = p;
+      for (let window = 0; window < windows; window++) {
+        base = p;
+        points.push(base);
+        for (let i = 1; i < windowSize; i++) {
+          base = base.add(p);
           points.push(base);
-          for (let i = 1; i < windowSize; i++) {
-            base = base.add(p);
-            points.push(base);
-          }
-          p = base.double();
-        }
-        return points;
-      },
-      /**
-       * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
-       * @param W window size
-       * @param precomputes precomputed tables
-       * @param n scalar (we don't check here, but should be less than curve order)
-       * @returns real and fake (for const-time) points
-       */
-      wNAF(W, precomputes, n) {
-        const { windows, windowSize } = calcWOpts(W, bits);
-        let p = c.ZERO;
-        let f = c.BASE;
-        const mask = BigInt(2 ** W - 1);
-        const maxNumber = 2 ** W;
-        const shiftBy = BigInt(W);
-        for (let window = 0; window < windows; window++) {
-          const offset = window * windowSize;
-          let wbits = Number(n & mask);
-          n >>= shiftBy;
-          if (wbits > windowSize) {
-            wbits -= maxNumber;
-            n += _1n3;
-          }
-          const offset1 = offset;
-          const offset2 = offset + Math.abs(wbits) - 1;
-          const cond1 = window % 2 !== 0;
-          const cond2 = wbits < 0;
-          if (wbits === 0) {
-            f = f.add(constTimeNegate(cond1, precomputes[offset1]));
-          } else {
-            p = p.add(constTimeNegate(cond2, precomputes[offset2]));
-          }
-        }
-        return { p, f };
-      },
-      /**
-       * Implements ec unsafe (non const-time) multiplication using precomputed tables and w-ary non-adjacent form.
-       * @param W window size
-       * @param precomputes precomputed tables
-       * @param n scalar (we don't check here, but should be less than curve order)
-       * @param acc accumulator point to add result of multiplication
-       * @returns point
-       */
-      wNAFUnsafe(W, precomputes, n, acc = c.ZERO) {
-        const { windows, windowSize } = calcWOpts(W, bits);
-        const mask = BigInt(2 ** W - 1);
-        const maxNumber = 2 ** W;
-        const shiftBy = BigInt(W);
-        for (let window = 0; window < windows; window++) {
-          const offset = window * windowSize;
-          if (n === _0n3)
-            break;
-          let wbits = Number(n & mask);
-          n >>= shiftBy;
-          if (wbits > windowSize) {
-            wbits -= maxNumber;
-            n += _1n3;
-          }
-          if (wbits === 0)
-            continue;
-          let curr = precomputes[offset + Math.abs(wbits) - 1];
-          if (wbits < 0)
-            curr = curr.negate();
-          acc = acc.add(curr);
         }
-        return acc;
-      },
-      getPrecomputes(W, P2, transform) {
-        let comp = pointPrecomputes.get(P2);
-        if (!comp) {
-          comp = this.precomputeWindow(P2, W);
-          if (W !== 1)
-            pointPrecomputes.set(P2, transform(comp));
+        p = base.double();
+      }
+      return points;
+    }
+    /**
+     * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
+     * More compact implementation:
+     * https://github.com/paulmillr/noble-secp256k1/blob/47cb1669b6e506ad66b35fe7d76132ae97465da2/index.ts#L502-L541
+     * @returns real and fake (for const-time) points
+     */
+    wNAF(W, precomputes, n) {
+      if (!this.Fn.isValid(n))
+        throw new Error("invalid scalar");
+      let p = this.ZERO;
+      let f = this.BASE;
+      const wo = calcWOpts(W, this.bits);
+      for (let window = 0; window < wo.windows; window++) {
+        const { nextN, offset, isZero, isNeg, isNegF, offsetF } = calcOffsets(n, window, wo);
+        n = nextN;
+        if (isZero) {
+          f = f.add(negateCt(isNegF, precomputes[offsetF]));
+        } else {
+          p = p.add(negateCt(isNeg, precomputes[offset]));
         }
-        return comp;
-      },
-      wNAFCached(P2, n, transform) {
-        const W = getW(P2);
-        return this.wNAF(W, this.getPrecomputes(W, P2, transform), n);
-      },
-      wNAFCachedUnsafe(P2, n, transform, prev) {
-        const W = getW(P2);
-        if (W === 1)
-          return this.unsafeLadder(P2, n, prev);
-        return this.wNAFUnsafe(W, this.getPrecomputes(W, P2, transform), n, prev);
-      },
-      // We calculate precomputes for elliptic curve point multiplication
-      // using windowed method. This specifies window size and
-      // stores precomputed values. Usually only base point would be precomputed.
-      setWindowSize(P2, W) {
-        validateW(W, bits);
-        pointWindowSizes.set(P2, W);
-        pointPrecomputes.delete(P2);
       }
-    };
-  }
-  __name(wNAF, "wNAF");
-  function pippenger(c, fieldN, points, scalars) {
-    validateMSMPoints(points, c);
-    validateMSMScalars(scalars, fieldN);
-    if (points.length !== scalars.length)
-      throw new Error("arrays of points and scalars must have equal length");
-    const zero = c.ZERO;
-    const wbits = bitLen(BigInt(points.length));
-    const windowSize = wbits > 12 ? wbits - 3 : wbits > 4 ? wbits - 2 : wbits ? 2 : 1;
-    const MASK = (1 << windowSize) - 1;
-    const buckets = new Array(MASK + 1).fill(zero);
-    const lastBits = Math.floor((fieldN.BITS - 1) / windowSize) * windowSize;
-    let sum = zero;
-    for (let i = lastBits; i >= 0; i -= windowSize) {
-      buckets.fill(zero);
-      for (let j = 0; j < scalars.length; j++) {
-        const scalar = scalars[j];
-        const wbits2 = Number(scalar >> BigInt(i) & BigInt(MASK));
-        buckets[wbits2] = buckets[wbits2].add(points[j]);
+      assert0(n);
+      return { p, f };
+    }
+    /**
+     * Implements ec unsafe (non const-time) multiplication using precomputed tables and w-ary non-adjacent form.
+     * @param acc accumulator point to add result of multiplication
+     * @returns point
+     */
+    wNAFUnsafe(W, precomputes, n, acc = this.ZERO) {
+      const wo = calcWOpts(W, this.bits);
+      for (let window = 0; window < wo.windows; window++) {
+        if (n === _0n3)
+          break;
+        const { nextN, offset, isZero, isNeg } = calcOffsets(n, window, wo);
+        n = nextN;
+        if (isZero) {
+          continue;
+        } else {
+          const item = precomputes[offset];
+          acc = acc.add(isNeg ? item.negate() : item);
+        }
       }
-      let resI = zero;
-      for (let j = buckets.length - 1, sumI = zero; j > 0; j--) {
-        sumI = sumI.add(buckets[j]);
-        resI = resI.add(sumI);
+      assert0(n);
+      return acc;
+    }
+    getPrecomputes(W, point, transform) {
+      let comp = pointPrecomputes.get(point);
+      if (!comp) {
+        comp = this.precomputeWindow(point, W);
+        if (W !== 1) {
+          if (typeof transform === "function")
+            comp = transform(comp);
+          pointPrecomputes.set(point, comp);
+        }
       }
-      sum = sum.add(resI);
-      if (i !== 0)
-        for (let j = 0; j < windowSize; j++)
-          sum = sum.double();
+      return comp;
+    }
+    cached(point, scalar, transform) {
+      const W = getW(point);
+      return this.wNAF(W, this.getPrecomputes(W, point, transform), scalar);
+    }
+    unsafe(point, scalar, transform, prev) {
+      const W = getW(point);
+      if (W === 1)
+        return this._unsafeLadder(point, scalar, prev);
+      return this.wNAFUnsafe(W, this.getPrecomputes(W, point, transform), scalar, prev);
+    }
+    // We calculate precomputes for elliptic curve point multiplication
+    // using windowed method. This specifies window size and
+    // stores precomputed values. Usually only base point would be precomputed.
+    createCache(P2, W) {
+      validateW(W, this.bits);
+      pointWindowSizes.set(P2, W);
+      pointPrecomputes.delete(P2);
+    }
+    hasCache(elm) {
+      return getW(elm) !== 1;
+    }
+  };
+  function createField(order, field, isLE) {
+    if (field) {
+      if (field.ORDER !== order)
+        throw new Error("Field.ORDER must match order: Fp == p, Fn == n");
+      validateField(field);
+      return field;
+    } else {
+      return Field(order, { isLE });
     }
-    return sum;
   }
-  __name(pippenger, "pippenger");
-  function validateBasic(curve) {
-    validateField(curve.Fp);
-    validateObject(curve, {
-      n: "bigint",
-      h: "bigint",
-      Gx: "field",
-      Gy: "field"
-    }, {
-      nBitLength: "isSafeInteger",
-      nByteLength: "isSafeInteger"
-    });
-    return Object.freeze({
-      ...nLength(curve.n, curve.nBitLength),
-      ...curve,
-      ...{ p: curve.Fp.ORDER }
-    });
+  __name(createField, "createField");
+  function createCurveFields(type, CURVE, curveOpts = {}, FpFnLE) {
+    if (FpFnLE === void 0)
+      FpFnLE = type === "edwards";
+    if (!CURVE || typeof CURVE !== "object")
+      throw new Error(`expected valid ${type} CURVE object`);
+    for (const p of ["p", "n", "h"]) {
+      const val = CURVE[p];
+      if (!(typeof val === "bigint" && val > _0n3))
+        throw new Error(`CURVE.${p} must be positive bigint`);
+    }
+    const Fp = createField(CURVE.p, curveOpts.Fp, FpFnLE);
+    const Fn = createField(CURVE.n, curveOpts.Fn, FpFnLE);
+    const _b = type === "weierstrass" ? "b" : "d";
+    const params = ["Gx", "Gy", "a", _b];
+    for (const p of params) {
+      if (!Fp.isValid(CURVE[p]))
+        throw new Error(`CURVE.${p} must be valid field element of CURVE.Fp`);
+    }
+    CURVE = Object.freeze(Object.assign({}, CURVE));
+    return { CURVE, Fp, Fn };
   }
-  __name(validateBasic, "validateBasic");
+  __name(createCurveFields, "createCurveFields");
+  function createKeygen(randomSecretKey, getPublicKey) {
+    return /* @__PURE__ */ __name(function keygen(seed) {
+      const secretKey = randomSecretKey(seed);
+      return { secretKey, publicKey: getPublicKey(secretKey) };
+    }, "keygen");
+  }
+  __name(createKeygen, "createKeygen");
 
-  // ../../node_modules/@noble/curves/esm/abstract/edwards.js
+  // ../utils/node_modules/@noble/curves/abstract/edwards.js
   var _0n4 = BigInt(0);
   var _1n4 = BigInt(1);
-  var _2n3 = BigInt(2);
+  var _2n2 = BigInt(2);
   var _8n2 = BigInt(8);
-  var VERIFY_DEFAULT = { zip215: true };
-  function validateOpts(curve) {
-    const opts = validateBasic(curve);
-    validateObject(curve, {
-      hash: "function",
-      a: "bigint",
-      d: "bigint",
-      randomBytes: "function"
-    }, {
-      adjustScalarBytes: "function",
-      domain: "function",
-      uvRatio: "function",
-      mapToCurve: "function"
-    });
-    return Object.freeze({ ...opts });
+  function isEdValidXY(Fp, CURVE, x, y) {
+    const x2 = Fp.sqr(x);
+    const y2 = Fp.sqr(y);
+    const left = Fp.add(Fp.mul(CURVE.a, x2), y2);
+    const right = Fp.add(Fp.ONE, Fp.mul(CURVE.d, Fp.mul(x2, y2)));
+    return Fp.eql(left, right);
   }
-  __name(validateOpts, "validateOpts");
-  function twistedEdwards(curveDef) {
-    const CURVE = validateOpts(curveDef);
-    const { Fp: Fp2, n: CURVE_ORDER, prehash, hash: cHash, randomBytes: randomBytes2, nByteLength, h: cofactor } = CURVE;
-    const MASK = _2n3 << BigInt(nByteLength * 8) - _1n4;
-    const modP = Fp2.create;
-    const Fn = Field(CURVE.n, CURVE.nBitLength);
-    const uvRatio2 = CURVE.uvRatio || ((u, v) => {
+  __name(isEdValidXY, "isEdValidXY");
+  function edwards(params, extraOpts = {}) {
+    const validated = createCurveFields("edwards", params, extraOpts, extraOpts.FpFnLE);
+    const { Fp, Fn } = validated;
+    let CURVE = validated.CURVE;
+    const { h: cofactor } = CURVE;
+    validateObject(extraOpts, {}, { uvRatio: "function" });
+    const MASK = _2n2 << BigInt(Fn.BYTES * 8) - _1n4;
+    const modP = /* @__PURE__ */ __name((n) => Fp.create(n), "modP");
+    const uvRatio2 = extraOpts.uvRatio || ((u, v) => {
       try {
-        return { isValid: true, value: Fp2.sqrt(u * Fp2.inv(v)) };
+        return { isValid: true, value: Fp.sqrt(Fp.div(u, v)) };
       } catch (e) {
         return { isValid: false, value: _0n4 };
       }
     });
-    const adjustScalarBytes2 = CURVE.adjustScalarBytes || ((bytes) => bytes);
-    const domain = CURVE.domain || ((data, ctx, phflag) => {
-      abool("phflag", phflag);
-      if (ctx.length || phflag)
-        throw new Error("Contexts/pre-hash are not supported");
-      return data;
-    });
-    function aCoordinate(title, n) {
-      aInRange("coordinate " + title, n, _0n4, MASK);
-    }
-    __name(aCoordinate, "aCoordinate");
-    function assertPoint(other) {
+    if (!isEdValidXY(Fp, CURVE, CURVE.Gx, CURVE.Gy))
+      throw new Error("bad curve params: generator point");
+    function acoord(title, n, banZero = false) {
+      const min = banZero ? _1n4 : _0n4;
+      aInRange("coordinate " + title, n, min, MASK);
+      return n;
+    }
+    __name(acoord, "acoord");
+    function aedpoint(other) {
       if (!(other instanceof Point))
-        throw new Error("ExtendedPoint expected");
+        throw new Error("EdwardsPoint expected");
     }
-    __name(assertPoint, "assertPoint");
+    __name(aedpoint, "aedpoint");
     const toAffineMemo = memoized((p, iz) => {
-      const { ex: x, ey: y, ez: z } = p;
+      const { X, Y, Z } = p;
       const is0 = p.is0();
       if (iz == null)
-        iz = is0 ? _8n2 : Fp2.inv(z);
-      const ax = modP(x * iz);
-      const ay = modP(y * iz);
-      const zz = modP(z * iz);
+        iz = is0 ? _8n2 : Fp.inv(Z);
+      const x = modP(X * iz);
+      const y = modP(Y * iz);
+      const zz = Fp.mul(Z, iz);
       if (is0)
         return { x: _0n4, y: _1n4 };
       if (zz !== _1n4)
         throw new Error("invZ was invalid");
-      return { x: ax, y: ay };
+      return { x, y };
     });
     const assertValidMemo = memoized((p) => {
       const { a, d } = CURVE;
       if (p.is0())
         throw new Error("bad point: ZERO");
-      const { ex: X, ey: Y, ez: Z, et: T } = p;
+      const { X, Y, Z, T } = p;
       const X2 = modP(X * X);
       const Y2 = modP(Y * Y);
       const Z2 = modP(Z * Z);
@@ -1817,53 +2049,87 @@ var near = (() => {
       static {
         __name(this, "Point");
       }
-      constructor(ex, ey, ez, et) {
-        this.ex = ex;
-        this.ey = ey;
-        this.ez = ez;
-        this.et = et;
-        aCoordinate("x", ex);
-        aCoordinate("y", ey);
-        aCoordinate("z", ez);
-        aCoordinate("t", et);
+      // base / generator point
+      static BASE = new Point(CURVE.Gx, CURVE.Gy, _1n4, modP(CURVE.Gx * CURVE.Gy));
+      // zero / infinity / identity point
+      static ZERO = new Point(_0n4, _1n4, _1n4, _0n4);
+      // 0, 1, 1, 0
+      // math field
+      static Fp = Fp;
+      // scalar field
+      static Fn = Fn;
+      X;
+      Y;
+      Z;
+      T;
+      constructor(X, Y, Z, T) {
+        this.X = acoord("x", X);
+        this.Y = acoord("y", Y);
+        this.Z = acoord("z", Z, true);
+        this.T = acoord("t", T);
         Object.freeze(this);
       }
-      get x() {
-        return this.toAffine().x;
-      }
-      get y() {
-        return this.toAffine().y;
+      static CURVE() {
+        return CURVE;
       }
       static fromAffine(p) {
         if (p instanceof Point)
           throw new Error("extended point not allowed");
         const { x, y } = p || {};
-        aCoordinate("x", x);
-        aCoordinate("y", y);
+        acoord("x", x);
+        acoord("y", y);
         return new Point(x, y, _1n4, modP(x * y));
       }
-      static normalizeZ(points) {
-        const toInv = Fp2.invertBatch(points.map((p) => p.ez));
-        return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);
+      // Uses algo from RFC8032 5.1.3.
+      static fromBytes(bytes, zip215 = false) {
+        const len = Fp.BYTES;
+        const { a, d } = CURVE;
+        bytes = copyBytes(abytes(bytes, len, "point"));
+        abool(zip215, "zip215");
+        const normed = copyBytes(bytes);
+        const lastByte = bytes[len - 1];
+        normed[len - 1] = lastByte & ~128;
+        const y = bytesToNumberLE(normed);
+        const max = zip215 ? MASK : Fp.ORDER;
+        aInRange("point.y", y, _0n4, max);
+        const y2 = modP(y * y);
+        const u = modP(y2 - _1n4);
+        const v = modP(d * y2 - a);
+        let { isValid, value: x } = uvRatio2(u, v);
+        if (!isValid)
+          throw new Error("bad point: invalid y coordinate");
+        const isXOdd = (x & _1n4) === _1n4;
+        const isLastByteOdd = (lastByte & 128) !== 0;
+        if (!zip215 && x === _0n4 && isLastByteOdd)
+          throw new Error("bad point: x=0 and x_0=1");
+        if (isLastByteOdd !== isXOdd)
+          x = modP(-x);
+        return Point.fromAffine({ x, y });
+      }
+      static fromHex(hex, zip215 = false) {
+        return Point.fromBytes(hexToBytes(hex), zip215);
+      }
+      get x() {
+        return this.toAffine().x;
       }
-      // Multiscalar Multiplication
-      static msm(points, scalars) {
-        return pippenger(Point, Fn, points, scalars);
+      get y() {
+        return this.toAffine().y;
       }
-      // "Private method", don't use it directly
-      _setWindowSize(windowSize) {
-        wnaf.setWindowSize(this, windowSize);
+      precompute(windowSize = 8, isLazy = true) {
+        wnaf.createCache(this, windowSize);
+        if (!isLazy)
+          this.multiply(_2n2);
+        return this;
       }
-      // Not required for fromHex(), which always creates valid points.
-      // Could be useful for fromAffine().
+      // Useful in fromAffine() - not for fromBytes(), which always created valid points.
       assertValidity() {
         assertValidMemo(this);
       }
       // Compare one point to another.
       equals(other) {
-        assertPoint(other);
-        const { ex: X1, ey: Y1, ez: Z1 } = this;
-        const { ex: X2, ey: Y2, ez: Z2 } = other;
+        aedpoint(other);
+        const { X: X1, Y: Y1, Z: Z1 } = this;
+        const { X: X2, Y: Y2, Z: Z2 } = other;
         const X1Z2 = modP(X1 * Z2);
         const X2Z1 = modP(X2 * Z1);
         const Y1Z2 = modP(Y1 * Z2);
@@ -1874,80 +2140,60 @@ var near = (() => {
         return this.equals(Point.ZERO);
       }
       negate() {
-        return new Point(modP(-this.ex), this.ey, this.ez, modP(-this.et));
+        return new Point(modP(-this.X), this.Y, this.Z, modP(-this.T));
       }
       // Fast algo for doubling Extended Point.
       // https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html#doubling-dbl-2008-hwcd
       // Cost: 4M + 4S + 1*a + 6add + 1*2.
       double() {
         const { a } = CURVE;
-        const { ex: X1, ey: Y1, ez: Z1 } = this;
+        const { X: X1, Y: Y1, Z: Z1 } = this;
         const A = modP(X1 * X1);
         const B = modP(Y1 * Y1);
-        const C = modP(_2n3 * modP(Z1 * Z1));
+        const C = modP(_2n2 * modP(Z1 * Z1));
         const D = modP(a * A);
         const x1y1 = X1 + Y1;
         const E = modP(modP(x1y1 * x1y1) - A - B);
-        const G2 = D + B;
-        const F = G2 - C;
+        const G = D + B;
+        const F = G - C;
         const H = D - B;
         const X3 = modP(E * F);
-        const Y3 = modP(G2 * H);
+        const Y3 = modP(G * H);
         const T3 = modP(E * H);
-        const Z3 = modP(F * G2);
+        const Z3 = modP(F * G);
         return new Point(X3, Y3, Z3, T3);
       }
       // Fast algo for adding 2 Extended Points.
       // https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html#addition-add-2008-hwcd
       // Cost: 9M + 1*a + 1*d + 7add.
       add(other) {
-        assertPoint(other);
+        aedpoint(other);
         const { a, d } = CURVE;
-        const { ex: X1, ey: Y1, ez: Z1, et: T1 } = this;
-        const { ex: X2, ey: Y2, ez: Z2, et: T2 } = other;
-        if (a === BigInt(-1)) {
-          const A2 = modP((Y1 - X1) * (Y2 + X2));
-          const B2 = modP((Y1 + X1) * (Y2 - X2));
-          const F2 = modP(B2 - A2);
-          if (F2 === _0n4)
-            return this.double();
-          const C2 = modP(Z1 * _2n3 * T2);
-          const D2 = modP(T1 * _2n3 * Z2);
-          const E2 = D2 + C2;
-          const G3 = B2 + A2;
-          const H2 = D2 - C2;
-          const X32 = modP(E2 * F2);
-          const Y32 = modP(G3 * H2);
-          const T32 = modP(E2 * H2);
-          const Z32 = modP(F2 * G3);
-          return new Point(X32, Y32, Z32, T32);
-        }
+        const { X: X1, Y: Y1, Z: Z1, T: T1 } = this;
+        const { X: X2, Y: Y2, Z: Z2, T: T2 } = other;
         const A = modP(X1 * X2);
         const B = modP(Y1 * Y2);
         const C = modP(T1 * d * T2);
         const D = modP(Z1 * Z2);
         const E = modP((X1 + Y1) * (X2 + Y2) - A - B);
         const F = D - C;
-        const G2 = D + C;
+        const G = D + C;
         const H = modP(B - a * A);
         const X3 = modP(E * F);
-        const Y3 = modP(G2 * H);
+        const Y3 = modP(G * H);
         const T3 = modP(E * H);
-        const Z3 = modP(F * G2);
+        const Z3 = modP(F * G);
         return new Point(X3, Y3, Z3, T3);
       }
       subtract(other) {
         return this.add(other.negate());
       }
-      wNAF(n) {
-        return wnaf.wNAFCached(this, n, Point.normalizeZ);
-      }
       // Constant-time multiplication.
       multiply(scalar) {
-        const n = scalar;
-        aInRange("scalar", n, _1n4, CURVE_ORDER);
-        const { p, f } = this.wNAF(n);
-        return Point.normalizeZ([p, f])[0];
+        if (!Fn.isValidNot0(scalar))
+          throw new Error("invalid scalar: expected 1 <= sc < curve.n");
+        const { p, f } = wnaf.cached(this, scalar, (p2) => normalizeZ(Point, p2));
+        return normalizeZ(Point, [p, f])[0];
       }
       // Non-constant-time multiplication. Uses double-and-add algorithm.
       // It's faster, but should only be used when you don't care about
@@ -1955,13 +2201,13 @@ var near = (() => {
       // Does NOT allow scalars higher than CURVE.n.
       // Accepts optional accumulator to merge with multiply (important for sparse scalars)
       multiplyUnsafe(scalar, acc = Point.ZERO) {
-        const n = scalar;
-        aInRange("scalar", n, _0n4, CURVE_ORDER);
-        if (n === _0n4)
-          return I;
-        if (this.is0() || n === _1n4)
+        if (!Fn.isValid(scalar))
+          throw new Error("invalid scalar: expected 0 <= sc < curve.n");
+        if (scalar === _0n4)
+          return Point.ZERO;
+        if (this.is0() || scalar === _1n4)
           return this;
-        return wnaf.wNAFCachedUnsafe(this, n, Point.normalizeZ, acc);
+        return wnaf.unsafe(this, scalar, (p) => normalizeZ(Point, p), acc);
       }
       // Checks if point is of small order.
       // If you add something to small order point, you will have "dirty"
@@ -1973,176 +2219,216 @@ var near = (() => {
       // Multiplies point by curve order and checks if the result is 0.
       // Returns `false` is the point is dirty.
       isTorsionFree() {
-        return wnaf.unsafeLadder(this, CURVE_ORDER).is0();
+        return wnaf.unsafe(this, CURVE.n).is0();
       }
       // Converts Extended point to default (x, y) coordinates.
       // Can accept precomputed Z^-1 - for example, from invertBatch.
-      toAffine(iz) {
-        return toAffineMemo(this, iz);
+      toAffine(invertedZ) {
+        return toAffineMemo(this, invertedZ);
       }
       clearCofactor() {
-        const { h: cofactor2 } = CURVE;
-        if (cofactor2 === _1n4)
+        if (cofactor === _1n4)
           return this;
-        return this.multiplyUnsafe(cofactor2);
-      }
-      // Converts hash string or Uint8Array to Point.
-      // Uses algo from RFC8032 5.1.3.
-      static fromHex(hex, zip215 = false) {
-        const { d, a } = CURVE;
-        const len = Fp2.BYTES;
-        hex = ensureBytes("pointHex", hex, len);
-        abool("zip215", zip215);
-        const normed = hex.slice();
-        const lastByte = hex[len - 1];
-        normed[len - 1] = lastByte & ~128;
-        const y = bytesToNumberLE(normed);
-        const max = zip215 ? MASK : Fp2.ORDER;
-        aInRange("pointHex.y", y, _0n4, max);
-        const y2 = modP(y * y);
-        const u = modP(y2 - _1n4);
-        const v = modP(d * y2 - a);
-        let { isValid, value: x } = uvRatio2(u, v);
-        if (!isValid)
-          throw new Error("Point.fromHex: invalid y coordinate");
-        const isXOdd = (x & _1n4) === _1n4;
-        const isLastByteOdd = (lastByte & 128) !== 0;
-        if (!zip215 && x === _0n4 && isLastByteOdd)
-          throw new Error("Point.fromHex: x=0 and x_0=1");
-        if (isLastByteOdd !== isXOdd)
-          x = modP(-x);
-        return Point.fromAffine({ x, y });
-      }
-      static fromPrivateKey(privKey) {
-        return getExtendedPublicKey(privKey).point;
+        return this.multiplyUnsafe(cofactor);
       }
-      toRawBytes() {
+      toBytes() {
         const { x, y } = this.toAffine();
-        const bytes = numberToBytesLE(y, Fp2.BYTES);
+        const bytes = Fp.toBytes(y);
         bytes[bytes.length - 1] |= x & _1n4 ? 128 : 0;
         return bytes;
       }
       toHex() {
-        return bytesToHex(this.toRawBytes());
+        return bytesToHex(this.toBytes());
+      }
+      toString() {
+        return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
       }
     }
-    Point.BASE = new Point(CURVE.Gx, CURVE.Gy, _1n4, modP(CURVE.Gx * CURVE.Gy));
-    Point.ZERO = new Point(_0n4, _1n4, _1n4, _0n4);
-    const { BASE: G, ZERO: I } = Point;
-    const wnaf = wNAF(Point, nByteLength * 8);
-    function modN(a) {
-      return mod(a, CURVE_ORDER);
-    }
-    __name(modN, "modN");
+    const wnaf = new wNAF(Point, Fn.BITS);
+    Point.BASE.precompute(8);
+    return Point;
+  }
+  __name(edwards, "edwards");
+  function eddsa(Point, cHash, eddsaOpts = {}) {
+    if (typeof cHash !== "function")
+      throw new Error('"hash" function param is required');
+    validateObject(eddsaOpts, {}, {
+      adjustScalarBytes: "function",
+      randomBytes: "function",
+      domain: "function",
+      prehash: "function",
+      mapToCurve: "function"
+    });
+    const { prehash } = eddsaOpts;
+    const { BASE, Fp, Fn } = Point;
+    const randomBytes2 = eddsaOpts.randomBytes || randomBytes;
+    const adjustScalarBytes2 = eddsaOpts.adjustScalarBytes || ((bytes) => bytes);
+    const domain = eddsaOpts.domain || ((data, ctx, phflag) => {
+      abool(phflag, "phflag");
+      if (ctx.length || phflag)
+        throw new Error("Contexts/pre-hash are not supported");
+      return data;
+    });
     function modN_LE(hash) {
-      return modN(bytesToNumberLE(hash));
+      return Fn.create(bytesToNumberLE(hash));
     }
     __name(modN_LE, "modN_LE");
-    function getExtendedPublicKey(key) {
-      const len = Fp2.BYTES;
-      key = ensureBytes("private key", key, len);
-      const hashed = ensureBytes("hashed private key", cHash(key), 2 * len);
+    function getPrivateScalar(key) {
+      const len = lengths.secretKey;
+      abytes(key, lengths.secretKey, "secretKey");
+      const hashed = abytes(cHash(key), 2 * len, "hashedSecretKey");
       const head = adjustScalarBytes2(hashed.slice(0, len));
       const prefix = hashed.slice(len, 2 * len);
       const scalar = modN_LE(head);
-      const point = G.multiply(scalar);
-      const pointBytes = point.toRawBytes();
+      return { head, prefix, scalar };
+    }
+    __name(getPrivateScalar, "getPrivateScalar");
+    function getExtendedPublicKey(secretKey) {
+      const { head, prefix, scalar } = getPrivateScalar(secretKey);
+      const point = BASE.multiply(scalar);
+      const pointBytes = point.toBytes();
       return { head, prefix, scalar, point, pointBytes };
     }
     __name(getExtendedPublicKey, "getExtendedPublicKey");
-    function getPublicKey(privKey) {
-      return getExtendedPublicKey(privKey).pointBytes;
+    function getPublicKey(secretKey) {
+      return getExtendedPublicKey(secretKey).pointBytes;
     }
     __name(getPublicKey, "getPublicKey");
-    function hashDomainToScalar(context = new Uint8Array(), ...msgs) {
+    function hashDomainToScalar(context = Uint8Array.of(), ...msgs) {
       const msg = concatBytes(...msgs);
-      return modN_LE(cHash(domain(msg, ensureBytes("context", context), !!prehash)));
+      return modN_LE(cHash(domain(msg, abytes(context, void 0, "context"), !!prehash)));
     }
     __name(hashDomainToScalar, "hashDomainToScalar");
-    function sign(msg, privKey, options = {}) {
-      msg = ensureBytes("message", msg);
+    function sign(msg, secretKey, options = {}) {
+      msg = abytes(msg, void 0, "message");
       if (prehash)
         msg = prehash(msg);
-      const { prefix, scalar, pointBytes } = getExtendedPublicKey(privKey);
+      const { prefix, scalar, pointBytes } = getExtendedPublicKey(secretKey);
       const r = hashDomainToScalar(options.context, prefix, msg);
-      const R = G.multiply(r).toRawBytes();
+      const R = BASE.multiply(r).toBytes();
       const k = hashDomainToScalar(options.context, R, pointBytes, msg);
-      const s = modN(r + k * scalar);
-      aInRange("signature.s", s, _0n4, CURVE_ORDER);
-      const res = concatBytes(R, numberToBytesLE(s, Fp2.BYTES));
-      return ensureBytes("result", res, Fp2.BYTES * 2);
+      const s = Fn.create(r + k * scalar);
+      if (!Fn.isValid(s))
+        throw new Error("sign failed: invalid s");
+      const rs = concatBytes(R, Fn.toBytes(s));
+      return abytes(rs, lengths.signature, "result");
     }
     __name(sign, "sign");
-    const verifyOpts = VERIFY_DEFAULT;
+    const verifyOpts = { zip215: true };
     function verify(sig, msg, publicKey2, options = verifyOpts) {
       const { context, zip215 } = options;
-      const len = Fp2.BYTES;
-      sig = ensureBytes("signature", sig, 2 * len);
-      msg = ensureBytes("message", msg);
-      publicKey2 = ensureBytes("publicKey", publicKey2, len);
+      const len = lengths.signature;
+      sig = abytes(sig, len, "signature");
+      msg = abytes(msg, void 0, "message");
+      publicKey2 = abytes(publicKey2, lengths.publicKey, "publicKey");
       if (zip215 !== void 0)
-        abool("zip215", zip215);
+        abool(zip215, "zip215");
       if (prehash)
         msg = prehash(msg);
-      const s = bytesToNumberLE(sig.slice(len, 2 * len));
+      const mid = len / 2;
+      const r = sig.subarray(0, mid);
+      const s = bytesToNumberLE(sig.subarray(mid, len));
       let A, R, SB;
       try {
-        A = Point.fromHex(publicKey2, zip215);
-        R = Point.fromHex(sig.slice(0, len), zip215);
-        SB = G.multiplyUnsafe(s);
+        A = Point.fromBytes(publicKey2, zip215);
+        R = Point.fromBytes(r, zip215);
+        SB = BASE.multiplyUnsafe(s);
       } catch (error) {
         return false;
       }
       if (!zip215 && A.isSmallOrder())
         return false;
-      const k = hashDomainToScalar(context, R.toRawBytes(), A.toRawBytes(), msg);
+      const k = hashDomainToScalar(context, R.toBytes(), A.toBytes(), msg);
       const RkA = R.add(A.multiplyUnsafe(k));
-      return RkA.subtract(SB).clearCofactor().equals(Point.ZERO);
+      return RkA.subtract(SB).clearCofactor().is0();
     }
     __name(verify, "verify");
-    G._setWindowSize(8);
+    const _size = Fp.BYTES;
+    const lengths = {
+      secretKey: _size,
+      publicKey: _size,
+      signature: 2 * _size,
+      seed: _size
+    };
+    function randomSecretKey(seed = randomBytes2(lengths.seed)) {
+      return abytes(seed, lengths.seed, "seed");
+    }
+    __name(randomSecretKey, "randomSecretKey");
+    function isValidSecretKey(key) {
+      return isBytes(key) && key.length === Fn.BYTES;
+    }
+    __name(isValidSecretKey, "isValidSecretKey");
+    function isValidPublicKey(key, zip215) {
+      try {
+        return !!Point.fromBytes(key, zip215);
+      } catch (error) {
+        return false;
+      }
+    }
+    __name(isValidPublicKey, "isValidPublicKey");
     const utils2 = {
       getExtendedPublicKey,
-      // ed25519 private keys are uniform 32b. No need to check for modulo bias, like in secp256k1.
-      randomPrivateKey: /* @__PURE__ */ __name(() => randomBytes2(Fp2.BYTES), "randomPrivateKey"),
+      randomSecretKey,
+      isValidSecretKey,
+      isValidPublicKey,
       /**
-       * We're doing scalar multiplication (used in getPublicKey etc) with precomputed BASE_POINT
-       * values. This slows down first getPublicKey() by milliseconds (see Speed section),
-       * but allows to speed-up subsequent getPublicKey() calls up to 20x.
-       * @param windowSize 2, 4, 8, 16
+       * Converts ed public key to x public key. Uses formula:
+       * - ed25519:
+       *   - `(u, v) = ((1+y)/(1-y), sqrt(-486664)*u/x)`
+       *   - `(x, y) = (sqrt(-486664)*u/v, (u-1)/(u+1))`
+       * - ed448:
+       *   - `(u, v) = ((y-1)/(y+1), sqrt(156324)*u/x)`
+       *   - `(x, y) = (sqrt(156324)*u/v, (1+u)/(1-u))`
        */
-      precompute(windowSize = 8, point = Point.BASE) {
-        point._setWindowSize(windowSize);
-        point.multiply(BigInt(3));
-        return point;
+      toMontgomery(publicKey2) {
+        const { y } = Point.fromBytes(publicKey2);
+        const size = lengths.publicKey;
+        const is25519 = size === 32;
+        if (!is25519 && size !== 57)
+          throw new Error("only defined for 25519 and 448");
+        const u = is25519 ? Fp.div(_1n4 + y, _1n4 - y) : Fp.div(y - _1n4, y + _1n4);
+        return Fp.toBytes(u);
+      },
+      toMontgomerySecret(secretKey) {
+        const size = lengths.secretKey;
+        abytes(secretKey, size);
+        const hashed = cHash(secretKey.subarray(0, size));
+        return adjustScalarBytes2(hashed).subarray(0, size);
       }
     };
-    return {
-      CURVE,
+    return Object.freeze({
+      keygen: createKeygen(randomSecretKey, getPublicKey),
       getPublicKey,
       sign,
       verify,
-      ExtendedPoint: Point,
-      utils: utils2
-    };
+      utils: utils2,
+      Point,
+      lengths
+    });
   }
-  __name(twistedEdwards, "twistedEdwards");
+  __name(eddsa, "eddsa");
 
-  // ../../node_modules/@noble/curves/esm/ed25519.js
-  var ED25519_P = BigInt("57896044618658097711785492504343953926634992332820282019728792003956564819949");
-  var ED25519_SQRT_M1 = /* @__PURE__ */ BigInt("19681161376707505956807079304988542015446066515923890162744021073123829784752");
-  var _0n5 = BigInt(0);
+  // ../utils/node_modules/@noble/curves/ed25519.js
   var _1n5 = BigInt(1);
-  var _2n4 = BigInt(2);
-  var _3n2 = BigInt(3);
+  var _2n3 = BigInt(2);
   var _5n2 = BigInt(5);
   var _8n3 = BigInt(8);
+  var ed25519_CURVE_p = BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed");
+  var ed25519_CURVE = /* @__PURE__ */ (() => ({
+    p: ed25519_CURVE_p,
+    n: BigInt("0x1000000000000000000000000000000014def9dea2f79cd65812631a5cf5d3ed"),
+    h: _8n3,
+    a: BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec"),
+    d: BigInt("0x52036cee2b6ffe738cc740797779e89800700a4d4141d8ab75eb4dca135978a3"),
+    Gx: BigInt("0x216936d3cd6e53fec0a4e231fdd6dc5c692cc7609525a7b2c9562d608f25d51a"),
+    Gy: BigInt("0x6666666666666666666666666666666666666666666666666666666666666658")
+  }))();
   function ed25519_pow_2_252_3(x) {
     const _10n = BigInt(10), _20n = BigInt(20), _40n = BigInt(40), _80n = BigInt(80);
-    const P2 = ED25519_P;
+    const P2 = ed25519_CURVE_p;
     const x2 = x * x % P2;
     const b2 = x2 * x % P2;
-    const b4 = pow2(b2, _2n4, P2) * b2 % P2;
+    const b4 = pow2(b2, _2n3, P2) * b2 % P2;
     const b5 = pow2(b4, _1n5, P2) * x % P2;
     const b10 = pow2(b5, _5n2, P2) * b5 % P2;
     const b20 = pow2(b10, _10n, P2) * b10 % P2;
@@ -2151,7 +2437,7 @@ var near = (() => {
     const b160 = pow2(b80, _80n, P2) * b80 % P2;
     const b240 = pow2(b160, _80n, P2) * b80 % P2;
     const b250 = pow2(b240, _10n, P2) * b10 % P2;
-    const pow_p_5_8 = pow2(b250, _2n4, P2) * x % P2;
+    const pow_p_5_8 = pow2(b250, _2n3, P2) * x % P2;
     return { pow_p_5_8, b2 };
   }
   __name(ed25519_pow_2_252_3, "ed25519_pow_2_252_3");
@@ -2162,207 +2448,34 @@ var near = (() => {
     return bytes;
   }
   __name(adjustScalarBytes, "adjustScalarBytes");
-  function uvRatio(u, v) {
-    const P2 = ED25519_P;
-    const v3 = mod(v * v * v, P2);
-    const v7 = mod(v3 * v3 * v, P2);
-    const pow3 = ed25519_pow_2_252_3(u * v7).pow_p_5_8;
-    let x = mod(u * v3 * pow3, P2);
-    const vx2 = mod(v * x * x, P2);
-    const root1 = x;
-    const root2 = mod(x * ED25519_SQRT_M1, P2);
-    const useRoot1 = vx2 === u;
-    const useRoot2 = vx2 === mod(-u, P2);
-    const noRoot = vx2 === mod(-u * ED25519_SQRT_M1, P2);
-    if (useRoot1)
-      x = root1;
-    if (useRoot2 || noRoot)
-      x = root2;
-    if (isNegativeLE(x, P2))
-      x = mod(-x, P2);
-    return { isValid: useRoot1 || useRoot2, value: x };
-  }
-  __name(uvRatio, "uvRatio");
-  var Fp = /* @__PURE__ */ (() => Field(ED25519_P, void 0, true))();
-  var ed25519Defaults = /* @__PURE__ */ (() => ({
-    // Param: a
-    a: BigInt(-1),
-    // Fp.create(-1) is proper; our way still works and is faster
-    // d is equal to -121665/121666 over finite field.
-    // Negative number is P - number, and division is invert(number, P)
-    d: BigInt("37095705934669439343138083508754565189542113879843219016388785533085940283555"),
-    // Finite field 𝔽p over which we'll do calculations; 2n**255n - 19n
-    Fp,
-    // Subgroup order: how many points curve has
-    // 2n**252n + 27742317777372353535851937790883648493n;
-    n: BigInt("7237005577332262213973186563042994240857116359379907606001950938285454250989"),
-    // Cofactor
-    h: _8n3,
-    // Base point (x, y) aka generator point
-    Gx: BigInt("15112221349535400772501151409588531511454012693041857206046113283949847762202"),
-    Gy: BigInt("46316835694926478169428394003475163141307993866256225615783033603165251855960"),
-    hash: sha512,
-    randomBytes,
-    adjustScalarBytes,
-    // dom2
-    // Ratio of u to v. Allows us to combine inversion and square root. Uses algo from RFC8032 5.1.3.
-    // Constant-time, u/√v
-    uvRatio
-  }))();
-  var ed25519 = /* @__PURE__ */ (() => twistedEdwards(ed25519Defaults))();
-
-  // ../../node_modules/@noble/hashes/esm/sha256.js
-  var SHA256_K = /* @__PURE__ */ new Uint32Array([
-    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
-  ]);
-  var SHA256_IV = /* @__PURE__ */ new Uint32Array([
-    1779033703,
-    3144134277,
-    1013904242,
-    2773480762,
-    1359893119,
-    2600822924,
-    528734635,
-    1541459225
-  ]);
-  var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
-  var SHA256 = class extends HashMD {
-    static {
-      __name(this, "SHA256");
-    }
-    constructor() {
-      super(64, 32, 8, false);
-      this.A = SHA256_IV[0] | 0;
-      this.B = SHA256_IV[1] | 0;
-      this.C = SHA256_IV[2] | 0;
-      this.D = SHA256_IV[3] | 0;
-      this.E = SHA256_IV[4] | 0;
-      this.F = SHA256_IV[5] | 0;
-      this.G = SHA256_IV[6] | 0;
-      this.H = SHA256_IV[7] | 0;
-    }
-    get() {
-      const { A, B, C, D, E, F, G, H } = this;
-      return [A, B, C, D, E, F, G, H];
-    }
-    // prettier-ignore
-    set(A, B, C, D, E, F, G, H) {
-      this.A = A | 0;
-      this.B = B | 0;
-      this.C = C | 0;
-      this.D = D | 0;
-      this.E = E | 0;
-      this.F = F | 0;
-      this.G = G | 0;
-      this.H = H | 0;
-    }
-    process(view2, offset) {
-      for (let i = 0; i < 16; i++, offset += 4)
-        SHA256_W[i] = view2.getUint32(offset, false);
-      for (let i = 16; i < 64; i++) {
-        const W15 = SHA256_W[i - 15];
-        const W2 = SHA256_W[i - 2];
-        const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
-        const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
-        SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
-      }
-      let { A, B, C, D, E, F, G, H } = this;
-      for (let i = 0; i < 64; i++) {
-        const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
-        const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
-        const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
-        const T2 = sigma0 + Maj(A, B, C) | 0;
-        H = G;
-        G = F;
-        F = E;
-        E = D + T1 | 0;
-        D = C;
-        C = B;
-        B = A;
-        A = T1 + T2 | 0;
-      }
-      A = A + this.A | 0;
-      B = B + this.B | 0;
-      C = C + this.C | 0;
-      D = D + this.D | 0;
-      E = E + this.E | 0;
-      F = F + this.F | 0;
-      G = G + this.G | 0;
-      H = H + this.H | 0;
-      this.set(A, B, C, D, E, F, G, H);
-    }
-    roundClean() {
-      SHA256_W.fill(0);
-    }
-    destroy() {
-      this.set(0, 0, 0, 0, 0, 0, 0, 0);
-      this.buffer.fill(0);
-    }
-  };
-  var sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
+  var ED25519_SQRT_M1 = /* @__PURE__ */ BigInt("19681161376707505956807079304988542015446066515923890162744021073123829784752");
+  function uvRatio(u, v) {
+    const P2 = ed25519_CURVE_p;
+    const v3 = mod(v * v * v, P2);
+    const v7 = mod(v3 * v3 * v, P2);
+    const pow = ed25519_pow_2_252_3(u * v7).pow_p_5_8;
+    let x = mod(u * v3 * pow, P2);
+    const vx2 = mod(v * x * x, P2);
+    const root1 = x;
+    const root2 = mod(x * ED25519_SQRT_M1, P2);
+    const useRoot1 = vx2 === u;
+    const useRoot2 = vx2 === mod(-u, P2);
+    const noRoot = vx2 === mod(-u * ED25519_SQRT_M1, P2);
+    if (useRoot1)
+      x = root1;
+    if (useRoot2 || noRoot)
+      x = root2;
+    if (isNegativeLE(x, P2))
+      x = mod(-x, P2);
+    return { isValid: useRoot1 || useRoot2, value: x };
+  }
+  __name(uvRatio, "uvRatio");
+  var ed25519_Point = /* @__PURE__ */ edwards(ed25519_CURVE, { uvRatio });
+  function ed(opts) {
+    return eddsa(ed25519_Point, sha512, Object.assign({ adjustScalarBytes }, opts));
+  }
+  __name(ed, "ed");
+  var ed25519 = /* @__PURE__ */ ed({});
 
   // ../utils/node_modules/base58-js/base58_chars.js
   var base58_chars = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
@@ -3702,6 +3815,341 @@ var near = (() => {
     lsSet("txHistory", _txHistory);
   }, "resetTxHistory");
 
+  // node_modules/@noble/hashes/utils.js
+  function isBytes2(a) {
+    return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+  }
+  __name(isBytes2, "isBytes");
+  function abytes2(value, length, title = "") {
+    const bytes = isBytes2(value);
+    const len = value?.length;
+    const needsLen = length !== void 0;
+    if (!bytes || needsLen && len !== length) {
+      const prefix = title && `"${title}" `;
+      const ofLen = needsLen ? ` of length ${length}` : "";
+      const got = bytes ? `length=${len}` : `type=${typeof value}`;
+      throw new Error(prefix + "expected Uint8Array" + ofLen + ", got " + got);
+    }
+    return value;
+  }
+  __name(abytes2, "abytes");
+  function aexists2(instance, checkFinished = true) {
+    if (instance.destroyed)
+      throw new Error("Hash instance has been destroyed");
+    if (checkFinished && instance.finished)
+      throw new Error("Hash#digest() has already been called");
+  }
+  __name(aexists2, "aexists");
+  function aoutput2(out, instance) {
+    abytes2(out, void 0, "digestInto() output");
+    const min = instance.outputLen;
+    if (out.length < min) {
+      throw new Error('"digestInto() output" expected to be of length >=' + min);
+    }
+  }
+  __name(aoutput2, "aoutput");
+  function clean2(...arrays) {
+    for (let i = 0; i < arrays.length; i++) {
+      arrays[i].fill(0);
+    }
+  }
+  __name(clean2, "clean");
+  function createView2(arr) {
+    return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+  }
+  __name(createView2, "createView");
+  function rotr2(word, shift) {
+    return word << 32 - shift | word >>> shift;
+  }
+  __name(rotr2, "rotr");
+  function createHasher2(hashCons, info = {}) {
+    const hashC = /* @__PURE__ */ __name((msg, opts) => hashCons(opts).update(msg).digest(), "hashC");
+    const tmp = hashCons(void 0);
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = (opts) => hashCons(opts);
+    Object.assign(hashC, info);
+    return Object.freeze(hashC);
+  }
+  __name(createHasher2, "createHasher");
+  var oidNist2 = /* @__PURE__ */ __name((suffix) => ({
+    oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, suffix])
+  }), "oidNist");
+
+  // node_modules/@noble/hashes/_md.js
+  function Chi2(a, b, c) {
+    return a & b ^ ~a & c;
+  }
+  __name(Chi2, "Chi");
+  function Maj2(a, b, c) {
+    return a & b ^ a & c ^ b & c;
+  }
+  __name(Maj2, "Maj");
+  var HashMD2 = class {
+    static {
+      __name(this, "HashMD");
+    }
+    blockLen;
+    outputLen;
+    padOffset;
+    isLE;
+    // For partial updates less than block size
+    buffer;
+    view;
+    finished = false;
+    length = 0;
+    pos = 0;
+    destroyed = false;
+    constructor(blockLen, outputLen, padOffset, isLE) {
+      this.blockLen = blockLen;
+      this.outputLen = outputLen;
+      this.padOffset = padOffset;
+      this.isLE = isLE;
+      this.buffer = new Uint8Array(blockLen);
+      this.view = createView2(this.buffer);
+    }
+    update(data) {
+      aexists2(this);
+      abytes2(data);
+      const { view: view2, buffer, blockLen } = this;
+      const len = data.length;
+      for (let pos = 0; pos < len; ) {
+        const take = Math.min(blockLen - this.pos, len - pos);
+        if (take === blockLen) {
+          const dataView = createView2(data);
+          for (; blockLen <= len - pos; pos += blockLen)
+            this.process(dataView, pos);
+          continue;
+        }
+        buffer.set(data.subarray(pos, pos + take), this.pos);
+        this.pos += take;
+        pos += take;
+        if (this.pos === blockLen) {
+          this.process(view2, 0);
+          this.pos = 0;
+        }
+      }
+      this.length += data.length;
+      this.roundClean();
+      return this;
+    }
+    digestInto(out) {
+      aexists2(this);
+      aoutput2(out, this);
+      this.finished = true;
+      const { buffer, view: view2, blockLen, isLE } = this;
+      let { pos } = this;
+      buffer[pos++] = 128;
+      clean2(this.buffer.subarray(pos));
+      if (this.padOffset > blockLen - pos) {
+        this.process(view2, 0);
+        pos = 0;
+      }
+      for (let i = pos; i < blockLen; i++)
+        buffer[i] = 0;
+      view2.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);
+      this.process(view2, 0);
+      const oview = createView2(out);
+      const len = this.outputLen;
+      if (len % 4)
+        throw new Error("_sha2: outputLen must be aligned to 32bit");
+      const outLen = len / 4;
+      const state2 = this.get();
+      if (outLen > state2.length)
+        throw new Error("_sha2: outputLen bigger than state");
+      for (let i = 0; i < outLen; i++)
+        oview.setUint32(4 * i, state2[i], isLE);
+    }
+    digest() {
+      const { buffer, outputLen } = this;
+      this.digestInto(buffer);
+      const res = buffer.slice(0, outputLen);
+      this.destroy();
+      return res;
+    }
+    _cloneInto(to) {
+      to ||= new this.constructor();
+      to.set(...this.get());
+      const { blockLen, buffer, length, finished, destroyed, pos } = this;
+      to.destroyed = destroyed;
+      to.finished = finished;
+      to.length = length;
+      to.pos = pos;
+      if (length % blockLen)
+        to.buffer.set(buffer);
+      return to;
+    }
+    clone() {
+      return this._cloneInto();
+    }
+  };
+  var SHA256_IV2 = /* @__PURE__ */ Uint32Array.from([
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ]);
+
+  // node_modules/@noble/hashes/sha2.js
+  var SHA256_K2 = /* @__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
+  ]);
+  var SHA256_W2 = /* @__PURE__ */ new Uint32Array(64);
+  var SHA2_32B2 = class extends HashMD2 {
+    static {
+      __name(this, "SHA2_32B");
+    }
+    constructor(outputLen) {
+      super(64, outputLen, 8, false);
+    }
+    get() {
+      const { A, B, C, D, E, F, G, H } = this;
+      return [A, B, C, D, E, F, G, H];
+    }
+    // prettier-ignore
+    set(A, B, C, D, E, F, G, H) {
+      this.A = A | 0;
+      this.B = B | 0;
+      this.C = C | 0;
+      this.D = D | 0;
+      this.E = E | 0;
+      this.F = F | 0;
+      this.G = G | 0;
+      this.H = H | 0;
+    }
+    process(view2, offset) {
+      for (let i = 0; i < 16; i++, offset += 4)
+        SHA256_W2[i] = view2.getUint32(offset, false);
+      for (let i = 16; i < 64; i++) {
+        const W15 = SHA256_W2[i - 15];
+        const W2 = SHA256_W2[i - 2];
+        const s0 = rotr2(W15, 7) ^ rotr2(W15, 18) ^ W15 >>> 3;
+        const s1 = rotr2(W2, 17) ^ rotr2(W2, 19) ^ W2 >>> 10;
+        SHA256_W2[i] = s1 + SHA256_W2[i - 7] + s0 + SHA256_W2[i - 16] | 0;
+      }
+      let { A, B, C, D, E, F, G, H } = this;
+      for (let i = 0; i < 64; i++) {
+        const sigma1 = rotr2(E, 6) ^ rotr2(E, 11) ^ rotr2(E, 25);
+        const T1 = H + sigma1 + Chi2(E, F, G) + SHA256_K2[i] + SHA256_W2[i] | 0;
+        const sigma0 = rotr2(A, 2) ^ rotr2(A, 13) ^ rotr2(A, 22);
+        const T2 = sigma0 + Maj2(A, B, C) | 0;
+        H = G;
+        G = F;
+        F = E;
+        E = D + T1 | 0;
+        D = C;
+        C = B;
+        B = A;
+        A = T1 + T2 | 0;
+      }
+      A = A + this.A | 0;
+      B = B + this.B | 0;
+      C = C + this.C | 0;
+      D = D + this.D | 0;
+      E = E + this.E | 0;
+      F = F + this.F | 0;
+      G = G + this.G | 0;
+      H = H + this.H | 0;
+      this.set(A, B, C, D, E, F, G, H);
+    }
+    roundClean() {
+      clean2(SHA256_W2);
+    }
+    destroy() {
+      this.set(0, 0, 0, 0, 0, 0, 0, 0);
+      clean2(this.buffer);
+    }
+  };
+  var _SHA2562 = class extends SHA2_32B2 {
+    static {
+      __name(this, "_SHA256");
+    }
+    // We cannot use array here since array allows indexing by variable
+    // which means optimizer/compiler cannot use registers.
+    A = SHA256_IV2[0] | 0;
+    B = SHA256_IV2[1] | 0;
+    C = SHA256_IV2[2] | 0;
+    D = SHA256_IV2[3] | 0;
+    E = SHA256_IV2[4] | 0;
+    F = SHA256_IV2[5] | 0;
+    G = SHA256_IV2[6] | 0;
+    H = SHA256_IV2[7] | 0;
+    constructor() {
+      super(32);
+    }
+  };
+  var sha2562 = /* @__PURE__ */ createHasher2(
+    () => new _SHA2562(),
+    /* @__PURE__ */ oidNist2(1)
+  );
+
   // src/near.ts
   big_default.DP = 27;
   var MaxBlockDelayMs = 1e3 * 60 * 60 * 6;
@@ -3992,7 +4440,7 @@ var near = (() => {
       actions: actions2
     };
     const txBytes = serializeTransaction(plainTransactionObj);
-    const txHashBytes = sha256(txBytes);
+    const txHashBytes = sha2562(txBytes);
     const txHash58 = binary_to_base58_default(txHashBytes);
     const signatureBase58 = signHash(txHashBytes, privKey, { returnBase58: true });
     const signedTransactionBytes = serializeSignedTransaction(plainTransactionObj, signatureBase58);
@@ -4105,23 +4553,26 @@ var near = (() => {
 })();
 /*! Bundled license information:
 
-@noble/hashes/esm/utils.js:
+@noble/hashes/utils.js:
   (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 
-@noble/curves/esm/abstract/utils.js:
+@noble/curves/utils.js:
   (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 
-@noble/curves/esm/abstract/modular.js:
+@noble/curves/abstract/modular.js:
   (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 
-@noble/curves/esm/abstract/curve.js:
+@noble/curves/abstract/curve.js:
   (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 
-@noble/curves/esm/abstract/edwards.js:
+@noble/curves/abstract/edwards.js:
   (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 
-@noble/curves/esm/ed25519.js:
+@noble/curves/ed25519.js:
   (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/hashes/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 */
 
 try {