@fastnear/utils 0.9.13 → 0.10.2

package/dist/umd/browser.global.js

@@ -1,5 +1,5 @@
-/* ⋈ 🏃🏻💨 FastNear Utils - IIFE/UMD (@fastnear/utils version 0.9.12) */
-/* https://www.npmjs.com/package/@fastnear/utils/v/0.9.12 */
+/* ⋈ 🏃🏻💨 FastNear Utils - IIFE/UMD (@fastnear/utils version 0.10.1) */
+/* https://www.npmjs.com/package/@fastnear/utils/v/0.10.1 */
 "use strict";
 var NearUtils = (() => {
   var __defProp = Object.defineProperty;
@@ -31,6 +31,7 @@ var NearUtils = (() => {
     canSignWithLAK: () => canSignWithLAK,
     convertUnit: () => convertUnit,
     createDefaultStorage: () => createDefaultStorage,
+    curveFromKey: () => curveFromKey,
     deepCopy: () => deepCopy,
     exp: () => exp,
     fromBase58: () => base58_to_binary_default,
@@ -85,6 +86,13 @@ var NearUtils = (() => {
     return value;
   }
   __name(abytes, "abytes");
+  function ahash(h) {
+    if (typeof h !== "function" || typeof h.create !== "function")
+      throw new Error("Hash must wrapped by utils.createHasher");
+    anumber(h.outputLen);
+    anumber(h.blockLen);
+  }
+  __name(ahash, "ahash");
   function aexists(instance, checkFinished = true) {
     if (instance.destroyed)
       throw new Error("Hash instance has been destroyed");
@@ -762,6 +770,11 @@ var NearUtils = (() => {
     return n;
   }
   __name(abignumber, "abignumber");
+  function numberToHexUnpadded(num) {
+    const hex = abignumber(num).toString(16);
+    return hex.length & 1 ? "0" + hex : hex;
+  }
+  __name(numberToHexUnpadded, "numberToHexUnpadded");
   function hexToNumber(hex) {
     if (typeof hex !== "string")
       throw new Error("hex string expected, got " + typeof hex);
@@ -803,7 +816,66 @@ var NearUtils = (() => {
       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) => (_1n << BigInt(n)) - _1n, "bitMask");
+  function createHmacDrbg(hashLen, qByteLen, hmacFn) {
+    anumber(hashLen, "hashLen");
+    anumber(qByteLen, "qByteLen");
+    if (typeof hmacFn !== "function")
+      throw new Error("hmacFn must be a function");
+    const u8n = /* @__PURE__ */ __name((len) => new Uint8Array(len), "u8n");
+    const NULL = Uint8Array.of();
+    const byte0 = Uint8Array.of(0);
+    const byte1 = Uint8Array.of(1);
+    const _maxDrbgIters = 1e3;
+    let v = u8n(hashLen);
+    let k = u8n(hashLen);
+    let i = 0;
+    const reset = /* @__PURE__ */ __name(() => {
+      v.fill(1);
+      k.fill(0);
+      i = 0;
+    }, "reset");
+    const h = /* @__PURE__ */ __name((...msgs) => hmacFn(k, concatBytes(v, ...msgs)), "h");
+    const reseed = /* @__PURE__ */ __name((seed = NULL) => {
+      k = h(byte0, seed);
+      v = h();
+      if (seed.length === 0)
+        return;
+      k = h(byte1, seed);
+      v = h();
+    }, "reseed");
+    const gen = /* @__PURE__ */ __name(() => {
+      if (i++ >= _maxDrbgIters)
+        throw new Error("drbg: tried max amount of iterations");
+      let len = 0;
+      const out = [];
+      while (len < qByteLen) {
+        v = h();
+        const sl = v.slice();
+        out.push(sl);
+        len += v.length;
+      }
+      return concatBytes(...out);
+    }, "gen");
+    const genUntil = /* @__PURE__ */ __name((seed, pred) => {
+      reset();
+      reseed(seed);
+      let res = void 0;
+      while (!(res = pred(gen())))
+        reseed();
+      reset();
+      return res;
+    }, "genUntil");
+    return genUntil;
+  }
+  __name(createHmacDrbg, "createHmacDrbg");
   function validateObject(object, fields = {}, optFields = {}) {
     if (!object || typeof object !== "object")
       throw new Error("expected valid options object");
@@ -903,13 +975,13 @@ var NearUtils = (() => {
     return root;
   }
   __name(sqrt5mod8, "sqrt5mod8");
-  function sqrt9mod16(P2) {
-    const Fp_ = Field(P2);
-    const tn = tonelliShanks(P2);
+  function sqrt9mod16(P) {
+    const Fp_ = Field(P);
+    const tn = tonelliShanks(P);
     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;
+    const c4 = (P + _7n) / _16n;
     return (Fp, n) => {
       let tv1 = Fp.pow(n, c4);
       let tv2 = Fp.mul(tv1, c1);
@@ -926,17 +998,17 @@ var NearUtils = (() => {
     };
   }
   __name(sqrt9mod16, "sqrt9mod16");
-  function tonelliShanks(P2) {
-    if (P2 < _3n)
+  function tonelliShanks(P) {
+    if (P < _3n)
       throw new Error("sqrt is not defined for small field");
-    let Q = P2 - _1n2;
+    let Q = P - _1n2;
     let S = 0;
     while (Q % _2n === _0n2) {
       Q /= _2n;
       S++;
     }
     let Z = _2n;
-    const _Fp = Field(P2);
+    const _Fp = Field(P);
     while (FpLegendre(_Fp, Z) === 1) {
       if (Z++ > 1e3)
         throw new Error("Cannot find square root: probably non-prime P");
@@ -976,14 +1048,14 @@ var NearUtils = (() => {
     }, "tonelliSlow");
   }
   __name(tonelliShanks, "tonelliShanks");
-  function FpSqrt(P2) {
-    if (P2 % _4n === _3n)
+  function FpSqrt(P) {
+    if (P % _4n === _3n)
       return sqrt3mod4;
-    if (P2 % _8n === _5n)
+    if (P % _8n === _5n)
       return sqrt5mod8;
-    if (P2 % _16n === _9n)
-      return sqrt9mod16(P2);
-    return tonelliShanks(P2);
+    if (P % _16n === _9n)
+      return sqrt9mod16(P);
+    return tonelliShanks(P);
   }
   __name(FpSqrt, "FpSqrt");
   var isNegativeLE = /* @__PURE__ */ __name((num, modulo) => (mod(num, modulo) & _1n2) === _1n2, "isNegativeLE");
@@ -1217,6 +1289,30 @@ var NearUtils = (() => {
     return new _Field(ORDER, opts);
   }
   __name(Field, "Field");
+  function getFieldBytesLength(fieldOrder) {
+    if (typeof fieldOrder !== "bigint")
+      throw new Error("field order must be bigint");
+    const bitLength = fieldOrder.toString(2).length;
+    return Math.ceil(bitLength / 8);
+  }
+  __name(getFieldBytesLength, "getFieldBytesLength");
+  function getMinHashLength(fieldOrder) {
+    const length = getFieldBytesLength(fieldOrder);
+    return length + Math.ceil(length / 2);
+  }
+  __name(getMinHashLength, "getMinHashLength");
+  function mapHashToField(key, fieldOrder, isLE = false) {
+    abytes(key);
+    const len = key.length;
+    const fieldLen = getFieldBytesLength(fieldOrder);
+    const minLen = getMinHashLength(fieldOrder);
+    if (len < 16 || len < minLen || len > 1024)
+      throw new Error("expected " + minLen + "-1024 bytes of input, got " + len);
+    const num = isLE ? bytesToNumberLE(key) : bytesToNumberBE(key);
+    const reduced = mod(num, fieldOrder - _1n2) + _1n2;
+    return isLE ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
+  }
+  __name(mapHashToField, "mapHashToField");
 
   // ../../node_modules/@noble/curves/abstract/curve.js
   var _0n3 = /* @__PURE__ */ BigInt(0);
@@ -1265,8 +1361,8 @@ var NearUtils = (() => {
   __name(calcOffsets, "calcOffsets");
   var pointPrecomputes = /* @__PURE__ */ new WeakMap();
   var pointWindowSizes = /* @__PURE__ */ new WeakMap();
-  function getW(P2) {
-    return pointWindowSizes.get(P2) || 1;
+  function getW(P) {
+    return pointWindowSizes.get(P) || 1;
   }
   __name(getW, "getW");
   function assert0(n) {
@@ -1399,15 +1495,31 @@ var NearUtils = (() => {
     // 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) {
+    createCache(P, W) {
       validateW(W, this.bits);
-      pointWindowSizes.set(P2, W);
-      pointPrecomputes.delete(P2);
+      pointWindowSizes.set(P, W);
+      pointPrecomputes.delete(P);
     }
     hasCache(elm) {
       return getW(elm) !== 1;
     }
   };
+  function mulEndoUnsafe(Point, point, k1, k2) {
+    let acc = point;
+    let p1 = Point.ZERO;
+    let p2 = Point.ZERO;
+    while (k1 > _0n3 || k2 > _0n3) {
+      if (k1 & _1n3)
+        p1 = p1.add(acc);
+      if (k2 & _1n3)
+        p2 = p2.add(acc);
+      acc = acc.double();
+      k1 >>= _1n3;
+      k2 >>= _1n3;
+    }
+    return { p1, p2 };
+  }
+  __name(mulEndoUnsafe, "mulEndoUnsafe");
   function createField(order, field, isLE) {
     if (field) {
       if (field.ORDER !== order)
@@ -1904,19 +2016,19 @@ var NearUtils = (() => {
   }))();
   function ed25519_pow_2_252_3(x) {
     const _10n = BigInt(10), _20n = BigInt(20), _40n = BigInt(40), _80n = BigInt(80);
-    const P2 = ed25519_CURVE_p;
-    const x2 = x * x % P2;
-    const b2 = x2 * x % 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;
-    const b40 = pow2(b20, _20n, P2) * b20 % P2;
-    const b80 = pow2(b40, _40n, P2) * b40 % P2;
-    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, _2n3, P2) * x % P2;
+    const P = ed25519_CURVE_p;
+    const x2 = x * x % P;
+    const b2 = x2 * x % P;
+    const b4 = pow2(b2, _2n3, P) * b2 % P;
+    const b5 = pow2(b4, _1n5, P) * x % P;
+    const b10 = pow2(b5, _5n2, P) * b5 % P;
+    const b20 = pow2(b10, _10n, P) * b10 % P;
+    const b40 = pow2(b20, _20n, P) * b20 % P;
+    const b80 = pow2(b40, _40n, P) * b40 % P;
+    const b160 = pow2(b80, _80n, P) * b80 % P;
+    const b240 = pow2(b160, _80n, P) * b80 % P;
+    const b250 = pow2(b240, _10n, P) * b10 % P;
+    const pow_p_5_8 = pow2(b250, _2n3, P) * x % P;
     return { pow_p_5_8, b2 };
   }
   __name(ed25519_pow_2_252_3, "ed25519_pow_2_252_3");
@@ -1929,23 +2041,23 @@ var NearUtils = (() => {
   __name(adjustScalarBytes, "adjustScalarBytes");
   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 P = ed25519_CURVE_p;
+    const v3 = mod(v * v * v, P);
+    const v7 = mod(v3 * v3 * v, P);
     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);
+    let x = mod(u * v3 * pow, P);
+    const vx2 = mod(v * x * x, P);
     const root1 = x;
-    const root2 = mod(x * ED25519_SQRT_M1, P2);
+    const root2 = mod(x * ED25519_SQRT_M1, P);
     const useRoot1 = vx2 === u;
-    const useRoot2 = vx2 === mod(-u, P2);
-    const noRoot = vx2 === mod(-u * ED25519_SQRT_M1, P2);
+    const useRoot2 = vx2 === mod(-u, P);
+    const noRoot = vx2 === mod(-u * ED25519_SQRT_M1, P);
     if (useRoot1)
       x = root1;
     if (useRoot2 || noRoot)
       x = root2;
-    if (isNegativeLE(x, P2))
-      x = mod(-x, P2);
+    if (isNegativeLE(x, P))
+      x = mod(-x, P);
     return { isValid: useRoot1 || useRoot2, value: x };
   }
   __name(uvRatio, "uvRatio");
@@ -1956,6 +2068,1043 @@ var NearUtils = (() => {
   __name(ed, "ed");
   var ed25519 = /* @__PURE__ */ ed({});
 
+  // ../../node_modules/@noble/hashes/hmac.js
+  var _HMAC = class {
+    static {
+      __name(this, "_HMAC");
+    }
+    oHash;
+    iHash;
+    blockLen;
+    outputLen;
+    finished = false;
+    destroyed = false;
+    constructor(hash, key) {
+      ahash(hash);
+      abytes(key, void 0, "key");
+      this.iHash = hash.create();
+      if (typeof this.iHash.update !== "function")
+        throw new Error("Expected instance of class which extends utils.Hash");
+      this.blockLen = this.iHash.blockLen;
+      this.outputLen = this.iHash.outputLen;
+      const blockLen = this.blockLen;
+      const pad = new Uint8Array(blockLen);
+      pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
+      for (let i = 0; i < pad.length; i++)
+        pad[i] ^= 54;
+      this.iHash.update(pad);
+      this.oHash = hash.create();
+      for (let i = 0; i < pad.length; i++)
+        pad[i] ^= 54 ^ 92;
+      this.oHash.update(pad);
+      clean(pad);
+    }
+    update(buf) {
+      aexists(this);
+      this.iHash.update(buf);
+      return this;
+    }
+    digestInto(out) {
+      aexists(this);
+      abytes(out, this.outputLen, "output");
+      this.finished = true;
+      this.iHash.digestInto(out);
+      this.oHash.update(out);
+      this.oHash.digestInto(out);
+      this.destroy();
+    }
+    digest() {
+      const out = new Uint8Array(this.oHash.outputLen);
+      this.digestInto(out);
+      return out;
+    }
+    _cloneInto(to) {
+      to ||= Object.create(Object.getPrototypeOf(this), {});
+      const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
+      to = to;
+      to.finished = finished;
+      to.destroyed = destroyed;
+      to.blockLen = blockLen;
+      to.outputLen = outputLen;
+      to.oHash = oHash._cloneInto(to.oHash);
+      to.iHash = iHash._cloneInto(to.iHash);
+      return to;
+    }
+    clone() {
+      return this._cloneInto();
+    }
+    destroy() {
+      this.destroyed = true;
+      this.oHash.destroy();
+      this.iHash.destroy();
+    }
+  };
+  var hmac = /* @__PURE__ */ __name((hash, key, message) => new _HMAC(hash, key).update(message).digest(), "hmac");
+  hmac.create = (hash, key) => new _HMAC(hash, key);
+
+  // ../../node_modules/@noble/curves/abstract/weierstrass.js
+  var divNearest = /* @__PURE__ */ __name((num, den) => (num + (num >= 0 ? den : -den) / _2n4) / den, "divNearest");
+  function _splitEndoScalar(k, basis, n) {
+    const [[a1, b1], [a2, b2]] = basis;
+    const c1 = divNearest(b2 * k, n);
+    const c2 = divNearest(-b1 * k, n);
+    let k1 = k - c1 * a1 - c2 * a2;
+    let k2 = -c1 * b1 - c2 * b2;
+    const k1neg = k1 < _0n5;
+    const k2neg = k2 < _0n5;
+    if (k1neg)
+      k1 = -k1;
+    if (k2neg)
+      k2 = -k2;
+    const MAX_NUM = bitMask(Math.ceil(bitLen(n) / 2)) + _1n6;
+    if (k1 < _0n5 || k1 >= MAX_NUM || k2 < _0n5 || k2 >= MAX_NUM) {
+      throw new Error("splitScalar (endomorphism): failed, k=" + k);
+    }
+    return { k1neg, k1, k2neg, k2 };
+  }
+  __name(_splitEndoScalar, "_splitEndoScalar");
+  function validateSigFormat(format) {
+    if (!["compact", "recovered", "der"].includes(format))
+      throw new Error('Signature format must be "compact", "recovered", or "der"');
+    return format;
+  }
+  __name(validateSigFormat, "validateSigFormat");
+  function validateSigOpts(opts, def) {
+    const optsn = {};
+    for (let optName of Object.keys(def)) {
+      optsn[optName] = opts[optName] === void 0 ? def[optName] : opts[optName];
+    }
+    abool(optsn.lowS, "lowS");
+    abool(optsn.prehash, "prehash");
+    if (optsn.format !== void 0)
+      validateSigFormat(optsn.format);
+    return optsn;
+  }
+  __name(validateSigOpts, "validateSigOpts");
+  var DERErr = class extends Error {
+    static {
+      __name(this, "DERErr");
+    }
+    constructor(m = "") {
+      super(m);
+    }
+  };
+  var DER = {
+    // asn.1 DER encoding utils
+    Err: DERErr,
+    // Basic building block is TLV (Tag-Length-Value)
+    _tlv: {
+      encode: /* @__PURE__ */ __name((tag, data) => {
+        const { Err: E } = DER;
+        if (tag < 0 || tag > 256)
+          throw new E("tlv.encode: wrong tag");
+        if (data.length & 1)
+          throw new E("tlv.encode: unpadded data");
+        const dataLen = data.length / 2;
+        const len = numberToHexUnpadded(dataLen);
+        if (len.length / 2 & 128)
+          throw new E("tlv.encode: long form length too big");
+        const lenLen = dataLen > 127 ? numberToHexUnpadded(len.length / 2 | 128) : "";
+        const t = numberToHexUnpadded(tag);
+        return t + lenLen + len + data;
+      }, "encode"),
+      // v - value, l - left bytes (unparsed)
+      decode(tag, data) {
+        const { Err: E } = DER;
+        let pos = 0;
+        if (tag < 0 || tag > 256)
+          throw new E("tlv.encode: wrong tag");
+        if (data.length < 2 || data[pos++] !== tag)
+          throw new E("tlv.decode: wrong tlv");
+        const first = data[pos++];
+        const isLong = !!(first & 128);
+        let length = 0;
+        if (!isLong)
+          length = first;
+        else {
+          const lenLen = first & 127;
+          if (!lenLen)
+            throw new E("tlv.decode(long): indefinite length not supported");
+          if (lenLen > 4)
+            throw new E("tlv.decode(long): byte length is too big");
+          const lengthBytes = data.subarray(pos, pos + lenLen);
+          if (lengthBytes.length !== lenLen)
+            throw new E("tlv.decode: length bytes not complete");
+          if (lengthBytes[0] === 0)
+            throw new E("tlv.decode(long): zero leftmost byte");
+          for (const b of lengthBytes)
+            length = length << 8 | b;
+          pos += lenLen;
+          if (length < 128)
+            throw new E("tlv.decode(long): not minimal encoding");
+        }
+        const v = data.subarray(pos, pos + length);
+        if (v.length !== length)
+          throw new E("tlv.decode: wrong value length");
+        return { v, l: data.subarray(pos + length) };
+      }
+    },
+    // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
+    // since we always use positive integers here. It must always be empty:
+    // - add zero byte if exists
+    // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
+    _int: {
+      encode(num) {
+        const { Err: E } = DER;
+        if (num < _0n5)
+          throw new E("integer: negative integers are not allowed");
+        let hex = numberToHexUnpadded(num);
+        if (Number.parseInt(hex[0], 16) & 8)
+          hex = "00" + hex;
+        if (hex.length & 1)
+          throw new E("unexpected DER parsing assertion: unpadded hex");
+        return hex;
+      },
+      decode(data) {
+        const { Err: E } = DER;
+        if (data[0] & 128)
+          throw new E("invalid signature integer: negative");
+        if (data[0] === 0 && !(data[1] & 128))
+          throw new E("invalid signature integer: unnecessary leading zero");
+        return bytesToNumberBE(data);
+      }
+    },
+    toSig(bytes) {
+      const { Err: E, _int: int, _tlv: tlv } = DER;
+      const data = abytes(bytes, void 0, "signature");
+      const { v: seqBytes, l: seqLeftBytes } = tlv.decode(48, data);
+      if (seqLeftBytes.length)
+        throw new E("invalid signature: left bytes after parsing");
+      const { v: rBytes, l: rLeftBytes } = tlv.decode(2, seqBytes);
+      const { v: sBytes, l: sLeftBytes } = tlv.decode(2, rLeftBytes);
+      if (sLeftBytes.length)
+        throw new E("invalid signature: left bytes after parsing");
+      return { r: int.decode(rBytes), s: int.decode(sBytes) };
+    },
+    hexFromSig(sig) {
+      const { _tlv: tlv, _int: int } = DER;
+      const rs = tlv.encode(2, int.encode(sig.r));
+      const ss = tlv.encode(2, int.encode(sig.s));
+      const seq = rs + ss;
+      return tlv.encode(48, seq);
+    }
+  };
+  var _0n5 = BigInt(0);
+  var _1n6 = BigInt(1);
+  var _2n4 = BigInt(2);
+  var _3n2 = BigInt(3);
+  var _4n2 = BigInt(4);
+  function weierstrass(params, extraOpts = {}) {
+    const validated = createCurveFields("weierstrass", params, extraOpts);
+    const { Fp, Fn } = validated;
+    let CURVE = validated.CURVE;
+    const { h: cofactor, n: CURVE_ORDER } = CURVE;
+    validateObject(extraOpts, {}, {
+      allowInfinityPoint: "boolean",
+      clearCofactor: "function",
+      isTorsionFree: "function",
+      fromBytes: "function",
+      toBytes: "function",
+      endo: "object"
+    });
+    const { endo } = extraOpts;
+    if (endo) {
+      if (!Fp.is0(CURVE.a) || typeof endo.beta !== "bigint" || !Array.isArray(endo.basises)) {
+        throw new Error('invalid endo: expected "beta": bigint and "basises": array');
+      }
+    }
+    const lengths = getWLengths(Fp, Fn);
+    function assertCompressionIsSupported() {
+      if (!Fp.isOdd)
+        throw new Error("compression is not supported: Field does not have .isOdd()");
+    }
+    __name(assertCompressionIsSupported, "assertCompressionIsSupported");
+    function pointToBytes(_c, point, isCompressed) {
+      const { x, y } = point.toAffine();
+      const bx = Fp.toBytes(x);
+      abool(isCompressed, "isCompressed");
+      if (isCompressed) {
+        assertCompressionIsSupported();
+        const hasEvenY = !Fp.isOdd(y);
+        return concatBytes(pprefix(hasEvenY), bx);
+      } else {
+        return concatBytes(Uint8Array.of(4), bx, Fp.toBytes(y));
+      }
+    }
+    __name(pointToBytes, "pointToBytes");
+    function pointFromBytes(bytes) {
+      abytes(bytes, void 0, "Point");
+      const { publicKey: comp, publicKeyUncompressed: uncomp } = lengths;
+      const length = bytes.length;
+      const head = bytes[0];
+      const tail = bytes.subarray(1);
+      if (length === comp && (head === 2 || head === 3)) {
+        const x = Fp.fromBytes(tail);
+        if (!Fp.isValid(x))
+          throw new Error("bad point: is not on curve, wrong x");
+        const y2 = weierstrassEquation(x);
+        let y;
+        try {
+          y = Fp.sqrt(y2);
+        } catch (sqrtError) {
+          const err = sqrtError instanceof Error ? ": " + sqrtError.message : "";
+          throw new Error("bad point: is not on curve, sqrt error" + err);
+        }
+        assertCompressionIsSupported();
+        const evenY = Fp.isOdd(y);
+        const evenH = (head & 1) === 1;
+        if (evenH !== evenY)
+          y = Fp.neg(y);
+        return { x, y };
+      } else if (length === uncomp && head === 4) {
+        const L = Fp.BYTES;
+        const x = Fp.fromBytes(tail.subarray(0, L));
+        const y = Fp.fromBytes(tail.subarray(L, L * 2));
+        if (!isValidXY(x, y))
+          throw new Error("bad point: is not on curve");
+        return { x, y };
+      } else {
+        throw new Error(`bad point: got length ${length}, expected compressed=${comp} or uncompressed=${uncomp}`);
+      }
+    }
+    __name(pointFromBytes, "pointFromBytes");
+    const encodePoint = extraOpts.toBytes || pointToBytes;
+    const decodePoint = extraOpts.fromBytes || pointFromBytes;
+    function weierstrassEquation(x) {
+      const x2 = Fp.sqr(x);
+      const x3 = Fp.mul(x2, x);
+      return Fp.add(Fp.add(x3, Fp.mul(x, CURVE.a)), CURVE.b);
+    }
+    __name(weierstrassEquation, "weierstrassEquation");
+    function isValidXY(x, y) {
+      const left = Fp.sqr(y);
+      const right = weierstrassEquation(x);
+      return Fp.eql(left, right);
+    }
+    __name(isValidXY, "isValidXY");
+    if (!isValidXY(CURVE.Gx, CURVE.Gy))
+      throw new Error("bad curve params: generator point");
+    const _4a3 = Fp.mul(Fp.pow(CURVE.a, _3n2), _4n2);
+    const _27b2 = Fp.mul(Fp.sqr(CURVE.b), BigInt(27));
+    if (Fp.is0(Fp.add(_4a3, _27b2)))
+      throw new Error("bad curve params: a or b");
+    function acoord(title, n, banZero = false) {
+      if (!Fp.isValid(n) || banZero && Fp.is0(n))
+        throw new Error(`bad point coordinate ${title}`);
+      return n;
+    }
+    __name(acoord, "acoord");
+    function aprjpoint(other) {
+      if (!(other instanceof Point))
+        throw new Error("Weierstrass Point expected");
+    }
+    __name(aprjpoint, "aprjpoint");
+    function splitEndoScalarN(k) {
+      if (!endo || !endo.basises)
+        throw new Error("no endo");
+      return _splitEndoScalar(k, endo.basises, Fn.ORDER);
+    }
+    __name(splitEndoScalarN, "splitEndoScalarN");
+    const toAffineMemo = memoized((p, iz) => {
+      const { X, Y, Z } = p;
+      if (Fp.eql(Z, Fp.ONE))
+        return { x: X, y: Y };
+      const is0 = p.is0();
+      if (iz == null)
+        iz = is0 ? Fp.ONE : Fp.inv(Z);
+      const x = Fp.mul(X, iz);
+      const y = Fp.mul(Y, iz);
+      const zz = Fp.mul(Z, iz);
+      if (is0)
+        return { x: Fp.ZERO, y: Fp.ZERO };
+      if (!Fp.eql(zz, Fp.ONE))
+        throw new Error("invZ was invalid");
+      return { x, y };
+    });
+    const assertValidMemo = memoized((p) => {
+      if (p.is0()) {
+        if (extraOpts.allowInfinityPoint && !Fp.is0(p.Y))
+          return;
+        throw new Error("bad point: ZERO");
+      }
+      const { x, y } = p.toAffine();
+      if (!Fp.isValid(x) || !Fp.isValid(y))
+        throw new Error("bad point: x or y not field elements");
+      if (!isValidXY(x, y))
+        throw new Error("bad point: equation left != right");
+      if (!p.isTorsionFree())
+        throw new Error("bad point: not in prime-order subgroup");
+      return true;
+    });
+    function finishEndo(endoBeta, k1p, k2p, k1neg, k2neg) {
+      k2p = new Point(Fp.mul(k2p.X, endoBeta), k2p.Y, k2p.Z);
+      k1p = negateCt(k1neg, k1p);
+      k2p = negateCt(k2neg, k2p);
+      return k1p.add(k2p);
+    }
+    __name(finishEndo, "finishEndo");
+    class Point {
+      static {
+        __name(this, "Point");
+      }
+      // base / generator point
+      static BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);
+      // zero / infinity / identity point
+      static ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO);
+      // 0, 1, 0
+      // math field
+      static Fp = Fp;
+      // scalar field
+      static Fn = Fn;
+      X;
+      Y;
+      Z;
+      /** Does NOT validate if the point is valid. Use `.assertValidity()`. */
+      constructor(X, Y, Z) {
+        this.X = acoord("x", X);
+        this.Y = acoord("y", Y, true);
+        this.Z = acoord("z", Z);
+        Object.freeze(this);
+      }
+      static CURVE() {
+        return CURVE;
+      }
+      /** Does NOT validate if the point is valid. Use `.assertValidity()`. */
+      static fromAffine(p) {
+        const { x, y } = p || {};
+        if (!p || !Fp.isValid(x) || !Fp.isValid(y))
+          throw new Error("invalid affine point");
+        if (p instanceof Point)
+          throw new Error("projective point not allowed");
+        if (Fp.is0(x) && Fp.is0(y))
+          return Point.ZERO;
+        return new Point(x, y, Fp.ONE);
+      }
+      static fromBytes(bytes) {
+        const P = Point.fromAffine(decodePoint(abytes(bytes, void 0, "point")));
+        P.assertValidity();
+        return P;
+      }
+      static fromHex(hex) {
+        return Point.fromBytes(hexToBytes(hex));
+      }
+      get x() {
+        return this.toAffine().x;
+      }
+      get y() {
+        return this.toAffine().y;
+      }
+      /**
+       *
+       * @param windowSize
+       * @param isLazy true will defer table computation until the first multiplication
+       * @returns
+       */
+      precompute(windowSize = 8, isLazy = true) {
+        wnaf.createCache(this, windowSize);
+        if (!isLazy)
+          this.multiply(_3n2);
+        return this;
+      }
+      // TODO: return `this`
+      /** A point on curve is valid if it conforms to equation. */
+      assertValidity() {
+        assertValidMemo(this);
+      }
+      hasEvenY() {
+        const { y } = this.toAffine();
+        if (!Fp.isOdd)
+          throw new Error("Field doesn't support isOdd");
+        return !Fp.isOdd(y);
+      }
+      /** Compare one point to another. */
+      equals(other) {
+        aprjpoint(other);
+        const { X: X1, Y: Y1, Z: Z1 } = this;
+        const { X: X2, Y: Y2, Z: Z2 } = other;
+        const U1 = Fp.eql(Fp.mul(X1, Z2), Fp.mul(X2, Z1));
+        const U2 = Fp.eql(Fp.mul(Y1, Z2), Fp.mul(Y2, Z1));
+        return U1 && U2;
+      }
+      /** Flips point to one corresponding to (x, -y) in Affine coordinates. */
+      negate() {
+        return new Point(this.X, Fp.neg(this.Y), this.Z);
+      }
+      // Renes-Costello-Batina exception-free doubling formula.
+      // There is 30% faster Jacobian formula, but it is not complete.
+      // https://eprint.iacr.org/2015/1060, algorithm 3
+      // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
+      double() {
+        const { a, b } = CURVE;
+        const b3 = Fp.mul(b, _3n2);
+        const { X: X1, Y: Y1, Z: Z1 } = this;
+        let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO;
+        let t0 = Fp.mul(X1, X1);
+        let t1 = Fp.mul(Y1, Y1);
+        let t2 = Fp.mul(Z1, Z1);
+        let t3 = Fp.mul(X1, Y1);
+        t3 = Fp.add(t3, t3);
+        Z3 = Fp.mul(X1, Z1);
+        Z3 = Fp.add(Z3, Z3);
+        X3 = Fp.mul(a, Z3);
+        Y3 = Fp.mul(b3, t2);
+        Y3 = Fp.add(X3, Y3);
+        X3 = Fp.sub(t1, Y3);
+        Y3 = Fp.add(t1, Y3);
+        Y3 = Fp.mul(X3, Y3);
+        X3 = Fp.mul(t3, X3);
+        Z3 = Fp.mul(b3, Z3);
+        t2 = Fp.mul(a, t2);
+        t3 = Fp.sub(t0, t2);
+        t3 = Fp.mul(a, t3);
+        t3 = Fp.add(t3, Z3);
+        Z3 = Fp.add(t0, t0);
+        t0 = Fp.add(Z3, t0);
+        t0 = Fp.add(t0, t2);
+        t0 = Fp.mul(t0, t3);
+        Y3 = Fp.add(Y3, t0);
+        t2 = Fp.mul(Y1, Z1);
+        t2 = Fp.add(t2, t2);
+        t0 = Fp.mul(t2, t3);
+        X3 = Fp.sub(X3, t0);
+        Z3 = Fp.mul(t2, t1);
+        Z3 = Fp.add(Z3, Z3);
+        Z3 = Fp.add(Z3, Z3);
+        return new Point(X3, Y3, Z3);
+      }
+      // Renes-Costello-Batina exception-free addition formula.
+      // There is 30% faster Jacobian formula, but it is not complete.
+      // https://eprint.iacr.org/2015/1060, algorithm 1
+      // Cost: 12M + 0S + 3*a + 3*b3 + 23add.
+      add(other) {
+        aprjpoint(other);
+        const { X: X1, Y: Y1, Z: Z1 } = this;
+        const { X: X2, Y: Y2, Z: Z2 } = other;
+        let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO;
+        const a = CURVE.a;
+        const b3 = Fp.mul(CURVE.b, _3n2);
+        let t0 = Fp.mul(X1, X2);
+        let t1 = Fp.mul(Y1, Y2);
+        let t2 = Fp.mul(Z1, Z2);
+        let t3 = Fp.add(X1, Y1);
+        let t4 = Fp.add(X2, Y2);
+        t3 = Fp.mul(t3, t4);
+        t4 = Fp.add(t0, t1);
+        t3 = Fp.sub(t3, t4);
+        t4 = Fp.add(X1, Z1);
+        let t5 = Fp.add(X2, Z2);
+        t4 = Fp.mul(t4, t5);
+        t5 = Fp.add(t0, t2);
+        t4 = Fp.sub(t4, t5);
+        t5 = Fp.add(Y1, Z1);
+        X3 = Fp.add(Y2, Z2);
+        t5 = Fp.mul(t5, X3);
+        X3 = Fp.add(t1, t2);
+        t5 = Fp.sub(t5, X3);
+        Z3 = Fp.mul(a, t4);
+        X3 = Fp.mul(b3, t2);
+        Z3 = Fp.add(X3, Z3);
+        X3 = Fp.sub(t1, Z3);
+        Z3 = Fp.add(t1, Z3);
+        Y3 = Fp.mul(X3, Z3);
+        t1 = Fp.add(t0, t0);
+        t1 = Fp.add(t1, t0);
+        t2 = Fp.mul(a, t2);
+        t4 = Fp.mul(b3, t4);
+        t1 = Fp.add(t1, t2);
+        t2 = Fp.sub(t0, t2);
+        t2 = Fp.mul(a, t2);
+        t4 = Fp.add(t4, t2);
+        t0 = Fp.mul(t1, t4);
+        Y3 = Fp.add(Y3, t0);
+        t0 = Fp.mul(t5, t4);
+        X3 = Fp.mul(t3, X3);
+        X3 = Fp.sub(X3, t0);
+        t0 = Fp.mul(t3, t1);
+        Z3 = Fp.mul(t5, Z3);
+        Z3 = Fp.add(Z3, t0);
+        return new Point(X3, Y3, Z3);
+      }
+      subtract(other) {
+        return this.add(other.negate());
+      }
+      is0() {
+        return this.equals(Point.ZERO);
+      }
+      /**
+       * Constant time multiplication.
+       * Uses wNAF method. Windowed method may be 10% faster,
+       * but takes 2x longer to generate and consumes 2x memory.
+       * Uses precomputes when available.
+       * Uses endomorphism for Koblitz curves.
+       * @param scalar by which the point would be multiplied
+       * @returns New point
+       */
+      multiply(scalar) {
+        const { endo: endo2 } = extraOpts;
+        if (!Fn.isValidNot0(scalar))
+          throw new Error("invalid scalar: out of range");
+        let point, fake;
+        const mul = /* @__PURE__ */ __name((n) => wnaf.cached(this, n, (p) => normalizeZ(Point, p)), "mul");
+        if (endo2) {
+          const { k1neg, k1, k2neg, k2 } = splitEndoScalarN(scalar);
+          const { p: k1p, f: k1f } = mul(k1);
+          const { p: k2p, f: k2f } = mul(k2);
+          fake = k1f.add(k2f);
+          point = finishEndo(endo2.beta, k1p, k2p, k1neg, k2neg);
+        } else {
+          const { p, f } = mul(scalar);
+          point = p;
+          fake = f;
+        }
+        return normalizeZ(Point, [point, fake])[0];
+      }
+      /**
+       * Non-constant-time multiplication. Uses double-and-add algorithm.
+       * It's faster, but should only be used when you don't care about
+       * an exposed secret key e.g. sig verification, which works over *public* keys.
+       */
+      multiplyUnsafe(sc) {
+        const { endo: endo2 } = extraOpts;
+        const p = this;
+        if (!Fn.isValid(sc))
+          throw new Error("invalid scalar: out of range");
+        if (sc === _0n5 || p.is0())
+          return Point.ZERO;
+        if (sc === _1n6)
+          return p;
+        if (wnaf.hasCache(this))
+          return this.multiply(sc);
+        if (endo2) {
+          const { k1neg, k1, k2neg, k2 } = splitEndoScalarN(sc);
+          const { p1, p2 } = mulEndoUnsafe(Point, p, k1, k2);
+          return finishEndo(endo2.beta, p1, p2, k1neg, k2neg);
+        } else {
+          return wnaf.unsafe(p, sc);
+        }
+      }
+      /**
+       * Converts Projective point to affine (x, y) coordinates.
+       * @param invertedZ Z^-1 (inverted zero) - optional, precomputation is useful for invertBatch
+       */
+      toAffine(invertedZ) {
+        return toAffineMemo(this, invertedZ);
+      }
+      /**
+       * Checks whether Point is free of torsion elements (is in prime subgroup).
+       * Always torsion-free for cofactor=1 curves.
+       */
+      isTorsionFree() {
+        const { isTorsionFree } = extraOpts;
+        if (cofactor === _1n6)
+          return true;
+        if (isTorsionFree)
+          return isTorsionFree(Point, this);
+        return wnaf.unsafe(this, CURVE_ORDER).is0();
+      }
+      clearCofactor() {
+        const { clearCofactor } = extraOpts;
+        if (cofactor === _1n6)
+          return this;
+        if (clearCofactor)
+          return clearCofactor(Point, this);
+        return this.multiplyUnsafe(cofactor);
+      }
+      isSmallOrder() {
+        return this.multiplyUnsafe(cofactor).is0();
+      }
+      toBytes(isCompressed = true) {
+        abool(isCompressed, "isCompressed");
+        this.assertValidity();
+        return encodePoint(Point, this, isCompressed);
+      }
+      toHex(isCompressed = true) {
+        return bytesToHex(this.toBytes(isCompressed));
+      }
+      toString() {
+        return `<Point ${this.is0() ? "ZERO" : this.toHex()}>`;
+      }
+    }
+    const bits = Fn.BITS;
+    const wnaf = new wNAF(Point, extraOpts.endo ? Math.ceil(bits / 2) : bits);
+    Point.BASE.precompute(8);
+    return Point;
+  }
+  __name(weierstrass, "weierstrass");
+  function pprefix(hasEvenY) {
+    return Uint8Array.of(hasEvenY ? 2 : 3);
+  }
+  __name(pprefix, "pprefix");
+  function getWLengths(Fp, Fn) {
+    return {
+      secretKey: Fn.BYTES,
+      publicKey: 1 + Fp.BYTES,
+      publicKeyUncompressed: 1 + 2 * Fp.BYTES,
+      publicKeyHasPrefix: true,
+      signature: 2 * Fn.BYTES
+    };
+  }
+  __name(getWLengths, "getWLengths");
+  function ecdh(Point, ecdhOpts = {}) {
+    const { Fn } = Point;
+    const randomBytes_ = ecdhOpts.randomBytes || randomBytes;
+    const lengths = Object.assign(getWLengths(Point.Fp, Fn), { seed: getMinHashLength(Fn.ORDER) });
+    function isValidSecretKey(secretKey) {
+      try {
+        const num = Fn.fromBytes(secretKey);
+        return Fn.isValidNot0(num);
+      } catch (error) {
+        return false;
+      }
+    }
+    __name(isValidSecretKey, "isValidSecretKey");
+    function isValidPublicKey(publicKey, isCompressed) {
+      const { publicKey: comp, publicKeyUncompressed } = lengths;
+      try {
+        const l = publicKey.length;
+        if (isCompressed === true && l !== comp)
+          return false;
+        if (isCompressed === false && l !== publicKeyUncompressed)
+          return false;
+        return !!Point.fromBytes(publicKey);
+      } catch (error) {
+        return false;
+      }
+    }
+    __name(isValidPublicKey, "isValidPublicKey");
+    function randomSecretKey(seed = randomBytes_(lengths.seed)) {
+      return mapHashToField(abytes(seed, lengths.seed, "seed"), Fn.ORDER);
+    }
+    __name(randomSecretKey, "randomSecretKey");
+    function getPublicKey(secretKey, isCompressed = true) {
+      return Point.BASE.multiply(Fn.fromBytes(secretKey)).toBytes(isCompressed);
+    }
+    __name(getPublicKey, "getPublicKey");
+    function isProbPub(item) {
+      const { secretKey, publicKey, publicKeyUncompressed } = lengths;
+      if (!isBytes(item))
+        return void 0;
+      if ("_lengths" in Fn && Fn._lengths || secretKey === publicKey)
+        return void 0;
+      const l = abytes(item, void 0, "key").length;
+      return l === publicKey || l === publicKeyUncompressed;
+    }
+    __name(isProbPub, "isProbPub");
+    function getSharedSecret(secretKeyA, publicKeyB, isCompressed = true) {
+      if (isProbPub(secretKeyA) === true)
+        throw new Error("first arg must be private key");
+      if (isProbPub(publicKeyB) === false)
+        throw new Error("second arg must be public key");
+      const s = Fn.fromBytes(secretKeyA);
+      const b = Point.fromBytes(publicKeyB);
+      return b.multiply(s).toBytes(isCompressed);
+    }
+    __name(getSharedSecret, "getSharedSecret");
+    const utils = {
+      isValidSecretKey,
+      isValidPublicKey,
+      randomSecretKey
+    };
+    const keygen = createKeygen(randomSecretKey, getPublicKey);
+    return Object.freeze({ getPublicKey, getSharedSecret, keygen, Point, utils, lengths });
+  }
+  __name(ecdh, "ecdh");
+  function ecdsa(Point, hash, ecdsaOpts = {}) {
+    ahash(hash);
+    validateObject(ecdsaOpts, {}, {
+      hmac: "function",
+      lowS: "boolean",
+      randomBytes: "function",
+      bits2int: "function",
+      bits2int_modN: "function"
+    });
+    ecdsaOpts = Object.assign({}, ecdsaOpts);
+    const randomBytes2 = ecdsaOpts.randomBytes || randomBytes;
+    const hmac2 = ecdsaOpts.hmac || ((key, msg) => hmac(hash, key, msg));
+    const { Fp, Fn } = Point;
+    const { ORDER: CURVE_ORDER, BITS: fnBits } = Fn;
+    const { keygen, getPublicKey, getSharedSecret, utils, lengths } = ecdh(Point, ecdsaOpts);
+    const defaultSigOpts = {
+      prehash: true,
+      lowS: typeof ecdsaOpts.lowS === "boolean" ? ecdsaOpts.lowS : true,
+      format: "compact",
+      extraEntropy: false
+    };
+    const hasLargeCofactor = CURVE_ORDER * _2n4 < Fp.ORDER;
+    function isBiggerThanHalfOrder(number) {
+      const HALF = CURVE_ORDER >> _1n6;
+      return number > HALF;
+    }
+    __name(isBiggerThanHalfOrder, "isBiggerThanHalfOrder");
+    function validateRS(title, num) {
+      if (!Fn.isValidNot0(num))
+        throw new Error(`invalid signature ${title}: out of range 1..Point.Fn.ORDER`);
+      return num;
+    }
+    __name(validateRS, "validateRS");
+    function assertSmallCofactor() {
+      if (hasLargeCofactor)
+        throw new Error('"recovered" sig type is not supported for cofactor >2 curves');
+    }
+    __name(assertSmallCofactor, "assertSmallCofactor");
+    function validateSigLength(bytes, format) {
+      validateSigFormat(format);
+      const size = lengths.signature;
+      const sizer = format === "compact" ? size : format === "recovered" ? size + 1 : void 0;
+      return abytes(bytes, sizer);
+    }
+    __name(validateSigLength, "validateSigLength");
+    class Signature {
+      static {
+        __name(this, "Signature");
+      }
+      r;
+      s;
+      recovery;
+      constructor(r, s, recovery) {
+        this.r = validateRS("r", r);
+        this.s = validateRS("s", s);
+        if (recovery != null) {
+          assertSmallCofactor();
+          if (![0, 1, 2, 3].includes(recovery))
+            throw new Error("invalid recovery id");
+          this.recovery = recovery;
+        }
+        Object.freeze(this);
+      }
+      static fromBytes(bytes, format = defaultSigOpts.format) {
+        validateSigLength(bytes, format);
+        let recid;
+        if (format === "der") {
+          const { r: r2, s: s2 } = DER.toSig(abytes(bytes));
+          return new Signature(r2, s2);
+        }
+        if (format === "recovered") {
+          recid = bytes[0];
+          format = "compact";
+          bytes = bytes.subarray(1);
+        }
+        const L = lengths.signature / 2;
+        const r = bytes.subarray(0, L);
+        const s = bytes.subarray(L, L * 2);
+        return new Signature(Fn.fromBytes(r), Fn.fromBytes(s), recid);
+      }
+      static fromHex(hex, format) {
+        return this.fromBytes(hexToBytes(hex), format);
+      }
+      assertRecovery() {
+        const { recovery } = this;
+        if (recovery == null)
+          throw new Error("invalid recovery id: must be present");
+        return recovery;
+      }
+      addRecoveryBit(recovery) {
+        return new Signature(this.r, this.s, recovery);
+      }
+      recoverPublicKey(messageHash) {
+        const { r, s } = this;
+        const recovery = this.assertRecovery();
+        const radj = recovery === 2 || recovery === 3 ? r + CURVE_ORDER : r;
+        if (!Fp.isValid(radj))
+          throw new Error("invalid recovery id: sig.r+curve.n != R.x");
+        const x = Fp.toBytes(radj);
+        const R = Point.fromBytes(concatBytes(pprefix((recovery & 1) === 0), x));
+        const ir = Fn.inv(radj);
+        const h = bits2int_modN(abytes(messageHash, void 0, "msgHash"));
+        const u1 = Fn.create(-h * ir);
+        const u2 = Fn.create(s * ir);
+        const Q = Point.BASE.multiplyUnsafe(u1).add(R.multiplyUnsafe(u2));
+        if (Q.is0())
+          throw new Error("invalid recovery: point at infinify");
+        Q.assertValidity();
+        return Q;
+      }
+      // Signatures should be low-s, to prevent malleability.
+      hasHighS() {
+        return isBiggerThanHalfOrder(this.s);
+      }
+      toBytes(format = defaultSigOpts.format) {
+        validateSigFormat(format);
+        if (format === "der")
+          return hexToBytes(DER.hexFromSig(this));
+        const { r, s } = this;
+        const rb = Fn.toBytes(r);
+        const sb = Fn.toBytes(s);
+        if (format === "recovered") {
+          assertSmallCofactor();
+          return concatBytes(Uint8Array.of(this.assertRecovery()), rb, sb);
+        }
+        return concatBytes(rb, sb);
+      }
+      toHex(format) {
+        return bytesToHex(this.toBytes(format));
+      }
+    }
+    const bits2int = ecdsaOpts.bits2int || /* @__PURE__ */ __name(function bits2int_def(bytes) {
+      if (bytes.length > 8192)
+        throw new Error("input is too large");
+      const num = bytesToNumberBE(bytes);
+      const delta = bytes.length * 8 - fnBits;
+      return delta > 0 ? num >> BigInt(delta) : num;
+    }, "bits2int_def");
+    const bits2int_modN = ecdsaOpts.bits2int_modN || /* @__PURE__ */ __name(function bits2int_modN_def(bytes) {
+      return Fn.create(bits2int(bytes));
+    }, "bits2int_modN_def");
+    const ORDER_MASK = bitMask(fnBits);
+    function int2octets(num) {
+      aInRange("num < 2^" + fnBits, num, _0n5, ORDER_MASK);
+      return Fn.toBytes(num);
+    }
+    __name(int2octets, "int2octets");
+    function validateMsgAndHash(message, prehash) {
+      abytes(message, void 0, "message");
+      return prehash ? abytes(hash(message), void 0, "prehashed message") : message;
+    }
+    __name(validateMsgAndHash, "validateMsgAndHash");
+    function prepSig(message, secretKey, opts) {
+      const { lowS, prehash, extraEntropy } = validateSigOpts(opts, defaultSigOpts);
+      message = validateMsgAndHash(message, prehash);
+      const h1int = bits2int_modN(message);
+      const d = Fn.fromBytes(secretKey);
+      if (!Fn.isValidNot0(d))
+        throw new Error("invalid private key");
+      const seedArgs = [int2octets(d), int2octets(h1int)];
+      if (extraEntropy != null && extraEntropy !== false) {
+        const e = extraEntropy === true ? randomBytes2(lengths.secretKey) : extraEntropy;
+        seedArgs.push(abytes(e, void 0, "extraEntropy"));
+      }
+      const seed = concatBytes(...seedArgs);
+      const m = h1int;
+      function k2sig(kBytes) {
+        const k = bits2int(kBytes);
+        if (!Fn.isValidNot0(k))
+          return;
+        const ik = Fn.inv(k);
+        const q = Point.BASE.multiply(k).toAffine();
+        const r = Fn.create(q.x);
+        if (r === _0n5)
+          return;
+        const s = Fn.create(ik * Fn.create(m + r * d));
+        if (s === _0n5)
+          return;
+        let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n6);
+        let normS = s;
+        if (lowS && isBiggerThanHalfOrder(s)) {
+          normS = Fn.neg(s);
+          recovery ^= 1;
+        }
+        return new Signature(r, normS, hasLargeCofactor ? void 0 : recovery);
+      }
+      __name(k2sig, "k2sig");
+      return { seed, k2sig };
+    }
+    __name(prepSig, "prepSig");
+    function sign(message, secretKey, opts = {}) {
+      const { seed, k2sig } = prepSig(message, secretKey, opts);
+      const drbg = createHmacDrbg(hash.outputLen, Fn.BYTES, hmac2);
+      const sig = drbg(seed, k2sig);
+      return sig.toBytes(opts.format);
+    }
+    __name(sign, "sign");
+    function verify(signature, message, publicKey, opts = {}) {
+      const { lowS, prehash, format } = validateSigOpts(opts, defaultSigOpts);
+      publicKey = abytes(publicKey, void 0, "publicKey");
+      message = validateMsgAndHash(message, prehash);
+      if (!isBytes(signature)) {
+        const end = signature instanceof Signature ? ", use sig.toBytes()" : "";
+        throw new Error("verify expects Uint8Array signature" + end);
+      }
+      validateSigLength(signature, format);
+      try {
+        const sig = Signature.fromBytes(signature, format);
+        const P = Point.fromBytes(publicKey);
+        if (lowS && sig.hasHighS())
+          return false;
+        const { r, s } = sig;
+        const h = bits2int_modN(message);
+        const is = Fn.inv(s);
+        const u1 = Fn.create(h * is);
+        const u2 = Fn.create(r * is);
+        const R = Point.BASE.multiplyUnsafe(u1).add(P.multiplyUnsafe(u2));
+        if (R.is0())
+          return false;
+        const v = Fn.create(R.x);
+        return v === r;
+      } catch (e) {
+        return false;
+      }
+    }
+    __name(verify, "verify");
+    function recoverPublicKey(signature, message, opts = {}) {
+      const { prehash } = validateSigOpts(opts, defaultSigOpts);
+      message = validateMsgAndHash(message, prehash);
+      return Signature.fromBytes(signature, "recovered").recoverPublicKey(message).toBytes();
+    }
+    __name(recoverPublicKey, "recoverPublicKey");
+    return Object.freeze({
+      keygen,
+      getPublicKey,
+      getSharedSecret,
+      utils,
+      lengths,
+      Point,
+      sign,
+      verify,
+      recoverPublicKey,
+      Signature,
+      hash
+    });
+  }
+  __name(ecdsa, "ecdsa");
+
+  // ../../node_modules/@noble/curves/secp256k1.js
+  var secp256k1_CURVE = {
+    p: BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"),
+    n: BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"),
+    h: BigInt(1),
+    a: BigInt(0),
+    b: BigInt(7),
+    Gx: BigInt("0x79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"),
+    Gy: BigInt("0x483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8")
+  };
+  var secp256k1_ENDO = {
+    beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
+    basises: [
+      [BigInt("0x3086d221a7d46bcde86c90e49284eb15"), -BigInt("0xe4437ed6010e88286f547fa90abfe4c3")],
+      [BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"), BigInt("0x3086d221a7d46bcde86c90e49284eb15")]
+    ]
+  };
+  var _2n5 = /* @__PURE__ */ BigInt(2);
+  function sqrtMod(y) {
+    const P = secp256k1_CURVE.p;
+    const _3n3 = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
+    const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);
+    const b2 = y * y * y % P;
+    const b3 = b2 * b2 * y % P;
+    const b6 = pow2(b3, _3n3, P) * b3 % P;
+    const b9 = pow2(b6, _3n3, P) * b3 % P;
+    const b11 = pow2(b9, _2n5, P) * b2 % P;
+    const b22 = pow2(b11, _11n, P) * b11 % P;
+    const b44 = pow2(b22, _22n, P) * b22 % P;
+    const b88 = pow2(b44, _44n, P) * b44 % P;
+    const b176 = pow2(b88, _88n, P) * b88 % P;
+    const b220 = pow2(b176, _44n, P) * b44 % P;
+    const b223 = pow2(b220, _3n3, P) * b3 % P;
+    const t1 = pow2(b223, _23n, P) * b22 % P;
+    const t2 = pow2(t1, _6n, P) * b2 % P;
+    const root = pow2(t2, _2n5, P);
+    if (!Fpk1.eql(Fpk1.sqr(root), y))
+      throw new Error("Cannot find square root");
+    return root;
+  }
+  __name(sqrtMod, "sqrtMod");
+  var Fpk1 = Field(secp256k1_CURVE.p, { sqrt: sqrtMod });
+  var Pointk1 = /* @__PURE__ */ weierstrass(secp256k1_CURVE, {
+    Fp: Fpk1,
+    endo: secp256k1_ENDO
+  });
+  var secp256k1 = /* @__PURE__ */ ecdsa(Pointk1, sha256);
+
   // node_modules/base58-js/base58_chars.js
   var base58_chars = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
   var base58_chars_default = base58_chars;
@@ -2025,494 +3174,6 @@ var NearUtils = (() => {
   __name(binary_to_base58, "binary_to_base58");
   var binary_to_base58_default = binary_to_base58;
 
-  // ../../node_modules/big.js/big.mjs
-  var DP = 20;
-  var RM = 1;
-  var MAX_DP = 1e6;
-  var MAX_POWER = 1e6;
-  var NE = -7;
-  var PE = 21;
-  var STRICT = false;
-  var NAME = "[big.js] ";
-  var INVALID = NAME + "Invalid ";
-  var INVALID_DP = INVALID + "decimal places";
-  var INVALID_RM = INVALID + "rounding mode";
-  var DIV_BY_ZERO = NAME + "Division by zero";
-  var P = {};
-  var UNDEFINED = void 0;
-  var NUMERIC = /^-?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i;
-  function _Big_() {
-    function Big2(n) {
-      var x = this;
-      if (!(x instanceof Big2)) return n === UNDEFINED ? _Big_() : new Big2(n);
-      if (n instanceof Big2) {
-        x.s = n.s;
-        x.e = n.e;
-        x.c = n.c.slice();
-      } else {
-        if (typeof n !== "string") {
-          if (Big2.strict === true && typeof n !== "bigint") {
-            throw TypeError(INVALID + "value");
-          }
-          n = n === 0 && 1 / n < 0 ? "-0" : String(n);
-        }
-        parse(x, n);
-      }
-      x.constructor = Big2;
-    }
-    __name(Big2, "Big");
-    Big2.prototype = P;
-    Big2.DP = DP;
-    Big2.RM = RM;
-    Big2.NE = NE;
-    Big2.PE = PE;
-    Big2.strict = STRICT;
-    Big2.roundDown = 0;
-    Big2.roundHalfUp = 1;
-    Big2.roundHalfEven = 2;
-    Big2.roundUp = 3;
-    return Big2;
-  }
-  __name(_Big_, "_Big_");
-  function parse(x, n) {
-    var e, i, nl;
-    if (!NUMERIC.test(n)) {
-      throw Error(INVALID + "number");
-    }
-    x.s = n.charAt(0) == "-" ? (n = n.slice(1), -1) : 1;
-    if ((e = n.indexOf(".")) > -1) n = n.replace(".", "");
-    if ((i = n.search(/e/i)) > 0) {
-      if (e < 0) e = i;
-      e += +n.slice(i + 1);
-      n = n.substring(0, i);
-    } else if (e < 0) {
-      e = n.length;
-    }
-    nl = n.length;
-    for (i = 0; i < nl && n.charAt(i) == "0"; ) ++i;
-    if (i == nl) {
-      x.c = [x.e = 0];
-    } else {
-      for (; nl > 0 && n.charAt(--nl) == "0"; ) ;
-      x.e = e - i - 1;
-      x.c = [];
-      for (e = 0; i <= nl; ) x.c[e++] = +n.charAt(i++);
-    }
-    return x;
-  }
-  __name(parse, "parse");
-  function round(x, sd, rm, more) {
-    var xc = x.c;
-    if (rm === UNDEFINED) rm = x.constructor.RM;
-    if (rm !== 0 && rm !== 1 && rm !== 2 && rm !== 3) {
-      throw Error(INVALID_RM);
-    }
-    if (sd < 1) {
-      more = rm === 3 && (more || !!xc[0]) || sd === 0 && (rm === 1 && xc[0] >= 5 || rm === 2 && (xc[0] > 5 || xc[0] === 5 && (more || xc[1] !== UNDEFINED)));
-      xc.length = 1;
-      if (more) {
-        x.e = x.e - sd + 1;
-        xc[0] = 1;
-      } else {
-        xc[0] = x.e = 0;
-      }
-    } else if (sd < xc.length) {
-      more = rm === 1 && xc[sd] >= 5 || rm === 2 && (xc[sd] > 5 || xc[sd] === 5 && (more || xc[sd + 1] !== UNDEFINED || xc[sd - 1] & 1)) || rm === 3 && (more || !!xc[0]);
-      xc.length = sd;
-      if (more) {
-        for (; ++xc[--sd] > 9; ) {
-          xc[sd] = 0;
-          if (sd === 0) {
-            ++x.e;
-            xc.unshift(1);
-            break;
-          }
-        }
-      }
-      for (sd = xc.length; !xc[--sd]; ) xc.pop();
-    }
-    return x;
-  }
-  __name(round, "round");
-  function stringify(x, doExponential, isNonzero) {
-    var e = x.e, s = x.c.join(""), n = s.length;
-    if (doExponential) {
-      s = s.charAt(0) + (n > 1 ? "." + s.slice(1) : "") + (e < 0 ? "e" : "e+") + e;
-    } else if (e < 0) {
-      for (; ++e; ) s = "0" + s;
-      s = "0." + s;
-    } else if (e > 0) {
-      if (++e > n) {
-        for (e -= n; e--; ) s += "0";
-      } else if (e < n) {
-        s = s.slice(0, e) + "." + s.slice(e);
-      }
-    } else if (n > 1) {
-      s = s.charAt(0) + "." + s.slice(1);
-    }
-    return x.s < 0 && isNonzero ? "-" + s : s;
-  }
-  __name(stringify, "stringify");
-  P.abs = function() {
-    var x = new this.constructor(this);
-    x.s = 1;
-    return x;
-  };
-  P.cmp = function(y) {
-    var isneg, x = this, xc = x.c, yc = (y = new x.constructor(y)).c, i = x.s, j = y.s, k = x.e, l = y.e;
-    if (!xc[0] || !yc[0]) return !xc[0] ? !yc[0] ? 0 : -j : i;
-    if (i != j) return i;
-    isneg = i < 0;
-    if (k != l) return k > l ^ isneg ? 1 : -1;
-    j = (k = xc.length) < (l = yc.length) ? k : l;
-    for (i = -1; ++i < j; ) {
-      if (xc[i] != yc[i]) return xc[i] > yc[i] ^ isneg ? 1 : -1;
-    }
-    return k == l ? 0 : k > l ^ isneg ? 1 : -1;
-  };
-  P.div = function(y) {
-    var x = this, Big2 = x.constructor, a = x.c, b = (y = new Big2(y)).c, k = x.s == y.s ? 1 : -1, dp = Big2.DP;
-    if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {
-      throw Error(INVALID_DP);
-    }
-    if (!b[0]) {
-      throw Error(DIV_BY_ZERO);
-    }
-    if (!a[0]) {
-      y.s = k;
-      y.c = [y.e = 0];
-      return y;
-    }
-    var bl, bt, n, cmp, ri, bz = b.slice(), ai = bl = b.length, al = a.length, r = a.slice(0, bl), rl = r.length, q = y, qc = q.c = [], qi = 0, p = dp + (q.e = x.e - y.e) + 1;
-    q.s = k;
-    k = p < 0 ? 0 : p;
-    bz.unshift(0);
-    for (; rl++ < bl; ) r.push(0);
-    do {
-      for (n = 0; n < 10; n++) {
-        if (bl != (rl = r.length)) {
-          cmp = bl > rl ? 1 : -1;
-        } else {
-          for (ri = -1, cmp = 0; ++ri < bl; ) {
-            if (b[ri] != r[ri]) {
-              cmp = b[ri] > r[ri] ? 1 : -1;
-              break;
-            }
-          }
-        }
-        if (cmp < 0) {
-          for (bt = rl == bl ? b : bz; rl; ) {
-            if (r[--rl] < bt[rl]) {
-              ri = rl;
-              for (; ri && !r[--ri]; ) r[ri] = 9;
-              --r[ri];
-              r[rl] += 10;
-            }
-            r[rl] -= bt[rl];
-          }
-          for (; !r[0]; ) r.shift();
-        } else {
-          break;
-        }
-      }
-      qc[qi++] = cmp ? n : ++n;
-      if (r[0] && cmp) r[rl] = a[ai] || 0;
-      else r = [a[ai]];
-    } while ((ai++ < al || r[0] !== UNDEFINED) && k--);
-    if (!qc[0] && qi != 1) {
-      qc.shift();
-      q.e--;
-      p--;
-    }
-    if (qi > p) round(q, p, Big2.RM, r[0] !== UNDEFINED);
-    return q;
-  };
-  P.eq = function(y) {
-    return this.cmp(y) === 0;
-  };
-  P.gt = function(y) {
-    return this.cmp(y) > 0;
-  };
-  P.gte = function(y) {
-    return this.cmp(y) > -1;
-  };
-  P.lt = function(y) {
-    return this.cmp(y) < 0;
-  };
-  P.lte = function(y) {
-    return this.cmp(y) < 1;
-  };
-  P.minus = P.sub = function(y) {
-    var i, j, t, xlty, x = this, Big2 = x.constructor, a = x.s, b = (y = new Big2(y)).s;
-    if (a != b) {
-      y.s = -b;
-      return x.plus(y);
-    }
-    var xc = x.c.slice(), xe = x.e, yc = y.c, ye = y.e;
-    if (!xc[0] || !yc[0]) {
-      if (yc[0]) {
-        y.s = -b;
-      } else if (xc[0]) {
-        y = new Big2(x);
-      } else {
-        y.s = 1;
-      }
-      return y;
-    }
-    if (a = xe - ye) {
-      if (xlty = a < 0) {
-        a = -a;
-        t = xc;
-      } else {
-        ye = xe;
-        t = yc;
-      }
-      t.reverse();
-      for (b = a; b--; ) t.push(0);
-      t.reverse();
-    } else {
-      j = ((xlty = xc.length < yc.length) ? xc : yc).length;
-      for (a = b = 0; b < j; b++) {
-        if (xc[b] != yc[b]) {
-          xlty = xc[b] < yc[b];
-          break;
-        }
-      }
-    }
-    if (xlty) {
-      t = xc;
-      xc = yc;
-      yc = t;
-      y.s = -y.s;
-    }
-    if ((b = (j = yc.length) - (i = xc.length)) > 0) for (; b--; ) xc[i++] = 0;
-    for (b = i; j > a; ) {
-      if (xc[--j] < yc[j]) {
-        for (i = j; i && !xc[--i]; ) xc[i] = 9;
-        --xc[i];
-        xc[j] += 10;
-      }
-      xc[j] -= yc[j];
-    }
-    for (; xc[--b] === 0; ) xc.pop();
-    for (; xc[0] === 0; ) {
-      xc.shift();
-      --ye;
-    }
-    if (!xc[0]) {
-      y.s = 1;
-      xc = [ye = 0];
-    }
-    y.c = xc;
-    y.e = ye;
-    return y;
-  };
-  P.mod = function(y) {
-    var ygtx, x = this, Big2 = x.constructor, a = x.s, b = (y = new Big2(y)).s;
-    if (!y.c[0]) {
-      throw Error(DIV_BY_ZERO);
-    }
-    x.s = y.s = 1;
-    ygtx = y.cmp(x) == 1;
-    x.s = a;
-    y.s = b;
-    if (ygtx) return new Big2(x);
-    a = Big2.DP;
-    b = Big2.RM;
-    Big2.DP = Big2.RM = 0;
-    x = x.div(y);
-    Big2.DP = a;
-    Big2.RM = b;
-    return this.minus(x.times(y));
-  };
-  P.neg = function() {
-    var x = new this.constructor(this);
-    x.s = -x.s;
-    return x;
-  };
-  P.plus = P.add = function(y) {
-    var e, k, t, x = this, Big2 = x.constructor;
-    y = new Big2(y);
-    if (x.s != y.s) {
-      y.s = -y.s;
-      return x.minus(y);
-    }
-    var xe = x.e, xc = x.c, ye = y.e, yc = y.c;
-    if (!xc[0] || !yc[0]) {
-      if (!yc[0]) {
-        if (xc[0]) {
-          y = new Big2(x);
-        } else {
-          y.s = x.s;
-        }
-      }
-      return y;
-    }
-    xc = xc.slice();
-    if (e = xe - ye) {
-      if (e > 0) {
-        ye = xe;
-        t = yc;
-      } else {
-        e = -e;
-        t = xc;
-      }
-      t.reverse();
-      for (; e--; ) t.push(0);
-      t.reverse();
-    }
-    if (xc.length - yc.length < 0) {
-      t = yc;
-      yc = xc;
-      xc = t;
-    }
-    e = yc.length;
-    for (k = 0; e; xc[e] %= 10) k = (xc[--e] = xc[e] + yc[e] + k) / 10 | 0;
-    if (k) {
-      xc.unshift(k);
-      ++ye;
-    }
-    for (e = xc.length; xc[--e] === 0; ) xc.pop();
-    y.c = xc;
-    y.e = ye;
-    return y;
-  };
-  P.pow = function(n) {
-    var x = this, one = new x.constructor("1"), y = one, isneg = n < 0;
-    if (n !== ~~n || n < -MAX_POWER || n > MAX_POWER) {
-      throw Error(INVALID + "exponent");
-    }
-    if (isneg) n = -n;
-    for (; ; ) {
-      if (n & 1) y = y.times(x);
-      n >>= 1;
-      if (!n) break;
-      x = x.times(x);
-    }
-    return isneg ? one.div(y) : y;
-  };
-  P.prec = function(sd, rm) {
-    if (sd !== ~~sd || sd < 1 || sd > MAX_DP) {
-      throw Error(INVALID + "precision");
-    }
-    return round(new this.constructor(this), sd, rm);
-  };
-  P.round = function(dp, rm) {
-    if (dp === UNDEFINED) dp = 0;
-    else if (dp !== ~~dp || dp < -MAX_DP || dp > MAX_DP) {
-      throw Error(INVALID_DP);
-    }
-    return round(new this.constructor(this), dp + this.e + 1, rm);
-  };
-  P.sqrt = function() {
-    var r, c, t, x = this, Big2 = x.constructor, s = x.s, e = x.e, half = new Big2("0.5");
-    if (!x.c[0]) return new Big2(x);
-    if (s < 0) {
-      throw Error(NAME + "No square root");
-    }
-    s = Math.sqrt(+stringify(x, true, true));
-    if (s === 0 || s === 1 / 0) {
-      c = x.c.join("");
-      if (!(c.length + e & 1)) c += "0";
-      s = Math.sqrt(c);
-      e = ((e + 1) / 2 | 0) - (e < 0 || e & 1);
-      r = new Big2((s == 1 / 0 ? "5e" : (s = s.toExponential()).slice(0, s.indexOf("e") + 1)) + e);
-    } else {
-      r = new Big2(s + "");
-    }
-    e = r.e + (Big2.DP += 4);
-    do {
-      t = r;
-      r = half.times(t.plus(x.div(t)));
-    } while (t.c.slice(0, e).join("") !== r.c.slice(0, e).join(""));
-    return round(r, (Big2.DP -= 4) + r.e + 1, Big2.RM);
-  };
-  P.times = P.mul = function(y) {
-    var c, x = this, Big2 = x.constructor, xc = x.c, yc = (y = new Big2(y)).c, a = xc.length, b = yc.length, i = x.e, j = y.e;
-    y.s = x.s == y.s ? 1 : -1;
-    if (!xc[0] || !yc[0]) {
-      y.c = [y.e = 0];
-      return y;
-    }
-    y.e = i + j;
-    if (a < b) {
-      c = xc;
-      xc = yc;
-      yc = c;
-      j = a;
-      a = b;
-      b = j;
-    }
-    for (c = new Array(j = a + b); j--; ) c[j] = 0;
-    for (i = b; i--; ) {
-      b = 0;
-      for (j = a + i; j > i; ) {
-        b = c[j] + yc[i] * xc[j - i - 1] + b;
-        c[j--] = b % 10;
-        b = b / 10 | 0;
-      }
-      c[j] = b;
-    }
-    if (b) ++y.e;
-    else c.shift();
-    for (i = c.length; !c[--i]; ) c.pop();
-    y.c = c;
-    return y;
-  };
-  P.toExponential = function(dp, rm) {
-    var x = this, n = x.c[0];
-    if (dp !== UNDEFINED) {
-      if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {
-        throw Error(INVALID_DP);
-      }
-      x = round(new x.constructor(x), ++dp, rm);
-      for (; x.c.length < dp; ) x.c.push(0);
-    }
-    return stringify(x, true, !!n);
-  };
-  P.toFixed = function(dp, rm) {
-    var x = this, n = x.c[0];
-    if (dp !== UNDEFINED) {
-      if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {
-        throw Error(INVALID_DP);
-      }
-      x = round(new x.constructor(x), dp + x.e + 1, rm);
-      for (dp = dp + x.e + 1; x.c.length < dp; ) x.c.push(0);
-    }
-    return stringify(x, false, !!n);
-  };
-  P[Symbol.for("nodejs.util.inspect.custom")] = P.toJSON = P.toString = function() {
-    var x = this, Big2 = x.constructor;
-    return stringify(x, x.e <= Big2.NE || x.e >= Big2.PE, !!x.c[0]);
-  };
-  P.toNumber = function() {
-    var n = +stringify(this, true, true);
-    if (this.constructor.strict === true && !this.eq(n.toString())) {
-      throw Error(NAME + "Imprecise conversion");
-    }
-    return n;
-  };
-  P.toPrecision = function(sd, rm) {
-    var x = this, Big2 = x.constructor, n = x.c[0];
-    if (sd !== UNDEFINED) {
-      if (sd !== ~~sd || sd < 1 || sd > MAX_DP) {
-        throw Error(INVALID + "precision");
-      }
-      x = round(new Big2(x), sd, rm);
-      for (; x.c.length < sd; ) x.c.push(0);
-    }
-    return stringify(x, sd <= x.e || x.e <= Big2.NE || x.e >= Big2.PE, !!n);
-  };
-  P.valueOf = function() {
-    var x = this, Big2 = x.constructor;
-    if (Big2.strict === true) {
-      throw Error(NAME + "valueOf disallowed");
-    }
-    return stringify(x, x.e <= Big2.NE || x.e >= Big2.PE, true);
-  };
-  var Big = _Big_();
-  var big_default = Big;
-
   // ../../node_modules/js-base64/base64.mjs
   var _hasBuffer = typeof Buffer === "function";
   var _TD = typeof TextDecoder === "function" ? new TextDecoder() : void 0;
@@ -2669,6 +3330,32 @@ var NearUtils = (() => {
     }
   }
   __name(fromBase64, "fromBase64");
+  var UNIT_DECIMALS = {
+    near: 24,
+    tgas: 12,
+    ggas: 9,
+    gas: 0,
+    yoctonear: 0
+  };
+  function scaleDecimal(amount, shift) {
+    const [whole, frac = ""] = amount.split(".");
+    if (shift >= 0) {
+      const padded = frac.padEnd(shift, "0").slice(0, shift);
+      const extra = frac.length > shift ? frac.slice(shift) : "";
+      if (extra && BigInt(extra) !== 0n) {
+        throw new Error(`Precision loss: "${amount}" has more than ${shift} decimal places`);
+      }
+      return BigInt(whole + padded).toString();
+    }
+    const divisor = 10n ** BigInt(-shift);
+    const bigVal = BigInt(whole);
+    const intPart = bigVal / divisor;
+    const remainder = bigVal % divisor;
+    if (remainder === 0n) return intPart.toString();
+    const fracStr = remainder.toString().padStart(-shift, "0").replace(/0+$/, "");
+    return `${intPart}.${fracStr}`;
+  }
+  __name(scaleDecimal, "scaleDecimal");
   function convertUnit(s, ...args) {
     if (Array.isArray(s)) {
       s = s.reduce((acc, part, i) => {
@@ -2681,25 +3368,15 @@ var NearUtils = (() => {
         const amount = match[1].replace(/[_,]/g, "");
         const unitPart = match[2];
         if (unitPart) {
-          switch (unitPart.toLowerCase()) {
-            case "near":
-              return big_default(amount).mul(big_default(10).pow(24)).toFixed(0);
-            case "tgas":
-              return big_default(amount).mul(big_default(10).pow(12)).toFixed(0);
-            case "ggas":
-              return big_default(amount).mul(big_default(10).pow(9)).toFixed(0);
-            case "gas":
-            case "yoctonear":
-              return big_default(amount).toFixed(0);
-            default:
-              throw new Error(`Unknown unit: ${unitPart}`);
-          }
+          const decimals = UNIT_DECIMALS[unitPart.toLowerCase()];
+          if (decimals === void 0) throw new Error(`Unknown unit: ${unitPart}`);
+          return scaleDecimal(amount, decimals);
         } else {
-          return big_default(amount).toFixed(0);
+          return scaleDecimal(amount, 0);
         }
       }
     }
-    return big_default(`${s}`).toFixed(0);
+    return scaleDecimal(`${s}`, 0);
   }
   __name(convertUnit, "convertUnit");
   function lsSet(key, value) {
@@ -2741,35 +3418,61 @@ var NearUtils = (() => {
   }
   __name(parseJsonFromBytes, "parseJsonFromBytes");
   function canSignWithLAK(actions) {
-    return actions.length === 1 && actions[0].type === "FunctionCall" && big_default(actions[0]?.deposit ?? "0").eq(0);
+    return actions.length === 1 && actions[0].type === "FunctionCall" && BigInt(actions[0]?.deposit ?? "0") === 0n;
   }
   __name(canSignWithLAK, "canSignWithLAK");
 
   // src/crypto.ts
+  function curveFromKey(key) {
+    if (!key.includes(":")) return "ed25519";
+    const curve = key.split(":")[0];
+    if (curve === "ed25519" || curve === "secp256k1") return curve;
+    throw new Error(`Unsupported curve: ${curve}`);
+  }
+  __name(curveFromKey, "curveFromKey");
   var keyFromString = /* @__PURE__ */ __name((key) => base58_to_binary_default(
     key.includes(":") ? (() => {
       const [curve, keyPart] = key.split(":");
-      if (curve !== "ed25519") {
+      if (curve !== "ed25519" && curve !== "secp256k1") {
         throw new Error(`Unsupported curve: ${curve}`);
       }
       return keyPart;
     })() : key
   ), "keyFromString");
-  var keyToString = /* @__PURE__ */ __name((key) => `ed25519:${binary_to_base58_default(key)}`, "keyToString");
+  var keyToString = /* @__PURE__ */ __name((key, curve = "ed25519") => `${curve}:${binary_to_base58_default(key)}`, "keyToString");
   function publicKeyFromPrivate(privateKey) {
+    const curve = curveFromKey(privateKey);
+    if (curve === "secp256k1") {
+      const secret2 = keyFromString(privateKey);
+      const fullPk = secp256k1.getPublicKey(secret2, false);
+      const publicKey2 = fullPk.slice(1);
+      return keyToString(publicKey2, "secp256k1");
+    }
     const secret = keyFromString(privateKey).slice(0, 32);
     const publicKey = ed25519.getPublicKey(secret);
     return keyToString(publicKey);
   }
   __name(publicKeyFromPrivate, "publicKeyFromPrivate");
-  function privateKeyFromRandom() {
-    const privateKey = crypto.getRandomValues(new Uint8Array(64));
-    return keyToString(privateKey);
+  function privateKeyFromRandom(curve = "ed25519") {
+    const size = curve === "secp256k1" ? 32 : 64;
+    const privateKey = crypto.getRandomValues(new Uint8Array(size));
+    return keyToString(privateKey, curve);
   }
   __name(privateKeyFromRandom, "privateKeyFromRandom");
   function signHash(hashBytes, privateKey, opts) {
-    const secret = keyFromString(privateKey).slice(0, 32);
-    const signature = ed25519.sign(hashBytes, secret);
+    const curve = curveFromKey(privateKey);
+    let signature;
+    if (curve === "secp256k1") {
+      const secret = keyFromString(privateKey);
+      const raw = secp256k1.sign(hashBytes, secret, { prehash: false, format: "recovered" });
+      signature = new Uint8Array(65);
+      signature.set(raw.slice(1, 33), 0);
+      signature.set(raw.slice(33, 65), 32);
+      signature[64] = raw[0];
+    } else {
+      const secret = keyFromString(privateKey).slice(0, 32);
+      signature = ed25519.sign(hashBytes, secret);
+    }
     if (opts?.returnBase58) {
       return binary_to_base58_default(signature);
     }
@@ -2782,533 +3485,275 @@ var NearUtils = (() => {
   }
   __name(signBytes, "signBytes");
 
-  // ../../node_modules/borsh/lib/esm/types.js
-  var integers = ["u8", "u16", "u32", "u64", "u128", "i8", "i16", "i32", "i64", "i128", "f32", "f64"];
-
-  // ../../node_modules/borsh/lib/esm/buffer.js
-  var EncodeBuffer = (
-    /** @class */
-    function() {
-      function EncodeBuffer2() {
-        this.offset = 0;
-        this.buffer_size = 256;
-        this.buffer = new ArrayBuffer(this.buffer_size);
-        this.view = new DataView(this.buffer);
-      }
-      __name(EncodeBuffer2, "EncodeBuffer");
-      EncodeBuffer2.prototype.resize_if_necessary = function(needed_space) {
-        if (this.buffer_size - this.offset < needed_space) {
-          this.buffer_size = Math.max(this.buffer_size * 2, this.buffer_size + needed_space);
-          var new_buffer = new ArrayBuffer(this.buffer_size);
-          new Uint8Array(new_buffer).set(new Uint8Array(this.buffer));
-          this.buffer = new_buffer;
-          this.view = new DataView(new_buffer);
-        }
-      };
-      EncodeBuffer2.prototype.get_used_buffer = function() {
-        return new Uint8Array(this.buffer).slice(0, this.offset);
-      };
-      EncodeBuffer2.prototype.store_value = function(value, type) {
-        var bSize = type.substring(1);
-        var size = parseInt(bSize) / 8;
-        this.resize_if_necessary(size);
-        var toCall = type[0] === "f" ? "setFloat".concat(bSize) : type[0] === "i" ? "setInt".concat(bSize) : "setUint".concat(bSize);
-        this.view[toCall](this.offset, value, true);
-        this.offset += size;
-      };
-      EncodeBuffer2.prototype.store_bytes = function(from) {
-        this.resize_if_necessary(from.length);
-        new Uint8Array(this.buffer).set(new Uint8Array(from), this.offset);
-        this.offset += from.length;
-      };
-      return EncodeBuffer2;
-    }()
-  );
-  var DecodeBuffer = (
-    /** @class */
-    function() {
-      function DecodeBuffer2(buf) {
-        this.offset = 0;
-        this.buffer_size = buf.length;
-        this.buffer = new ArrayBuffer(buf.length);
-        new Uint8Array(this.buffer).set(buf);
-        this.view = new DataView(this.buffer);
-      }
-      __name(DecodeBuffer2, "DecodeBuffer");
-      DecodeBuffer2.prototype.assert_enough_buffer = function(size) {
-        if (this.offset + size > this.buffer.byteLength) {
-          throw new Error("Error in schema, the buffer is smaller than expected");
-        }
-      };
-      DecodeBuffer2.prototype.consume_value = function(type) {
-        var bSize = type.substring(1);
-        var size = parseInt(bSize) / 8;
-        this.assert_enough_buffer(size);
-        var toCall = type[0] === "f" ? "getFloat".concat(bSize) : type[0] === "i" ? "getInt".concat(bSize) : "getUint".concat(bSize);
-        var ret = this.view[toCall](this.offset, true);
-        this.offset += size;
-        return ret;
-      };
-      DecodeBuffer2.prototype.consume_bytes = function(size) {
-        this.assert_enough_buffer(size);
-        var ret = this.buffer.slice(this.offset, this.offset + size);
-        this.offset += size;
-        return ret;
-      };
-      return DecodeBuffer2;
-    }()
-  );
-
-  // ../../node_modules/borsh/lib/esm/utils.js
-  var __extends = /* @__PURE__ */ function() {
-    var extendStatics = /* @__PURE__ */ __name(function(d, b) {
-      extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
-        d2.__proto__ = b2;
-      } || function(d2, b2) {
-        for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
-      };
-      return extendStatics(d, b);
-    }, "extendStatics");
-    return function(d, b) {
-      if (typeof b !== "function" && b !== null)
-        throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-      extendStatics(d, b);
-      function __() {
-        this.constructor = d;
-      }
-      __name(__, "__");
-      d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-  }();
-  function isArrayLike(value) {
-    return Array.isArray(value) || !!value && typeof value === "object" && "length" in value && typeof value.length === "number" && (value.length === 0 || value.length > 0 && value.length - 1 in value);
-  }
-  __name(isArrayLike, "isArrayLike");
-  function expect_type(value, type, fieldPath) {
-    if (typeof value !== type) {
-      throw new Error("Expected ".concat(type, " not ").concat(typeof value, "(").concat(value, ") at ").concat(fieldPath.join(".")));
+  // ../borsh/src/index.ts
+  var EncodeBuffer = class {
+    static {
+      __name(this, "EncodeBuffer");
+    }
+    offset = 0;
+    bufferSize = 256;
+    buffer = new ArrayBuffer(this.bufferSize);
+    view = new DataView(this.buffer);
+    resize(needed) {
+      if (this.bufferSize - this.offset < needed) {
+        this.bufferSize = Math.max(this.bufferSize * 2, this.bufferSize + needed);
+        const next = new ArrayBuffer(this.bufferSize);
+        new Uint8Array(next).set(new Uint8Array(this.buffer));
+        this.buffer = next;
+        this.view = new DataView(next);
+      }
     }
-  }
-  __name(expect_type, "expect_type");
-  function expect_bigint(value, fieldPath) {
-    var basicType = ["number", "string", "bigint", "boolean"].includes(typeof value);
-    var strObject = typeof value === "object" && value !== null && "toString" in value;
-    if (!basicType && !strObject) {
-      throw new Error("Expected bigint, number, boolean or string not ".concat(typeof value, "(").concat(value, ") at ").concat(fieldPath.join(".")));
+    storeU8(v) {
+      this.resize(1);
+      this.view.setUint8(this.offset, v);
+      this.offset += 1;
     }
-  }
-  __name(expect_bigint, "expect_bigint");
-  function expect_same_size(length, expected, fieldPath) {
-    if (length !== expected) {
-      throw new Error("Array length ".concat(length, " does not match schema length ").concat(expected, " at ").concat(fieldPath.join(".")));
+    storeU16(v) {
+      this.resize(2);
+      this.view.setUint16(this.offset, v, true);
+      this.offset += 2;
     }
-  }
-  __name(expect_same_size, "expect_same_size");
-  function expect_enum(value, fieldPath) {
-    if (typeof value !== "object" || value === null) {
-      throw new Error("Expected object not ".concat(typeof value, "(").concat(value, ") at ").concat(fieldPath.join(".")));
+    storeU32(v) {
+      this.resize(4);
+      this.view.setUint32(this.offset, v, true);
+      this.offset += 4;
+    }
+    storeBytes(from) {
+      this.resize(from.length);
+      new Uint8Array(this.buffer).set(from, this.offset);
+      this.offset += from.length;
+    }
+    result() {
+      return new Uint8Array(this.buffer).slice(0, this.offset);
+    }
+  };
+  var DecodeBuffer = class {
+    static {
+      __name(this, "DecodeBuffer");
     }
+    offset = 0;
+    view;
+    bytes;
+    constructor(buf) {
+      const ab = new ArrayBuffer(buf.length);
+      new Uint8Array(ab).set(buf);
+      this.view = new DataView(ab);
+      this.bytes = new Uint8Array(ab);
+    }
+    assert(size) {
+      if (this.offset + size > this.bytes.length) {
+        throw new Error("Borsh: buffer overrun");
+      }
+    }
+    readU8() {
+      this.assert(1);
+      const v = this.view.getUint8(this.offset);
+      this.offset += 1;
+      return v;
+    }
+    readU16() {
+      this.assert(2);
+      const v = this.view.getUint16(this.offset, true);
+      this.offset += 2;
+      return v;
+    }
+    readU32() {
+      this.assert(4);
+      const v = this.view.getUint32(this.offset, true);
+      this.offset += 4;
+      return v;
+    }
+    readBytes(len) {
+      this.assert(len);
+      const slice = this.bytes.slice(this.offset, this.offset + len);
+      this.offset += len;
+      return slice;
+    }
+  };
+  function encodeBigint(buf, value, byteLen) {
+    const out = new Uint8Array(byteLen);
+    let v = value;
+    for (let i = 0; i < byteLen; i++) {
+      out[i] = Number(v & 0xffn);
+      v >>= 8n;
+    }
+    buf.storeBytes(out);
+  }
+  __name(encodeBigint, "encodeBigint");
+  function decodeBigint(buf, byteLen) {
+    const bytes = buf.readBytes(byteLen);
+    const hex = bytes.reduceRight((r, x) => r + x.toString(16).padStart(2, "0"), "");
+    return BigInt("0x" + hex);
   }
-  __name(expect_enum, "expect_enum");
-  var VALID_STRING_TYPES = integers.concat(["bool", "string"]);
-  var VALID_OBJECT_KEYS = ["option", "enum", "array", "set", "map", "struct"];
-  var ErrorSchema = (
-    /** @class */
-    function(_super) {
-      __extends(ErrorSchema2, _super);
-      function ErrorSchema2(schema, expected) {
-        var message = "Invalid schema: ".concat(JSON.stringify(schema), " expected ").concat(expected);
-        return _super.call(this, message) || this;
+  __name(decodeBigint, "decodeBigint");
+  function utf8Encode(str) {
+    const bytes = [];
+    for (let i = 0; i < str.length; i++) {
+      let c = str.charCodeAt(i);
+      if (c < 128) {
+        bytes.push(c);
+      } else if (c < 2048) {
+        bytes.push(192 | c >> 6, 128 | c & 63);
+      } else if (c < 55296 || c >= 57344) {
+        bytes.push(224 | c >> 12, 128 | c >> 6 & 63, 128 | c & 63);
+      } else {
+        i++;
+        c = 65536 + ((c & 1023) << 10 | str.charCodeAt(i) & 1023);
+        bytes.push(240 | c >> 18, 128 | c >> 12 & 63, 128 | c >> 6 & 63, 128 | c & 63);
       }
-      __name(ErrorSchema2, "ErrorSchema");
-      return ErrorSchema2;
-    }(Error)
-  );
-  function validate_schema(schema) {
-    if (typeof schema === "string" && VALID_STRING_TYPES.includes(schema)) {
-      return;
-    }
-    if (schema && typeof schema === "object") {
-      var keys = Object.keys(schema);
-      if (keys.length === 1 && VALID_OBJECT_KEYS.includes(keys[0])) {
-        var key = keys[0];
-        if (key === "option")
-          return validate_schema(schema[key]);
-        if (key === "enum")
-          return validate_enum_schema(schema[key]);
-        if (key === "array")
-          return validate_array_schema(schema[key]);
-        if (key === "set")
-          return validate_schema(schema[key]);
-        if (key === "map")
-          return validate_map_schema(schema[key]);
-        if (key === "struct")
-          return validate_struct_schema(schema[key]);
-      }
-    }
-    throw new ErrorSchema(schema, VALID_OBJECT_KEYS.join(", ") + " or " + VALID_STRING_TYPES.join(", "));
-  }
-  __name(validate_schema, "validate_schema");
-  function validate_enum_schema(schema) {
-    if (!Array.isArray(schema))
-      throw new ErrorSchema(schema, "Array");
-    for (var _i = 0, schema_1 = schema; _i < schema_1.length; _i++) {
-      var sch = schema_1[_i];
-      if (typeof sch !== "object" || !("struct" in sch)) {
-        throw new Error('Missing "struct" key in enum schema');
-      }
-      if (typeof sch.struct !== "object" || Object.keys(sch.struct).length !== 1) {
-        throw new Error('The "struct" in each enum must have a single key');
-      }
-      validate_schema({ struct: sch.struct });
-    }
-  }
-  __name(validate_enum_schema, "validate_enum_schema");
-  function validate_array_schema(schema) {
-    if (typeof schema !== "object")
-      throw new ErrorSchema(schema, "{ type, len? }");
-    if (schema.len && typeof schema.len !== "number") {
-      throw new Error("Invalid schema: ".concat(schema));
-    }
-    if ("type" in schema)
-      return validate_schema(schema.type);
-    throw new ErrorSchema(schema, "{ type, len? }");
-  }
-  __name(validate_array_schema, "validate_array_schema");
-  function validate_map_schema(schema) {
-    if (typeof schema === "object" && "key" in schema && "value" in schema) {
-      validate_schema(schema.key);
-      validate_schema(schema.value);
-    } else {
-      throw new ErrorSchema(schema, "{ key, value }");
     }
+    return new Uint8Array(bytes);
   }
-  __name(validate_map_schema, "validate_map_schema");
-  function validate_struct_schema(schema) {
-    if (typeof schema !== "object")
-      throw new ErrorSchema(schema, "object");
-    for (var key in schema) {
-      validate_schema(schema[key]);
+  __name(utf8Encode, "utf8Encode");
+  function utf8Decode(bytes) {
+    const codePoints = [];
+    for (let i = 0; i < bytes.length; i++) {
+      const b = bytes[i];
+      if (b < 128) {
+        codePoints.push(b);
+      } else if (b < 224) {
+        codePoints.push((b & 31) << 6 | bytes[++i] & 63);
+      } else if (b < 240) {
+        codePoints.push((b & 15) << 12 | (bytes[++i] & 63) << 6 | bytes[++i] & 63);
+      } else {
+        codePoints.push((b & 7) << 18 | (bytes[++i] & 63) << 12 | (bytes[++i] & 63) << 6 | bytes[++i] & 63);
+      }
     }
+    return String.fromCodePoint(...codePoints);
   }
-  __name(validate_struct_schema, "validate_struct_schema");
-
-  // ../../node_modules/borsh/lib/esm/serialize.js
-  var BorshSerializer = (
-    /** @class */
-    function() {
-      function BorshSerializer2(checkTypes) {
-        this.encoded = new EncodeBuffer();
-        this.fieldPath = ["value"];
-        this.checkTypes = checkTypes;
-      }
-      __name(BorshSerializer2, "BorshSerializer");
-      BorshSerializer2.prototype.encode = function(value, schema) {
-        this.encode_value(value, schema);
-        return this.encoded.get_used_buffer();
-      };
-      BorshSerializer2.prototype.encode_value = function(value, schema) {
-        if (typeof schema === "string") {
-          if (integers.includes(schema))
-            return this.encode_integer(value, schema);
-          if (schema === "string")
-            return this.encode_string(value);
-          if (schema === "bool")
-            return this.encode_boolean(value);
-        }
-        if (typeof schema === "object") {
-          if ("option" in schema)
-            return this.encode_option(value, schema);
-          if ("enum" in schema)
-            return this.encode_enum(value, schema);
-          if ("array" in schema)
-            return this.encode_array(value, schema);
-          if ("set" in schema)
-            return this.encode_set(value, schema);
-          if ("map" in schema)
-            return this.encode_map(value, schema);
-          if ("struct" in schema)
-            return this.encode_struct(value, schema);
+  __name(utf8Decode, "utf8Decode");
+  function encodeValue(buf, value, schema) {
+    if (typeof schema === "string") {
+      switch (schema) {
+        case "u8":
+          return buf.storeU8(value);
+        case "u16":
+          return buf.storeU16(value);
+        case "u32":
+          return buf.storeU32(value);
+        case "u64":
+          return encodeBigint(buf, BigInt(value), 8);
+        case "u128":
+          return encodeBigint(buf, BigInt(value), 16);
+        case "string": {
+          const encoded = utf8Encode(value);
+          buf.storeU32(encoded.length);
+          buf.storeBytes(encoded);
+          return;
         }
-      };
-      BorshSerializer2.prototype.encode_integer = function(value, schema) {
-        var size = parseInt(schema.substring(1));
-        if (size <= 32 || schema == "f64") {
-          this.checkTypes && expect_type(value, "number", this.fieldPath);
-          this.encoded.store_value(value, schema);
-        } else {
-          this.checkTypes && expect_bigint(value, this.fieldPath);
-          this.encode_bigint(BigInt(value), size);
-        }
-      };
-      BorshSerializer2.prototype.encode_bigint = function(value, size) {
-        var buffer_len = size / 8;
-        var buffer = new Uint8Array(buffer_len);
-        for (var i = 0; i < buffer_len; i++) {
-          buffer[i] = Number(value & BigInt(255));
-          value = value >> BigInt(8);
-        }
-        this.encoded.store_bytes(new Uint8Array(buffer));
-      };
-      BorshSerializer2.prototype.encode_string = function(value) {
-        this.checkTypes && expect_type(value, "string", this.fieldPath);
-        var _value = value;
-        var utf8Bytes = [];
-        for (var i = 0; i < _value.length; i++) {
-          var charCode = _value.charCodeAt(i);
-          if (charCode < 128) {
-            utf8Bytes.push(charCode);
-          } else if (charCode < 2048) {
-            utf8Bytes.push(192 | charCode >> 6, 128 | charCode & 63);
-          } else if (charCode < 55296 || charCode >= 57344) {
-            utf8Bytes.push(224 | charCode >> 12, 128 | charCode >> 6 & 63, 128 | charCode & 63);
-          } else {
-            i++;
-            charCode = 65536 + ((charCode & 1023) << 10 | _value.charCodeAt(i) & 1023);
-            utf8Bytes.push(240 | charCode >> 18, 128 | charCode >> 12 & 63, 128 | charCode >> 6 & 63, 128 | charCode & 63);
-          }
-        }
-        this.encoded.store_value(utf8Bytes.length, "u32");
-        this.encoded.store_bytes(new Uint8Array(utf8Bytes));
-      };
-      BorshSerializer2.prototype.encode_boolean = function(value) {
-        this.checkTypes && expect_type(value, "boolean", this.fieldPath);
-        this.encoded.store_value(value ? 1 : 0, "u8");
-      };
-      BorshSerializer2.prototype.encode_option = function(value, schema) {
+      }
+    }
+    if (typeof schema === "object") {
+      if ("option" in schema) {
         if (value === null || value === void 0) {
-          this.encoded.store_value(0, "u8");
+          buf.storeU8(0);
         } else {
-          this.encoded.store_value(1, "u8");
-          this.encode_value(value, schema.option);
+          buf.storeU8(1);
+          encodeValue(buf, value, schema.option);
         }
-      };
-      BorshSerializer2.prototype.encode_enum = function(value, schema) {
-        this.checkTypes && expect_enum(value, this.fieldPath);
-        var valueKey = Object.keys(value)[0];
-        for (var i = 0; i < schema["enum"].length; i++) {
-          var valueSchema = schema["enum"][i];
-          if (valueKey === Object.keys(valueSchema.struct)[0]) {
-            this.encoded.store_value(i, "u8");
-            return this.encode_struct(value, valueSchema);
-          }
-        }
-        throw new Error("Enum key (".concat(valueKey, ") not found in enum schema: ").concat(JSON.stringify(schema), " at ").concat(this.fieldPath.join(".")));
-      };
-      BorshSerializer2.prototype.encode_array = function(value, schema) {
-        if (isArrayLike(value))
-          return this.encode_arraylike(value, schema);
-        if (value instanceof ArrayBuffer)
-          return this.encode_buffer(value, schema);
-        throw new Error("Expected Array-like not ".concat(typeof value, "(").concat(value, ") at ").concat(this.fieldPath.join(".")));
-      };
-      BorshSerializer2.prototype.encode_arraylike = function(value, schema) {
-        if (schema.array.len) {
-          expect_same_size(value.length, schema.array.len, this.fieldPath);
-        } else {
-          this.encoded.store_value(value.length, "u32");
-        }
-        for (var i = 0; i < value.length; i++) {
-          this.encode_value(value[i], schema.array.type);
-        }
-      };
-      BorshSerializer2.prototype.encode_buffer = function(value, schema) {
-        if (schema.array.len) {
-          expect_same_size(value.byteLength, schema.array.len, this.fieldPath);
-        } else {
-          this.encoded.store_value(value.byteLength, "u32");
-        }
-        this.encoded.store_bytes(new Uint8Array(value));
-      };
-      BorshSerializer2.prototype.encode_set = function(value, schema) {
-        this.checkTypes && expect_type(value, "object", this.fieldPath);
-        var isSet = value instanceof Set;
-        var values = isSet ? Array.from(value.values()) : Object.values(value);
-        this.encoded.store_value(values.length, "u32");
-        for (var _i = 0, values_1 = values; _i < values_1.length; _i++) {
-          var value_1 = values_1[_i];
-          this.encode_value(value_1, schema.set);
-        }
-      };
-      BorshSerializer2.prototype.encode_map = function(value, schema) {
-        this.checkTypes && expect_type(value, "object", this.fieldPath);
-        var isMap = value instanceof Map;
-        var keys = isMap ? Array.from(value.keys()) : Object.keys(value);
-        this.encoded.store_value(keys.length, "u32");
-        for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {
-          var key = keys_1[_i];
-          this.encode_value(key, schema.map.key);
-          this.encode_value(isMap ? value.get(key) : value[key], schema.map.value);
-        }
-      };
-      BorshSerializer2.prototype.encode_struct = function(value, schema) {
-        this.checkTypes && expect_type(value, "object", this.fieldPath);
-        for (var _i = 0, _a = Object.keys(schema.struct); _i < _a.length; _i++) {
-          var key = _a[_i];
-          this.fieldPath.push(key);
-          this.encode_value(value[key], schema.struct[key]);
-          this.fieldPath.pop();
-        }
-      };
-      return BorshSerializer2;
-    }()
-  );
-
-  // ../../node_modules/borsh/lib/esm/deserialize.js
-  var BorshDeserializer = (
-    /** @class */
-    function() {
-      function BorshDeserializer2(bufferArray) {
-        this.buffer = new DecodeBuffer(bufferArray);
-      }
-      __name(BorshDeserializer2, "BorshDeserializer");
-      BorshDeserializer2.prototype.decode = function(schema) {
-        return this.decode_value(schema);
-      };
-      BorshDeserializer2.prototype.decode_value = function(schema) {
-        if (typeof schema === "string") {
-          if (integers.includes(schema))
-            return this.decode_integer(schema);
-          if (schema === "string")
-            return this.decode_string();
-          if (schema === "bool")
-            return this.decode_boolean();
-        }
-        if (typeof schema === "object") {
-          if ("option" in schema)
-            return this.decode_option(schema);
-          if ("enum" in schema)
-            return this.decode_enum(schema);
-          if ("array" in schema)
-            return this.decode_array(schema);
-          if ("set" in schema)
-            return this.decode_set(schema);
-          if ("map" in schema)
-            return this.decode_map(schema);
-          if ("struct" in schema)
-            return this.decode_struct(schema);
-        }
-        throw new Error("Unsupported type: ".concat(schema));
-      };
-      BorshDeserializer2.prototype.decode_integer = function(schema) {
-        var size = parseInt(schema.substring(1));
-        if (size <= 32 || schema == "f64") {
-          return this.buffer.consume_value(schema);
-        }
-        return this.decode_bigint(size, schema.startsWith("i"));
-      };
-      BorshDeserializer2.prototype.decode_bigint = function(size, signed) {
-        if (signed === void 0) {
-          signed = false;
-        }
-        var buffer_len = size / 8;
-        var buffer = new Uint8Array(this.buffer.consume_bytes(buffer_len));
-        var bits = buffer.reduceRight(function(r, x) {
-          return r + x.toString(16).padStart(2, "0");
-        }, "");
-        if (signed && buffer[buffer_len - 1]) {
-          return BigInt.asIntN(size, BigInt("0x".concat(bits)));
-        }
-        return BigInt("0x".concat(bits));
-      };
-      BorshDeserializer2.prototype.decode_string = function() {
-        var len = this.decode_integer("u32");
-        var buffer = new Uint8Array(this.buffer.consume_bytes(len));
-        var codePoints = [];
-        for (var i = 0; i < len; ++i) {
-          var byte = buffer[i];
-          if (byte < 128) {
-            codePoints.push(byte);
-          } else if (byte < 224) {
-            codePoints.push((byte & 31) << 6 | buffer[++i] & 63);
-          } else if (byte < 240) {
-            codePoints.push((byte & 15) << 12 | (buffer[++i] & 63) << 6 | buffer[++i] & 63);
-          } else {
-            var codePoint = (byte & 7) << 18 | (buffer[++i] & 63) << 12 | (buffer[++i] & 63) << 6 | buffer[++i] & 63;
-            codePoints.push(codePoint);
+        return;
+      }
+      if ("enum" in schema) {
+        const valueKey = Object.keys(value)[0];
+        const variants = schema.enum;
+        for (let i = 0; i < variants.length; i++) {
+          const variantKey = Object.keys(variants[i].struct)[0];
+          if (valueKey === variantKey) {
+            buf.storeU8(i);
+            encodeStruct(buf, value, variants[i]);
+            return;
           }
         }
-        return String.fromCodePoint.apply(String, codePoints);
-      };
-      BorshDeserializer2.prototype.decode_boolean = function() {
-        return this.buffer.consume_value("u8") > 0;
-      };
-      BorshDeserializer2.prototype.decode_option = function(schema) {
-        var option = this.buffer.consume_value("u8");
-        if (option === 1) {
-          return this.decode_value(schema.option);
+        throw new Error(`Borsh: enum key "${valueKey}" not found in schema`);
+      }
+      if ("array" in schema) {
+        if (schema.array.len == null) {
+          buf.storeU32(value.length);
         }
-        if (option !== 0) {
-          throw new Error("Invalid option ".concat(option));
+        for (let i = 0; i < value.length; i++) {
+          encodeValue(buf, value[i], schema.array.type);
         }
-        return null;
-      };
-      BorshDeserializer2.prototype.decode_enum = function(schema) {
-        var _a;
-        var valueIndex = this.buffer.consume_value("u8");
-        if (valueIndex > schema["enum"].length) {
-          throw new Error("Enum option ".concat(valueIndex, " is not available"));
+        return;
+      }
+      if ("struct" in schema) {
+        encodeStruct(buf, value, schema);
+        return;
+      }
+    }
+  }
+  __name(encodeValue, "encodeValue");
+  function encodeStruct(buf, value, schema) {
+    for (const key of Object.keys(schema.struct)) {
+      encodeValue(buf, value[key], schema.struct[key]);
+    }
+  }
+  __name(encodeStruct, "encodeStruct");
+  function decodeValue(buf, schema) {
+    if (typeof schema === "string") {
+      switch (schema) {
+        case "u8":
+          return buf.readU8();
+        case "u16":
+          return buf.readU16();
+        case "u32":
+          return buf.readU32();
+        case "u64":
+          return decodeBigint(buf, 8);
+        case "u128":
+          return decodeBigint(buf, 16);
+        case "string": {
+          const len = buf.readU32();
+          return utf8Decode(buf.readBytes(len));
         }
-        var struct = schema["enum"][valueIndex].struct;
-        var key = Object.keys(struct)[0];
-        return _a = {}, _a[key] = this.decode_value(struct[key]), _a;
-      };
-      BorshDeserializer2.prototype.decode_array = function(schema) {
-        var result = [];
-        var len = schema.array.len ? schema.array.len : this.decode_integer("u32");
-        for (var i = 0; i < len; ++i) {
-          result.push(this.decode_value(schema.array.type));
+      }
+    }
+    if (typeof schema === "object") {
+      if ("option" in schema) {
+        const flag = buf.readU8();
+        if (flag === 1) return decodeValue(buf, schema.option);
+        if (flag === 0) return null;
+        throw new Error(`Borsh: invalid option flag ${flag}`);
+      }
+      if ("enum" in schema) {
+        const idx = buf.readU8();
+        if (idx >= schema.enum.length) {
+          throw new Error(`Borsh: enum index ${idx} out of range`);
         }
-        return result;
-      };
-      BorshDeserializer2.prototype.decode_set = function(schema) {
-        var len = this.decode_integer("u32");
-        var result = /* @__PURE__ */ new Set();
-        for (var i = 0; i < len; ++i) {
-          result.add(this.decode_value(schema.set));
+        const variant = schema.enum[idx];
+        const result = {};
+        for (const key of Object.keys(variant.struct)) {
+          result[key] = decodeValue(buf, variant.struct[key]);
         }
         return result;
-      };
-      BorshDeserializer2.prototype.decode_map = function(schema) {
-        var len = this.decode_integer("u32");
-        var result = /* @__PURE__ */ new Map();
-        for (var i = 0; i < len; ++i) {
-          var key = this.decode_value(schema.map.key);
-          var value = this.decode_value(schema.map.value);
-          result.set(key, value);
+      }
+      if ("array" in schema) {
+        const len = schema.array.len ?? buf.readU32();
+        const result = [];
+        for (let i = 0; i < len; i++) {
+          result.push(decodeValue(buf, schema.array.type));
         }
         return result;
-      };
-      BorshDeserializer2.prototype.decode_struct = function(schema) {
-        var result = {};
-        for (var key in schema.struct) {
-          result[key] = this.decode_value(schema.struct[key]);
+      }
+      if ("struct" in schema) {
+        const result = {};
+        for (const key in schema.struct) {
+          result[key] = decodeValue(buf, schema.struct[key]);
         }
         return result;
-      };
-      return BorshDeserializer2;
-    }()
-  );
-
-  // ../../node_modules/borsh/lib/esm/index.js
-  function serialize(schema, value, validate) {
-    if (validate === void 0) {
-      validate = true;
+      }
     }
-    if (validate)
-      validate_schema(schema);
-    var serializer = new BorshSerializer(validate);
-    return serializer.encode(value, schema);
+    throw new Error(`Borsh: unsupported schema: ${JSON.stringify(schema)}`);
+  }
+  __name(decodeValue, "decodeValue");
+  function serialize(schema, value) {
+    const buf = new EncodeBuffer();
+    encodeValue(buf, value, schema);
+    return buf.result();
   }
   __name(serialize, "serialize");
-  function deserialize(schema, buffer, validate) {
-    if (validate === void 0) {
-      validate = true;
-    }
-    if (validate)
-      validate_schema(schema);
-    var deserializer = new BorshDeserializer(buffer);
-    return deserializer.decode(schema);
+  function deserialize(schema, buffer) {
+    const buf = new DecodeBuffer(buffer);
+    return decodeValue(buf, schema);
   }
   __name(deserialize, "deserialize");
 
@@ -3489,14 +3934,22 @@ var NearUtils = (() => {
   var txToJsonStringified = /* @__PURE__ */ __name((tx) => {
     return JSON.stringify(txToJson(tx));
   }, "txToJsonStringified");
+  function mapPublicKey(keyString) {
+    const curve = curveFromKey(keyString);
+    const data = keyFromString(keyString);
+    return curve === "secp256k1" ? { secp256k1Key: { data } } : { ed25519Key: { data } };
+  }
+  __name(mapPublicKey, "mapPublicKey");
+  function mapSignature(sigBase58, signerKeyString) {
+    const curve = curveFromKey(signerKeyString);
+    const data = base58_to_binary_default(sigBase58);
+    return curve === "secp256k1" ? { secp256k1Signature: { data } } : { ed25519Signature: { data } };
+  }
+  __name(mapSignature, "mapSignature");
   function mapTransaction(jsonTransaction) {
     return {
       signerId: jsonTransaction.signerId,
-      publicKey: {
-        ed25519Key: {
-          data: keyFromString(jsonTransaction.publicKey)
-        }
-      },
+      publicKey: mapPublicKey(jsonTransaction.publicKey),
       nonce: BigInt(jsonTransaction.nonce),
       receiverId: jsonTransaction.receiverId,
       blockHash: base58_to_binary_default(jsonTransaction.blockHash),
@@ -3519,13 +3972,9 @@ var NearUtils = (() => {
     console.log("fastnear: mapped (for borsh schema) signed transaction", mappedSignedTx);
     const plainSignedTransaction = {
       transaction: mappedSignedTx,
-      signature: {
-        ed25519Signature: {
-          data: base58_to_binary_default(signature)
-        }
-      }
+      signature: mapSignature(signature, jsonTransaction.publicKey)
     };
-    const borshSignedTx = serialize(SCHEMA.SignedTransaction, plainSignedTransaction, true);
+    const borshSignedTx = serialize(SCHEMA.SignedTransaction, plainSignedTransaction);
     console.log("fastnear: borsh-serialized signed transaction:", borshSignedTx);
     return borshSignedTx;
   }
@@ -3565,22 +4014,14 @@ var NearUtils = (() => {
         return {
           stake: {
             stake: BigInt(action.stake),
-            publicKey: {
-              ed25519Key: {
-                data: keyFromString(action.publicKey)
-              }
-            }
+            publicKey: mapPublicKey(action.publicKey)
           }
         };
       }
       case "AddKey": {
         return {
           addKey: {
-            publicKey: {
-              ed25519Key: {
-                data: keyFromString(action.publicKey)
-              }
-            },
+            publicKey: mapPublicKey(action.publicKey),
             accessKey: {
               nonce: BigInt(action.accessKey.nonce),
               permission: action.accessKey.permission === "FullAccess" ? { fullAccess: {} } : {
@@ -3597,11 +4038,7 @@ var NearUtils = (() => {
       case "DeleteKey": {
         return {
           deleteKey: {
-            publicKey: {
-              ed25519Key: {
-                data: keyFromString(action.publicKey)
-              }
-            }
+            publicKey: mapPublicKey(action.publicKey)
           }
         };
       }
@@ -3616,9 +4053,7 @@ var NearUtils = (() => {
         return {
           signedDelegate: {
             delegateAction: mapAction(action.delegateAction),
-            signature: {
-              ed25519Signature: base58_to_binary_default(action.signature)
-            }
+            signature: mapSignature(action.signature, action.publicKey)
           }
         };
       }
@@ -3659,6 +4094,12 @@ var NearUtils = (() => {
 
 @noble/curves/ed25519.js:
   (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/curves/abstract/weierstrass.js:
+  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/curves/secp256k1.js:
+  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
 */
 
 Object.defineProperty(globalThis, 'NearUtils', {