{"version":3,"sources":["jsdelivr-header.js","/npm/@fastnear/api@0.9.7/src/index.ts","/npm/node_modules/big.js/big.mjs","/npm/@fastnear/utils/src/index.ts","/npm/node_modules/@noble/hashes/src/_assert.ts","/npm/node_modules/@noble/hashes/src/crypto.ts","/npm/node_modules/@noble/hashes/src/utils.ts","/npm/node_modules/@noble/hashes/src/_md.ts","/npm/node_modules/@noble/hashes/src/_u64.ts","/npm/node_modules/@noble/hashes/src/sha512.ts","/npm/node_modules/@noble/curves/src/abstract/utils.ts","/npm/node_modules/@noble/curves/src/abstract/modular.ts","/npm/node_modules/@noble/curves/src/abstract/curve.ts","/npm/node_modules/@noble/curves/src/abstract/edwards.ts","/npm/node_modules/@noble/curves/src/ed25519.ts","/npm/node_modules/@noble/hashes/src/sha256.ts","/npm/node_modules/base58-js/base58_chars.mjs","/npm/node_modules/base58-js/base58_to_binary.mjs","/npm/node_modules/base58-js/binary_to_base58.mjs","/npm/node_modules/base58-js/create_base58_map.mjs","/npm/node_modules/js-base64/base64.mjs","/npm/@fastnear/utils/src/storage.ts","/npm/@fastnear/utils/src/misc.ts","/npm/@fastnear/utils/src/crypto.ts","/npm/node_modules/borsh/lib/esm/types.js","/npm/node_modules/borsh/lib/esm/buffer.js","/npm/node_modules/borsh/lib/esm/utils.js","/npm/node_modules/borsh/lib/esm/serialize.js","/npm/node_modules/borsh/lib/esm/deserialize.js","/npm/node_modules/borsh/lib/esm/index.js","/npm/@fastnear/borsh-schema/src/index.ts","/npm/@fastnear/utils/src/transaction.ts","/npm/@fastnear/api@0.9.7/src/state.ts","/npm/@fastnear/wallet-adapter/src/index.ts","/npm/@fastnear/api@0.9.7/src/near.ts"],"names":[],"mappings":"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","file":"/npm/@fastnear/api@0.9.7/dist/umd/browser.global.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/@fastnear/api@0.9.7/dist/umd/browser.global.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","// See tsup.config.ts for additional banner/footer js\nexport * from \"./near.js\";\n","/*\r\n *  big.js v6.2.2\r\n *  A small, fast, easy-to-use library for arbitrary-precision decimal arithmetic.\r\n *  Copyright (c) 2024 Michael Mclaughlin\r\n *  https://github.com/MikeMcl/big.js/LICENCE.md\r\n */\r\n\r\n\r\n/************************************** EDITABLE DEFAULTS *****************************************/\r\n\r\n\r\n  // The default values below must be integers within the stated ranges.\r\n\r\n  /*\r\n   * The maximum number of decimal places (DP) of the results of operations involving division:\r\n   * div and sqrt, and pow with negative exponents.\r\n   */\r\nvar DP = 20,          // 0 to MAX_DP\r\n\r\n  /*\r\n   * The rounding mode (RM) used when rounding to the above decimal places.\r\n   *\r\n   *  0  Towards zero (i.e. truncate, no rounding).       (ROUND_DOWN)\r\n   *  1  To nearest neighbour. If equidistant, round up.  (ROUND_HALF_UP)\r\n   *  2  To nearest neighbour. If equidistant, to even.   (ROUND_HALF_EVEN)\r\n   *  3  Away from zero.                                  (ROUND_UP)\r\n   */\r\n  RM = 1,             // 0, 1, 2 or 3\r\n\r\n  // The maximum value of DP and Big.DP.\r\n  MAX_DP = 1E6,       // 0 to 1000000\r\n\r\n  // The maximum magnitude of the exponent argument to the pow method.\r\n  MAX_POWER = 1E6,    // 1 to 1000000\r\n\r\n  /*\r\n   * The negative exponent (NE) at and beneath which toString returns exponential notation.\r\n   * (JavaScript numbers: -7)\r\n   * -1000000 is the minimum recommended exponent value of a Big.\r\n   */\r\n  NE = -7,            // 0 to -1000000\r\n\r\n  /*\r\n   * The positive exponent (PE) at and above which toString returns exponential notation.\r\n   * (JavaScript numbers: 21)\r\n   * 1000000 is the maximum recommended exponent value of a Big, but this limit is not enforced.\r\n   */\r\n  PE = 21,            // 0 to 1000000\r\n\r\n  /*\r\n   * When true, an error will be thrown if a primitive number is passed to the Big constructor,\r\n   * or if valueOf is called, or if toNumber is called on a Big which cannot be converted to a\r\n   * primitive number without a loss of precision.\r\n   */\r\n  STRICT = false,     // true or false\r\n\r\n\r\n/**************************************************************************************************/\r\n\r\n\r\n  // Error messages.\r\n  NAME = '[big.js] ',\r\n  INVALID = NAME + 'Invalid ',\r\n  INVALID_DP = INVALID + 'decimal places',\r\n  INVALID_RM = INVALID + 'rounding mode',\r\n  DIV_BY_ZERO = NAME + 'Division by zero',\r\n\r\n  // The shared prototype object.\r\n  P = {},\r\n  UNDEFINED = void 0,\r\n  NUMERIC = /^-?(\\d+(\\.\\d*)?|\\.\\d+)(e[+-]?\\d+)?$/i;\r\n\r\n\r\n/*\r\n * Create and return a Big constructor.\r\n */\r\nfunction _Big_() {\r\n\r\n  /*\r\n   * The Big constructor and exported function.\r\n   * Create and return a new instance of a Big number object.\r\n   *\r\n   * n {number|string|Big} A numeric value.\r\n   */\r\n  function Big(n) {\r\n    var x = this;\r\n\r\n    // Enable constructor usage without new.\r\n    if (!(x instanceof Big)) return n === UNDEFINED ? _Big_() : new Big(n);\r\n\r\n    // Duplicate.\r\n    if (n instanceof Big) {\r\n      x.s = n.s;\r\n      x.e = n.e;\r\n      x.c = n.c.slice();\r\n    } else {\r\n      if (typeof n !== 'string') {\r\n        if (Big.strict === true && typeof n !== 'bigint') {\r\n          throw TypeError(INVALID + 'value');\r\n        }\r\n\r\n        // Minus zero?\r\n        n = n === 0 && 1 / n < 0 ? '-0' : String(n);\r\n      }\r\n\r\n      parse(x, n);\r\n    }\r\n\r\n    // Retain a reference to this Big constructor.\r\n    // Shadow Big.prototype.constructor which points to Object.\r\n    x.constructor = Big;\r\n  }\r\n\r\n  Big.prototype = P;\r\n  Big.DP = DP;\r\n  Big.RM = RM;\r\n  Big.NE = NE;\r\n  Big.PE = PE;\r\n  Big.strict = STRICT;\r\n  Big.roundDown = 0;\r\n  Big.roundHalfUp = 1;\r\n  Big.roundHalfEven = 2;\r\n  Big.roundUp = 3;\r\n\r\n  return Big;\r\n}\r\n\r\n\r\n/*\r\n * Parse the number or string value passed to a Big constructor.\r\n *\r\n * x {Big} A Big number instance.\r\n * n {number|string} A numeric value.\r\n */\r\nfunction parse(x, n) {\r\n  var e, i, nl;\r\n\r\n  if (!NUMERIC.test(n)) {\r\n    throw Error(INVALID + 'number');\r\n  }\r\n\r\n  // Determine sign.\r\n  x.s = n.charAt(0) == '-' ? (n = n.slice(1), -1) : 1;\r\n\r\n  // Decimal point?\r\n  if ((e = n.indexOf('.')) > -1) n = n.replace('.', '');\r\n\r\n  // Exponential form?\r\n  if ((i = n.search(/e/i)) > 0) {\r\n\r\n    // Determine exponent.\r\n    if (e < 0) e = i;\r\n    e += +n.slice(i + 1);\r\n    n = n.substring(0, i);\r\n  } else if (e < 0) {\r\n\r\n    // Integer.\r\n    e = n.length;\r\n  }\r\n\r\n  nl = n.length;\r\n\r\n  // Determine leading zeros.\r\n  for (i = 0; i < nl && n.charAt(i) == '0';) ++i;\r\n\r\n  if (i == nl) {\r\n\r\n    // Zero.\r\n    x.c = [x.e = 0];\r\n  } else {\r\n\r\n    // Determine trailing zeros.\r\n    for (; nl > 0 && n.charAt(--nl) == '0';);\r\n    x.e = e - i - 1;\r\n    x.c = [];\r\n\r\n    // Convert string to array of digits without leading/trailing zeros.\r\n    for (e = 0; i <= nl;) x.c[e++] = +n.charAt(i++);\r\n  }\r\n\r\n  return x;\r\n}\r\n\r\n\r\n/*\r\n * Round Big x to a maximum of sd significant digits using rounding mode rm.\r\n *\r\n * x {Big} The Big to round.\r\n * sd {number} Significant digits: integer, 0 to MAX_DP inclusive.\r\n * rm {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\r\n * [more] {boolean} Whether the result of division was truncated.\r\n */\r\nfunction round(x, sd, rm, more) {\r\n  var xc = x.c;\r\n\r\n  if (rm === UNDEFINED) rm = x.constructor.RM;\r\n  if (rm !== 0 && rm !== 1 && rm !== 2 && rm !== 3) {\r\n    throw Error(INVALID_RM);\r\n  }\r\n\r\n  if (sd < 1) {\r\n    more =\r\n      rm === 3 && (more || !!xc[0]) || sd === 0 && (\r\n      rm === 1 && xc[0] >= 5 ||\r\n      rm === 2 && (xc[0] > 5 || xc[0] === 5 && (more || xc[1] !== UNDEFINED))\r\n    );\r\n\r\n    xc.length = 1;\r\n\r\n    if (more) {\r\n\r\n      // 1, 0.1, 0.01, 0.001, 0.0001 etc.\r\n      x.e = x.e - sd + 1;\r\n      xc[0] = 1;\r\n    } else {\r\n\r\n      // Zero.\r\n      xc[0] = x.e = 0;\r\n    }\r\n  } else if (sd < xc.length) {\r\n\r\n    // xc[sd] is the digit after the digit that may be rounded up.\r\n    more =\r\n      rm === 1 && xc[sd] >= 5 ||\r\n      rm === 2 && (xc[sd] > 5 || xc[sd] === 5 &&\r\n        (more || xc[sd + 1] !== UNDEFINED || xc[sd - 1] & 1)) ||\r\n      rm === 3 && (more || !!xc[0]);\r\n\r\n    // Remove any digits after the required precision.\r\n    xc.length = sd;\r\n\r\n    // Round up?\r\n    if (more) {\r\n\r\n      // Rounding up may mean the previous digit has to be rounded up.\r\n      for (; ++xc[--sd] > 9;) {\r\n        xc[sd] = 0;\r\n        if (sd === 0) {\r\n          ++x.e;\r\n          xc.unshift(1);\r\n          break;\r\n        }\r\n      }\r\n    }\r\n\r\n    // Remove trailing zeros.\r\n    for (sd = xc.length; !xc[--sd];) xc.pop();\r\n  }\r\n\r\n  return x;\r\n}\r\n\r\n\r\n/*\r\n * Return a string representing the value of Big x in normal or exponential notation.\r\n * Handles P.toExponential, P.toFixed, P.toJSON, P.toPrecision, P.toString and P.valueOf.\r\n */\r\nfunction stringify(x, doExponential, isNonzero) {\r\n  var e = x.e,\r\n    s = x.c.join(''),\r\n    n = s.length;\r\n\r\n  // Exponential notation?\r\n  if (doExponential) {\r\n    s = s.charAt(0) + (n > 1 ? '.' + s.slice(1) : '') + (e < 0 ? 'e' : 'e+') + e;\r\n\r\n  // Normal notation.\r\n  } else if (e < 0) {\r\n    for (; ++e;) s = '0' + s;\r\n    s = '0.' + s;\r\n  } else if (e > 0) {\r\n    if (++e > n) {\r\n      for (e -= n; e--;) s += '0';\r\n    } else if (e < n) {\r\n      s = s.slice(0, e) + '.' + s.slice(e);\r\n    }\r\n  } else if (n > 1) {\r\n    s = s.charAt(0) + '.' + s.slice(1);\r\n  }\r\n\r\n  return x.s < 0 && isNonzero ? '-' + s : s;\r\n}\r\n\r\n\r\n// Prototype/instance methods\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the absolute value of this Big.\r\n */\r\nP.abs = function () {\r\n  var x = new this.constructor(this);\r\n  x.s = 1;\r\n  return x;\r\n};\r\n\r\n\r\n/*\r\n * Return 1 if the value of this Big is greater than the value of Big y,\r\n *       -1 if the value of this Big is less than the value of Big y, or\r\n *        0 if they have the same value.\r\n */\r\nP.cmp = function (y) {\r\n  var isneg,\r\n    x = this,\r\n    xc = x.c,\r\n    yc = (y = new x.constructor(y)).c,\r\n    i = x.s,\r\n    j = y.s,\r\n    k = x.e,\r\n    l = y.e;\r\n\r\n  // Either zero?\r\n  if (!xc[0] || !yc[0]) return !xc[0] ? !yc[0] ? 0 : -j : i;\r\n\r\n  // Signs differ?\r\n  if (i != j) return i;\r\n\r\n  isneg = i < 0;\r\n\r\n  // Compare exponents.\r\n  if (k != l) return k > l ^ isneg ? 1 : -1;\r\n\r\n  j = (k = xc.length) < (l = yc.length) ? k : l;\r\n\r\n  // Compare digit by digit.\r\n  for (i = -1; ++i < j;) {\r\n    if (xc[i] != yc[i]) return xc[i] > yc[i] ^ isneg ? 1 : -1;\r\n  }\r\n\r\n  // Compare lengths.\r\n  return k == l ? 0 : k > l ^ isneg ? 1 : -1;\r\n};\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the value of this Big divided by the value of Big y, rounded,\r\n * if necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.\r\n */\r\nP.div = function (y) {\r\n  var x = this,\r\n    Big = x.constructor,\r\n    a = x.c,                  // dividend\r\n    b = (y = new Big(y)).c,   // divisor\r\n    k = x.s == y.s ? 1 : -1,\r\n    dp = Big.DP;\r\n\r\n  if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {\r\n    throw Error(INVALID_DP);\r\n  }\r\n\r\n  // Divisor is zero?\r\n  if (!b[0]) {\r\n    throw Error(DIV_BY_ZERO);\r\n  }\r\n\r\n  // Dividend is 0? Return +-0.\r\n  if (!a[0]) {\r\n    y.s = k;\r\n    y.c = [y.e = 0];\r\n    return y;\r\n  }\r\n\r\n  var bl, bt, n, cmp, ri,\r\n    bz = b.slice(),\r\n    ai = bl = b.length,\r\n    al = a.length,\r\n    r = a.slice(0, bl),   // remainder\r\n    rl = r.length,\r\n    q = y,                // quotient\r\n    qc = q.c = [],\r\n    qi = 0,\r\n    p = dp + (q.e = x.e - y.e) + 1;    // precision of the result\r\n\r\n  q.s = k;\r\n  k = p < 0 ? 0 : p;\r\n\r\n  // Create version of divisor with leading zero.\r\n  bz.unshift(0);\r\n\r\n  // Add zeros to make remainder as long as divisor.\r\n  for (; rl++ < bl;) r.push(0);\r\n\r\n  do {\r\n\r\n    // n is how many times the divisor goes into current remainder.\r\n    for (n = 0; n < 10; n++) {\r\n\r\n      // Compare divisor and remainder.\r\n      if (bl != (rl = r.length)) {\r\n        cmp = bl > rl ? 1 : -1;\r\n      } else {\r\n        for (ri = -1, cmp = 0; ++ri < bl;) {\r\n          if (b[ri] != r[ri]) {\r\n            cmp = b[ri] > r[ri] ? 1 : -1;\r\n            break;\r\n          }\r\n        }\r\n      }\r\n\r\n      // If divisor < remainder, subtract divisor from remainder.\r\n      if (cmp < 0) {\r\n\r\n        // Remainder can't be more than 1 digit longer than divisor.\r\n        // Equalise lengths using divisor with extra leading zero?\r\n        for (bt = rl == bl ? b : bz; rl;) {\r\n          if (r[--rl] < bt[rl]) {\r\n            ri = rl;\r\n            for (; ri && !r[--ri];) r[ri] = 9;\r\n            --r[ri];\r\n            r[rl] += 10;\r\n          }\r\n          r[rl] -= bt[rl];\r\n        }\r\n\r\n        for (; !r[0];) r.shift();\r\n      } else {\r\n        break;\r\n      }\r\n    }\r\n\r\n    // Add the digit n to the result array.\r\n    qc[qi++] = cmp ? n : ++n;\r\n\r\n    // Update the remainder.\r\n    if (r[0] && cmp) r[rl] = a[ai] || 0;\r\n    else r = [a[ai]];\r\n\r\n  } while ((ai++ < al || r[0] !== UNDEFINED) && k--);\r\n\r\n  // Leading zero? Do not remove if result is simply zero (qi == 1).\r\n  if (!qc[0] && qi != 1) {\r\n\r\n    // There can't be more than one zero.\r\n    qc.shift();\r\n    q.e--;\r\n    p--;\r\n  }\r\n\r\n  // Round?\r\n  if (qi > p) round(q, p, Big.RM, r[0] !== UNDEFINED);\r\n\r\n  return q;\r\n};\r\n\r\n\r\n/*\r\n * Return true if the value of this Big is equal to the value of Big y, otherwise return false.\r\n */\r\nP.eq = function (y) {\r\n  return this.cmp(y) === 0;\r\n};\r\n\r\n\r\n/*\r\n * Return true if the value of this Big is greater than the value of Big y, otherwise return\r\n * false.\r\n */\r\nP.gt = function (y) {\r\n  return this.cmp(y) > 0;\r\n};\r\n\r\n\r\n/*\r\n * Return true if the value of this Big is greater than or equal to the value of Big y, otherwise\r\n * return false.\r\n */\r\nP.gte = function (y) {\r\n  return this.cmp(y) > -1;\r\n};\r\n\r\n\r\n/*\r\n * Return true if the value of this Big is less than the value of Big y, otherwise return false.\r\n */\r\nP.lt = function (y) {\r\n  return this.cmp(y) < 0;\r\n};\r\n\r\n\r\n/*\r\n * Return true if the value of this Big is less than or equal to the value of Big y, otherwise\r\n * return false.\r\n */\r\nP.lte = function (y) {\r\n  return this.cmp(y) < 1;\r\n};\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the value of this Big minus the value of Big y.\r\n */\r\nP.minus = P.sub = function (y) {\r\n  var i, j, t, xlty,\r\n    x = this,\r\n    Big = x.constructor,\r\n    a = x.s,\r\n    b = (y = new Big(y)).s;\r\n\r\n  // Signs differ?\r\n  if (a != b) {\r\n    y.s = -b;\r\n    return x.plus(y);\r\n  }\r\n\r\n  var xc = x.c.slice(),\r\n    xe = x.e,\r\n    yc = y.c,\r\n    ye = y.e;\r\n\r\n  // Either zero?\r\n  if (!xc[0] || !yc[0]) {\r\n    if (yc[0]) {\r\n      y.s = -b;\r\n    } else if (xc[0]) {\r\n      y = new Big(x);\r\n    } else {\r\n      y.s = 1;\r\n    }\r\n    return y;\r\n  }\r\n\r\n  // Determine which is the bigger number. Prepend zeros to equalise exponents.\r\n  if (a = xe - ye) {\r\n\r\n    if (xlty = a < 0) {\r\n      a = -a;\r\n      t = xc;\r\n    } else {\r\n      ye = xe;\r\n      t = yc;\r\n    }\r\n\r\n    t.reverse();\r\n    for (b = a; b--;) t.push(0);\r\n    t.reverse();\r\n  } else {\r\n\r\n    // Exponents equal. Check digit by digit.\r\n    j = ((xlty = xc.length < yc.length) ? xc : yc).length;\r\n\r\n    for (a = b = 0; b < j; b++) {\r\n      if (xc[b] != yc[b]) {\r\n        xlty = xc[b] < yc[b];\r\n        break;\r\n      }\r\n    }\r\n  }\r\n\r\n  // x < y? Point xc to the array of the bigger number.\r\n  if (xlty) {\r\n    t = xc;\r\n    xc = yc;\r\n    yc = t;\r\n    y.s = -y.s;\r\n  }\r\n\r\n  /*\r\n   * Append zeros to xc if shorter. No need to add zeros to yc if shorter as subtraction only\r\n   * needs to start at yc.length.\r\n   */\r\n  if ((b = (j = yc.length) - (i = xc.length)) > 0) for (; b--;) xc[i++] = 0;\r\n\r\n  // Subtract yc from xc.\r\n  for (b = i; j > a;) {\r\n    if (xc[--j] < yc[j]) {\r\n      for (i = j; i && !xc[--i];) xc[i] = 9;\r\n      --xc[i];\r\n      xc[j] += 10;\r\n    }\r\n\r\n    xc[j] -= yc[j];\r\n  }\r\n\r\n  // Remove trailing zeros.\r\n  for (; xc[--b] === 0;) xc.pop();\r\n\r\n  // Remove leading zeros and adjust exponent accordingly.\r\n  for (; xc[0] === 0;) {\r\n    xc.shift();\r\n    --ye;\r\n  }\r\n\r\n  if (!xc[0]) {\r\n\r\n    // n - n = +0\r\n    y.s = 1;\r\n\r\n    // Result must be zero.\r\n    xc = [ye = 0];\r\n  }\r\n\r\n  y.c = xc;\r\n  y.e = ye;\r\n\r\n  return y;\r\n};\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the value of this Big modulo the value of Big y.\r\n */\r\nP.mod = function (y) {\r\n  var ygtx,\r\n    x = this,\r\n    Big = x.constructor,\r\n    a = x.s,\r\n    b = (y = new Big(y)).s;\r\n\r\n  if (!y.c[0]) {\r\n    throw Error(DIV_BY_ZERO);\r\n  }\r\n\r\n  x.s = y.s = 1;\r\n  ygtx = y.cmp(x) == 1;\r\n  x.s = a;\r\n  y.s = b;\r\n\r\n  if (ygtx) return new Big(x);\r\n\r\n  a = Big.DP;\r\n  b = Big.RM;\r\n  Big.DP = Big.RM = 0;\r\n  x = x.div(y);\r\n  Big.DP = a;\r\n  Big.RM = b;\r\n\r\n  return this.minus(x.times(y));\r\n};\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the value of this Big negated.\r\n */\r\nP.neg = function () {\r\n  var x = new this.constructor(this);\r\n  x.s = -x.s;\r\n  return x;\r\n};\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the value of this Big plus the value of Big y.\r\n */\r\nP.plus = P.add = function (y) {\r\n  var e, k, t,\r\n    x = this,\r\n    Big = x.constructor;\r\n\r\n  y = new Big(y);\r\n\r\n  // Signs differ?\r\n  if (x.s != y.s) {\r\n    y.s = -y.s;\r\n    return x.minus(y);\r\n  }\r\n\r\n  var xe = x.e,\r\n    xc = x.c,\r\n    ye = y.e,\r\n    yc = y.c;\r\n\r\n  // Either zero?\r\n  if (!xc[0] || !yc[0]) {\r\n    if (!yc[0]) {\r\n      if (xc[0]) {\r\n        y = new Big(x);\r\n      } else {\r\n        y.s = x.s;\r\n      }\r\n    }\r\n    return y;\r\n  }\r\n\r\n  xc = xc.slice();\r\n\r\n  // Prepend zeros to equalise exponents.\r\n  // Note: reverse faster than unshifts.\r\n  if (e = xe - ye) {\r\n    if (e > 0) {\r\n      ye = xe;\r\n      t = yc;\r\n    } else {\r\n      e = -e;\r\n      t = xc;\r\n    }\r\n\r\n    t.reverse();\r\n    for (; e--;) t.push(0);\r\n    t.reverse();\r\n  }\r\n\r\n  // Point xc to the longer array.\r\n  if (xc.length - yc.length < 0) {\r\n    t = yc;\r\n    yc = xc;\r\n    xc = t;\r\n  }\r\n\r\n  e = yc.length;\r\n\r\n  // Only start adding at yc.length - 1 as the further digits of xc can be left as they are.\r\n  for (k = 0; e; xc[e] %= 10) k = (xc[--e] = xc[e] + yc[e] + k) / 10 | 0;\r\n\r\n  // No need to check for zero, as +x + +y != 0 && -x + -y != 0\r\n\r\n  if (k) {\r\n    xc.unshift(k);\r\n    ++ye;\r\n  }\r\n\r\n  // Remove trailing zeros.\r\n  for (e = xc.length; xc[--e] === 0;) xc.pop();\r\n\r\n  y.c = xc;\r\n  y.e = ye;\r\n\r\n  return y;\r\n};\r\n\r\n\r\n/*\r\n * Return a Big whose value is the value of this Big raised to the power n.\r\n * If n is negative, round to a maximum of Big.DP decimal places using rounding\r\n * mode Big.RM.\r\n *\r\n * n {number} Integer, -MAX_POWER to MAX_POWER inclusive.\r\n */\r\nP.pow = function (n) {\r\n  var x = this,\r\n    one = new x.constructor('1'),\r\n    y = one,\r\n    isneg = n < 0;\r\n\r\n  if (n !== ~~n || n < -MAX_POWER || n > MAX_POWER) {\r\n    throw Error(INVALID + 'exponent');\r\n  }\r\n\r\n  if (isneg) n = -n;\r\n\r\n  for (;;) {\r\n    if (n & 1) y = y.times(x);\r\n    n >>= 1;\r\n    if (!n) break;\r\n    x = x.times(x);\r\n  }\r\n\r\n  return isneg ? one.div(y) : y;\r\n};\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the value of this Big rounded to a maximum precision of sd\r\n * significant digits using rounding mode rm, or Big.RM if rm is not specified.\r\n *\r\n * sd {number} Significant digits: integer, 1 to MAX_DP inclusive.\r\n * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\r\n */\r\nP.prec = function (sd, rm) {\r\n  if (sd !== ~~sd || sd < 1 || sd > MAX_DP) {\r\n    throw Error(INVALID + 'precision');\r\n  }\r\n  return round(new this.constructor(this), sd, rm);\r\n};\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the value of this Big rounded to a maximum of dp decimal places\r\n * using rounding mode rm, or Big.RM if rm is not specified.\r\n * If dp is negative, round to an integer which is a multiple of 10**-dp.\r\n * If dp is not specified, round to 0 decimal places.\r\n *\r\n * dp? {number} Integer, -MAX_DP to MAX_DP inclusive.\r\n * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\r\n */\r\nP.round = function (dp, rm) {\r\n  if (dp === UNDEFINED) dp = 0;\r\n  else if (dp !== ~~dp || dp < -MAX_DP || dp > MAX_DP) {\r\n    throw Error(INVALID_DP);\r\n  }\r\n  return round(new this.constructor(this), dp + this.e + 1, rm);\r\n};\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the square root of the value of this Big, rounded, if\r\n * necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.\r\n */\r\nP.sqrt = function () {\r\n  var r, c, t,\r\n    x = this,\r\n    Big = x.constructor,\r\n    s = x.s,\r\n    e = x.e,\r\n    half = new Big('0.5');\r\n\r\n  // Zero?\r\n  if (!x.c[0]) return new Big(x);\r\n\r\n  // Negative?\r\n  if (s < 0) {\r\n    throw Error(NAME + 'No square root');\r\n  }\r\n\r\n  // Estimate.\r\n  s = Math.sqrt(+stringify(x, true, true));\r\n\r\n  // Math.sqrt underflow/overflow?\r\n  // Re-estimate: pass x coefficient to Math.sqrt as integer, then adjust the result exponent.\r\n  if (s === 0 || s === 1 / 0) {\r\n    c = x.c.join('');\r\n    if (!(c.length + e & 1)) c += '0';\r\n    s = Math.sqrt(c);\r\n    e = ((e + 1) / 2 | 0) - (e < 0 || e & 1);\r\n    r = new Big((s == 1 / 0 ? '5e' : (s = s.toExponential()).slice(0, s.indexOf('e') + 1)) + e);\r\n  } else {\r\n    r = new Big(s + '');\r\n  }\r\n\r\n  e = r.e + (Big.DP += 4);\r\n\r\n  // Newton-Raphson iteration.\r\n  do {\r\n    t = r;\r\n    r = half.times(t.plus(x.div(t)));\r\n  } while (t.c.slice(0, e).join('') !== r.c.slice(0, e).join(''));\r\n\r\n  return round(r, (Big.DP -= 4) + r.e + 1, Big.RM);\r\n};\r\n\r\n\r\n/*\r\n * Return a new Big whose value is the value of this Big times the value of Big y.\r\n */\r\nP.times = P.mul = function (y) {\r\n  var c,\r\n    x = this,\r\n    Big = x.constructor,\r\n    xc = x.c,\r\n    yc = (y = new Big(y)).c,\r\n    a = xc.length,\r\n    b = yc.length,\r\n    i = x.e,\r\n    j = y.e;\r\n\r\n  // Determine sign of result.\r\n  y.s = x.s == y.s ? 1 : -1;\r\n\r\n  // Return signed 0 if either 0.\r\n  if (!xc[0] || !yc[0]) {\r\n    y.c = [y.e = 0];\r\n    return y;\r\n  }\r\n\r\n  // Initialise exponent of result as x.e + y.e.\r\n  y.e = i + j;\r\n\r\n  // If array xc has fewer digits than yc, swap xc and yc, and lengths.\r\n  if (a < b) {\r\n    c = xc;\r\n    xc = yc;\r\n    yc = c;\r\n    j = a;\r\n    a = b;\r\n    b = j;\r\n  }\r\n\r\n  // Initialise coefficient array of result with zeros.\r\n  for (c = new Array(j = a + b); j--;) c[j] = 0;\r\n\r\n  // Multiply.\r\n\r\n  // i is initially xc.length.\r\n  for (i = b; i--;) {\r\n    b = 0;\r\n\r\n    // a is yc.length.\r\n    for (j = a + i; j > i;) {\r\n\r\n      // Current sum of products at this digit position, plus carry.\r\n      b = c[j] + yc[i] * xc[j - i - 1] + b;\r\n      c[j--] = b % 10;\r\n\r\n      // carry\r\n      b = b / 10 | 0;\r\n    }\r\n\r\n    c[j] = b;\r\n  }\r\n\r\n  // Increment result exponent if there is a final carry, otherwise remove leading zero.\r\n  if (b) ++y.e;\r\n  else c.shift();\r\n\r\n  // Remove trailing zeros.\r\n  for (i = c.length; !c[--i];) c.pop();\r\n  y.c = c;\r\n\r\n  return y;\r\n};\r\n\r\n\r\n/*\r\n * Return a string representing the value of this Big in exponential notation rounded to dp fixed\r\n * decimal places using rounding mode rm, or Big.RM if rm is not specified.\r\n *\r\n * dp? {number} Decimal places: integer, 0 to MAX_DP inclusive.\r\n * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\r\n */\r\nP.toExponential = function (dp, rm) {\r\n  var x = this,\r\n    n = x.c[0];\r\n\r\n  if (dp !== UNDEFINED) {\r\n    if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {\r\n      throw Error(INVALID_DP);\r\n    }\r\n    x = round(new x.constructor(x), ++dp, rm);\r\n    for (; x.c.length < dp;) x.c.push(0);\r\n  }\r\n\r\n  return stringify(x, true, !!n);\r\n};\r\n\r\n\r\n/*\r\n * Return a string representing the value of this Big in normal notation rounded to dp fixed\r\n * decimal places using rounding mode rm, or Big.RM if rm is not specified.\r\n *\r\n * dp? {number} Decimal places: integer, 0 to MAX_DP inclusive.\r\n * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\r\n *\r\n * (-0).toFixed(0) is '0', but (-0.1).toFixed(0) is '-0'.\r\n * (-0).toFixed(1) is '0.0', but (-0.01).toFixed(1) is '-0.0'.\r\n */\r\nP.toFixed = function (dp, rm) {\r\n  var x = this,\r\n    n = x.c[0];\r\n\r\n  if (dp !== UNDEFINED) {\r\n    if (dp !== ~~dp || dp < 0 || dp > MAX_DP) {\r\n      throw Error(INVALID_DP);\r\n    }\r\n    x = round(new x.constructor(x), dp + x.e + 1, rm);\r\n\r\n    // x.e may have changed if the value is rounded up.\r\n    for (dp = dp + x.e + 1; x.c.length < dp;) x.c.push(0);\r\n  }\r\n\r\n  return stringify(x, false, !!n);\r\n};\r\n\r\n\r\n/*\r\n * Return a string representing the value of this Big.\r\n * Return exponential notation if this Big has a positive exponent equal to or greater than\r\n * Big.PE, or a negative exponent equal to or less than Big.NE.\r\n * Omit the sign for negative zero.\r\n */\r\nP[Symbol.for('nodejs.util.inspect.custom')] = P.toJSON = P.toString = function () {\r\n  var x = this,\r\n    Big = x.constructor;\r\n  return stringify(x, x.e <= Big.NE || x.e >= Big.PE, !!x.c[0]);\r\n};\r\n\r\n\r\n/*\r\n * Return the value of this Big as a primitve number.\r\n */\r\nP.toNumber = function () {\r\n  var n = +stringify(this, true, true);\r\n  if (this.constructor.strict === true && !this.eq(n.toString())) {\r\n    throw Error(NAME + 'Imprecise conversion');\r\n  }\r\n  return n;\r\n};\r\n\r\n\r\n/*\r\n * Return a string representing the value of this Big rounded to sd significant digits using\r\n * rounding mode rm, or Big.RM if rm is not specified.\r\n * Use exponential notation if sd is less than the number of digits necessary to represent\r\n * the integer part of the value in normal notation.\r\n *\r\n * sd {number} Significant digits: integer, 1 to MAX_DP inclusive.\r\n * rm? {number} Rounding mode: 0 (down), 1 (half-up), 2 (half-even) or 3 (up).\r\n */\r\nP.toPrecision = function (sd, rm) {\r\n  var x = this,\r\n    Big = x.constructor,\r\n    n = x.c[0];\r\n\r\n  if (sd !== UNDEFINED) {\r\n    if (sd !== ~~sd || sd < 1 || sd > MAX_DP) {\r\n      throw Error(INVALID + 'precision');\r\n    }\r\n    x = round(new Big(x), sd, rm);\r\n    for (; x.c.length < sd;) x.c.push(0);\r\n  }\r\n\r\n  return stringify(x, sd <= x.e || x.e <= Big.NE || x.e >= Big.PE, !!n);\r\n};\r\n\r\n\r\n/*\r\n * Return a string representing the value of this Big.\r\n * Return exponential notation if this Big has a positive exponent equal to or greater than\r\n * Big.PE, or a negative exponent equal to or less than Big.NE.\r\n * Include the sign for negative zero.\r\n */\r\nP.valueOf = function () {\r\n  var x = this,\r\n    Big = x.constructor;\r\n  if (Big.strict === true) {\r\n    throw Error(NAME + 'valueOf disallowed');\r\n  }\r\n  return stringify(x, x.e <= Big.NE || x.e >= Big.PE, true);\r\n};\r\n\r\n\r\n// Export\r\n\r\n\r\nexport var Big = _Big_();\r\n\r\n/// <reference types=\"https://raw.githubusercontent.com/DefinitelyTyped/DefinitelyTyped/master/types/big.js/index.d.ts\" />\r\nexport default Big;\r\n","export * from \"./crypto.js\";\nexport * from \"./transaction.js\";\nexport * from \"./misc.js\";\nexport * from \"./storage.js\";\n\nimport { serialize, deserialize } from \"borsh\";\nimport * as borshSchema from \"@fastnear/borsh-schema\";\n\n// exports (or re-exports as well)\nconst exp = {\n  borsh: {\n    serialize,\n    deserialize\n  },\n  borshSchema,\n}\n\nexport { exp }\n","/**\n * Internal assertion helpers.\n * @module\n */\n\n/** Asserts something is positive integer. */\nfunction anumber(n: number): void {\n  if (!Number.isSafeInteger(n) || n < 0) throw new Error('positive integer expected, got ' + n);\n}\n\n/** Is number an Uint8Array? Copied from utils for perf. */\nfunction isBytes(a: unknown): a is Uint8Array {\n  return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');\n}\n\n/** Asserts something is Uint8Array. */\nfunction abytes(b: Uint8Array | undefined, ...lengths: number[]): void {\n  if (!isBytes(b)) throw new Error('Uint8Array expected');\n  if (lengths.length > 0 && !lengths.includes(b.length))\n    throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);\n}\n\n/** Hash interface. */\nexport type Hash = {\n  (data: Uint8Array): Uint8Array;\n  blockLen: number;\n  outputLen: number;\n  create: any;\n};\n\n/** Asserts something is hash */\nfunction ahash(h: Hash): void {\n  if (typeof h !== 'function' || typeof h.create !== 'function')\n    throw new Error('Hash should be wrapped by utils.wrapConstructor');\n  anumber(h.outputLen);\n  anumber(h.blockLen);\n}\n\n/** Asserts a hash instance has not been destroyed / finished */\nfunction aexists(instance: any, checkFinished = true): void {\n  if (instance.destroyed) throw new Error('Hash instance has been destroyed');\n  if (checkFinished && instance.finished) throw new Error('Hash#digest() has already been called');\n}\n\n/** Asserts output is properly-sized byte array */\nfunction aoutput(out: any, instance: any): void {\n  abytes(out);\n  const min = instance.outputLen;\n  if (out.length < min) {\n    throw new Error('digestInto() expects output buffer of length at least ' + min);\n  }\n}\n\nexport { anumber, abytes, ahash, aexists, aoutput };\n","/**\n * Internal webcrypto alias.\n * We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.\n * See utils.ts for details.\n * @module\n */\ndeclare const globalThis: Record<string, any> | undefined;\nexport const crypto: any =\n  typeof globalThis === 'object' && 'crypto' in globalThis ? globalThis.crypto : undefined;\n","/**\n * Utilities for hex, bytes, CSPRNG.\n * @module\n */\n/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n\n// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.\n// node.js versions earlier than v19 don't declare it in global scope.\n// For node.js, package.json#exports field mapping rewrites import\n// from `crypto` to `cryptoNode`, which imports native module.\n// Makes the utils un-importable in browsers without a bundler.\n// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.\nimport { crypto } from '@noble/hashes/crypto';\nimport { abytes } from './_assert.js';\n// export { isBytes } from './_assert.js';\n// We can't reuse isBytes from _assert, because somehow this causes huge perf issues\nexport function isBytes(a: unknown): a is Uint8Array {\n  return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');\n}\n\n// prettier-ignore\nexport type TypedArray = Int8Array | Uint8ClampedArray | Uint8Array |\n  Uint16Array | Int16Array | Uint32Array | Int32Array;\n\n// Cast array to different type\nexport function u8(arr: TypedArray): Uint8Array {\n  return new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);\n}\nexport function u32(arr: TypedArray): Uint32Array {\n  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));\n}\n\n// Cast array to view\nexport function createView(arr: TypedArray): DataView {\n  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\n}\n\n/** The rotate right (circular right shift) operation for uint32 */\nexport function rotr(word: number, shift: number): number {\n  return (word << (32 - shift)) | (word >>> shift);\n}\n/** The rotate left (circular left shift) operation for uint32 */\nexport function rotl(word: number, shift: number): number {\n  return (word << shift) | ((word >>> (32 - shift)) >>> 0);\n}\n\n/** Is current platform little-endian? Most are. Big-Endian platform: IBM */\nexport const isLE: boolean = /* @__PURE__ */ (() =>\n  new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44)();\n// The byte swap operation for uint32\nexport function byteSwap(word: number): number {\n  return (\n    ((word << 24) & 0xff000000) |\n    ((word << 8) & 0xff0000) |\n    ((word >>> 8) & 0xff00) |\n    ((word >>> 24) & 0xff)\n  );\n}\n/** Conditionally byte swap if on a big-endian platform */\nexport const byteSwapIfBE: (n: number) => number = isLE\n  ? (n: number) => n\n  : (n: number) => byteSwap(n);\n\n/** In place byte swap for Uint32Array */\nexport function byteSwap32(arr: Uint32Array): void {\n  for (let i = 0; i < arr.length; i++) {\n    arr[i] = byteSwap(arr[i]);\n  }\n}\n\n// Array where index 0xf0 (240) is mapped to string 'f0'\nconst hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) =>\n  i.toString(16).padStart(2, '0')\n);\n/**\n * Convert byte array to hex string.\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes: Uint8Array): string {\n  abytes(bytes);\n  // pre-caching improves the speed 6x\n  let hex = '';\n  for (let i = 0; i < bytes.length; i++) {\n    hex += hexes[bytes[i]];\n  }\n  return hex;\n}\n\n// We use optimized technique to convert hex string to byte array\nconst asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 } as const;\nfunction asciiToBase16(ch: number): number | undefined {\n  if (ch >= asciis._0 && ch <= asciis._9) return ch - asciis._0; // '2' => 50-48\n  if (ch >= asciis.A && ch <= asciis.F) return ch - (asciis.A - 10); // 'B' => 66-(65-10)\n  if (ch >= asciis.a && ch <= asciis.f) return ch - (asciis.a - 10); // 'b' => 98-(97-10)\n  return;\n}\n\n/**\n * Convert hex string to byte array.\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex: string): Uint8Array {\n  if (typeof hex !== 'string') throw new Error('hex string expected, got ' + typeof hex);\n  const hl = hex.length;\n  const al = hl / 2;\n  if (hl % 2) throw new Error('hex string expected, got unpadded hex of length ' + hl);\n  const array = new Uint8Array(al);\n  for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {\n    const n1 = asciiToBase16(hex.charCodeAt(hi));\n    const n2 = asciiToBase16(hex.charCodeAt(hi + 1));\n    if (n1 === undefined || n2 === undefined) {\n      const char = hex[hi] + hex[hi + 1];\n      throw new Error('hex string expected, got non-hex character \"' + char + '\" at index ' + hi);\n    }\n    array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163\n  }\n  return array;\n}\n\n/**\n * There is no setImmediate in browser and setTimeout is slow.\n * Call of async fn will return Promise, which will be fullfiled only on\n * next scheduler queue processing step and this is exactly what we need.\n */\nexport const nextTick = async (): Promise<void> => {};\n\n/** Returns control to thread each 'tick' ms to avoid blocking. */\nexport async function asyncLoop(\n  iters: number,\n  tick: number,\n  cb: (i: number) => void\n): Promise<void> {\n  let ts = Date.now();\n  for (let i = 0; i < iters; i++) {\n    cb(i);\n    // Date.now() is not monotonic, so in case if clock goes backwards we return return control too\n    const diff = Date.now() - ts;\n    if (diff >= 0 && diff < tick) continue;\n    await nextTick();\n    ts += diff;\n  }\n}\n\n// Global symbols in both browsers and Node.js since v11\n// See https://github.com/microsoft/TypeScript/issues/31535\ndeclare const TextEncoder: any;\n\n/**\n * Convert JS string to byte array.\n * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])\n */\nexport function utf8ToBytes(str: string): Uint8Array {\n  if (typeof str !== 'string') throw new Error('utf8ToBytes expected string, got ' + typeof str);\n  return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n\n/** Accepted input of hash functions. Strings are converted to byte arrays. */\nexport type Input = Uint8Array | string;\n/**\n * Normalizes (non-hex) string or Uint8Array to Uint8Array.\n * Warning: when Uint8Array is passed, it would NOT get copied.\n * Keep in mind for future mutable operations.\n */\nexport function toBytes(data: Input): Uint8Array {\n  if (typeof data === 'string') data = utf8ToBytes(data);\n  abytes(data);\n  return data;\n}\n\n/**\n * Copies several Uint8Arrays into one.\n */\nexport function concatBytes(...arrays: Uint8Array[]): Uint8Array {\n  let sum = 0;\n  for (let i = 0; i < arrays.length; i++) {\n    const a = arrays[i];\n    abytes(a);\n    sum += a.length;\n  }\n  const res = new Uint8Array(sum);\n  for (let i = 0, pad = 0; i < arrays.length; i++) {\n    const a = arrays[i];\n    res.set(a, pad);\n    pad += a.length;\n  }\n  return res;\n}\n\n/** For runtime check if class implements interface */\nexport abstract class Hash<T extends Hash<T>> {\n  abstract blockLen: number; // Bytes per block\n  abstract outputLen: number; // Bytes in output\n  abstract update(buf: Input): this;\n  // Writes digest into buf\n  abstract digestInto(buf: Uint8Array): void;\n  abstract digest(): Uint8Array;\n  /**\n   * Resets internal state. Makes Hash instance unusable.\n   * Reset is impossible for keyed hashes if key is consumed into state. If digest is not consumed\n   * by user, they will need to manually call `destroy()` when zeroing is necessary.\n   */\n  abstract destroy(): void;\n  /**\n   * Clones hash instance. Unsafe: doesn't check whether `to` is valid. Can be used as `clone()`\n   * when no options are passed.\n   * Reasons to use `_cloneInto` instead of clone: 1) performance 2) reuse instance => all internal\n   * buffers are overwritten => causes buffer overwrite which is used for digest in some cases.\n   * There are no guarantees for clean-up because it's impossible in JS.\n   */\n  abstract _cloneInto(to?: T): T;\n  // Safe version that clones internal state\n  clone(): T {\n    return this._cloneInto();\n  }\n}\n\n/**\n * XOF: streaming API to read digest in chunks.\n * Same as 'squeeze' in keccak/k12 and 'seek' in blake3, but more generic name.\n * When hash used in XOF mode it is up to user to call '.destroy' afterwards, since we cannot\n * destroy state, next call can require more bytes.\n */\nexport type HashXOF<T extends Hash<T>> = Hash<T> & {\n  xof(bytes: number): Uint8Array; // Read 'bytes' bytes from digest stream\n  xofInto(buf: Uint8Array): Uint8Array; // read buf.length bytes from digest stream into buf\n};\n\ntype EmptyObj = {};\nexport function checkOpts<T1 extends EmptyObj, T2 extends EmptyObj>(\n  defaults: T1,\n  opts?: T2\n): T1 & T2 {\n  if (opts !== undefined && {}.toString.call(opts) !== '[object Object]')\n    throw new Error('Options should be object or undefined');\n  const merged = Object.assign(defaults, opts);\n  return merged as T1 & T2;\n}\n\n/** Hash function */\nexport type CHash = ReturnType<typeof wrapConstructor>;\n/** Hash function with output */\nexport type CHashO = ReturnType<typeof wrapConstructorWithOpts>;\n/** XOF with output */\nexport type CHashXO = ReturnType<typeof wrapXOFConstructorWithOpts>;\n\n/** Wraps hash function, creating an interface on top of it */\nexport function wrapConstructor<T extends Hash<T>>(\n  hashCons: () => Hash<T>\n): {\n  (msg: Input): Uint8Array;\n  outputLen: number;\n  blockLen: number;\n  create(): Hash<T>;\n} {\n  const hashC = (msg: Input): Uint8Array => hashCons().update(toBytes(msg)).digest();\n  const tmp = hashCons();\n  hashC.outputLen = tmp.outputLen;\n  hashC.blockLen = tmp.blockLen;\n  hashC.create = () => hashCons();\n  return hashC;\n}\n\nexport function wrapConstructorWithOpts<H extends Hash<H>, T extends Object>(\n  hashCons: (opts?: T) => Hash<H>\n): {\n  (msg: Input, opts?: T): Uint8Array;\n  outputLen: number;\n  blockLen: number;\n  create(opts: T): Hash<H>;\n} {\n  const hashC = (msg: Input, opts?: T): Uint8Array => hashCons(opts).update(toBytes(msg)).digest();\n  const tmp = hashCons({} as T);\n  hashC.outputLen = tmp.outputLen;\n  hashC.blockLen = tmp.blockLen;\n  hashC.create = (opts: T) => hashCons(opts);\n  return hashC;\n}\n\nexport function wrapXOFConstructorWithOpts<H extends HashXOF<H>, T extends Object>(\n  hashCons: (opts?: T) => HashXOF<H>\n): {\n  (msg: Input, opts?: T): Uint8Array;\n  outputLen: number;\n  blockLen: number;\n  create(opts: T): HashXOF<H>;\n} {\n  const hashC = (msg: Input, opts?: T): Uint8Array => hashCons(opts).update(toBytes(msg)).digest();\n  const tmp = hashCons({} as T);\n  hashC.outputLen = tmp.outputLen;\n  hashC.blockLen = tmp.blockLen;\n  hashC.create = (opts: T) => hashCons(opts);\n  return hashC;\n}\n\n/** Cryptographically secure PRNG. Uses internal OS-level `crypto.getRandomValues`. */\nexport function randomBytes(bytesLength = 32): Uint8Array {\n  if (crypto && typeof crypto.getRandomValues === 'function') {\n    return crypto.getRandomValues(new Uint8Array(bytesLength));\n  }\n  // Legacy Node.js compatibility\n  if (crypto && typeof crypto.randomBytes === 'function') {\n    return crypto.randomBytes(bytesLength);\n  }\n  throw new Error('crypto.getRandomValues must be defined');\n}\n","/**\n * Internal Merkle-Damgard hash utils.\n * @module\n */\nimport { aexists, aoutput } from './_assert.js';\nimport { type Input, Hash, createView, toBytes } from './utils.js';\n\n/** Polyfill for Safari 14. https://caniuse.com/mdn-javascript_builtins_dataview_setbiguint64 */\nexport function setBigUint64(\n  view: DataView,\n  byteOffset: number,\n  value: bigint,\n  isLE: boolean\n): void {\n  if (typeof view.setBigUint64 === 'function') return view.setBigUint64(byteOffset, value, isLE);\n  const _32n = BigInt(32);\n  const _u32_max = BigInt(0xffffffff);\n  const wh = Number((value >> _32n) & _u32_max);\n  const wl = Number(value & _u32_max);\n  const h = isLE ? 4 : 0;\n  const l = isLE ? 0 : 4;\n  view.setUint32(byteOffset + h, wh, isLE);\n  view.setUint32(byteOffset + l, wl, isLE);\n}\n\n/** Choice: a ? b : c */\nexport function Chi(a: number, b: number, c: number): number {\n  return (a & b) ^ (~a & c);\n}\n\n/** Majority function, true if any two inputs is true. */\nexport function Maj(a: number, b: number, c: number): number {\n  return (a & b) ^ (a & c) ^ (b & c);\n}\n\n/**\n * Merkle-Damgard hash construction base class.\n * Could be used to create MD5, RIPEMD, SHA1, SHA2.\n */\nexport abstract class HashMD<T extends HashMD<T>> extends Hash<T> {\n  protected abstract process(buf: DataView, offset: number): void;\n  protected abstract get(): number[];\n  protected abstract set(...args: number[]): void;\n  abstract destroy(): void;\n  protected abstract roundClean(): void;\n  // For partial updates less than block size\n  protected buffer: Uint8Array;\n  protected view: DataView;\n  protected finished = false;\n  protected length = 0;\n  protected pos = 0;\n  protected destroyed = false;\n\n  constructor(\n    readonly blockLen: number,\n    public outputLen: number,\n    readonly padOffset: number,\n    readonly isLE: boolean\n  ) {\n    super();\n    this.buffer = new Uint8Array(blockLen);\n    this.view = createView(this.buffer);\n  }\n  update(data: Input): this {\n    aexists(this);\n    const { view, buffer, blockLen } = this;\n    data = toBytes(data);\n    const len = data.length;\n    for (let pos = 0; pos < len; ) {\n      const take = Math.min(blockLen - this.pos, len - pos);\n      // Fast path: we have at least one block in input, cast it to view and process\n      if (take === blockLen) {\n        const dataView = createView(data);\n        for (; blockLen <= len - pos; pos += blockLen) this.process(dataView, pos);\n        continue;\n      }\n      buffer.set(data.subarray(pos, pos + take), this.pos);\n      this.pos += take;\n      pos += take;\n      if (this.pos === blockLen) {\n        this.process(view, 0);\n        this.pos = 0;\n      }\n    }\n    this.length += data.length;\n    this.roundClean();\n    return this;\n  }\n  digestInto(out: Uint8Array): void {\n    aexists(this);\n    aoutput(out, this);\n    this.finished = true;\n    // Padding\n    // We can avoid allocation of buffer for padding completely if it\n    // was previously not allocated here. But it won't change performance.\n    const { buffer, view, blockLen, isLE } = this;\n    let { pos } = this;\n    // append the bit '1' to the message\n    buffer[pos++] = 0b10000000;\n    this.buffer.subarray(pos).fill(0);\n    // we have less than padOffset left in buffer, so we cannot put length in\n    // current block, need process it and pad again\n    if (this.padOffset > blockLen - pos) {\n      this.process(view, 0);\n      pos = 0;\n    }\n    // Pad until full block byte with zeros\n    for (let i = pos; i < blockLen; i++) buffer[i] = 0;\n    // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that\n    // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.\n    // So we just write lowest 64 bits of that value.\n    setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);\n    this.process(view, 0);\n    const oview = createView(out);\n    const len = this.outputLen;\n    // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT\n    if (len % 4) throw new Error('_sha2: outputLen should be aligned to 32bit');\n    const outLen = len / 4;\n    const state = this.get();\n    if (outLen > state.length) throw new Error('_sha2: outputLen bigger than state');\n    for (let i = 0; i < outLen; i++) oview.setUint32(4 * i, state[i], isLE);\n  }\n  digest(): Uint8Array {\n    const { buffer, outputLen } = this;\n    this.digestInto(buffer);\n    const res = buffer.slice(0, outputLen);\n    this.destroy();\n    return res;\n  }\n  _cloneInto(to?: T): T {\n    to ||= new (this.constructor as any)() as T;\n    to.set(...this.get());\n    const { blockLen, buffer, length, finished, destroyed, pos } = this;\n    to.length = length;\n    to.pos = pos;\n    to.finished = finished;\n    to.destroyed = destroyed;\n    if (length % blockLen) to.buffer.set(buffer);\n    return to;\n  }\n}\n","/**\n * Internal helpers for u64. BigUint64Array is too slow as per 2025, so we implement it using Uint32Array.\n * @todo re-check https://issues.chromium.org/issues/42212588\n * @module\n */\nconst U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);\nconst _32n = /* @__PURE__ */ BigInt(32);\n\nfunction fromBig(\n  n: bigint,\n  le = false\n): {\n  h: number;\n  l: number;\n} {\n  if (le) return { h: Number(n & U32_MASK64), l: Number((n >> _32n) & U32_MASK64) };\n  return { h: Number((n >> _32n) & U32_MASK64) | 0, l: Number(n & U32_MASK64) | 0 };\n}\n\nfunction split(lst: bigint[], le = false): Uint32Array[] {\n  let Ah = new Uint32Array(lst.length);\n  let Al = new Uint32Array(lst.length);\n  for (let i = 0; i < lst.length; i++) {\n    const { h, l } = fromBig(lst[i], le);\n    [Ah[i], Al[i]] = [h, l];\n  }\n  return [Ah, Al];\n}\n\nconst toBig = (h: number, l: number): bigint => (BigInt(h >>> 0) << _32n) | BigInt(l >>> 0);\n// for Shift in [0, 32)\nconst shrSH = (h: number, _l: number, s: number): number => h >>> s;\nconst shrSL = (h: number, l: number, s: number): number => (h << (32 - s)) | (l >>> s);\n// Right rotate for Shift in [1, 32)\nconst rotrSH = (h: number, l: number, s: number): number => (h >>> s) | (l << (32 - s));\nconst rotrSL = (h: number, l: number, s: number): number => (h << (32 - s)) | (l >>> s);\n// Right rotate for Shift in (32, 64), NOTE: 32 is special case.\nconst rotrBH = (h: number, l: number, s: number): number => (h << (64 - s)) | (l >>> (s - 32));\nconst rotrBL = (h: number, l: number, s: number): number => (h >>> (s - 32)) | (l << (64 - s));\n// Right rotate for shift===32 (just swaps l&h)\nconst rotr32H = (_h: number, l: number): number => l;\nconst rotr32L = (h: number, _l: number): number => h;\n// Left rotate for Shift in [1, 32)\nconst rotlSH = (h: number, l: number, s: number): number => (h << s) | (l >>> (32 - s));\nconst rotlSL = (h: number, l: number, s: number): number => (l << s) | (h >>> (32 - s));\n// Left rotate for Shift in (32, 64), NOTE: 32 is special case.\nconst rotlBH = (h: number, l: number, s: number): number => (l << (s - 32)) | (h >>> (64 - s));\nconst rotlBL = (h: number, l: number, s: number): number => (h << (s - 32)) | (l >>> (64 - s));\n\n// JS uses 32-bit signed integers for bitwise operations which means we cannot\n// simple take carry out of low bit sum by shift, we need to use division.\nfunction add(\n  Ah: number,\n  Al: number,\n  Bh: number,\n  Bl: number\n): {\n  h: number;\n  l: number;\n} {\n  const l = (Al >>> 0) + (Bl >>> 0);\n  return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };\n}\n// Addition with more than 2 elements\nconst add3L = (Al: number, Bl: number, Cl: number): number => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);\nconst add3H = (low: number, Ah: number, Bh: number, Ch: number): number =>\n  (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;\nconst add4L = (Al: number, Bl: number, Cl: number, Dl: number): number =>\n  (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);\nconst add4H = (low: number, Ah: number, Bh: number, Ch: number, Dh: number): number =>\n  (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;\nconst add5L = (Al: number, Bl: number, Cl: number, Dl: number, El: number): number =>\n  (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);\nconst add5H = (low: number, Ah: number, Bh: number, Ch: number, Dh: number, Eh: number): number =>\n  (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;\n\n// prettier-ignore\nexport {\n  fromBig, split, toBig,\n  shrSH, shrSL,\n  rotrSH, rotrSL, rotrBH, rotrBL,\n  rotr32H, rotr32L,\n  rotlSH, rotlSL, rotlBH, rotlBL,\n  add, add3L, add3H, add4L, add4H, add5H, add5L,\n};\n// prettier-ignore\nconst u64: { fromBig: typeof fromBig; split: typeof split; toBig: (h: number, l: number) => bigint; shrSH: (h: number, _l: number, s: number) => number; shrSL: (h: number, l: number, s: number) => number; rotrSH: (h: number, l: number, s: number) => number; rotrSL: (h: number, l: number, s: number) => number; rotrBH: (h: number, l: number, s: number) => number; rotrBL: (h: number, l: number, s: number) => number; rotr32H: (_h: number, l: number) => number; rotr32L: (h: number, _l: number) => number; rotlSH: (h: number, l: number, s: number) => number; rotlSL: (h: number, l: number, s: number) => number; rotlBH: (h: number, l: number, s: number) => number; rotlBL: (h: number, l: number, s: number) => number; add: typeof add; add3L: (Al: number, Bl: number, Cl: number) => number; add3H: (low: number, Ah: number, Bh: number, Ch: number) => number; add4L: (Al: number, Bl: number, Cl: number, Dl: number) => number; add4H: (low: number, Ah: number, Bh: number, Ch: number, Dh: number) => number; add5H: (low: number, Ah: number, Bh: number, Ch: number, Dh: number, Eh: number) => number; add5L: (Al: number, Bl: number, Cl: number, Dl: number, El: number) => number; } = {\n  fromBig, split, toBig,\n  shrSH, shrSL,\n  rotrSH, rotrSL, rotrBH, rotrBL,\n  rotr32H, rotr32L,\n  rotlSH, rotlSL, rotlBH, rotlBL,\n  add, add3L, add3H, add4L, add4H, add5H, add5L,\n};\nexport default u64;\n","/**\n * SHA2-512 a.k.a. sha512 and sha384. It is slower than sha256 in js because u64 operations are slow.\n *\n * Check out [RFC 4634](https://datatracker.ietf.org/doc/html/rfc4634) and\n * [the paper on truncated SHA512/256](https://eprint.iacr.org/2010/548.pdf).\n * @module\n */\nimport { HashMD } from './_md.js';\nimport u64 from './_u64.js';\nimport { type CHash, wrapConstructor } from './utils.js';\n\n// Round contants (first 32 bits of the fractional parts of the cube roots of the first 80 primes 2..409):\n// prettier-ignore\nconst [SHA512_Kh, SHA512_Kl] = /* @__PURE__ */ (() => u64.split([\n  '0x428a2f98d728ae22', '0x7137449123ef65cd', '0xb5c0fbcfec4d3b2f', '0xe9b5dba58189dbbc',\n  '0x3956c25bf348b538', '0x59f111f1b605d019', '0x923f82a4af194f9b', '0xab1c5ed5da6d8118',\n  '0xd807aa98a3030242', '0x12835b0145706fbe', '0x243185be4ee4b28c', '0x550c7dc3d5ffb4e2',\n  '0x72be5d74f27b896f', '0x80deb1fe3b1696b1', '0x9bdc06a725c71235', '0xc19bf174cf692694',\n  '0xe49b69c19ef14ad2', '0xefbe4786384f25e3', '0x0fc19dc68b8cd5b5', '0x240ca1cc77ac9c65',\n  '0x2de92c6f592b0275', '0x4a7484aa6ea6e483', '0x5cb0a9dcbd41fbd4', '0x76f988da831153b5',\n  '0x983e5152ee66dfab', '0xa831c66d2db43210', '0xb00327c898fb213f', '0xbf597fc7beef0ee4',\n  '0xc6e00bf33da88fc2', '0xd5a79147930aa725', '0x06ca6351e003826f', '0x142929670a0e6e70',\n  '0x27b70a8546d22ffc', '0x2e1b21385c26c926', '0x4d2c6dfc5ac42aed', '0x53380d139d95b3df',\n  '0x650a73548baf63de', '0x766a0abb3c77b2a8', '0x81c2c92e47edaee6', '0x92722c851482353b',\n  '0xa2bfe8a14cf10364', '0xa81a664bbc423001', '0xc24b8b70d0f89791', '0xc76c51a30654be30',\n  '0xd192e819d6ef5218', '0xd69906245565a910', '0xf40e35855771202a', '0x106aa07032bbd1b8',\n  '0x19a4c116b8d2d0c8', '0x1e376c085141ab53', '0x2748774cdf8eeb99', '0x34b0bcb5e19b48a8',\n  '0x391c0cb3c5c95a63', '0x4ed8aa4ae3418acb', '0x5b9cca4f7763e373', '0x682e6ff3d6b2b8a3',\n  '0x748f82ee5defb2fc', '0x78a5636f43172f60', '0x84c87814a1f0ab72', '0x8cc702081a6439ec',\n  '0x90befffa23631e28', '0xa4506cebde82bde9', '0xbef9a3f7b2c67915', '0xc67178f2e372532b',\n  '0xca273eceea26619c', '0xd186b8c721c0c207', '0xeada7dd6cde0eb1e', '0xf57d4f7fee6ed178',\n  '0x06f067aa72176fba', '0x0a637dc5a2c898a6', '0x113f9804bef90dae', '0x1b710b35131c471b',\n  '0x28db77f523047d84', '0x32caab7b40c72493', '0x3c9ebe0a15c9bebc', '0x431d67c49c100d4c',\n  '0x4cc5d4becb3e42b6', '0x597f299cfc657e2a', '0x5fcb6fab3ad6faec', '0x6c44198c4a475817'\n].map(n => BigInt(n))))();\n\n// Temporary buffer, not used to store anything between runs\nconst SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);\nconst SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);\nexport class SHA512 extends HashMD<SHA512> {\n  // We cannot use array here since array allows indexing by variable which means optimizer/compiler cannot use registers.\n  // Also looks cleaner and easier to verify with spec.\n  // Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):\n  // h -- high 32 bits, l -- low 32 bits\n  protected Ah: number = 0x6a09e667 | 0;\n  protected Al: number = 0xf3bcc908 | 0;\n  protected Bh: number = 0xbb67ae85 | 0;\n  protected Bl: number = 0x84caa73b | 0;\n  protected Ch: number = 0x3c6ef372 | 0;\n  protected Cl: number = 0xfe94f82b | 0;\n  protected Dh: number = 0xa54ff53a | 0;\n  protected Dl: number = 0x5f1d36f1 | 0;\n  protected Eh: number = 0x510e527f | 0;\n  protected El: number = 0xade682d1 | 0;\n  protected Fh: number = 0x9b05688c | 0;\n  protected Fl: number = 0x2b3e6c1f | 0;\n  protected Gh: number = 0x1f83d9ab | 0;\n  protected Gl: number = 0xfb41bd6b | 0;\n  protected Hh: number = 0x5be0cd19 | 0;\n  protected Hl: number = 0x137e2179 | 0;\n\n  constructor() {\n    super(128, 64, 16, false);\n  }\n  // prettier-ignore\n  protected get(): [\n    number, number, number, number, number, number, number, number,\n    number, number, number, number, number, number, number, number\n  ] {\n    const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n    return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];\n  }\n  // prettier-ignore\n  protected set(\n    Ah: number, Al: number, Bh: number, Bl: number, Ch: number, Cl: number, Dh: number, Dl: number,\n    Eh: number, El: number, Fh: number, Fl: number, Gh: number, Gl: number, Hh: number, Hl: number\n  ): void {\n    this.Ah = Ah | 0;\n    this.Al = Al | 0;\n    this.Bh = Bh | 0;\n    this.Bl = Bl | 0;\n    this.Ch = Ch | 0;\n    this.Cl = Cl | 0;\n    this.Dh = Dh | 0;\n    this.Dl = Dl | 0;\n    this.Eh = Eh | 0;\n    this.El = El | 0;\n    this.Fh = Fh | 0;\n    this.Fl = Fl | 0;\n    this.Gh = Gh | 0;\n    this.Gl = Gl | 0;\n    this.Hh = Hh | 0;\n    this.Hl = Hl | 0;\n  }\n  protected process(view: DataView, offset: number): void {\n    // Extend the first 16 words into the remaining 64 words w[16..79] of the message schedule array\n    for (let i = 0; i < 16; i++, offset += 4) {\n      SHA512_W_H[i] = view.getUint32(offset);\n      SHA512_W_L[i] = view.getUint32((offset += 4));\n    }\n    for (let i = 16; i < 80; i++) {\n      // s0 := (w[i-15] rightrotate 1) xor (w[i-15] rightrotate 8) xor (w[i-15] rightshift 7)\n      const W15h = SHA512_W_H[i - 15] | 0;\n      const W15l = SHA512_W_L[i - 15] | 0;\n      const s0h = u64.rotrSH(W15h, W15l, 1) ^ u64.rotrSH(W15h, W15l, 8) ^ u64.shrSH(W15h, W15l, 7);\n      const s0l = u64.rotrSL(W15h, W15l, 1) ^ u64.rotrSL(W15h, W15l, 8) ^ u64.shrSL(W15h, W15l, 7);\n      // s1 := (w[i-2] rightrotate 19) xor (w[i-2] rightrotate 61) xor (w[i-2] rightshift 6)\n      const W2h = SHA512_W_H[i - 2] | 0;\n      const W2l = SHA512_W_L[i - 2] | 0;\n      const s1h = u64.rotrSH(W2h, W2l, 19) ^ u64.rotrBH(W2h, W2l, 61) ^ u64.shrSH(W2h, W2l, 6);\n      const s1l = u64.rotrSL(W2h, W2l, 19) ^ u64.rotrBL(W2h, W2l, 61) ^ u64.shrSL(W2h, W2l, 6);\n      // SHA256_W[i] = s0 + s1 + SHA256_W[i - 7] + SHA256_W[i - 16];\n      const SUMl = u64.add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);\n      const SUMh = u64.add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);\n      SHA512_W_H[i] = SUMh | 0;\n      SHA512_W_L[i] = SUMl | 0;\n    }\n    let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;\n    // Compression function main loop, 80 rounds\n    for (let i = 0; i < 80; i++) {\n      // S1 := (e rightrotate 14) xor (e rightrotate 18) xor (e rightrotate 41)\n      const sigma1h = u64.rotrSH(Eh, El, 14) ^ u64.rotrSH(Eh, El, 18) ^ u64.rotrBH(Eh, El, 41);\n      const sigma1l = u64.rotrSL(Eh, El, 14) ^ u64.rotrSL(Eh, El, 18) ^ u64.rotrBL(Eh, El, 41);\n      //const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\n      const CHIh = (Eh & Fh) ^ (~Eh & Gh);\n      const CHIl = (El & Fl) ^ (~El & Gl);\n      // T1 = H + sigma1 + Chi(E, F, G) + SHA512_K[i] + SHA512_W[i]\n      // prettier-ignore\n      const T1ll = u64.add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);\n      const T1h = u64.add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);\n      const T1l = T1ll | 0;\n      // S0 := (a rightrotate 28) xor (a rightrotate 34) xor (a rightrotate 39)\n      const sigma0h = u64.rotrSH(Ah, Al, 28) ^ u64.rotrBH(Ah, Al, 34) ^ u64.rotrBH(Ah, Al, 39);\n      const sigma0l = u64.rotrSL(Ah, Al, 28) ^ u64.rotrBL(Ah, Al, 34) ^ u64.rotrBL(Ah, Al, 39);\n      const MAJh = (Ah & Bh) ^ (Ah & Ch) ^ (Bh & Ch);\n      const MAJl = (Al & Bl) ^ (Al & Cl) ^ (Bl & Cl);\n      Hh = Gh | 0;\n      Hl = Gl | 0;\n      Gh = Fh | 0;\n      Gl = Fl | 0;\n      Fh = Eh | 0;\n      Fl = El | 0;\n      ({ h: Eh, l: El } = u64.add(Dh | 0, Dl | 0, T1h | 0, T1l | 0));\n      Dh = Ch | 0;\n      Dl = Cl | 0;\n      Ch = Bh | 0;\n      Cl = Bl | 0;\n      Bh = Ah | 0;\n      Bl = Al | 0;\n      const All = u64.add3L(T1l, sigma0l, MAJl);\n      Ah = u64.add3H(All, T1h, sigma0h, MAJh);\n      Al = All | 0;\n    }\n    // Add the compressed chunk to the current hash value\n    ({ h: Ah, l: Al } = u64.add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));\n    ({ h: Bh, l: Bl } = u64.add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));\n    ({ h: Ch, l: Cl } = u64.add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));\n    ({ h: Dh, l: Dl } = u64.add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));\n    ({ h: Eh, l: El } = u64.add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));\n    ({ h: Fh, l: Fl } = u64.add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));\n    ({ h: Gh, l: Gl } = u64.add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));\n    ({ h: Hh, l: Hl } = u64.add(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));\n    this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);\n  }\n  protected roundClean(): void {\n    SHA512_W_H.fill(0);\n    SHA512_W_L.fill(0);\n  }\n  destroy(): void {\n    this.buffer.fill(0);\n    this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);\n  }\n}\n\nexport class SHA512_224 extends SHA512 {\n  // h -- high 32 bits, l -- low 32 bits\n  protected Ah: number = 0x8c3d37c8 | 0;\n  protected Al: number = 0x19544da2 | 0;\n  protected Bh: number = 0x73e19966 | 0;\n  protected Bl: number = 0x89dcd4d6 | 0;\n  protected Ch: number = 0x1dfab7ae | 0;\n  protected Cl: number = 0x32ff9c82 | 0;\n  protected Dh: number = 0x679dd514 | 0;\n  protected Dl: number = 0x582f9fcf | 0;\n  protected Eh: number = 0x0f6d2b69 | 0;\n  protected El: number = 0x7bd44da8 | 0;\n  protected Fh: number = 0x77e36f73 | 0;\n  protected Fl: number = 0x04c48942 | 0;\n  protected Gh: number = 0x3f9d85a8 | 0;\n  protected Gl: number = 0x6a1d36c8 | 0;\n  protected Hh: number = 0x1112e6ad | 0;\n  protected Hl: number = 0x91d692a1 | 0;\n\n  constructor() {\n    super();\n    this.outputLen = 28;\n  }\n}\n\nexport class SHA512_256 extends SHA512 {\n  // h -- high 32 bits, l -- low 32 bits\n  protected Ah: number = 0x22312194 | 0;\n  protected Al: number = 0xfc2bf72c | 0;\n  protected Bh: number = 0x9f555fa3 | 0;\n  protected Bl: number = 0xc84c64c2 | 0;\n  protected Ch: number = 0x2393b86b | 0;\n  protected Cl: number = 0x6f53b151 | 0;\n  protected Dh: number = 0x96387719 | 0;\n  protected Dl: number = 0x5940eabd | 0;\n  protected Eh: number = 0x96283ee2 | 0;\n  protected El: number = 0xa88effe3 | 0;\n  protected Fh: number = 0xbe5e1e25 | 0;\n  protected Fl: number = 0x53863992 | 0;\n  protected Gh: number = 0x2b0199fc | 0;\n  protected Gl: number = 0x2c85b8aa | 0;\n  protected Hh: number = 0x0eb72ddc | 0;\n  protected Hl: number = 0x81c52ca2 | 0;\n\n  constructor() {\n    super();\n    this.outputLen = 32;\n  }\n}\n\nexport class SHA384 extends SHA512 {\n  // h -- high 32 bits, l -- low 32 bits\n  protected Ah: number = 0xcbbb9d5d | 0;\n  protected Al: number = 0xc1059ed8 | 0;\n  protected Bh: number = 0x629a292a | 0;\n  protected Bl: number = 0x367cd507 | 0;\n  protected Ch: number = 0x9159015a | 0;\n  protected Cl: number = 0x3070dd17 | 0;\n  protected Dh: number = 0x152fecd8 | 0;\n  protected Dl: number = 0xf70e5939 | 0;\n  protected Eh: number = 0x67332667 | 0;\n  protected El: number = 0xffc00b31 | 0;\n  protected Fh: number = 0x8eb44a87 | 0;\n  protected Fl: number = 0x68581511 | 0;\n  protected Gh: number = 0xdb0c2e0d | 0;\n  protected Gl: number = 0x64f98fa7 | 0;\n  protected Hh: number = 0x47b5481d | 0;\n  protected Hl: number = 0xbefa4fa4 | 0;\n\n  constructor() {\n    super();\n    this.outputLen = 48;\n  }\n}\n\n/** SHA2-512 hash function. */\nexport const sha512: CHash = /* @__PURE__ */ wrapConstructor(() => new SHA512());\n/** SHA2-512/224 \"truncated\" hash function, with improved resistance to length extension attacks. */\nexport const sha512_224: CHash = /* @__PURE__ */ wrapConstructor(() => new SHA512_224());\n/** SHA2-512/256 \"truncated\" hash function, with improved resistance to length extension attacks. */\nexport const sha512_256: CHash = /* @__PURE__ */ wrapConstructor(() => new SHA512_256());\n/** SHA2-384 hash function. */\nexport const sha384: CHash = /* @__PURE__ */ wrapConstructor(() => new SHA384());\n","/**\n * Hex, bytes and number utilities.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n\n// 100 lines of code in the file are duplicated from noble-hashes (utils).\n// This is OK: `abstract` directory does not use noble-hashes.\n// User may opt-in into using different hashing library. This way, noble-hashes\n// won't be included into their bundle.\nconst _0n = /* @__PURE__ */ BigInt(0);\nconst _1n = /* @__PURE__ */ BigInt(1);\nconst _2n = /* @__PURE__ */ BigInt(2);\nexport type Hex = Uint8Array | string; // hex strings are accepted for simplicity\nexport type PrivKey = Hex | bigint; // bigints are accepted to ease learning curve\nexport type CHash = {\n  (message: Uint8Array | string): Uint8Array;\n  blockLen: number;\n  outputLen: number;\n  create(opts?: { dkLen?: number }): any; // For shake\n};\nexport type FHash = (message: Uint8Array | string) => Uint8Array;\n\nexport function isBytes(a: unknown): a is Uint8Array {\n  return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');\n}\n\nexport function abytes(item: unknown): void {\n  if (!isBytes(item)) throw new Error('Uint8Array expected');\n}\n\nexport function abool(title: string, value: boolean): void {\n  if (typeof value !== 'boolean') throw new Error(title + ' boolean expected, got ' + value);\n}\n\n// Array where index 0xf0 (240) is mapped to string 'f0'\nconst hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) =>\n  i.toString(16).padStart(2, '0')\n);\n/**\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes: Uint8Array): string {\n  abytes(bytes);\n  // pre-caching improves the speed 6x\n  let hex = '';\n  for (let i = 0; i < bytes.length; i++) {\n    hex += hexes[bytes[i]];\n  }\n  return hex;\n}\n\nexport function numberToHexUnpadded(num: number | bigint): string {\n  const hex = num.toString(16);\n  return hex.length & 1 ? '0' + hex : hex;\n}\n\nexport function hexToNumber(hex: string): bigint {\n  if (typeof hex !== 'string') throw new Error('hex string expected, got ' + typeof hex);\n  return hex === '' ? _0n : BigInt('0x' + hex); // Big Endian\n}\n\n// We use optimized technique to convert hex string to byte array\nconst asciis = { _0: 48, _9: 57, A: 65, F: 70, a: 97, f: 102 } as const;\nfunction asciiToBase16(ch: number): number | undefined {\n  if (ch >= asciis._0 && ch <= asciis._9) return ch - asciis._0; // '2' => 50-48\n  if (ch >= asciis.A && ch <= asciis.F) return ch - (asciis.A - 10); // 'B' => 66-(65-10)\n  if (ch >= asciis.a && ch <= asciis.f) return ch - (asciis.a - 10); // 'b' => 98-(97-10)\n  return;\n}\n\n/**\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex: string): Uint8Array {\n  if (typeof hex !== 'string') throw new Error('hex string expected, got ' + typeof hex);\n  const hl = hex.length;\n  const al = hl / 2;\n  if (hl % 2) throw new Error('hex string expected, got unpadded hex of length ' + hl);\n  const array = new Uint8Array(al);\n  for (let ai = 0, hi = 0; ai < al; ai++, hi += 2) {\n    const n1 = asciiToBase16(hex.charCodeAt(hi));\n    const n2 = asciiToBase16(hex.charCodeAt(hi + 1));\n    if (n1 === undefined || n2 === undefined) {\n      const char = hex[hi] + hex[hi + 1];\n      throw new Error('hex string expected, got non-hex character \"' + char + '\" at index ' + hi);\n    }\n    array[ai] = n1 * 16 + n2; // multiply first octet, e.g. 'a3' => 10*16+3 => 160 + 3 => 163\n  }\n  return array;\n}\n\n// BE: Big Endian, LE: Little Endian\nexport function bytesToNumberBE(bytes: Uint8Array): bigint {\n  return hexToNumber(bytesToHex(bytes));\n}\nexport function bytesToNumberLE(bytes: Uint8Array): bigint {\n  abytes(bytes);\n  return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));\n}\n\nexport function numberToBytesBE(n: number | bigint, len: number): Uint8Array {\n  return hexToBytes(n.toString(16).padStart(len * 2, '0'));\n}\nexport function numberToBytesLE(n: number | bigint, len: number): Uint8Array {\n  return numberToBytesBE(n, len).reverse();\n}\n// Unpadded, rarely used\nexport function numberToVarBytesBE(n: number | bigint): Uint8Array {\n  return hexToBytes(numberToHexUnpadded(n));\n}\n\n/**\n * Takes hex string or Uint8Array, converts to Uint8Array.\n * Validates output length.\n * Will throw error for other types.\n * @param title descriptive title for an error e.g. 'private key'\n * @param hex hex string or Uint8Array\n * @param expectedLength optional, will compare to result array's length\n * @returns\n */\nexport function ensureBytes(title: string, hex: Hex, expectedLength?: number): Uint8Array {\n  let res: Uint8Array;\n  if (typeof hex === 'string') {\n    try {\n      res = hexToBytes(hex);\n    } catch (e) {\n      throw new Error(title + ' must be hex string or Uint8Array, cause: ' + e);\n    }\n  } else if (isBytes(hex)) {\n    // Uint8Array.from() instead of hash.slice() because node.js Buffer\n    // is instance of Uint8Array, and its slice() creates **mutable** copy\n    res = Uint8Array.from(hex);\n  } else {\n    throw new Error(title + ' must be hex string or Uint8Array');\n  }\n  const len = res.length;\n  if (typeof expectedLength === 'number' && len !== expectedLength)\n    throw new Error(title + ' of length ' + expectedLength + ' expected, got ' + len);\n  return res;\n}\n\n/**\n * Copies several Uint8Arrays into one.\n */\nexport function concatBytes(...arrays: Uint8Array[]): Uint8Array {\n  let sum = 0;\n  for (let i = 0; i < arrays.length; i++) {\n    const a = arrays[i];\n    abytes(a);\n    sum += a.length;\n  }\n  const res = new Uint8Array(sum);\n  for (let i = 0, pad = 0; i < arrays.length; i++) {\n    const a = arrays[i];\n    res.set(a, pad);\n    pad += a.length;\n  }\n  return res;\n}\n\n// Compares 2 u8a-s in kinda constant time\nexport function equalBytes(a: Uint8Array, b: Uint8Array): boolean {\n  if (a.length !== b.length) return false;\n  let diff = 0;\n  for (let i = 0; i < a.length; i++) diff |= a[i] ^ b[i];\n  return diff === 0;\n}\n\n// Global symbols in both browsers and Node.js since v11\n// See https://github.com/microsoft/TypeScript/issues/31535\ndeclare const TextEncoder: any;\n\n/**\n * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])\n */\nexport function utf8ToBytes(str: string): Uint8Array {\n  if (typeof str !== 'string') throw new Error('string expected');\n  return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n\n// Is positive bigint\nconst isPosBig = (n: bigint) => typeof n === 'bigint' && _0n <= n;\n\nexport function inRange(n: bigint, min: bigint, max: bigint): boolean {\n  return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;\n}\n\n/**\n * Asserts min <= n < max. NOTE: It's < max and not <= max.\n * @example\n * aInRange('x', x, 1n, 256n); // would assume x is in (1n..255n)\n */\nexport function aInRange(title: string, n: bigint, min: bigint, max: bigint): void {\n  // Why min <= n < max and not a (min < n < max) OR b (min <= n <= max)?\n  // consider P=256n, min=0n, max=P\n  // - a for min=0 would require -1:          `inRange('x', x, -1n, P)`\n  // - b would commonly require subtraction:  `inRange('x', x, 0n, P - 1n)`\n  // - our way is the cleanest:               `inRange('x', x, 0n, P)\n  if (!inRange(n, min, max))\n    throw new Error('expected valid ' + title + ': ' + min + ' <= n < ' + max + ', got ' + n);\n}\n\n// Bit operations\n\n/**\n * Calculates amount of bits in a bigint.\n * Same as `n.toString(2).length`\n */\nexport function bitLen(n: bigint): number {\n  let len;\n  for (len = 0; n > _0n; n >>= _1n, len += 1);\n  return len;\n}\n\n/**\n * Gets single bit at position.\n * NOTE: first bit position is 0 (same as arrays)\n * Same as `!!+Array.from(n.toString(2)).reverse()[pos]`\n */\nexport function bitGet(n: bigint, pos: number): bigint {\n  return (n >> BigInt(pos)) & _1n;\n}\n\n/**\n * Sets single bit at position.\n */\nexport function bitSet(n: bigint, pos: number, value: boolean): bigint {\n  return n | ((value ? _1n : _0n) << BigInt(pos));\n}\n\n/**\n * Calculate mask for N bits. Not using ** operator with bigints because of old engines.\n * Same as BigInt(`0b${Array(i).fill('1').join('')}`)\n */\nexport const bitMask = (n: number): bigint => (_2n << BigInt(n - 1)) - _1n;\n\n// DRBG\n\nconst u8n = (data?: any) => new Uint8Array(data); // creates Uint8Array\nconst u8fr = (arr: any) => Uint8Array.from(arr); // another shortcut\ntype Pred<T> = (v: Uint8Array) => T | undefined;\n/**\n * Minimal HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n * @returns function that will call DRBG until 2nd arg returns something meaningful\n * @example\n *   const drbg = createHmacDRBG<Key>(32, 32, hmac);\n *   drbg(seed, bytesToKey); // bytesToKey must return Key or undefined\n */\nexport function createHmacDrbg<T>(\n  hashLen: number,\n  qByteLen: number,\n  hmacFn: (key: Uint8Array, ...messages: Uint8Array[]) => Uint8Array\n): (seed: Uint8Array, predicate: Pred<T>) => T {\n  if (typeof hashLen !== 'number' || hashLen < 2) throw new Error('hashLen must be a number');\n  if (typeof qByteLen !== 'number' || qByteLen < 2) throw new Error('qByteLen must be a number');\n  if (typeof hmacFn !== 'function') throw new Error('hmacFn must be a function');\n  // Step B, Step C: set hashLen to 8*ceil(hlen/8)\n  let v = u8n(hashLen); // Minimal non-full-spec HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n  let k = u8n(hashLen); // Steps B and C of RFC6979 3.2: set hashLen, in our case always same\n  let i = 0; // Iterations counter, will throw when over 1000\n  const reset = () => {\n    v.fill(1);\n    k.fill(0);\n    i = 0;\n  };\n  const h = (...b: Uint8Array[]) => hmacFn(k, v, ...b); // hmac(k)(v, ...values)\n  const reseed = (seed = u8n()) => {\n    // HMAC-DRBG reseed() function. Steps D-G\n    k = h(u8fr([0x00]), seed); // k = hmac(k || v || 0x00 || seed)\n    v = h(); // v = hmac(k || v)\n    if (seed.length === 0) return;\n    k = h(u8fr([0x01]), seed); // k = hmac(k || v || 0x01 || seed)\n    v = h(); // v = hmac(k || v)\n  };\n  const gen = () => {\n    // HMAC-DRBG generate() function\n    if (i++ >= 1000) throw new Error('drbg: tried 1000 values');\n    let len = 0;\n    const out: Uint8Array[] = [];\n    while (len < qByteLen) {\n      v = h();\n      const sl = v.slice();\n      out.push(sl);\n      len += v.length;\n    }\n    return concatBytes(...out);\n  };\n  const genUntil = (seed: Uint8Array, pred: Pred<T>): T => {\n    reset();\n    reseed(seed); // Steps D-G\n    let res: T | undefined = undefined; // Step H: grind until k is in [1..n-1]\n    while (!(res = pred(gen()))) reseed();\n    reset();\n    return res;\n  };\n  return genUntil;\n}\n\n// Validating curves and fields\n\nconst validatorFns = {\n  bigint: (val: any): boolean => typeof val === 'bigint',\n  function: (val: any): boolean => typeof val === 'function',\n  boolean: (val: any): boolean => typeof val === 'boolean',\n  string: (val: any): boolean => typeof val === 'string',\n  stringOrUint8Array: (val: any): boolean => typeof val === 'string' || isBytes(val),\n  isSafeInteger: (val: any): boolean => Number.isSafeInteger(val),\n  array: (val: any): boolean => Array.isArray(val),\n  field: (val: any, object: any): any => (object as any).Fp.isValid(val),\n  hash: (val: any): boolean => typeof val === 'function' && Number.isSafeInteger(val.outputLen),\n} as const;\ntype Validator = keyof typeof validatorFns;\ntype ValMap<T extends Record<string, any>> = { [K in keyof T]?: Validator };\n// type Record<K extends string | number | symbol, T> = { [P in K]: T; }\n\nexport function validateObject<T extends Record<string, any>>(\n  object: T,\n  validators: ValMap<T>,\n  optValidators: ValMap<T> = {}\n): T {\n  const checkField = (fieldName: keyof T, type: Validator, isOptional: boolean) => {\n    const checkVal = validatorFns[type];\n    if (typeof checkVal !== 'function') throw new Error('invalid validator function');\n\n    const val = object[fieldName as keyof typeof object];\n    if (isOptional && val === undefined) return;\n    if (!checkVal(val, object)) {\n      throw new Error(\n        'param ' + String(fieldName) + ' is invalid. Expected ' + type + ', got ' + val\n      );\n    }\n  };\n  for (const [fieldName, type] of Object.entries(validators)) checkField(fieldName, type!, false);\n  for (const [fieldName, type] of Object.entries(optValidators)) checkField(fieldName, type!, true);\n  return object;\n}\n// validate type tests\n// const o: { a: number; b: number; c: number } = { a: 1, b: 5, c: 6 };\n// const z0 = validateObject(o, { a: 'isSafeInteger' }, { c: 'bigint' }); // Ok!\n// // Should fail type-check\n// const z1 = validateObject(o, { a: 'tmp' }, { c: 'zz' });\n// const z2 = validateObject(o, { a: 'isSafeInteger' }, { c: 'zz' });\n// const z3 = validateObject(o, { test: 'boolean', z: 'bug' });\n// const z4 = validateObject(o, { a: 'boolean', z: 'bug' });\n\n/**\n * throws not implemented error\n */\nexport const notImplemented = (): never => {\n  throw new Error('not implemented');\n};\n\n/**\n * Memoizes (caches) computation result.\n * Uses WeakMap: the value is going auto-cleaned by GC after last reference is removed.\n */\nexport function memoized<T extends object, R, O extends any[]>(\n  fn: (arg: T, ...args: O) => R\n): (arg: T, ...args: O) => R {\n  const map = new WeakMap<T, R>();\n  return (arg: T, ...args: O): R => {\n    const val = map.get(arg);\n    if (val !== undefined) return val;\n    const computed = fn(arg, ...args);\n    map.set(arg, computed);\n    return computed;\n  };\n}\n","/**\n * Utils for modular division and finite fields.\n * A finite field over 11 is integer number operations `mod 11`.\n * There is no division: it is replaced by modular multiplicative inverse.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport {\n  bitMask,\n  bytesToNumberBE,\n  bytesToNumberLE,\n  ensureBytes,\n  numberToBytesBE,\n  numberToBytesLE,\n  validateObject,\n} from './utils.js';\n\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = /* @__PURE__ */ BigInt(2), _3n = /* @__PURE__ */ BigInt(3);\n// prettier-ignore\nconst _4n = /* @__PURE__ */ BigInt(4), _5n = /* @__PURE__ */ BigInt(5), _8n = /* @__PURE__ */ BigInt(8);\n// prettier-ignore\nconst _9n =/* @__PURE__ */ BigInt(9), _16n = /* @__PURE__ */ BigInt(16);\n\n// Calculates a modulo b\nexport function mod(a: bigint, b: bigint): bigint {\n  const result = a % b;\n  return result >= _0n ? result : b + result;\n}\n/**\n * Efficiently raise num to power and do modular division.\n * Unsafe in some contexts: uses ladder, so can expose bigint bits.\n * @todo use field version && remove\n * @example\n * pow(2n, 6n, 11n) // 64n % 11n == 9n\n */\nexport function pow(num: bigint, power: bigint, modulo: bigint): bigint {\n  if (power < _0n) throw new Error('invalid exponent, negatives unsupported');\n  if (modulo <= _0n) throw new Error('invalid modulus');\n  if (modulo === _1n) return _0n;\n  let res = _1n;\n  while (power > _0n) {\n    if (power & _1n) res = (res * num) % modulo;\n    num = (num * num) % modulo;\n    power >>= _1n;\n  }\n  return res;\n}\n\n/** Does `x^(2^power)` mod p. `pow2(30, 4)` == `30^(2^4)` */\nexport function pow2(x: bigint, power: bigint, modulo: bigint): bigint {\n  let res = x;\n  while (power-- > _0n) {\n    res *= res;\n    res %= modulo;\n  }\n  return res;\n}\n\n/**\n * Inverses number over modulo.\n * Implemented using [Euclidean GCD](https://brilliant.org/wiki/extended-euclidean-algorithm/).\n */\nexport function invert(number: bigint, modulo: bigint): bigint {\n  if (number === _0n) throw new Error('invert: expected non-zero number');\n  if (modulo <= _0n) throw new Error('invert: expected positive modulus, got ' + modulo);\n  // Fermat's little theorem \"CT-like\" version inv(n) = n^(m-2) mod m is 30x slower.\n  let a = mod(number, modulo);\n  let b = modulo;\n  // prettier-ignore\n  let x = _0n, y = _1n, u = _1n, v = _0n;\n  while (a !== _0n) {\n    // JIT applies optimization if those two lines follow each other\n    const q = b / a;\n    const r = b % a;\n    const m = x - u * q;\n    const n = y - v * q;\n    // prettier-ignore\n    b = a, a = r, x = u, y = v, u = m, v = n;\n  }\n  const gcd = b;\n  if (gcd !== _1n) throw new Error('invert: does not exist');\n  return mod(x, modulo);\n}\n\n/**\n * Tonelli-Shanks square root search algorithm.\n * 1. https://eprint.iacr.org/2012/685.pdf (page 12)\n * 2. Square Roots from 1; 24, 51, 10 to Dan Shanks\n * Will start an infinite loop if field order P is not prime.\n * @param P field order\n * @returns function that takes field Fp (created from P) and number n\n */\nexport function tonelliShanks(P: bigint): <T>(Fp: IField<T>, n: T) => T {\n  // Legendre constant: used to calculate Legendre symbol (a | p),\n  // which denotes the value of a^((p-1)/2) (mod p).\n  // (a | p) ≡ 1    if a is a square (mod p)\n  // (a | p) ≡ -1   if a is not a square (mod p)\n  // (a | p) ≡ 0    if a ≡ 0 (mod p)\n  const legendreC = (P - _1n) / _2n;\n\n  let Q: bigint, S: number, Z: bigint;\n  // Step 1: By factoring out powers of 2 from p - 1,\n  // find q and s such that p - 1 = q*(2^s) with q odd\n  for (Q = P - _1n, S = 0; Q % _2n === _0n; Q /= _2n, S++);\n\n  // Step 2: Select a non-square z such that (z | p) ≡ -1 and set c ≡ zq\n  for (Z = _2n; Z < P && pow(Z, legendreC, P) !== P - _1n; Z++) {\n    // Crash instead of infinity loop, we cannot reasonable count until P.\n    if (Z > 1000) throw new Error('Cannot find square root: likely non-prime P');\n  }\n\n  // Fast-path\n  if (S === 1) {\n    const p1div4 = (P + _1n) / _4n;\n    return function tonelliFast<T>(Fp: IField<T>, n: T) {\n      const root = Fp.pow(n, p1div4);\n      if (!Fp.eql(Fp.sqr(root), n)) throw new Error('Cannot find square root');\n      return root;\n    };\n  }\n\n  // Slow-path\n  const Q1div2 = (Q + _1n) / _2n;\n  return function tonelliSlow<T>(Fp: IField<T>, n: T): T {\n    // Step 0: Check that n is indeed a square: (n | p) should not be ≡ -1\n    if (Fp.pow(n, legendreC) === Fp.neg(Fp.ONE)) throw new Error('Cannot find square root');\n    let r = S;\n    // TODO: will fail at Fp2/etc\n    let g = Fp.pow(Fp.mul(Fp.ONE, Z), Q); // will update both x and b\n    let x = Fp.pow(n, Q1div2); // first guess at the square root\n    let b = Fp.pow(n, Q); // first guess at the fudge factor\n\n    while (!Fp.eql(b, Fp.ONE)) {\n      if (Fp.eql(b, Fp.ZERO)) return Fp.ZERO; // https://en.wikipedia.org/wiki/Tonelli%E2%80%93Shanks_algorithm (4. If t = 0, return r = 0)\n      // Find m such b^(2^m)==1\n      let m = 1;\n      for (let t2 = Fp.sqr(b); m < r; m++) {\n        if (Fp.eql(t2, Fp.ONE)) break;\n        t2 = Fp.sqr(t2); // t2 *= t2\n      }\n      // NOTE: r-m-1 can be bigger than 32, need to convert to bigint before shift, otherwise there will be overflow\n      const ge = Fp.pow(g, _1n << BigInt(r - m - 1)); // ge = 2^(r-m-1)\n      g = Fp.sqr(ge); // g = ge * ge\n      x = Fp.mul(x, ge); // x *= ge\n      b = Fp.mul(b, g); // b *= g\n      r = m;\n    }\n    return x;\n  };\n}\n\n/**\n * Square root for a finite field. It will try to check if optimizations are applicable and fall back to 4:\n *\n * 1. P ≡ 3 (mod 4)\n * 2. P ≡ 5 (mod 8)\n * 3. P ≡ 9 (mod 16)\n * 4. Tonelli-Shanks algorithm\n *\n * Different algorithms can give different roots, it is up to user to decide which one they want.\n * For example there is FpSqrtOdd/FpSqrtEven to choice root based on oddness (used for hash-to-curve).\n */\nexport function FpSqrt(P: bigint): <T>(Fp: IField<T>, n: T) => T {\n  // P ≡ 3 (mod 4)\n  // √n = n^((P+1)/4)\n  if (P % _4n === _3n) {\n    // Not all roots possible!\n    // const ORDER =\n    //   0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaabn;\n    // const NUM = 72057594037927816n;\n    const p1div4 = (P + _1n) / _4n;\n    return function sqrt3mod4<T>(Fp: IField<T>, n: T) {\n      const root = Fp.pow(n, p1div4);\n      // Throw if root**2 != n\n      if (!Fp.eql(Fp.sqr(root), n)) throw new Error('Cannot find square root');\n      return root;\n    };\n  }\n\n  // Atkin algorithm for q ≡ 5 (mod 8), https://eprint.iacr.org/2012/685.pdf (page 10)\n  if (P % _8n === _5n) {\n    const c1 = (P - _5n) / _8n;\n    return function sqrt5mod8<T>(Fp: IField<T>, n: T) {\n      const n2 = Fp.mul(n, _2n);\n      const v = Fp.pow(n2, c1);\n      const nv = Fp.mul(n, v);\n      const i = Fp.mul(Fp.mul(nv, _2n), v);\n      const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));\n      if (!Fp.eql(Fp.sqr(root), n)) throw new Error('Cannot find square root');\n      return root;\n    };\n  }\n\n  // P ≡ 9 (mod 16)\n  if (P % _16n === _9n) {\n    // NOTE: tonelli is too slow for bls-Fp2 calculations even on start\n    // Means we cannot use sqrt for constants at all!\n    //\n    // const c1 = Fp.sqrt(Fp.negate(Fp.ONE)); //  1. c1 = sqrt(-1) in F, i.e., (c1^2) == -1 in F\n    // const c2 = Fp.sqrt(c1);                //  2. c2 = sqrt(c1) in F, i.e., (c2^2) == c1 in F\n    // const c3 = Fp.sqrt(Fp.negate(c1));     //  3. c3 = sqrt(-c1) in F, i.e., (c3^2) == -c1 in F\n    // const c4 = (P + _7n) / _16n;           //  4. c4 = (q + 7) / 16        # Integer arithmetic\n    // sqrt = (x) => {\n    //   let tv1 = Fp.pow(x, c4);             //  1. tv1 = x^c4\n    //   let tv2 = Fp.mul(c1, tv1);           //  2. tv2 = c1 * tv1\n    //   const tv3 = Fp.mul(c2, tv1);         //  3. tv3 = c2 * tv1\n    //   let tv4 = Fp.mul(c3, tv1);           //  4. tv4 = c3 * tv1\n    //   const e1 = Fp.equals(Fp.square(tv2), x); //  5.  e1 = (tv2^2) == x\n    //   const e2 = Fp.equals(Fp.square(tv3), x); //  6.  e2 = (tv3^2) == x\n    //   tv1 = Fp.cmov(tv1, tv2, e1); //  7. tv1 = CMOV(tv1, tv2, e1)  # Select tv2 if (tv2^2) == x\n    //   tv2 = Fp.cmov(tv4, tv3, e2); //  8. tv2 = CMOV(tv4, tv3, e2)  # Select tv3 if (tv3^2) == x\n    //   const e3 = Fp.equals(Fp.square(tv2), x); //  9.  e3 = (tv2^2) == x\n    //   return Fp.cmov(tv1, tv2, e3); //  10.  z = CMOV(tv1, tv2, e3)  # Select the sqrt from tv1 and tv2\n    // }\n  }\n  // Other cases: Tonelli-Shanks algorithm\n  return tonelliShanks(P);\n}\n\n// Little-endian check for first LE bit (last BE bit);\nexport const isNegativeLE = (num: bigint, modulo: bigint): boolean =>\n  (mod(num, modulo) & _1n) === _1n;\n\n/** Field is not always over prime: for example, Fp2 has ORDER(q)=p^m. */\nexport interface IField<T> {\n  ORDER: bigint;\n  isLE: boolean;\n  BYTES: number;\n  BITS: number;\n  MASK: bigint;\n  ZERO: T;\n  ONE: T;\n  // 1-arg\n  create: (num: T) => T;\n  isValid: (num: T) => boolean;\n  is0: (num: T) => boolean;\n  neg(num: T): T;\n  inv(num: T): T;\n  sqrt(num: T): T;\n  sqr(num: T): T;\n  // 2-args\n  eql(lhs: T, rhs: T): boolean;\n  add(lhs: T, rhs: T): T;\n  sub(lhs: T, rhs: T): T;\n  mul(lhs: T, rhs: T | bigint): T;\n  pow(lhs: T, power: bigint): T;\n  div(lhs: T, rhs: T | bigint): T;\n  // N for NonNormalized (for now)\n  addN(lhs: T, rhs: T): T;\n  subN(lhs: T, rhs: T): T;\n  mulN(lhs: T, rhs: T | bigint): T;\n  sqrN(num: T): T;\n\n  // Optional\n  // Should be same as sgn0 function in\n  // [RFC9380](https://www.rfc-editor.org/rfc/rfc9380#section-4.1).\n  // NOTE: sgn0 is 'negative in LE', which is same as odd. And negative in LE is kinda strange definition anyway.\n  isOdd?(num: T): boolean; // Odd instead of even since we have it for Fp2\n  // legendre?(num: T): T;\n  pow(lhs: T, power: bigint): T;\n  invertBatch: (lst: T[]) => T[];\n  toBytes(num: T): Uint8Array;\n  fromBytes(bytes: Uint8Array): T;\n  // If c is False, CMOV returns a, otherwise it returns b.\n  cmov(a: T, b: T, c: boolean): T;\n}\n// prettier-ignore\nconst FIELD_FIELDS = [\n  'create', 'isValid', 'is0', 'neg', 'inv', 'sqrt', 'sqr',\n  'eql', 'add', 'sub', 'mul', 'pow', 'div',\n  'addN', 'subN', 'mulN', 'sqrN'\n] as const;\nexport function validateField<T>(field: IField<T>): IField<T> {\n  const initial = {\n    ORDER: 'bigint',\n    MASK: 'bigint',\n    BYTES: 'isSafeInteger',\n    BITS: 'isSafeInteger',\n  } as Record<string, string>;\n  const opts = FIELD_FIELDS.reduce((map, val: string) => {\n    map[val] = 'function';\n    return map;\n  }, initial);\n  return validateObject(field, opts);\n}\n\n// Generic field functions\n\n/**\n * Same as `pow` but for Fp: non-constant-time.\n * Unsafe in some contexts: uses ladder, so can expose bigint bits.\n */\nexport function FpPow<T>(f: IField<T>, num: T, power: bigint): T {\n  // Should have same speed as pow for bigints\n  // TODO: benchmark!\n  if (power < _0n) throw new Error('invalid exponent, negatives unsupported');\n  if (power === _0n) return f.ONE;\n  if (power === _1n) return num;\n  let p = f.ONE;\n  let d = num;\n  while (power > _0n) {\n    if (power & _1n) p = f.mul(p, d);\n    d = f.sqr(d);\n    power >>= _1n;\n  }\n  return p;\n}\n\n/**\n * Efficiently invert an array of Field elements.\n * `inv(0)` will return `undefined` here: make sure to throw an error.\n */\nexport function FpInvertBatch<T>(f: IField<T>, nums: T[]): T[] {\n  const tmp = new Array(nums.length);\n  // Walk from first to last, multiply them by each other MOD p\n  const lastMultiplied = nums.reduce((acc, num, i) => {\n    if (f.is0(num)) return acc;\n    tmp[i] = acc;\n    return f.mul(acc, num);\n  }, f.ONE);\n  // Invert last element\n  const inverted = f.inv(lastMultiplied);\n  // Walk from last to first, multiply them by inverted each other MOD p\n  nums.reduceRight((acc, num, i) => {\n    if (f.is0(num)) return acc;\n    tmp[i] = f.mul(acc, tmp[i]);\n    return f.mul(acc, num);\n  }, inverted);\n  return tmp;\n}\n\nexport function FpDiv<T>(f: IField<T>, lhs: T, rhs: T | bigint): T {\n  return f.mul(lhs, typeof rhs === 'bigint' ? invert(rhs, f.ORDER) : f.inv(rhs));\n}\n\n/**\n * Legendre symbol.\n * * (a | p) ≡ 1    if a is a square (mod p), quadratic residue\n * * (a | p) ≡ -1   if a is not a square (mod p), quadratic non residue\n * * (a | p) ≡ 0    if a ≡ 0 (mod p)\n */\nexport function FpLegendre(order: bigint): <T>(f: IField<T>, x: T) => T {\n  const legendreConst = (order - _1n) / _2n; // Integer arithmetic\n  return <T>(f: IField<T>, x: T): T => f.pow(x, legendreConst);\n}\n\n// This function returns True whenever the value x is a square in the field F.\nexport function FpIsSquare<T>(f: IField<T>): (x: T) => boolean {\n  const legendre = FpLegendre(f.ORDER);\n  return (x: T): boolean => {\n    const p = legendre(f, x);\n    return f.eql(p, f.ZERO) || f.eql(p, f.ONE);\n  };\n}\n\n// CURVE.n lengths\nexport function nLength(\n  n: bigint,\n  nBitLength?: number\n): {\n  nBitLength: number;\n  nByteLength: number;\n} {\n  // Bit size, byte size of CURVE.n\n  const _nBitLength = nBitLength !== undefined ? nBitLength : n.toString(2).length;\n  const nByteLength = Math.ceil(_nBitLength / 8);\n  return { nBitLength: _nBitLength, nByteLength };\n}\n\ntype FpField = IField<bigint> & Required<Pick<IField<bigint>, 'isOdd'>>;\n/**\n * Initializes a finite field over prime.\n * Major performance optimizations:\n * * a) denormalized operations like mulN instead of mul\n * * b) same object shape: never add or remove keys\n * * c) Object.freeze\n * Fragile: always run a benchmark on a change.\n * Security note: operations don't check 'isValid' for all elements for performance reasons,\n * it is caller responsibility to check this.\n * This is low-level code, please make sure you know what you're doing.\n * @param ORDER prime positive bigint\n * @param bitLen how many bits the field consumes\n * @param isLE (def: false) if encoding / decoding should be in little-endian\n * @param redef optional faster redefinitions of sqrt and other methods\n */\nexport function Field(\n  ORDER: bigint,\n  bitLen?: number,\n  isLE = false,\n  redef: Partial<IField<bigint>> = {}\n): Readonly<FpField> {\n  if (ORDER <= _0n) throw new Error('invalid field: expected ORDER > 0, got ' + ORDER);\n  const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen);\n  if (BYTES > 2048) throw new Error('invalid field: expected ORDER of <= 2048 bytes');\n  let sqrtP: ReturnType<typeof FpSqrt>; // cached sqrtP\n  const f: Readonly<FpField> = Object.freeze({\n    ORDER,\n    isLE,\n    BITS,\n    BYTES,\n    MASK: bitMask(BITS),\n    ZERO: _0n,\n    ONE: _1n,\n    create: (num) => mod(num, ORDER),\n    isValid: (num) => {\n      if (typeof num !== 'bigint')\n        throw new Error('invalid field element: expected bigint, got ' + typeof num);\n      return _0n <= num && num < ORDER; // 0 is valid element, but it's not invertible\n    },\n    is0: (num) => num === _0n,\n    isOdd: (num) => (num & _1n) === _1n,\n    neg: (num) => mod(-num, ORDER),\n    eql: (lhs, rhs) => lhs === rhs,\n\n    sqr: (num) => mod(num * num, ORDER),\n    add: (lhs, rhs) => mod(lhs + rhs, ORDER),\n    sub: (lhs, rhs) => mod(lhs - rhs, ORDER),\n    mul: (lhs, rhs) => mod(lhs * rhs, ORDER),\n    pow: (num, power) => FpPow(f, num, power),\n    div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),\n\n    // Same as above, but doesn't normalize\n    sqrN: (num) => num * num,\n    addN: (lhs, rhs) => lhs + rhs,\n    subN: (lhs, rhs) => lhs - rhs,\n    mulN: (lhs, rhs) => lhs * rhs,\n\n    inv: (num) => invert(num, ORDER),\n    sqrt:\n      redef.sqrt ||\n      ((n) => {\n        if (!sqrtP) sqrtP = FpSqrt(ORDER);\n        return sqrtP(f, n);\n      }),\n    invertBatch: (lst) => FpInvertBatch(f, lst),\n    // TODO: do we really need constant cmov?\n    // We don't have const-time bigints anyway, so probably will be not very useful\n    cmov: (a, b, c) => (c ? b : a),\n    toBytes: (num) => (isLE ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES)),\n    fromBytes: (bytes) => {\n      if (bytes.length !== BYTES)\n        throw new Error('Field.fromBytes: expected ' + BYTES + ' bytes, got ' + bytes.length);\n      return isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);\n    },\n  } as FpField);\n  return Object.freeze(f);\n}\n\nexport function FpSqrtOdd<T>(Fp: IField<T>, elm: T): T {\n  if (!Fp.isOdd) throw new Error(\"Field doesn't have isOdd\");\n  const root = Fp.sqrt(elm);\n  return Fp.isOdd(root) ? root : Fp.neg(root);\n}\n\nexport function FpSqrtEven<T>(Fp: IField<T>, elm: T): T {\n  if (!Fp.isOdd) throw new Error(\"Field doesn't have isOdd\");\n  const root = Fp.sqrt(elm);\n  return Fp.isOdd(root) ? Fp.neg(root) : root;\n}\n\n/**\n * \"Constant-time\" private key generation utility.\n * Same as mapKeyToField, but accepts less bytes (40 instead of 48 for 32-byte field).\n * Which makes it slightly more biased, less secure.\n * @deprecated use `mapKeyToField` instead\n */\nexport function hashToPrivateScalar(\n  hash: string | Uint8Array,\n  groupOrder: bigint,\n  isLE = false\n): bigint {\n  hash = ensureBytes('privateHash', hash);\n  const hashLen = hash.length;\n  const minLen = nLength(groupOrder).nByteLength + 8;\n  if (minLen < 24 || hashLen < minLen || hashLen > 1024)\n    throw new Error(\n      'hashToPrivateScalar: expected ' + minLen + '-1024 bytes of input, got ' + hashLen\n    );\n  const num = isLE ? bytesToNumberLE(hash) : bytesToNumberBE(hash);\n  return mod(num, groupOrder - _1n) + _1n;\n}\n\n/**\n * Returns total number of bytes consumed by the field element.\n * For example, 32 bytes for usual 256-bit weierstrass curve.\n * @param fieldOrder number of field elements, usually CURVE.n\n * @returns byte length of field\n */\nexport function getFieldBytesLength(fieldOrder: bigint): number {\n  if (typeof fieldOrder !== 'bigint') throw new Error('field order must be bigint');\n  const bitLength = fieldOrder.toString(2).length;\n  return Math.ceil(bitLength / 8);\n}\n\n/**\n * Returns minimal amount of bytes that can be safely reduced\n * by field order.\n * Should be 2^-128 for 128-bit curve such as P256.\n * @param fieldOrder number of field elements, usually CURVE.n\n * @returns byte length of target hash\n */\nexport function getMinHashLength(fieldOrder: bigint): number {\n  const length = getFieldBytesLength(fieldOrder);\n  return length + Math.ceil(length / 2);\n}\n\n/**\n * \"Constant-time\" private key generation utility.\n * Can take (n + n/2) or more bytes of uniform input e.g. from CSPRNG or KDF\n * and convert them into private scalar, with the modulo bias being negligible.\n * Needs at least 48 bytes of input for 32-byte private key.\n * https://research.kudelskisecurity.com/2020/07/28/the-definitive-guide-to-modulo-bias-and-how-to-avoid-it/\n * FIPS 186-5, A.2 https://csrc.nist.gov/publications/detail/fips/186/5/final\n * RFC 9380, https://www.rfc-editor.org/rfc/rfc9380#section-5\n * @param hash hash output from SHA3 or a similar function\n * @param groupOrder size of subgroup - (e.g. secp256k1.CURVE.n)\n * @param isLE interpret hash bytes as LE num\n * @returns valid private scalar\n */\nexport function mapHashToField(key: Uint8Array, fieldOrder: bigint, isLE = false): Uint8Array {\n  const len = key.length;\n  const fieldLen = getFieldBytesLength(fieldOrder);\n  const minLen = getMinHashLength(fieldOrder);\n  // No small numbers: need to understand bias story. No huge numbers: easier to detect JS timings.\n  if (len < 16 || len < minLen || len > 1024)\n    throw new Error('expected ' + minLen + '-1024 bytes of input, got ' + len);\n  const num = isLE ? bytesToNumberLE(key) : bytesToNumberBE(key);\n  // `mod(x, 11)` can sometimes produce 0. `mod(x, 10) + 1` is the same, but no 0\n  const reduced = mod(num, fieldOrder - _1n) + _1n;\n  return isLE ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);\n}\n","/**\n * Methods for elliptic curve multiplication by scalars.\n * Contains wNAF, pippenger\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { type IField, nLength, validateField } from './modular.js';\nimport { bitLen, validateObject } from './utils.js';\n\nconst _0n = BigInt(0);\nconst _1n = BigInt(1);\n\nexport type AffinePoint<T> = {\n  x: T;\n  y: T;\n} & { z?: never; t?: never };\n\nexport interface Group<T extends Group<T>> {\n  double(): T;\n  negate(): T;\n  add(other: T): T;\n  subtract(other: T): T;\n  equals(other: T): boolean;\n  multiply(scalar: bigint): T;\n}\n\nexport type GroupConstructor<T> = {\n  BASE: T;\n  ZERO: T;\n};\nexport type Mapper<T> = (i: T[]) => T[];\n\nfunction constTimeNegate<T extends Group<T>>(condition: boolean, item: T): T {\n  const neg = item.negate();\n  return condition ? neg : item;\n}\n\nfunction validateW(W: number, bits: number) {\n  if (!Number.isSafeInteger(W) || W <= 0 || W > bits)\n    throw new Error('invalid window size, expected [1..' + bits + '], got W=' + W);\n}\n\nfunction calcWOpts(W: number, bits: number) {\n  validateW(W, bits);\n  const windows = Math.ceil(bits / W) + 1; // +1, because\n  const windowSize = 2 ** (W - 1); // -1 because we skip zero\n  return { windows, windowSize };\n}\n\nfunction validateMSMPoints(points: any[], c: any) {\n  if (!Array.isArray(points)) throw new Error('array expected');\n  points.forEach((p, i) => {\n    if (!(p instanceof c)) throw new Error('invalid point at index ' + i);\n  });\n}\nfunction validateMSMScalars(scalars: any[], field: any) {\n  if (!Array.isArray(scalars)) throw new Error('array of scalars expected');\n  scalars.forEach((s, i) => {\n    if (!field.isValid(s)) throw new Error('invalid scalar at index ' + i);\n  });\n}\n\n// Since points in different groups cannot be equal (different object constructor),\n// we can have single place to store precomputes\nconst pointPrecomputes = new WeakMap<any, any[]>();\nconst pointWindowSizes = new WeakMap<any, number>(); // This allows use make points immutable (nothing changes inside)\n\nfunction getW(P: any): number {\n  return pointWindowSizes.get(P) || 1;\n}\n\nexport type IWNAF<T extends Group<T>> = {\n  constTimeNegate: <T extends Group<T>>(condition: boolean, item: T) => T;\n  hasPrecomputes(elm: T): boolean;\n  unsafeLadder(elm: T, n: bigint, p?: T): T;\n  precomputeWindow(elm: T, W: number): Group<T>[];\n  wNAF(W: number, precomputes: T[], n: bigint): { p: T; f: T };\n  wNAFUnsafe(W: number, precomputes: T[], n: bigint, acc?: T): T;\n  getPrecomputes(W: number, P: T, transform: Mapper<T>): T[];\n  wNAFCached(P: T, n: bigint, transform: Mapper<T>): { p: T; f: T };\n  wNAFCachedUnsafe(P: T, n: bigint, transform: Mapper<T>, prev?: T): T;\n  setWindowSize(P: T, W: number): void;\n};\n\n/**\n * Elliptic curve multiplication of Point by scalar. Fragile.\n * Scalars should always be less than curve order: this should be checked inside of a curve itself.\n * Creates precomputation tables for fast multiplication:\n * - private scalar is split by fixed size windows of W bits\n * - every window point is collected from window's table & added to accumulator\n * - since windows are different, same point inside tables won't be accessed more than once per calc\n * - each multiplication is 'Math.ceil(CURVE_ORDER / 𝑊) + 1' point additions (fixed for any scalar)\n * - +1 window is neccessary for wNAF\n * - wNAF reduces table size: 2x less memory + 2x faster generation, but 10% slower multiplication\n *\n * @todo Research returning 2d JS array of windows, instead of a single window.\n * This would allow windows to be in different memory locations\n */\nexport function wNAF<T extends Group<T>>(c: GroupConstructor<T>, bits: number): IWNAF<T> {\n  return {\n    constTimeNegate,\n\n    hasPrecomputes(elm: T) {\n      return getW(elm) !== 1;\n    },\n\n    // non-const time multiplication ladder\n    unsafeLadder(elm: T, n: bigint, p = c.ZERO) {\n      let d: T = elm;\n      while (n > _0n) {\n        if (n & _1n) p = p.add(d);\n        d = d.double();\n        n >>= _1n;\n      }\n      return p;\n    },\n\n    /**\n     * Creates a wNAF precomputation window. Used for caching.\n     * Default window size is set by `utils.precompute()` and is equal to 8.\n     * Number of precomputed points depends on the curve size:\n     * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:\n     * - 𝑊 is the window size\n     * - 𝑛 is the bitlength of the curve order.\n     * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.\n     * @param elm Point instance\n     * @param W window size\n     * @returns precomputed point tables flattened to a single array\n     */\n    precomputeWindow(elm: T, W: number): Group<T>[] {\n      const { windows, windowSize } = calcWOpts(W, bits);\n      const points: T[] = [];\n      let p: T = elm;\n      let base = p;\n      for (let window = 0; window < windows; window++) {\n        base = p;\n        points.push(base);\n        // =1, because we skip zero\n        for (let i = 1; i < windowSize; i++) {\n          base = base.add(p);\n          points.push(base);\n        }\n        p = base.double();\n      }\n      return points;\n    },\n\n    /**\n     * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.\n     * @param W window size\n     * @param precomputes precomputed tables\n     * @param n scalar (we don't check here, but should be less than curve order)\n     * @returns real and fake (for const-time) points\n     */\n    wNAF(W: number, precomputes: T[], n: bigint): { p: T; f: T } {\n      // TODO: maybe check that scalar is less than group order? wNAF behavious is undefined otherwise\n      // But need to carefully remove other checks before wNAF. ORDER == bits here\n      const { windows, windowSize } = calcWOpts(W, bits);\n\n      let p = c.ZERO;\n      let f = c.BASE;\n\n      const mask = BigInt(2 ** W - 1); // Create mask with W ones: 0b1111 for W=4 etc.\n      const maxNumber = 2 ** W;\n      const shiftBy = BigInt(W);\n\n      for (let window = 0; window < windows; window++) {\n        const offset = window * windowSize;\n        // Extract W bits.\n        let wbits = Number(n & mask);\n\n        // Shift number by W bits.\n        n >>= shiftBy;\n\n        // If the bits are bigger than max size, we'll split those.\n        // +224 => 256 - 32\n        if (wbits > windowSize) {\n          wbits -= maxNumber;\n          n += _1n;\n        }\n\n        // This code was first written with assumption that 'f' and 'p' will never be infinity point:\n        // since each addition is multiplied by 2 ** W, it cannot cancel each other. However,\n        // there is negate now: it is possible that negated element from low value\n        // would be the same as high element, which will create carry into next window.\n        // It's not obvious how this can fail, but still worth investigating later.\n\n        // Check if we're onto Zero point.\n        // Add random point inside current window to f.\n        const offset1 = offset;\n        const offset2 = offset + Math.abs(wbits) - 1; // -1 because we skip zero\n        const cond1 = window % 2 !== 0;\n        const cond2 = wbits < 0;\n        if (wbits === 0) {\n          // The most important part for const-time getPublicKey\n          f = f.add(constTimeNegate(cond1, precomputes[offset1]));\n        } else {\n          p = p.add(constTimeNegate(cond2, precomputes[offset2]));\n        }\n      }\n      // JIT-compiler should not eliminate f here, since it will later be used in normalizeZ()\n      // Even if the variable is still unused, there are some checks which will\n      // throw an exception, so compiler needs to prove they won't happen, which is hard.\n      // At this point there is a way to F be infinity-point even if p is not,\n      // which makes it less const-time: around 1 bigint multiply.\n      return { p, f };\n    },\n\n    /**\n     * Implements ec unsafe (non const-time) multiplication using precomputed tables and w-ary non-adjacent form.\n     * @param W window size\n     * @param precomputes precomputed tables\n     * @param n scalar (we don't check here, but should be less than curve order)\n     * @param acc accumulator point to add result of multiplication\n     * @returns point\n     */\n    wNAFUnsafe(W: number, precomputes: T[], n: bigint, acc: T = c.ZERO): T {\n      const { windows, windowSize } = calcWOpts(W, bits);\n      const mask = BigInt(2 ** W - 1); // Create mask with W ones: 0b1111 for W=4 etc.\n      const maxNumber = 2 ** W;\n      const shiftBy = BigInt(W);\n      for (let window = 0; window < windows; window++) {\n        const offset = window * windowSize;\n        if (n === _0n) break; // No need to go over empty scalar\n        // Extract W bits.\n        let wbits = Number(n & mask);\n        // Shift number by W bits.\n        n >>= shiftBy;\n        // If the bits are bigger than max size, we'll split those.\n        // +224 => 256 - 32\n        if (wbits > windowSize) {\n          wbits -= maxNumber;\n          n += _1n;\n        }\n        if (wbits === 0) continue;\n        let curr = precomputes[offset + Math.abs(wbits) - 1]; // -1 because we skip zero\n        if (wbits < 0) curr = curr.negate();\n        // NOTE: by re-using acc, we can save a lot of additions in case of MSM\n        acc = acc.add(curr);\n      }\n      return acc;\n    },\n\n    getPrecomputes(W: number, P: T, transform: Mapper<T>): T[] {\n      // Calculate precomputes on a first run, reuse them after\n      let comp = pointPrecomputes.get(P);\n      if (!comp) {\n        comp = this.precomputeWindow(P, W) as T[];\n        if (W !== 1) pointPrecomputes.set(P, transform(comp));\n      }\n      return comp;\n    },\n\n    wNAFCached(P: T, n: bigint, transform: Mapper<T>): { p: T; f: T } {\n      const W = getW(P);\n      return this.wNAF(W, this.getPrecomputes(W, P, transform), n);\n    },\n\n    wNAFCachedUnsafe(P: T, n: bigint, transform: Mapper<T>, prev?: T): T {\n      const W = getW(P);\n      if (W === 1) return this.unsafeLadder(P, n, prev); // For W=1 ladder is ~x2 faster\n      return this.wNAFUnsafe(W, this.getPrecomputes(W, P, transform), n, prev);\n    },\n\n    // We calculate precomputes for elliptic curve point multiplication\n    // using windowed method. This specifies window size and\n    // stores precomputed values. Usually only base point would be precomputed.\n\n    setWindowSize(P: T, W: number) {\n      validateW(W, bits);\n      pointWindowSizes.set(P, W);\n      pointPrecomputes.delete(P);\n    },\n  };\n}\n\n/**\n * Pippenger algorithm for multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).\n * 30x faster vs naive addition on L=4096, 10x faster with precomputes.\n * For N=254bit, L=1, it does: 1024 ADD + 254 DBL. For L=5: 1536 ADD + 254 DBL.\n * Algorithmically constant-time (for same L), even when 1 point + scalar, or when scalar = 0.\n * @param c Curve Point constructor\n * @param fieldN field over CURVE.N - important that it's not over CURVE.P\n * @param points array of L curve points\n * @param scalars array of L scalars (aka private keys / bigints)\n */\nexport function pippenger<T extends Group<T>>(\n  c: GroupConstructor<T>,\n  fieldN: IField<bigint>,\n  points: T[],\n  scalars: bigint[]\n): T {\n  // If we split scalars by some window (let's say 8 bits), every chunk will only\n  // take 256 buckets even if there are 4096 scalars, also re-uses double.\n  // TODO:\n  // - https://eprint.iacr.org/2024/750.pdf\n  // - https://tches.iacr.org/index.php/TCHES/article/view/10287\n  // 0 is accepted in scalars\n  validateMSMPoints(points, c);\n  validateMSMScalars(scalars, fieldN);\n  if (points.length !== scalars.length)\n    throw new Error('arrays of points and scalars must have equal length');\n  const zero = c.ZERO;\n  const wbits = bitLen(BigInt(points.length));\n  const windowSize = wbits > 12 ? wbits - 3 : wbits > 4 ? wbits - 2 : wbits ? 2 : 1; // in bits\n  const MASK = (1 << windowSize) - 1;\n  const buckets = new Array(MASK + 1).fill(zero); // +1 for zero array\n  const lastBits = Math.floor((fieldN.BITS - 1) / windowSize) * windowSize;\n  let sum = zero;\n  for (let i = lastBits; i >= 0; i -= windowSize) {\n    buckets.fill(zero);\n    for (let j = 0; j < scalars.length; j++) {\n      const scalar = scalars[j];\n      const wbits = Number((scalar >> BigInt(i)) & BigInt(MASK));\n      buckets[wbits] = buckets[wbits].add(points[j]);\n    }\n    let resI = zero; // not using this will do small speed-up, but will lose ct\n    // Skip first bucket, because it is zero\n    for (let j = buckets.length - 1, sumI = zero; j > 0; j--) {\n      sumI = sumI.add(buckets[j]);\n      resI = resI.add(sumI);\n    }\n    sum = sum.add(resI);\n    if (i !== 0) for (let j = 0; j < windowSize; j++) sum = sum.double();\n  }\n  return sum as T;\n}\n/**\n * Precomputed multi-scalar multiplication (MSM, Pa + Qb + Rc + ...).\n * @param c Curve Point constructor\n * @param fieldN field over CURVE.N - important that it's not over CURVE.P\n * @param points array of L curve points\n * @returns function which multiplies points with scaars\n */\nexport function precomputeMSMUnsafe<T extends Group<T>>(\n  c: GroupConstructor<T>,\n  fieldN: IField<bigint>,\n  points: T[],\n  windowSize: number\n): (scalars: bigint[]) => T {\n  /**\n   * Performance Analysis of Window-based Precomputation\n   *\n   * Base Case (256-bit scalar, 8-bit window):\n   * - Standard precomputation requires:\n   *   - 31 additions per scalar × 256 scalars = 7,936 ops\n   *   - Plus 255 summary additions = 8,191 total ops\n   *   Note: Summary additions can be optimized via accumulator\n   *\n   * Chunked Precomputation Analysis:\n   * - Using 32 chunks requires:\n   *   - 255 additions per chunk\n   *   - 256 doublings\n   *   - Total: (255 × 32) + 256 = 8,416 ops\n   *\n   * Memory Usage Comparison:\n   * Window Size | Standard Points | Chunked Points\n   * ------------|-----------------|---------------\n   *     4-bit   |     520         |      15\n   *     8-bit   |    4,224        |     255\n   *    10-bit   |   13,824        |   1,023\n   *    16-bit   |  557,056        |  65,535\n   *\n   * Key Advantages:\n   * 1. Enables larger window sizes due to reduced memory overhead\n   * 2. More efficient for smaller scalar counts:\n   *    - 16 chunks: (16 × 255) + 256 = 4,336 ops\n   *    - ~2x faster than standard 8,191 ops\n   *\n   * Limitations:\n   * - Not suitable for plain precomputes (requires 256 constant doublings)\n   * - Performance degrades with larger scalar counts:\n   *   - Optimal for ~256 scalars\n   *   - Less efficient for 4096+ scalars (Pippenger preferred)\n   */\n  validateW(windowSize, fieldN.BITS);\n  validateMSMPoints(points, c);\n  const zero = c.ZERO;\n  const tableSize = 2 ** windowSize - 1; // table size (without zero)\n  const chunks = Math.ceil(fieldN.BITS / windowSize); // chunks of item\n  const MASK = BigInt((1 << windowSize) - 1);\n  const tables = points.map((p: T) => {\n    const res = [];\n    for (let i = 0, acc = p; i < tableSize; i++) {\n      res.push(acc);\n      acc = acc.add(p);\n    }\n    return res;\n  });\n  return (scalars: bigint[]): T => {\n    validateMSMScalars(scalars, fieldN);\n    if (scalars.length > points.length)\n      throw new Error('array of scalars must be smaller than array of points');\n    let res = zero;\n    for (let i = 0; i < chunks; i++) {\n      // No need to double if accumulator is still zero.\n      if (res !== zero) for (let j = 0; j < windowSize; j++) res = res.double();\n      const shiftBy = BigInt(chunks * windowSize - (i + 1) * windowSize);\n      for (let j = 0; j < scalars.length; j++) {\n        const n = scalars[j];\n        const curr = Number((n >> shiftBy) & MASK);\n        if (!curr) continue; // skip zero scalars chunks\n        res = res.add(tables[j][curr - 1]);\n      }\n    }\n    return res;\n  };\n}\n\n/**\n * Generic BasicCurve interface: works even for polynomial fields (BLS): P, n, h would be ok.\n * Though generator can be different (Fp2 / Fp6 for BLS).\n */\nexport type BasicCurve<T> = {\n  Fp: IField<T>; // Field over which we'll do calculations (Fp)\n  n: bigint; // Curve order, total count of valid points in the field\n  nBitLength?: number; // bit length of curve order\n  nByteLength?: number; // byte length of curve order\n  h: bigint; // cofactor. we can assign default=1, but users will just ignore it w/o validation\n  hEff?: bigint; // Number to multiply to clear cofactor\n  Gx: T; // base point X coordinate\n  Gy: T; // base point Y coordinate\n  allowInfinityPoint?: boolean; // bls12-381 requires it. ZERO point is valid, but invalid pubkey\n};\n\nexport function validateBasic<FP, T>(\n  curve: BasicCurve<FP> & T\n): Readonly<\n  {\n    readonly nBitLength: number;\n    readonly nByteLength: number;\n  } & BasicCurve<FP> &\n    T & {\n      p: bigint;\n    }\n> {\n  validateField(curve.Fp);\n  validateObject(\n    curve,\n    {\n      n: 'bigint',\n      h: 'bigint',\n      Gx: 'field',\n      Gy: 'field',\n    },\n    {\n      nBitLength: 'isSafeInteger',\n      nByteLength: 'isSafeInteger',\n    }\n  );\n  // Set defaults\n  return Object.freeze({\n    ...nLength(curve.n, curve.nBitLength),\n    ...curve,\n    ...{ p: curve.Fp.ORDER },\n  } as const);\n}\n","/**\n * Twisted Edwards curve. The formula is: ax² + y² = 1 + dx²y².\n * For design rationale of types / exports, see weierstrass module documentation.\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport {\n  type AffinePoint,\n  type BasicCurve,\n  type Group,\n  type GroupConstructor,\n  pippenger,\n  validateBasic,\n  wNAF,\n} from './curve.js';\nimport { Field, mod } from './modular.js';\nimport * as ut from './utils.js';\nimport { abool, ensureBytes, type FHash, type Hex, memoized } from './utils.js';\n\n// Be friendly to bad ECMAScript parsers by not using bigint literals\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _8n = BigInt(8);\n\n/** Edwards curves must declare params a & d. */\nexport type CurveType = BasicCurve<bigint> & {\n  a: bigint; // curve param a\n  d: bigint; // curve param d\n  hash: FHash; // Hashing\n  randomBytes: (bytesLength?: number) => Uint8Array; // CSPRNG\n  adjustScalarBytes?: (bytes: Uint8Array) => Uint8Array; // clears bits to get valid field elemtn\n  domain?: (data: Uint8Array, ctx: Uint8Array, phflag: boolean) => Uint8Array; // Used for hashing\n  uvRatio?: (u: bigint, v: bigint) => { isValid: boolean; value: bigint }; // Ratio √(u/v)\n  prehash?: FHash; // RFC 8032 pre-hashing of messages to sign() / verify()\n  mapToCurve?: (scalar: bigint[]) => AffinePoint<bigint>; // for hash-to-curve standard\n};\n\nexport type CurveTypeWithLength = Readonly<CurveType & { nByteLength: number; nBitLength: number }>;\n\n// verification rule is either zip215 or rfc8032 / nist186-5. Consult fromHex:\nconst VERIFY_DEFAULT = { zip215: true };\n\nfunction validateOpts(curve: CurveType): CurveTypeWithLength {\n  const opts = validateBasic(curve);\n  ut.validateObject(\n    curve,\n    {\n      hash: 'function',\n      a: 'bigint',\n      d: 'bigint',\n      randomBytes: 'function',\n    },\n    {\n      adjustScalarBytes: 'function',\n      domain: 'function',\n      uvRatio: 'function',\n      mapToCurve: 'function',\n    }\n  );\n  // Set defaults\n  return Object.freeze({ ...opts } as const);\n}\n\n/** Instance of Extended Point with coordinates in X, Y, Z, T. */\nexport interface ExtPointType extends Group<ExtPointType> {\n  readonly ex: bigint;\n  readonly ey: bigint;\n  readonly ez: bigint;\n  readonly et: bigint;\n  get x(): bigint;\n  get y(): bigint;\n  assertValidity(): void;\n  multiply(scalar: bigint): ExtPointType;\n  multiplyUnsafe(scalar: bigint): ExtPointType;\n  isSmallOrder(): boolean;\n  isTorsionFree(): boolean;\n  clearCofactor(): ExtPointType;\n  toAffine(iz?: bigint): AffinePoint<bigint>;\n  toRawBytes(isCompressed?: boolean): Uint8Array;\n  toHex(isCompressed?: boolean): string;\n  _setWindowSize(windowSize: number): void;\n}\n/** Static methods of Extended Point with coordinates in X, Y, Z, T. */\nexport interface ExtPointConstructor extends GroupConstructor<ExtPointType> {\n  new (x: bigint, y: bigint, z: bigint, t: bigint): ExtPointType;\n  fromAffine(p: AffinePoint<bigint>): ExtPointType;\n  fromHex(hex: Hex): ExtPointType;\n  fromPrivateKey(privateKey: Hex): ExtPointType;\n  msm(points: ExtPointType[], scalars: bigint[]): ExtPointType;\n}\n\n/**\n * Edwards Curve interface.\n * Main methods: `getPublicKey(priv)`, `sign(msg, priv)`, `verify(sig, msg, pub)`.\n */\nexport type CurveFn = {\n  CURVE: ReturnType<typeof validateOpts>;\n  getPublicKey: (privateKey: Hex) => Uint8Array;\n  sign: (message: Hex, privateKey: Hex, options?: { context?: Hex }) => Uint8Array;\n  verify: (\n    sig: Hex,\n    message: Hex,\n    publicKey: Hex,\n    options?: { context?: Hex; zip215: boolean }\n  ) => boolean;\n  ExtendedPoint: ExtPointConstructor;\n  utils: {\n    randomPrivateKey: () => Uint8Array;\n    getExtendedPublicKey: (key: Hex) => {\n      head: Uint8Array;\n      prefix: Uint8Array;\n      scalar: bigint;\n      point: ExtPointType;\n      pointBytes: Uint8Array;\n    };\n    precompute: (windowSize?: number, point?: ExtPointType) => ExtPointType;\n  };\n};\n\n/**\n * Creates Twisted Edwards curve with EdDSA signatures.\n * @example\n * import { Field } from '@noble/curves/abstract/modular';\n * // Before that, define BigInt-s: a, d, p, n, Gx, Gy, h\n * const curve = twistedEdwards({ a, d, Fp: Field(p), n, Gx, Gy, h })\n */\nexport function twistedEdwards(curveDef: CurveType): CurveFn {\n  const CURVE = validateOpts(curveDef) as ReturnType<typeof validateOpts>;\n  const {\n    Fp,\n    n: CURVE_ORDER,\n    prehash: prehash,\n    hash: cHash,\n    randomBytes,\n    nByteLength,\n    h: cofactor,\n  } = CURVE;\n  // Important:\n  // There are some places where Fp.BYTES is used instead of nByteLength.\n  // So far, everything has been tested with curves of Fp.BYTES == nByteLength.\n  // TODO: test and find curves which behave otherwise.\n  const MASK = _2n << (BigInt(nByteLength * 8) - _1n);\n  const modP = Fp.create; // Function overrides\n  const Fn = Field(CURVE.n, CURVE.nBitLength);\n\n  // sqrt(u/v)\n  const uvRatio =\n    CURVE.uvRatio ||\n    ((u: bigint, v: bigint) => {\n      try {\n        return { isValid: true, value: Fp.sqrt(u * Fp.inv(v)) };\n      } catch (e) {\n        return { isValid: false, value: _0n };\n      }\n    });\n  const adjustScalarBytes = CURVE.adjustScalarBytes || ((bytes: Uint8Array) => bytes); // NOOP\n  const domain =\n    CURVE.domain ||\n    ((data: Uint8Array, ctx: Uint8Array, phflag: boolean) => {\n      abool('phflag', phflag);\n      if (ctx.length || phflag) throw new Error('Contexts/pre-hash are not supported');\n      return data;\n    }); // NOOP\n  // 0 <= n < MASK\n  // Coordinates larger than Fp.ORDER are allowed for zip215\n  function aCoordinate(title: string, n: bigint) {\n    ut.aInRange('coordinate ' + title, n, _0n, MASK);\n  }\n\n  function assertPoint(other: unknown) {\n    if (!(other instanceof Point)) throw new Error('ExtendedPoint expected');\n  }\n  // Converts Extended point to default (x, y) coordinates.\n  // Can accept precomputed Z^-1 - for example, from invertBatch.\n  const toAffineMemo = memoized((p: Point, iz?: bigint): AffinePoint<bigint> => {\n    const { ex: x, ey: y, ez: z } = p;\n    const is0 = p.is0();\n    if (iz == null) iz = is0 ? _8n : (Fp.inv(z) as bigint); // 8 was chosen arbitrarily\n    const ax = modP(x * iz);\n    const ay = modP(y * iz);\n    const zz = modP(z * iz);\n    if (is0) return { x: _0n, y: _1n };\n    if (zz !== _1n) throw new Error('invZ was invalid');\n    return { x: ax, y: ay };\n  });\n  const assertValidMemo = memoized((p: Point) => {\n    const { a, d } = CURVE;\n    if (p.is0()) throw new Error('bad point: ZERO'); // TODO: optimize, with vars below?\n    // Equation in affine coordinates: ax² + y² = 1 + dx²y²\n    // Equation in projective coordinates (X/Z, Y/Z, Z):  (aX² + Y²)Z² = Z⁴ + dX²Y²\n    const { ex: X, ey: Y, ez: Z, et: T } = p;\n    const X2 = modP(X * X); // X²\n    const Y2 = modP(Y * Y); // Y²\n    const Z2 = modP(Z * Z); // Z²\n    const Z4 = modP(Z2 * Z2); // Z⁴\n    const aX2 = modP(X2 * a); // aX²\n    const left = modP(Z2 * modP(aX2 + Y2)); // (aX² + Y²)Z²\n    const right = modP(Z4 + modP(d * modP(X2 * Y2))); // Z⁴ + dX²Y²\n    if (left !== right) throw new Error('bad point: equation left != right (1)');\n    // In Extended coordinates we also have T, which is x*y=T/Z: check X*Y == Z*T\n    const XY = modP(X * Y);\n    const ZT = modP(Z * T);\n    if (XY !== ZT) throw new Error('bad point: equation left != right (2)');\n    return true;\n  });\n\n  // Extended Point works in extended coordinates: (x, y, z, t) ∋ (x=x/z, y=y/z, t=xy).\n  // https://en.wikipedia.org/wiki/Twisted_Edwards_curve#Extended_coordinates\n  class Point implements ExtPointType {\n    static readonly BASE = new Point(CURVE.Gx, CURVE.Gy, _1n, modP(CURVE.Gx * CURVE.Gy));\n    static readonly ZERO = new Point(_0n, _1n, _1n, _0n); // 0, 1, 1, 0\n\n    constructor(\n      readonly ex: bigint,\n      readonly ey: bigint,\n      readonly ez: bigint,\n      readonly et: bigint\n    ) {\n      aCoordinate('x', ex);\n      aCoordinate('y', ey);\n      aCoordinate('z', ez);\n      aCoordinate('t', et);\n      Object.freeze(this);\n    }\n\n    get x(): bigint {\n      return this.toAffine().x;\n    }\n    get y(): bigint {\n      return this.toAffine().y;\n    }\n\n    static fromAffine(p: AffinePoint<bigint>): Point {\n      if (p instanceof Point) throw new Error('extended point not allowed');\n      const { x, y } = p || {};\n      aCoordinate('x', x);\n      aCoordinate('y', y);\n      return new Point(x, y, _1n, modP(x * y));\n    }\n    static normalizeZ(points: Point[]): Point[] {\n      const toInv = Fp.invertBatch(points.map((p) => p.ez));\n      return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);\n    }\n    // Multiscalar Multiplication\n    static msm(points: Point[], scalars: bigint[]): Point {\n      return pippenger(Point, Fn, points, scalars);\n    }\n\n    // \"Private method\", don't use it directly\n    _setWindowSize(windowSize: number) {\n      wnaf.setWindowSize(this, windowSize);\n    }\n    // Not required for fromHex(), which always creates valid points.\n    // Could be useful for fromAffine().\n    assertValidity(): void {\n      assertValidMemo(this);\n    }\n\n    // Compare one point to another.\n    equals(other: Point): boolean {\n      assertPoint(other);\n      const { ex: X1, ey: Y1, ez: Z1 } = this;\n      const { ex: X2, ey: Y2, ez: Z2 } = other;\n      const X1Z2 = modP(X1 * Z2);\n      const X2Z1 = modP(X2 * Z1);\n      const Y1Z2 = modP(Y1 * Z2);\n      const Y2Z1 = modP(Y2 * Z1);\n      return X1Z2 === X2Z1 && Y1Z2 === Y2Z1;\n    }\n\n    is0(): boolean {\n      return this.equals(Point.ZERO);\n    }\n\n    negate(): Point {\n      // Flips point sign to a negative one (-x, y in affine coords)\n      return new Point(modP(-this.ex), this.ey, this.ez, modP(-this.et));\n    }\n\n    // Fast algo for doubling Extended Point.\n    // https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html#doubling-dbl-2008-hwcd\n    // Cost: 4M + 4S + 1*a + 6add + 1*2.\n    double(): Point {\n      const { a } = CURVE;\n      const { ex: X1, ey: Y1, ez: Z1 } = this;\n      const A = modP(X1 * X1); // A = X12\n      const B = modP(Y1 * Y1); // B = Y12\n      const C = modP(_2n * modP(Z1 * Z1)); // C = 2*Z12\n      const D = modP(a * A); // D = a*A\n      const x1y1 = X1 + Y1;\n      const E = modP(modP(x1y1 * x1y1) - A - B); // E = (X1+Y1)2-A-B\n      const G = D + B; // G = D+B\n      const F = G - C; // F = G-C\n      const H = D - B; // H = D-B\n      const X3 = modP(E * F); // X3 = E*F\n      const Y3 = modP(G * H); // Y3 = G*H\n      const T3 = modP(E * H); // T3 = E*H\n      const Z3 = modP(F * G); // Z3 = F*G\n      return new Point(X3, Y3, Z3, T3);\n    }\n\n    // Fast algo for adding 2 Extended Points.\n    // https://hyperelliptic.org/EFD/g1p/auto-twisted-extended.html#addition-add-2008-hwcd\n    // Cost: 9M + 1*a + 1*d + 7add.\n    add(other: Point) {\n      assertPoint(other);\n      const { a, d } = CURVE;\n      const { ex: X1, ey: Y1, ez: Z1, et: T1 } = this;\n      const { ex: X2, ey: Y2, ez: Z2, et: T2 } = other;\n      // Faster algo for adding 2 Extended Points when curve's a=-1.\n      // http://hyperelliptic.org/EFD/g1p/auto-twisted-extended-1.html#addition-add-2008-hwcd-4\n      // Cost: 8M + 8add + 2*2.\n      // Note: It does not check whether the `other` point is valid.\n      if (a === BigInt(-1)) {\n        const A = modP((Y1 - X1) * (Y2 + X2));\n        const B = modP((Y1 + X1) * (Y2 - X2));\n        const F = modP(B - A);\n        if (F === _0n) return this.double(); // Same point. Tests say it doesn't affect timing\n        const C = modP(Z1 * _2n * T2);\n        const D = modP(T1 * _2n * Z2);\n        const E = D + C;\n        const G = B + A;\n        const H = D - C;\n        const X3 = modP(E * F);\n        const Y3 = modP(G * H);\n        const T3 = modP(E * H);\n        const Z3 = modP(F * G);\n        return new Point(X3, Y3, Z3, T3);\n      }\n      const A = modP(X1 * X2); // A = X1*X2\n      const B = modP(Y1 * Y2); // B = Y1*Y2\n      const C = modP(T1 * d * T2); // C = T1*d*T2\n      const D = modP(Z1 * Z2); // D = Z1*Z2\n      const E = modP((X1 + Y1) * (X2 + Y2) - A - B); // E = (X1+Y1)*(X2+Y2)-A-B\n      const F = D - C; // F = D-C\n      const G = D + C; // G = D+C\n      const H = modP(B - a * A); // H = B-a*A\n      const X3 = modP(E * F); // X3 = E*F\n      const Y3 = modP(G * H); // Y3 = G*H\n      const T3 = modP(E * H); // T3 = E*H\n      const Z3 = modP(F * G); // Z3 = F*G\n\n      return new Point(X3, Y3, Z3, T3);\n    }\n\n    subtract(other: Point): Point {\n      return this.add(other.negate());\n    }\n\n    private wNAF(n: bigint): { p: Point; f: Point } {\n      return wnaf.wNAFCached(this, n, Point.normalizeZ);\n    }\n\n    // Constant-time multiplication.\n    multiply(scalar: bigint): Point {\n      const n = scalar;\n      ut.aInRange('scalar', n, _1n, CURVE_ORDER); // 1 <= scalar < L\n      const { p, f } = this.wNAF(n);\n      return Point.normalizeZ([p, f])[0];\n    }\n\n    // Non-constant-time multiplication. Uses double-and-add algorithm.\n    // It's faster, but should only be used when you don't care about\n    // an exposed private key e.g. sig verification.\n    // Does NOT allow scalars higher than CURVE.n.\n    // Accepts optional accumulator to merge with multiply (important for sparse scalars)\n    multiplyUnsafe(scalar: bigint, acc = Point.ZERO): Point {\n      const n = scalar;\n      ut.aInRange('scalar', n, _0n, CURVE_ORDER); // 0 <= scalar < L\n      if (n === _0n) return I;\n      if (this.is0() || n === _1n) return this;\n      return wnaf.wNAFCachedUnsafe(this, n, Point.normalizeZ, acc);\n    }\n\n    // Checks if point is of small order.\n    // If you add something to small order point, you will have \"dirty\"\n    // point with torsion component.\n    // Multiplies point by cofactor and checks if the result is 0.\n    isSmallOrder(): boolean {\n      return this.multiplyUnsafe(cofactor).is0();\n    }\n\n    // Multiplies point by curve order and checks if the result is 0.\n    // Returns `false` is the point is dirty.\n    isTorsionFree(): boolean {\n      return wnaf.unsafeLadder(this, CURVE_ORDER).is0();\n    }\n\n    // Converts Extended point to default (x, y) coordinates.\n    // Can accept precomputed Z^-1 - for example, from invertBatch.\n    toAffine(iz?: bigint): AffinePoint<bigint> {\n      return toAffineMemo(this, iz);\n    }\n\n    clearCofactor(): Point {\n      const { h: cofactor } = CURVE;\n      if (cofactor === _1n) return this;\n      return this.multiplyUnsafe(cofactor);\n    }\n\n    // Converts hash string or Uint8Array to Point.\n    // Uses algo from RFC8032 5.1.3.\n    static fromHex(hex: Hex, zip215 = false): Point {\n      const { d, a } = CURVE;\n      const len = Fp.BYTES;\n      hex = ensureBytes('pointHex', hex, len); // copy hex to a new array\n      abool('zip215', zip215);\n      const normed = hex.slice(); // copy again, we'll manipulate it\n      const lastByte = hex[len - 1]; // select last byte\n      normed[len - 1] = lastByte & ~0x80; // clear last bit\n      const y = ut.bytesToNumberLE(normed);\n\n      // zip215=true is good for consensus-critical apps. =false follows RFC8032 / NIST186-5.\n      // RFC8032 prohibits >= p, but ZIP215 doesn't\n      // zip215=true:  0 <= y < MASK (2^256 for ed25519)\n      // zip215=false: 0 <= y < P (2^255-19 for ed25519)\n      const max = zip215 ? MASK : Fp.ORDER;\n      ut.aInRange('pointHex.y', y, _0n, max);\n\n      // Ed25519: x² = (y²-1)/(dy²+1) mod p. Ed448: x² = (y²-1)/(dy²-1) mod p. Generic case:\n      // ax²+y²=1+dx²y² => y²-1=dx²y²-ax² => y²-1=x²(dy²-a) => x²=(y²-1)/(dy²-a)\n      const y2 = modP(y * y); // denominator is always non-0 mod p.\n      const u = modP(y2 - _1n); // u = y² - 1\n      const v = modP(d * y2 - a); // v = d y² + 1.\n      let { isValid, value: x } = uvRatio(u, v); // √(u/v)\n      if (!isValid) throw new Error('Point.fromHex: invalid y coordinate');\n      const isXOdd = (x & _1n) === _1n; // There are 2 square roots. Use x_0 bit to select proper\n      const isLastByteOdd = (lastByte & 0x80) !== 0; // x_0, last bit\n      if (!zip215 && x === _0n && isLastByteOdd)\n        // if x=0 and x_0 = 1, fail\n        throw new Error('Point.fromHex: x=0 and x_0=1');\n      if (isLastByteOdd !== isXOdd) x = modP(-x); // if x_0 != x mod 2, set x = p-x\n      return Point.fromAffine({ x, y });\n    }\n    static fromPrivateKey(privKey: Hex) {\n      return getExtendedPublicKey(privKey).point;\n    }\n    toRawBytes(): Uint8Array {\n      const { x, y } = this.toAffine();\n      const bytes = ut.numberToBytesLE(y, Fp.BYTES); // each y has 2 x values (x, -y)\n      bytes[bytes.length - 1] |= x & _1n ? 0x80 : 0; // when compressing, it's enough to store y\n      return bytes; // and use the last byte to encode sign of x\n    }\n    toHex(): string {\n      return ut.bytesToHex(this.toRawBytes()); // Same as toRawBytes, but returns string.\n    }\n  }\n  const { BASE: G, ZERO: I } = Point;\n  const wnaf = wNAF(Point, nByteLength * 8);\n\n  function modN(a: bigint) {\n    return mod(a, CURVE_ORDER);\n  }\n  // Little-endian SHA512 with modulo n\n  function modN_LE(hash: Uint8Array): bigint {\n    return modN(ut.bytesToNumberLE(hash));\n  }\n\n  /** Convenience method that creates public key and other stuff. RFC8032 5.1.5 */\n  function getExtendedPublicKey(key: Hex) {\n    const len = Fp.BYTES;\n    key = ensureBytes('private key', key, len);\n    // Hash private key with curve's hash function to produce uniformingly random input\n    // Check byte lengths: ensure(64, h(ensure(32, key)))\n    const hashed = ensureBytes('hashed private key', cHash(key), 2 * len);\n    const head = adjustScalarBytes(hashed.slice(0, len)); // clear first half bits, produce FE\n    const prefix = hashed.slice(len, 2 * len); // second half is called key prefix (5.1.6)\n    const scalar = modN_LE(head); // The actual private scalar\n    const point = G.multiply(scalar); // Point on Edwards curve aka public key\n    const pointBytes = point.toRawBytes(); // Uint8Array representation\n    return { head, prefix, scalar, point, pointBytes };\n  }\n\n  // Calculates EdDSA pub key. RFC8032 5.1.5. Privkey is hashed. Use first half with 3 bits cleared\n  function getPublicKey(privKey: Hex): Uint8Array {\n    return getExtendedPublicKey(privKey).pointBytes;\n  }\n\n  // int('LE', SHA512(dom2(F, C) || msgs)) mod N\n  function hashDomainToScalar(context: Hex = new Uint8Array(), ...msgs: Uint8Array[]) {\n    const msg = ut.concatBytes(...msgs);\n    return modN_LE(cHash(domain(msg, ensureBytes('context', context), !!prehash)));\n  }\n\n  /** Signs message with privateKey. RFC8032 5.1.6 */\n  function sign(msg: Hex, privKey: Hex, options: { context?: Hex } = {}): Uint8Array {\n    msg = ensureBytes('message', msg);\n    if (prehash) msg = prehash(msg); // for ed25519ph etc.\n    const { prefix, scalar, pointBytes } = getExtendedPublicKey(privKey);\n    const r = hashDomainToScalar(options.context, prefix, msg); // r = dom2(F, C) || prefix || PH(M)\n    const R = G.multiply(r).toRawBytes(); // R = rG\n    const k = hashDomainToScalar(options.context, R, pointBytes, msg); // R || A || PH(M)\n    const s = modN(r + k * scalar); // S = (r + k * s) mod L\n    ut.aInRange('signature.s', s, _0n, CURVE_ORDER); // 0 <= s < l\n    const res = ut.concatBytes(R, ut.numberToBytesLE(s, Fp.BYTES));\n    return ensureBytes('result', res, Fp.BYTES * 2); // 64-byte signature\n  }\n\n  const verifyOpts: { context?: Hex; zip215?: boolean } = VERIFY_DEFAULT;\n\n  /**\n   * Verifies EdDSA signature against message and public key. RFC8032 5.1.7.\n   * An extended group equation is checked.\n   */\n  function verify(sig: Hex, msg: Hex, publicKey: Hex, options = verifyOpts): boolean {\n    const { context, zip215 } = options;\n    const len = Fp.BYTES; // Verifies EdDSA signature against message and public key. RFC8032 5.1.7.\n    sig = ensureBytes('signature', sig, 2 * len); // An extended group equation is checked.\n    msg = ensureBytes('message', msg);\n    publicKey = ensureBytes('publicKey', publicKey, len);\n    if (zip215 !== undefined) abool('zip215', zip215);\n    if (prehash) msg = prehash(msg); // for ed25519ph, etc\n\n    const s = ut.bytesToNumberLE(sig.slice(len, 2 * len));\n    let A, R, SB;\n    try {\n      // zip215=true is good for consensus-critical apps. =false follows RFC8032 / NIST186-5.\n      // zip215=true:  0 <= y < MASK (2^256 for ed25519)\n      // zip215=false: 0 <= y < P (2^255-19 for ed25519)\n      A = Point.fromHex(publicKey, zip215);\n      R = Point.fromHex(sig.slice(0, len), zip215);\n      SB = G.multiplyUnsafe(s); // 0 <= s < l is done inside\n    } catch (error) {\n      return false;\n    }\n    if (!zip215 && A.isSmallOrder()) return false;\n\n    const k = hashDomainToScalar(context, R.toRawBytes(), A.toRawBytes(), msg);\n    const RkA = R.add(A.multiplyUnsafe(k));\n    // Extended group equation\n    // [8][S]B = [8]R + [8][k]A'\n    return RkA.subtract(SB).clearCofactor().equals(Point.ZERO);\n  }\n\n  G._setWindowSize(8); // Enable precomputes. Slows down first publicKey computation by 20ms.\n\n  const utils = {\n    getExtendedPublicKey,\n    // ed25519 private keys are uniform 32b. No need to check for modulo bias, like in secp256k1.\n    randomPrivateKey: (): Uint8Array => randomBytes(Fp.BYTES),\n\n    /**\n     * We're doing scalar multiplication (used in getPublicKey etc) with precomputed BASE_POINT\n     * values. This slows down first getPublicKey() by milliseconds (see Speed section),\n     * but allows to speed-up subsequent getPublicKey() calls up to 20x.\n     * @param windowSize 2, 4, 8, 16\n     */\n    precompute(windowSize = 8, point: ExtPointType = Point.BASE): ExtPointType {\n      point._setWindowSize(windowSize);\n      point.multiply(BigInt(3));\n      return point;\n    },\n  };\n\n  return {\n    CURVE,\n    getPublicKey,\n    sign,\n    verify,\n    ExtendedPoint: Point,\n    utils,\n  };\n}\n","/**\n * ed25519 Twisted Edwards curve with following addons:\n * - X25519 ECDH\n * - Ristretto cofactor elimination\n * - Elligator hash-to-group / point indistinguishability\n * @module\n */\n/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\nimport { sha512 } from '@noble/hashes/sha512';\nimport { concatBytes, randomBytes, utf8ToBytes } from '@noble/hashes/utils';\nimport { type AffinePoint, type Group, pippenger } from './abstract/curve.js';\nimport { type CurveFn, type ExtPointType, twistedEdwards } from './abstract/edwards.js';\nimport {\n  createHasher,\n  expand_message_xmd,\n  type htfBasicOpts,\n  type HTFMethod,\n} from './abstract/hash-to-curve.js';\nimport { Field, FpSqrtEven, isNegativeLE, mod, pow2 } from './abstract/modular.js';\nimport { montgomery, type CurveFn as XCurveFn } from './abstract/montgomery.js';\nimport {\n  bytesToHex,\n  bytesToNumberLE,\n  ensureBytes,\n  equalBytes,\n  type Hex,\n  numberToBytesLE,\n} from './abstract/utils.js';\n\nconst ED25519_P = BigInt(\n  '57896044618658097711785492504343953926634992332820282019728792003956564819949'\n);\n// √(-1) aka √(a) aka 2^((p-1)/4)\nconst ED25519_SQRT_M1 = /* @__PURE__ */ BigInt(\n  '19681161376707505956807079304988542015446066515923890162744021073123829784752'\n);\n\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3);\n// prettier-ignore\nconst _5n = BigInt(5), _8n = BigInt(8);\n\nfunction ed25519_pow_2_252_3(x: bigint) {\n  // prettier-ignore\n  const _10n = BigInt(10), _20n = BigInt(20), _40n = BigInt(40), _80n = BigInt(80);\n  const P = ED25519_P;\n  const x2 = (x * x) % P;\n  const b2 = (x2 * x) % P; // x^3, 11\n  const b4 = (pow2(b2, _2n, P) * b2) % P; // x^15, 1111\n  const b5 = (pow2(b4, _1n, P) * x) % P; // x^31\n  const b10 = (pow2(b5, _5n, P) * b5) % P;\n  const b20 = (pow2(b10, _10n, P) * b10) % P;\n  const b40 = (pow2(b20, _20n, P) * b20) % P;\n  const b80 = (pow2(b40, _40n, P) * b40) % P;\n  const b160 = (pow2(b80, _80n, P) * b80) % P;\n  const b240 = (pow2(b160, _80n, P) * b80) % P;\n  const b250 = (pow2(b240, _10n, P) * b10) % P;\n  const pow_p_5_8 = (pow2(b250, _2n, P) * x) % P;\n  // ^ To pow to (p+3)/8, multiply it by x.\n  return { pow_p_5_8, b2 };\n}\n\nfunction adjustScalarBytes(bytes: Uint8Array): Uint8Array {\n  // Section 5: For X25519, in order to decode 32 random bytes as an integer scalar,\n  // set the three least significant bits of the first byte\n  bytes[0] &= 248; // 0b1111_1000\n  // and the most significant bit of the last to zero,\n  bytes[31] &= 127; // 0b0111_1111\n  // set the second most significant bit of the last byte to 1\n  bytes[31] |= 64; // 0b0100_0000\n  return bytes;\n}\n\n// sqrt(u/v)\nfunction uvRatio(u: bigint, v: bigint): { isValid: boolean; value: bigint } {\n  const P = ED25519_P;\n  const v3 = mod(v * v * v, P); // v³\n  const v7 = mod(v3 * v3 * v, P); // v⁷\n  // (p+3)/8 and (p-5)/8\n  const pow = ed25519_pow_2_252_3(u * v7).pow_p_5_8;\n  let x = mod(u * v3 * pow, P); // (uv³)(uv⁷)^(p-5)/8\n  const vx2 = mod(v * x * x, P); // vx²\n  const root1 = x; // First root candidate\n  const root2 = mod(x * ED25519_SQRT_M1, P); // Second root candidate\n  const useRoot1 = vx2 === u; // If vx² = u (mod p), x is a square root\n  const useRoot2 = vx2 === mod(-u, P); // If vx² = -u, set x <-- x * 2^((p-1)/4)\n  const noRoot = vx2 === mod(-u * ED25519_SQRT_M1, P); // There is no valid root, vx² = -u√(-1)\n  if (useRoot1) x = root1;\n  if (useRoot2 || noRoot) x = root2; // We return root2 anyway, for const-time\n  if (isNegativeLE(x, P)) x = mod(-x, P);\n  return { isValid: useRoot1 || useRoot2, value: x };\n}\n\n// Just in case\nexport const ED25519_TORSION_SUBGROUP: string[] = [\n  '0100000000000000000000000000000000000000000000000000000000000000',\n  'c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac037a',\n  '0000000000000000000000000000000000000000000000000000000000000080',\n  '26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc05',\n  'ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f',\n  '26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc85',\n  '0000000000000000000000000000000000000000000000000000000000000000',\n  'c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac03fa',\n];\n\nconst Fp = /* @__PURE__ */ (() => Field(ED25519_P, undefined, true))();\n\nconst ed25519Defaults = /* @__PURE__ */ (() =>\n  ({\n    // Param: a\n    a: BigInt(-1), // Fp.create(-1) is proper; our way still works and is faster\n    // d is equal to -121665/121666 over finite field.\n    // Negative number is P - number, and division is invert(number, P)\n    d: BigInt('37095705934669439343138083508754565189542113879843219016388785533085940283555'),\n    // Finite field 𝔽p over which we'll do calculations; 2n**255n - 19n\n    Fp,\n    // Subgroup order: how many points curve has\n    // 2n**252n + 27742317777372353535851937790883648493n;\n    n: BigInt('7237005577332262213973186563042994240857116359379907606001950938285454250989'),\n    // Cofactor\n    h: _8n,\n    // Base point (x, y) aka generator point\n    Gx: BigInt('15112221349535400772501151409588531511454012693041857206046113283949847762202'),\n    Gy: BigInt('46316835694926478169428394003475163141307993866256225615783033603165251855960'),\n    hash: sha512,\n    randomBytes,\n    adjustScalarBytes,\n    // dom2\n    // Ratio of u to v. Allows us to combine inversion and square root. Uses algo from RFC8032 5.1.3.\n    // Constant-time, u/√v\n    uvRatio,\n  }) as const)();\n\n/**\n * ed25519 curve with EdDSA signatures.\n * @example\n * import { ed25519 } from '@noble/curves/ed25519';\n * const priv = ed25519.utils.randomPrivateKey();\n * const pub = ed25519.getPublicKey(priv);\n * const msg = new TextEncoder().encode('hello');\n * const sig = ed25519.sign(msg, priv);\n * ed25519.verify(sig, msg, pub); // Default mode: follows ZIP215\n * ed25519.verify(sig, msg, pub, { zip215: false }); // RFC8032 / FIPS 186-5\n */\nexport const ed25519: CurveFn = /* @__PURE__ */ (() => twistedEdwards(ed25519Defaults))();\n\nfunction ed25519_domain(data: Uint8Array, ctx: Uint8Array, phflag: boolean) {\n  if (ctx.length > 255) throw new Error('Context is too big');\n  return concatBytes(\n    utf8ToBytes('SigEd25519 no Ed25519 collisions'),\n    new Uint8Array([phflag ? 1 : 0, ctx.length]),\n    ctx,\n    data\n  );\n}\n\nexport const ed25519ctx: CurveFn = /* @__PURE__ */ (() =>\n  twistedEdwards({\n    ...ed25519Defaults,\n    domain: ed25519_domain,\n  }))();\nexport const ed25519ph: CurveFn = /* @__PURE__ */ (() =>\n  twistedEdwards(\n    Object.assign({}, ed25519Defaults, {\n      domain: ed25519_domain,\n      prehash: sha512,\n    })\n  ))();\n\n/**\n * ECDH using curve25519 aka x25519.\n * @example\n * import { x25519 } from '@noble/curves/ed25519';\n * const priv = 'a546e36bf0527c9d3b16154b82465edd62144c0ac1fc5a18506a2244ba449ac4';\n * const pub = 'e6db6867583030db3594c1a424b15f7c726624ec26b3353b10a903a6d0ab1c4c';\n * x25519.getSharedSecret(priv, pub) === x25519.scalarMult(priv, pub); // aliases\n * x25519.getPublicKey(priv) === x25519.scalarMultBase(priv);\n * x25519.getPublicKey(x25519.utils.randomPrivateKey());\n */\nexport const x25519: XCurveFn = /* @__PURE__ */ (() =>\n  montgomery({\n    P: ED25519_P,\n    a: BigInt(486662),\n    montgomeryBits: 255, // n is 253 bits\n    nByteLength: 32,\n    Gu: BigInt(9),\n    powPminus2: (x: bigint): bigint => {\n      const P = ED25519_P;\n      // x^(p-2) aka x^(2^255-21)\n      const { pow_p_5_8, b2 } = ed25519_pow_2_252_3(x);\n      return mod(pow2(pow_p_5_8, _3n, P) * b2, P);\n    },\n    adjustScalarBytes,\n    randomBytes,\n  }))();\n\n/**\n * Converts ed25519 public key to x25519 public key. Uses formula:\n * * `(u, v) = ((1+y)/(1-y), sqrt(-486664)*u/x)`\n * * `(x, y) = (sqrt(-486664)*u/v, (u-1)/(u+1))`\n * @example\n *   const someonesPub = ed25519.getPublicKey(ed25519.utils.randomPrivateKey());\n *   const aPriv = x25519.utils.randomPrivateKey();\n *   x25519.getSharedSecret(aPriv, edwardsToMontgomeryPub(someonesPub))\n */\nexport function edwardsToMontgomeryPub(edwardsPub: Hex): Uint8Array {\n  const { y } = ed25519.ExtendedPoint.fromHex(edwardsPub);\n  const _1n = BigInt(1);\n  return Fp.toBytes(Fp.create((_1n + y) * Fp.inv(_1n - y)));\n}\nexport const edwardsToMontgomery: typeof edwardsToMontgomeryPub = edwardsToMontgomeryPub; // deprecated\n\n/**\n * Converts ed25519 secret key to x25519 secret key.\n * @example\n *   const someonesPub = x25519.getPublicKey(x25519.utils.randomPrivateKey());\n *   const aPriv = ed25519.utils.randomPrivateKey();\n *   x25519.getSharedSecret(edwardsToMontgomeryPriv(aPriv), someonesPub)\n */\nexport function edwardsToMontgomeryPriv(edwardsPriv: Uint8Array): Uint8Array {\n  const hashed = ed25519Defaults.hash(edwardsPriv.subarray(0, 32));\n  return ed25519Defaults.adjustScalarBytes(hashed).subarray(0, 32);\n}\n\n// Hash To Curve Elligator2 Map (NOTE: different from ristretto255 elligator)\n// NOTE: very important part is usage of FpSqrtEven for ELL2_C1_EDWARDS, since\n// SageMath returns different root first and everything falls apart\n\nconst ELL2_C1 = /* @__PURE__ */ (() => (Fp.ORDER + _3n) / _8n)(); // 1. c1 = (q + 3) / 8       # Integer arithmetic\nconst ELL2_C2 = /* @__PURE__ */ (() => Fp.pow(_2n, ELL2_C1))(); // 2. c2 = 2^c1\nconst ELL2_C3 = /* @__PURE__ */ (() => Fp.sqrt(Fp.neg(Fp.ONE)))(); // 3. c3 = sqrt(-1)\n\n// prettier-ignore\nfunction map_to_curve_elligator2_curve25519(u: bigint) {\n  const ELL2_C4 = (Fp.ORDER - _5n) / _8n; // 4. c4 = (q - 5) / 8       # Integer arithmetic\n  const ELL2_J = BigInt(486662);\n\n  let tv1 = Fp.sqr(u);          //  1.  tv1 = u^2\n  tv1 = Fp.mul(tv1, _2n);       //  2.  tv1 = 2 * tv1\n  let xd = Fp.add(tv1, Fp.ONE); //  3.   xd = tv1 + 1         # Nonzero: -1 is square (mod p), tv1 is not\n  let x1n = Fp.neg(ELL2_J);     //  4.  x1n = -J              # x1 = x1n / xd = -J / (1 + 2 * u^2)\n  let tv2 = Fp.sqr(xd);         //  5.  tv2 = xd^2\n  let gxd = Fp.mul(tv2, xd);    //  6.  gxd = tv2 * xd        # gxd = xd^3\n  let gx1 = Fp.mul(tv1, ELL2_J);//  7.  gx1 = J * tv1         # x1n + J * xd\n  gx1 = Fp.mul(gx1, x1n);       //  8.  gx1 = gx1 * x1n       # x1n^2 + J * x1n * xd\n  gx1 = Fp.add(gx1, tv2);       //  9.  gx1 = gx1 + tv2       # x1n^2 + J * x1n * xd + xd^2\n  gx1 = Fp.mul(gx1, x1n);       //  10. gx1 = gx1 * x1n       # x1n^3 + J * x1n^2 * xd + x1n * xd^2\n  let tv3 = Fp.sqr(gxd);        //  11. tv3 = gxd^2\n  tv2 = Fp.sqr(tv3);            //  12. tv2 = tv3^2           # gxd^4\n  tv3 = Fp.mul(tv3, gxd);       //  13. tv3 = tv3 * gxd       # gxd^3\n  tv3 = Fp.mul(tv3, gx1);       //  14. tv3 = tv3 * gx1       # gx1 * gxd^3\n  tv2 = Fp.mul(tv2, tv3);       //  15. tv2 = tv2 * tv3       # gx1 * gxd^7\n  let y11 = Fp.pow(tv2, ELL2_C4); //  16. y11 = tv2^c4        # (gx1 * gxd^7)^((p - 5) / 8)\n  y11 = Fp.mul(y11, tv3);       //  17. y11 = y11 * tv3       # gx1*gxd^3*(gx1*gxd^7)^((p-5)/8)\n  let y12 = Fp.mul(y11, ELL2_C3); //  18. y12 = y11 * c3\n  tv2 = Fp.sqr(y11);            //  19. tv2 = y11^2\n  tv2 = Fp.mul(tv2, gxd);       //  20. tv2 = tv2 * gxd\n  let e1 = Fp.eql(tv2, gx1);    //  21.  e1 = tv2 == gx1\n  let y1 = Fp.cmov(y12, y11, e1); //  22.  y1 = CMOV(y12, y11, e1)  # If g(x1) is square, this is its sqrt\n  let x2n = Fp.mul(x1n, tv1);   //  23. x2n = x1n * tv1       # x2 = x2n / xd = 2 * u^2 * x1n / xd\n  let y21 = Fp.mul(y11, u);     //  24. y21 = y11 * u\n  y21 = Fp.mul(y21, ELL2_C2);   //  25. y21 = y21 * c2\n  let y22 = Fp.mul(y21, ELL2_C3); //  26. y22 = y21 * c3\n  let gx2 = Fp.mul(gx1, tv1);   //  27. gx2 = gx1 * tv1       # g(x2) = gx2 / gxd = 2 * u^2 * g(x1)\n  tv2 = Fp.sqr(y21);            //  28. tv2 = y21^2\n  tv2 = Fp.mul(tv2, gxd);       //  29. tv2 = tv2 * gxd\n  let e2 = Fp.eql(tv2, gx2);    //  30.  e2 = tv2 == gx2\n  let y2 = Fp.cmov(y22, y21, e2); //  31.  y2 = CMOV(y22, y21, e2)  # If g(x2) is square, this is its sqrt\n  tv2 = Fp.sqr(y1);             //  32. tv2 = y1^2\n  tv2 = Fp.mul(tv2, gxd);       //  33. tv2 = tv2 * gxd\n  let e3 = Fp.eql(tv2, gx1);    //  34.  e3 = tv2 == gx1\n  let xn = Fp.cmov(x2n, x1n, e3); //  35.  xn = CMOV(x2n, x1n, e3)  # If e3, x = x1, else x = x2\n  let y = Fp.cmov(y2, y1, e3);  //  36.   y = CMOV(y2, y1, e3)    # If e3, y = y1, else y = y2\n  let e4 = Fp.isOdd(y);         //  37.  e4 = sgn0(y) == 1        # Fix sign of y\n  y = Fp.cmov(y, Fp.neg(y), e3 !== e4); //  38.   y = CMOV(y, -y, e3 XOR e4)\n  return { xMn: xn, xMd: xd, yMn: y, yMd: _1n }; //  39. return (xn, xd, y, 1)\n}\n\nconst ELL2_C1_EDWARDS = /* @__PURE__ */ (() => FpSqrtEven(Fp, Fp.neg(BigInt(486664))))(); // sgn0(c1) MUST equal 0\nfunction map_to_curve_elligator2_edwards25519(u: bigint) {\n  const { xMn, xMd, yMn, yMd } = map_to_curve_elligator2_curve25519(u); //  1.  (xMn, xMd, yMn, yMd) =\n  // map_to_curve_elligator2_curve25519(u)\n  let xn = Fp.mul(xMn, yMd); //  2.  xn = xMn * yMd\n  xn = Fp.mul(xn, ELL2_C1_EDWARDS); //  3.  xn = xn * c1\n  let xd = Fp.mul(xMd, yMn); //  4.  xd = xMd * yMn    # xn / xd = c1 * xM / yM\n  let yn = Fp.sub(xMn, xMd); //  5.  yn = xMn - xMd\n  let yd = Fp.add(xMn, xMd); //  6.  yd = xMn + xMd    # (n / d - 1) / (n / d + 1) = (n - d) / (n + d)\n  let tv1 = Fp.mul(xd, yd); //  7. tv1 = xd * yd\n  let e = Fp.eql(tv1, Fp.ZERO); //  8.   e = tv1 == 0\n  xn = Fp.cmov(xn, Fp.ZERO, e); //  9.  xn = CMOV(xn, 0, e)\n  xd = Fp.cmov(xd, Fp.ONE, e); //  10. xd = CMOV(xd, 1, e)\n  yn = Fp.cmov(yn, Fp.ONE, e); //  11. yn = CMOV(yn, 1, e)\n  yd = Fp.cmov(yd, Fp.ONE, e); //  12. yd = CMOV(yd, 1, e)\n\n  const inv = Fp.invertBatch([xd, yd]); // batch division\n  return { x: Fp.mul(xn, inv[0]), y: Fp.mul(yn, inv[1]) }; //  13. return (xn, xd, yn, yd)\n}\n\nconst htf = /* @__PURE__ */ (() =>\n  createHasher(\n    ed25519.ExtendedPoint,\n    (scalars: bigint[]) => map_to_curve_elligator2_edwards25519(scalars[0]),\n    {\n      DST: 'edwards25519_XMD:SHA-512_ELL2_RO_',\n      encodeDST: 'edwards25519_XMD:SHA-512_ELL2_NU_',\n      p: Fp.ORDER,\n      m: 1,\n      k: 128,\n      expand: 'xmd',\n      hash: sha512,\n    }\n  ))();\nexport const hashToCurve: HTFMethod<bigint> = /* @__PURE__ */ (() => htf.hashToCurve)();\nexport const encodeToCurve: HTFMethod<bigint> = /* @__PURE__ */ (() => htf.encodeToCurve)();\n\nfunction assertRstPoint(other: unknown) {\n  if (!(other instanceof RistPoint)) throw new Error('RistrettoPoint expected');\n}\n\n// √(-1) aka √(a) aka 2^((p-1)/4)\nconst SQRT_M1 = ED25519_SQRT_M1;\n// √(ad - 1)\nconst SQRT_AD_MINUS_ONE = /* @__PURE__ */ BigInt(\n  '25063068953384623474111414158702152701244531502492656460079210482610430750235'\n);\n// 1 / √(a-d)\nconst INVSQRT_A_MINUS_D = /* @__PURE__ */ BigInt(\n  '54469307008909316920995813868745141605393597292927456921205312896311721017578'\n);\n// 1-d²\nconst ONE_MINUS_D_SQ = /* @__PURE__ */ BigInt(\n  '1159843021668779879193775521855586647937357759715417654439879720876111806838'\n);\n// (d-1)²\nconst D_MINUS_ONE_SQ = /* @__PURE__ */ BigInt(\n  '40440834346308536858101042469323190826248399146238708352240133220865137265952'\n);\n// Calculates 1/√(number)\nconst invertSqrt = (number: bigint) => uvRatio(_1n, number);\n\nconst MAX_255B = /* @__PURE__ */ BigInt(\n  '0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'\n);\nconst bytes255ToNumberLE = (bytes: Uint8Array) =>\n  ed25519.CURVE.Fp.create(bytesToNumberLE(bytes) & MAX_255B);\n\ntype ExtendedPoint = ExtPointType;\n\n// Computes Elligator map for Ristretto\n// https://ristretto.group/formulas/elligator.html\nfunction calcElligatorRistrettoMap(r0: bigint): ExtendedPoint {\n  const { d } = ed25519.CURVE;\n  const P = ed25519.CURVE.Fp.ORDER;\n  const mod = ed25519.CURVE.Fp.create;\n  const r = mod(SQRT_M1 * r0 * r0); // 1\n  const Ns = mod((r + _1n) * ONE_MINUS_D_SQ); // 2\n  let c = BigInt(-1); // 3\n  const D = mod((c - d * r) * mod(r + d)); // 4\n  let { isValid: Ns_D_is_sq, value: s } = uvRatio(Ns, D); // 5\n  let s_ = mod(s * r0); // 6\n  if (!isNegativeLE(s_, P)) s_ = mod(-s_);\n  if (!Ns_D_is_sq) s = s_; // 7\n  if (!Ns_D_is_sq) c = r; // 8\n  const Nt = mod(c * (r - _1n) * D_MINUS_ONE_SQ - D); // 9\n  const s2 = s * s;\n  const W0 = mod((s + s) * D); // 10\n  const W1 = mod(Nt * SQRT_AD_MINUS_ONE); // 11\n  const W2 = mod(_1n - s2); // 12\n  const W3 = mod(_1n + s2); // 13\n  return new ed25519.ExtendedPoint(mod(W0 * W3), mod(W2 * W1), mod(W1 * W3), mod(W0 * W2));\n}\n\n/**\n * Each ed25519/ExtendedPoint has 8 different equivalent points. This can be\n * a source of bugs for protocols like ring signatures. Ristretto was created to solve this.\n * Ristretto point operates in X:Y:Z:T extended coordinates like ExtendedPoint,\n * but it should work in its own namespace: do not combine those two.\n * https://datatracker.ietf.org/doc/html/draft-irtf-cfrg-ristretto255-decaf448\n */\nclass RistPoint implements Group<RistPoint> {\n  static BASE: RistPoint;\n  static ZERO: RistPoint;\n  // Private property to discourage combining ExtendedPoint + RistrettoPoint\n  // Always use Ristretto encoding/decoding instead.\n  constructor(private readonly ep: ExtendedPoint) {}\n\n  static fromAffine(ap: AffinePoint<bigint>): RistPoint {\n    return new RistPoint(ed25519.ExtendedPoint.fromAffine(ap));\n  }\n\n  /**\n   * Takes uniform output of 64-byte hash function like sha512 and converts it to `RistrettoPoint`.\n   * The hash-to-group operation applies Elligator twice and adds the results.\n   * **Note:** this is one-way map, there is no conversion from point to hash.\n   * https://ristretto.group/formulas/elligator.html\n   * @param hex 64-byte output of a hash function\n   */\n  static hashToCurve(hex: Hex): RistPoint {\n    hex = ensureBytes('ristrettoHash', hex, 64);\n    const r1 = bytes255ToNumberLE(hex.slice(0, 32));\n    const R1 = calcElligatorRistrettoMap(r1);\n    const r2 = bytes255ToNumberLE(hex.slice(32, 64));\n    const R2 = calcElligatorRistrettoMap(r2);\n    return new RistPoint(R1.add(R2));\n  }\n\n  /**\n   * Converts ristretto-encoded string to ristretto point.\n   * https://ristretto.group/formulas/decoding.html\n   * @param hex Ristretto-encoded 32 bytes. Not every 32-byte string is valid ristretto encoding\n   */\n  static fromHex(hex: Hex): RistPoint {\n    hex = ensureBytes('ristrettoHex', hex, 32);\n    const { a, d } = ed25519.CURVE;\n    const P = ed25519.CURVE.Fp.ORDER;\n    const mod = ed25519.CURVE.Fp.create;\n    const emsg = 'RistrettoPoint.fromHex: the hex is not valid encoding of RistrettoPoint';\n    const s = bytes255ToNumberLE(hex);\n    // 1. Check that s_bytes is the canonical encoding of a field element, or else abort.\n    // 3. Check that s is non-negative, or else abort\n    if (!equalBytes(numberToBytesLE(s, 32), hex) || isNegativeLE(s, P)) throw new Error(emsg);\n    const s2 = mod(s * s);\n    const u1 = mod(_1n + a * s2); // 4 (a is -1)\n    const u2 = mod(_1n - a * s2); // 5\n    const u1_2 = mod(u1 * u1);\n    const u2_2 = mod(u2 * u2);\n    const v = mod(a * d * u1_2 - u2_2); // 6\n    const { isValid, value: I } = invertSqrt(mod(v * u2_2)); // 7\n    const Dx = mod(I * u2); // 8\n    const Dy = mod(I * Dx * v); // 9\n    let x = mod((s + s) * Dx); // 10\n    if (isNegativeLE(x, P)) x = mod(-x); // 10\n    const y = mod(u1 * Dy); // 11\n    const t = mod(x * y); // 12\n    if (!isValid || isNegativeLE(t, P) || y === _0n) throw new Error(emsg);\n    return new RistPoint(new ed25519.ExtendedPoint(x, y, _1n, t));\n  }\n\n  static msm(points: RistPoint[], scalars: bigint[]): RistPoint {\n    const Fn = Field(ed25519.CURVE.n, ed25519.CURVE.nBitLength);\n    return pippenger(RistPoint, Fn, points, scalars);\n  }\n\n  /**\n   * Encodes ristretto point to Uint8Array.\n   * https://ristretto.group/formulas/encoding.html\n   */\n  toRawBytes(): Uint8Array {\n    let { ex: x, ey: y, ez: z, et: t } = this.ep;\n    const P = ed25519.CURVE.Fp.ORDER;\n    const mod = ed25519.CURVE.Fp.create;\n    const u1 = mod(mod(z + y) * mod(z - y)); // 1\n    const u2 = mod(x * y); // 2\n    // Square root always exists\n    const u2sq = mod(u2 * u2);\n    const { value: invsqrt } = invertSqrt(mod(u1 * u2sq)); // 3\n    const D1 = mod(invsqrt * u1); // 4\n    const D2 = mod(invsqrt * u2); // 5\n    const zInv = mod(D1 * D2 * t); // 6\n    let D: bigint; // 7\n    if (isNegativeLE(t * zInv, P)) {\n      let _x = mod(y * SQRT_M1);\n      let _y = mod(x * SQRT_M1);\n      x = _x;\n      y = _y;\n      D = mod(D1 * INVSQRT_A_MINUS_D);\n    } else {\n      D = D2; // 8\n    }\n    if (isNegativeLE(x * zInv, P)) y = mod(-y); // 9\n    let s = mod((z - y) * D); // 10 (check footer's note, no sqrt(-a))\n    if (isNegativeLE(s, P)) s = mod(-s);\n    return numberToBytesLE(s, 32); // 11\n  }\n\n  toHex(): string {\n    return bytesToHex(this.toRawBytes());\n  }\n\n  toString(): string {\n    return this.toHex();\n  }\n\n  // Compare one point to another.\n  equals(other: RistPoint): boolean {\n    assertRstPoint(other);\n    const { ex: X1, ey: Y1 } = this.ep;\n    const { ex: X2, ey: Y2 } = other.ep;\n    const mod = ed25519.CURVE.Fp.create;\n    // (x1 * y2 == y1 * x2) | (y1 * y2 == x1 * x2)\n    const one = mod(X1 * Y2) === mod(Y1 * X2);\n    const two = mod(Y1 * Y2) === mod(X1 * X2);\n    return one || two;\n  }\n\n  add(other: RistPoint): RistPoint {\n    assertRstPoint(other);\n    return new RistPoint(this.ep.add(other.ep));\n  }\n\n  subtract(other: RistPoint): RistPoint {\n    assertRstPoint(other);\n    return new RistPoint(this.ep.subtract(other.ep));\n  }\n\n  multiply(scalar: bigint): RistPoint {\n    return new RistPoint(this.ep.multiply(scalar));\n  }\n\n  multiplyUnsafe(scalar: bigint): RistPoint {\n    return new RistPoint(this.ep.multiplyUnsafe(scalar));\n  }\n\n  double(): RistPoint {\n    return new RistPoint(this.ep.double());\n  }\n\n  negate(): RistPoint {\n    return new RistPoint(this.ep.negate());\n  }\n}\nexport const RistrettoPoint: typeof RistPoint = /* @__PURE__ */ (() => {\n  if (!RistPoint.BASE) RistPoint.BASE = new RistPoint(ed25519.ExtendedPoint.BASE);\n  if (!RistPoint.ZERO) RistPoint.ZERO = new RistPoint(ed25519.ExtendedPoint.ZERO);\n  return RistPoint;\n})();\n\n// Hashing to ristretto255. https://www.rfc-editor.org/rfc/rfc9380#appendix-B\nexport const hashToRistretto255 = (msg: Uint8Array, options: htfBasicOpts): RistPoint => {\n  const d = options.DST;\n  const DST = typeof d === 'string' ? utf8ToBytes(d) : d;\n  const uniform_bytes = expand_message_xmd(msg, DST, 64, sha512);\n  const P = RistPoint.hashToCurve(uniform_bytes);\n  return P;\n};\nexport const hash_to_ristretto255: (msg: Uint8Array, options: htfBasicOpts) => RistPoint =\n  hashToRistretto255; // legacy\n","/**\n * SHA2-256 a.k.a. sha256. In JS, it is the fastest hash, even faster than Blake3.\n *\n * To break sha256 using birthday attack, attackers need to try 2^128 hashes.\n * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.\n *\n * Check out [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).\n * @module\n */\nimport { Chi, HashMD, Maj } from './_md.js';\nimport { type CHash, rotr, wrapConstructor } from './utils.js';\n\n/** Round constants: first 32 bits of fractional parts of the cube roots of the first 64 primes 2..311). */\n// prettier-ignore\nconst SHA256_K = /* @__PURE__ */ new Uint32Array([\n  0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,\n  0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,\n  0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,\n  0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,\n  0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n  0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,\n  0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,\n  0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2\n]);\n\n/** Initial state: first 32 bits of fractional parts of the square roots of the first 8 primes 2..19. */\n// prettier-ignore\nconst SHA256_IV = /* @__PURE__ */ new Uint32Array([\n  0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19\n]);\n\n/**\n * Temporary buffer, not used to store anything between runs.\n * Named this way because it matches specification.\n */\nconst SHA256_W = /* @__PURE__ */ new Uint32Array(64);\nexport class SHA256 extends HashMD<SHA256> {\n  // We cannot use array here since array allows indexing by variable\n  // which means optimizer/compiler cannot use registers.\n  protected A: number = SHA256_IV[0] | 0;\n  protected B: number = SHA256_IV[1] | 0;\n  protected C: number = SHA256_IV[2] | 0;\n  protected D: number = SHA256_IV[3] | 0;\n  protected E: number = SHA256_IV[4] | 0;\n  protected F: number = SHA256_IV[5] | 0;\n  protected G: number = SHA256_IV[6] | 0;\n  protected H: number = SHA256_IV[7] | 0;\n\n  constructor() {\n    super(64, 32, 8, false);\n  }\n  protected get(): [number, number, number, number, number, number, number, number] {\n    const { A, B, C, D, E, F, G, H } = this;\n    return [A, B, C, D, E, F, G, H];\n  }\n  // prettier-ignore\n  protected set(\n    A: number, B: number, C: number, D: number, E: number, F: number, G: number, H: number\n  ): void {\n    this.A = A | 0;\n    this.B = B | 0;\n    this.C = C | 0;\n    this.D = D | 0;\n    this.E = E | 0;\n    this.F = F | 0;\n    this.G = G | 0;\n    this.H = H | 0;\n  }\n  protected process(view: DataView, offset: number): void {\n    // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array\n    for (let i = 0; i < 16; i++, offset += 4) SHA256_W[i] = view.getUint32(offset, false);\n    for (let i = 16; i < 64; i++) {\n      const W15 = SHA256_W[i - 15];\n      const W2 = SHA256_W[i - 2];\n      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3);\n      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10);\n      SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;\n    }\n    // Compression function main loop, 64 rounds\n    let { A, B, C, D, E, F, G, H } = this;\n    for (let i = 0; i < 64; i++) {\n      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);\n      const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;\n      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);\n      const T2 = (sigma0 + Maj(A, B, C)) | 0;\n      H = G;\n      G = F;\n      F = E;\n      E = (D + T1) | 0;\n      D = C;\n      C = B;\n      B = A;\n      A = (T1 + T2) | 0;\n    }\n    // Add the compressed chunk to the current hash value\n    A = (A + this.A) | 0;\n    B = (B + this.B) | 0;\n    C = (C + this.C) | 0;\n    D = (D + this.D) | 0;\n    E = (E + this.E) | 0;\n    F = (F + this.F) | 0;\n    G = (G + this.G) | 0;\n    H = (H + this.H) | 0;\n    this.set(A, B, C, D, E, F, G, H);\n  }\n  protected roundClean(): void {\n    SHA256_W.fill(0);\n  }\n  destroy(): void {\n    this.set(0, 0, 0, 0, 0, 0, 0, 0);\n    this.buffer.fill(0);\n  }\n}\n\n/**\n * Constants taken from https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf.\n */\nclass SHA224 extends SHA256 {\n  protected A = 0xc1059ed8 | 0;\n  protected B = 0x367cd507 | 0;\n  protected C = 0x3070dd17 | 0;\n  protected D = 0xf70e5939 | 0;\n  protected E = 0xffc00b31 | 0;\n  protected F = 0x68581511 | 0;\n  protected G = 0x64f98fa7 | 0;\n  protected H = 0xbefa4fa4 | 0;\n  constructor() {\n    super();\n    this.outputLen = 28;\n  }\n}\n\n/** SHA2-256 hash function */\nexport const sha256: CHash = /* @__PURE__ */ wrapConstructor(() => new SHA256());\n/** SHA2-224 hash function */\nexport const sha224: CHash = /* @__PURE__ */ wrapConstructor(() => new SHA224());\n","// @ts-check\n\n/**\n * Base58 characters include numbers 123456789, uppercase ABCDEFGHJKLMNPQRSTUVWXYZ and lowercase abcdefghijkmnopqrstuvwxyz.\n * @typedef {String} base58_chars Base58 characters include numbers 123456789, uppercase ABCDEFGHJKLMNPQRSTUVWXYZ and lowercase abcdefghijkmnopqrstuvwxyz.\n */\nconst base58_chars =\n  \"123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz\";\n\nexport default base58_chars;\n","// @ts-check\n\nimport base58_chars from \"./base58_chars.mjs\";\n\n/**\n * Converts a base58 string to the corresponding binary representation.\n * @param { import(\"./base58_chars.mjs\").base58_chars } base58String base58 encoded string.\n * @returns {Uint8Array} Binary representation for the base58 string.\n * @example\n * ```js\n * const bin = base58_to_binary(\"6MRy\")\n * console.log(bin)\n * ```\n * Logged output will be Uint8Array(3) [15, 239, 64].\n */\nfunction base58_to_binary(base58String) {\n  if (!base58String || typeof base58String !== \"string\")\n    throw new Error(`Expected base58 string but got “${base58String}”`);\n  if (base58String.match(/[IOl0]/gmu))\n    throw new Error(\n      `Invalid base58 character “${base58String.match(/[IOl0]/gmu)}”`\n    );\n  const lz = base58String.match(/^1+/gmu);\n  const psz = lz ? lz[0].length : 0;\n  const size =\n    ((base58String.length - psz) * (Math.log(58) / Math.log(256)) + 1) >>> 0;\n\n  return new Uint8Array([\n    ...new Uint8Array(psz),\n    ...base58String\n      .match(/.{1}/gmu)\n      .map((i) => base58_chars.indexOf(i))\n      .reduce((acc, i) => {\n        acc = acc.map((j) => {\n          const x = j * 58 + i;\n          i = x >> 8;\n          return x;\n        });\n        return acc;\n      }, new Uint8Array(size))\n      .reverse()\n      .filter(\n        (\n          (lastValue) => (value) =>\n            // @ts-ignore\n            (lastValue = lastValue || value)\n        )(false)\n      ),\n  ]);\n}\n\nexport default base58_to_binary;\n","// @ts-check\n\nimport base58_chars from \"./base58_chars.mjs\";\nimport create_base58_map from \"./create_base58_map.mjs\";\n\nconst base58Map = create_base58_map();\n\n/** @typedef {import(\"./base58_chars.mjs\").base58_chars} base58_chars */\n\n/**\n * Converts a Uint8Array into a base58 string.\n * @param {Uint8Array} uint8array Unsigned integer array.\n * @returns { import(\"./base58_chars.mjs\").base58_chars } base58 string representation of the binary array.\n * @example <caption>Usage.</caption>\n * ```js\n * const str = binary_to_base58([15, 239, 64])\n * console.log(str)\n * ```\n * Logged output will be 6MRy.\n */\nfunction binary_to_base58(uint8array) {\n  const result = [];\n\n  for (const byte of uint8array) {\n    let carry = byte;\n    for (let j = 0; j < result.length; ++j) {\n      // @ts-ignore\n      const x = (base58Map[result[j]] << 8) + carry;\n      result[j] = base58_chars.charCodeAt(x % 58);\n      carry = (x / 58) | 0;\n    }\n    while (carry) {\n      result.push(base58_chars.charCodeAt(carry % 58));\n      carry = (carry / 58) | 0;\n    }\n  }\n\n  for (const byte of uint8array)\n    if (byte) break;\n    else result.push(\"1\".charCodeAt(0));\n\n  result.reverse();\n\n  return String.fromCharCode(...result);\n}\n\nexport default binary_to_base58;\n","// @ts-check\n\nimport base58_chars from \"./base58_chars.mjs\";\n\n/**\n * Generates a mapping between base58 and ascii.\n * @returns {Array<Number>} mapping between ascii and base58.\n */\nconst create_base58_map = () => {\n  const base58M = Array(256).fill(-1);\n  for (let i = 0; i < base58_chars.length; ++i)\n    base58M[base58_chars.charCodeAt(i)] = i;\n\n  return base58M;\n};\n\nexport default create_base58_map;\n","/**\n *  base64.ts\n *\n *  Licensed under the BSD 3-Clause License.\n *    http://opensource.org/licenses/BSD-3-Clause\n *\n *  References:\n *    http://en.wikipedia.org/wiki/Base64\n *\n * @author Dan Kogai (https://github.com/dankogai)\n */\nconst version = '3.7.7';\n/**\n * @deprecated use lowercase `version`.\n */\nconst VERSION = version;\nconst _hasBuffer = typeof Buffer === 'function';\nconst _TD = typeof TextDecoder === 'function' ? new TextDecoder() : undefined;\nconst _TE = typeof TextEncoder === 'function' ? new TextEncoder() : undefined;\nconst b64ch = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';\nconst b64chs = Array.prototype.slice.call(b64ch);\nconst b64tab = ((a) => {\n    let tab = {};\n    a.forEach((c, i) => tab[c] = i);\n    return tab;\n})(b64chs);\nconst b64re = /^(?:[A-Za-z\\d+\\/]{4})*?(?:[A-Za-z\\d+\\/]{2}(?:==)?|[A-Za-z\\d+\\/]{3}=?)?$/;\nconst _fromCC = String.fromCharCode.bind(String);\nconst _U8Afrom = typeof Uint8Array.from === 'function'\n    ? Uint8Array.from.bind(Uint8Array)\n    : (it) => new Uint8Array(Array.prototype.slice.call(it, 0));\nconst _mkUriSafe = (src) => src\n    .replace(/=/g, '').replace(/[+\\/]/g, (m0) => m0 == '+' ? '-' : '_');\nconst _tidyB64 = (s) => s.replace(/[^A-Za-z0-9\\+\\/]/g, '');\n/**\n * polyfill version of `btoa`\n */\nconst btoaPolyfill = (bin) => {\n    // console.log('polyfilled');\n    let u32, c0, c1, c2, asc = '';\n    const pad = bin.length % 3;\n    for (let i = 0; i < bin.length;) {\n        if ((c0 = bin.charCodeAt(i++)) > 255 ||\n            (c1 = bin.charCodeAt(i++)) > 255 ||\n            (c2 = bin.charCodeAt(i++)) > 255)\n            throw new TypeError('invalid character found');\n        u32 = (c0 << 16) | (c1 << 8) | c2;\n        asc += b64chs[u32 >> 18 & 63]\n            + b64chs[u32 >> 12 & 63]\n            + b64chs[u32 >> 6 & 63]\n            + b64chs[u32 & 63];\n    }\n    return pad ? asc.slice(0, pad - 3) + \"===\".substring(pad) : asc;\n};\n/**\n * does what `window.btoa` of web browsers do.\n * @param {String} bin binary string\n * @returns {string} Base64-encoded string\n */\nconst _btoa = typeof btoa === 'function' ? (bin) => btoa(bin)\n    : _hasBuffer ? (bin) => Buffer.from(bin, 'binary').toString('base64')\n        : btoaPolyfill;\nconst _fromUint8Array = _hasBuffer\n    ? (u8a) => Buffer.from(u8a).toString('base64')\n    : (u8a) => {\n        // cf. https://stackoverflow.com/questions/12710001/how-to-convert-uint8-array-to-base64-encoded-string/12713326#12713326\n        const maxargs = 0x1000;\n        let strs = [];\n        for (let i = 0, l = u8a.length; i < l; i += maxargs) {\n            strs.push(_fromCC.apply(null, u8a.subarray(i, i + maxargs)));\n        }\n        return _btoa(strs.join(''));\n    };\n/**\n * converts a Uint8Array to a Base64 string.\n * @param {boolean} [urlsafe] URL-and-filename-safe a la RFC4648 §5\n * @returns {string} Base64 string\n */\nconst fromUint8Array = (u8a, urlsafe = false) => urlsafe ? _mkUriSafe(_fromUint8Array(u8a)) : _fromUint8Array(u8a);\n// This trick is found broken https://github.com/dankogai/js-base64/issues/130\n// const utob = (src: string) => unescape(encodeURIComponent(src));\n// reverting good old fationed regexp\nconst cb_utob = (c) => {\n    if (c.length < 2) {\n        var cc = c.charCodeAt(0);\n        return cc < 0x80 ? c\n            : cc < 0x800 ? (_fromCC(0xc0 | (cc >>> 6))\n                + _fromCC(0x80 | (cc & 0x3f)))\n                : (_fromCC(0xe0 | ((cc >>> 12) & 0x0f))\n                    + _fromCC(0x80 | ((cc >>> 6) & 0x3f))\n                    + _fromCC(0x80 | (cc & 0x3f)));\n    }\n    else {\n        var cc = 0x10000\n            + (c.charCodeAt(0) - 0xD800) * 0x400\n            + (c.charCodeAt(1) - 0xDC00);\n        return (_fromCC(0xf0 | ((cc >>> 18) & 0x07))\n            + _fromCC(0x80 | ((cc >>> 12) & 0x3f))\n            + _fromCC(0x80 | ((cc >>> 6) & 0x3f))\n            + _fromCC(0x80 | (cc & 0x3f)));\n    }\n};\nconst re_utob = /[\\uD800-\\uDBFF][\\uDC00-\\uDFFFF]|[^\\x00-\\x7F]/g;\n/**\n * @deprecated should have been internal use only.\n * @param {string} src UTF-8 string\n * @returns {string} UTF-16 string\n */\nconst utob = (u) => u.replace(re_utob, cb_utob);\n//\nconst _encode = _hasBuffer\n    ? (s) => Buffer.from(s, 'utf8').toString('base64')\n    : _TE\n        ? (s) => _fromUint8Array(_TE.encode(s))\n        : (s) => _btoa(utob(s));\n/**\n * converts a UTF-8-encoded string to a Base64 string.\n * @param {boolean} [urlsafe] if `true` make the result URL-safe\n * @returns {string} Base64 string\n */\nconst encode = (src, urlsafe = false) => urlsafe\n    ? _mkUriSafe(_encode(src))\n    : _encode(src);\n/**\n * converts a UTF-8-encoded string to URL-safe Base64 RFC4648 §5.\n * @returns {string} Base64 string\n */\nconst encodeURI = (src) => encode(src, true);\n// This trick is found broken https://github.com/dankogai/js-base64/issues/130\n// const btou = (src: string) => decodeURIComponent(escape(src));\n// reverting good old fationed regexp\nconst re_btou = /[\\xC0-\\xDF][\\x80-\\xBF]|[\\xE0-\\xEF][\\x80-\\xBF]{2}|[\\xF0-\\xF7][\\x80-\\xBF]{3}/g;\nconst cb_btou = (cccc) => {\n    switch (cccc.length) {\n        case 4:\n            var cp = ((0x07 & cccc.charCodeAt(0)) << 18)\n                | ((0x3f & cccc.charCodeAt(1)) << 12)\n                | ((0x3f & cccc.charCodeAt(2)) << 6)\n                | (0x3f & cccc.charCodeAt(3)), offset = cp - 0x10000;\n            return (_fromCC((offset >>> 10) + 0xD800)\n                + _fromCC((offset & 0x3FF) + 0xDC00));\n        case 3:\n            return _fromCC(((0x0f & cccc.charCodeAt(0)) << 12)\n                | ((0x3f & cccc.charCodeAt(1)) << 6)\n                | (0x3f & cccc.charCodeAt(2)));\n        default:\n            return _fromCC(((0x1f & cccc.charCodeAt(0)) << 6)\n                | (0x3f & cccc.charCodeAt(1)));\n    }\n};\n/**\n * @deprecated should have been internal use only.\n * @param {string} src UTF-16 string\n * @returns {string} UTF-8 string\n */\nconst btou = (b) => b.replace(re_btou, cb_btou);\n/**\n * polyfill version of `atob`\n */\nconst atobPolyfill = (asc) => {\n    // console.log('polyfilled');\n    asc = asc.replace(/\\s+/g, '');\n    if (!b64re.test(asc))\n        throw new TypeError('malformed base64.');\n    asc += '=='.slice(2 - (asc.length & 3));\n    let u24, bin = '', r1, r2;\n    for (let i = 0; i < asc.length;) {\n        u24 = b64tab[asc.charAt(i++)] << 18\n            | b64tab[asc.charAt(i++)] << 12\n            | (r1 = b64tab[asc.charAt(i++)]) << 6\n            | (r2 = b64tab[asc.charAt(i++)]);\n        bin += r1 === 64 ? _fromCC(u24 >> 16 & 255)\n            : r2 === 64 ? _fromCC(u24 >> 16 & 255, u24 >> 8 & 255)\n                : _fromCC(u24 >> 16 & 255, u24 >> 8 & 255, u24 & 255);\n    }\n    return bin;\n};\n/**\n * does what `window.atob` of web browsers do.\n * @param {String} asc Base64-encoded string\n * @returns {string} binary string\n */\nconst _atob = typeof atob === 'function' ? (asc) => atob(_tidyB64(asc))\n    : _hasBuffer ? (asc) => Buffer.from(asc, 'base64').toString('binary')\n        : atobPolyfill;\n//\nconst _toUint8Array = _hasBuffer\n    ? (a) => _U8Afrom(Buffer.from(a, 'base64'))\n    : (a) => _U8Afrom(_atob(a).split('').map(c => c.charCodeAt(0)));\n/**\n * converts a Base64 string to a Uint8Array.\n */\nconst toUint8Array = (a) => _toUint8Array(_unURI(a));\n//\nconst _decode = _hasBuffer\n    ? (a) => Buffer.from(a, 'base64').toString('utf8')\n    : _TD\n        ? (a) => _TD.decode(_toUint8Array(a))\n        : (a) => btou(_atob(a));\nconst _unURI = (a) => _tidyB64(a.replace(/[-_]/g, (m0) => m0 == '-' ? '+' : '/'));\n/**\n * converts a Base64 string to a UTF-8 string.\n * @param {String} src Base64 string.  Both normal and URL-safe are supported\n * @returns {string} UTF-8 string\n */\nconst decode = (src) => _decode(_unURI(src));\n/**\n * check if a value is a valid Base64 string\n * @param {String} src a value to check\n  */\nconst isValid = (src) => {\n    if (typeof src !== 'string')\n        return false;\n    const s = src.replace(/\\s+/g, '').replace(/={0,2}$/, '');\n    return !/[^\\s0-9a-zA-Z\\+/]/.test(s) || !/[^\\s0-9a-zA-Z\\-_]/.test(s);\n};\n//\nconst _noEnum = (v) => {\n    return {\n        value: v, enumerable: false, writable: true, configurable: true\n    };\n};\n/**\n * extend String.prototype with relevant methods\n */\nconst extendString = function () {\n    const _add = (name, body) => Object.defineProperty(String.prototype, name, _noEnum(body));\n    _add('fromBase64', function () { return decode(this); });\n    _add('toBase64', function (urlsafe) { return encode(this, urlsafe); });\n    _add('toBase64URI', function () { return encode(this, true); });\n    _add('toBase64URL', function () { return encode(this, true); });\n    _add('toUint8Array', function () { return toUint8Array(this); });\n};\n/**\n * extend Uint8Array.prototype with relevant methods\n */\nconst extendUint8Array = function () {\n    const _add = (name, body) => Object.defineProperty(Uint8Array.prototype, name, _noEnum(body));\n    _add('toBase64', function (urlsafe) { return fromUint8Array(this, urlsafe); });\n    _add('toBase64URI', function () { return fromUint8Array(this, true); });\n    _add('toBase64URL', function () { return fromUint8Array(this, true); });\n};\n/**\n * extend Builtin prototypes with relevant methods\n */\nconst extendBuiltins = () => {\n    extendString();\n    extendUint8Array();\n};\nconst gBase64 = {\n    version: version,\n    VERSION: VERSION,\n    atob: _atob,\n    atobPolyfill: atobPolyfill,\n    btoa: _btoa,\n    btoaPolyfill: btoaPolyfill,\n    fromBase64: decode,\n    toBase64: encode,\n    encode: encode,\n    encodeURI: encodeURI,\n    encodeURL: encodeURI,\n    utob: utob,\n    btou: btou,\n    decode: decode,\n    isValid: isValid,\n    fromUint8Array: fromUint8Array,\n    toUint8Array: toUint8Array,\n    extendString: extendString,\n    extendUint8Array: extendUint8Array,\n    extendBuiltins: extendBuiltins\n};\n// makecjs:CUT //\nexport { version };\nexport { VERSION };\nexport { _atob as atob };\nexport { atobPolyfill };\nexport { _btoa as btoa };\nexport { btoaPolyfill };\nexport { decode as fromBase64 };\nexport { encode as toBase64 };\nexport { utob };\nexport { encode };\nexport { encodeURI };\nexport { encodeURI as encodeURL };\nexport { btou };\nexport { decode };\nexport { isValid };\nexport { fromUint8Array };\nexport { toUint8Array };\nexport { extendString };\nexport { extendUint8Array };\nexport { extendBuiltins };\n// and finally,\nexport { gBase64 as Base64 };\n","export const LsPrefix = \"__fastnear_\";\n\nexport interface StorageBackend {\n  getItem(key: string): string | null;\n  setItem(key: string, value: string): void;\n  removeItem(key: string): void;\n  clear(): void;\n}\n\n// Default: Use `localStorage` if available, otherwise an in-memory fallback\nexport const createDefaultStorage = (): StorageBackend =>\n  typeof localStorage !== \"undefined\"\n    ? localStorage\n    : {\n      getItem: (key) => memoryStore.get(key) || null,\n      setItem: (key, value) => memoryStore.set(key, value),\n      removeItem: (key) => memoryStore.delete(key),\n      clear: () => memoryStore.clear(),\n    };\n\nexport const memoryStore = new Map<string, string>(); // Internal memory storage\n\nlet storageBackend: StorageBackend = createDefaultStorage();\n\n// Functional storage module\nexport const storage = {\n  setBackend: (customBackend: StorageBackend) => {\n    storageBackend = customBackend;\n  },\n\n  set: (key: string, value: any) => {\n    if (value === null || value === undefined) {\n      storageBackend.removeItem(LsPrefix + key);\n    } else {\n      storageBackend.setItem(LsPrefix + key, JSON.stringify(value));\n    }\n  },\n\n  get: (key: string): any => {\n    const value = storageBackend.getItem(LsPrefix + key);\n    if (value === null) return null;\n    try {\n      return JSON.parse(value);\n    } catch {\n      return value; // Return raw string if not JSON\n    }\n  },\n\n  remove: (key: string) => storageBackend.removeItem(key),\n  clear: () => storageBackend.clear(),\n};\n","import {\n  binary_to_base58 as toBase58,\n  base58_to_binary as fromBase58,\n} from \"base58-js\";\nimport Big from \"big.js\";\nimport {\n  encode as JsBase64Encode,\n  decode as JsBase64Decode,\n  fromUint8Array as JsBase64FromUint8Array,\n  toUint8Array as JsBase64ToUint8Array\n} from 'js-base64';\nimport { storage } from \"./storage.js\";\n\nexport { toBase58, fromBase58 };\n\nexport function toHex(data: Uint8Array): string {\n  return Array.from(data)\n    .map(b => b.toString(16).padStart(2, '0'))\n    .join('');\n}\n\nexport function fromHex(hex: string): Uint8Array {\n  if (hex.length % 2) throw new Error('Hex string must be even length');\n  const bytes = new Uint8Array(hex.length / 2);\n  for (let i = 0; i < hex.length; i += 2) {\n    bytes[i/2] = parseInt(hex.slice(i, i + 2), 16);\n  }\n  return bytes;\n}\n\nexport function base64ToBytes(b64Val: string): Uint8Array {\n  return JsBase64ToUint8Array(b64Val);\n}\n\nexport function bytesToBase64(bytesArr: Uint8Array): string {\n  return JsBase64FromUint8Array(bytesArr);\n}\n\nexport function toBase64(strVal: string) {\n  try {\n    return JsBase64Encode(strVal);\n  } catch (e) {\n    console.error('Issue base64 encoding', e);\n    return null;\n  }\n}\n\nexport function fromBase64(strVal: string) {\n  try {\n    return JsBase64Decode(strVal);\n  } catch (e) {\n    console.error('Issue base64 decoding', e);\n    return null;\n  }\n}\n\nexport function convertUnit(s: string | TemplateStringsArray, ...args: any[]): string {\n  // Reconstruct raw string from template literal\n  if (Array.isArray(s)) {\n    s = s.reduce((acc, part, i) => {\n      return acc + (args[i - 1] ?? \"\") + part;\n    });\n  }\n  // Convert from `100 NEAR` into yoctoNear\n  if (typeof s == \"string\") {\n    const match = s.match(/([0-9.,_]+)\\s*([a-zA-Z]+)?/);\n    if (match) {\n      const amount = match[1].replace(/[_,]/g, \"\");\n      const unitPart = match[2];\n      if (unitPart) {\n        switch (unitPart.toLowerCase()) {\n          case \"near\":\n            return Big(amount).mul(Big(10).pow(24)).toFixed(0);\n          case \"tgas\":\n            return Big(amount).mul(Big(10).pow(12)).toFixed(0);\n          case \"ggas\":\n            return Big(amount).mul(Big(10).pow(9)).toFixed(0);\n          case \"gas\":\n          case \"yoctonear\":\n            return Big(amount).toFixed(0);\n          default:\n            throw new Error(`Unknown unit: ${unitPart}`);\n        }\n      } else {\n        return Big(amount).toFixed(0);\n      }\n    }\n  }\n  return Big(`${s}`).toFixed(0);\n}\n\nexport function lsSet(key: string, value: any) {\n  storage.set(key, value);\n}\n\nexport function lsGet(key: string): any {\n  return storage.get(key);\n}\n\nexport function deepCopy(obj) {\n  return JSON.parse(JSON.stringify(obj));\n}\n\nexport function tryParseJson(...args) {\n  try {\n    return JSON.parse(args[0]);\n  } catch {\n    if (args.length > 1) {\n      return args[1];\n    }\n    return args[0];\n  }\n}\n\nexport function parseJsonFromBytes(bytes: Uint8Array) {\n  try {\n    const decoder = new TextDecoder();\n    return JSON.parse(\n      decoder.decode(bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes))\n    );\n  } catch (e) {\n    try {\n      return bytes instanceof Uint8Array ? bytes : new Uint8Array(bytes);\n    } catch (e) {\n      return bytes;\n    }\n  }\n}\n\nexport function canSignWithLAK(actions) {\n  return (\n    actions.length === 1 &&\n    actions[0].type === \"FunctionCall\" &&\n    Big(actions[0]?.deposit ?? \"0\").eq(0)\n  );\n}\n","import { ed25519 } from \"@noble/curves/ed25519\";\nimport { sha256 } from \"@noble/hashes/sha2\";\nimport { fromBase58, toBase58 } from \"./misc.js\";\nimport { Hex } from \"@noble/curves/abstract/utils\";\n\nexport { sha256 };\n\nexport const keyFromString = (key) =>\n  fromBase58(\n    key.includes(\":\")\n      ? (() => {\n          const [curve, keyPart] = key.split(\":\");\n          if (curve !== \"ed25519\") {\n            throw new Error(`Unsupported curve: ${curve}`);\n          }\n          return keyPart;\n        })()\n      : key,\n  );\n\nexport const keyToString = (key: Uint8Array) => `ed25519:${toBase58(key)}`;\n\nexport function publicKeyFromPrivate(privateKey: string) {\n  const secret = keyFromString(privateKey).slice(0, 32);\n  const publicKey = ed25519.getPublicKey(secret);\n  return keyToString(publicKey);\n}\n\nexport function privateKeyFromRandom() {\n  const privateKey = crypto.getRandomValues(new Uint8Array(64));\n  return keyToString(privateKey);\n}\n\nexport function signHash(hashBytes: Uint8Array, privateKey: string, opts?: any): Hex {\n  const secret = keyFromString(privateKey).slice(0, 32);\n  const signature = ed25519.sign(hashBytes, secret);\n\n  if (opts?.returnBase58) {\n    return toBase58(signature);\n  }\n\n  return signature;\n}\n\nexport function signBytes(bytes: Uint8Array, privateKey: string) {\n  const hash = sha256(bytes);\n  return signHash(hash, privateKey);\n}\n","export var integers = ['u8', 'u16', 'u32', 'u64', 'u128', 'i8', 'i16', 'i32', 'i64', 'i128', 'f32', 'f64'];\n","var EncodeBuffer = /** @class */ (function () {\n    function EncodeBuffer() {\n        this.offset = 0;\n        this.buffer_size = 256;\n        this.buffer = new ArrayBuffer(this.buffer_size);\n        this.view = new DataView(this.buffer);\n    }\n    EncodeBuffer.prototype.resize_if_necessary = function (needed_space) {\n        if (this.buffer_size - this.offset < needed_space) {\n            this.buffer_size = Math.max(this.buffer_size * 2, this.buffer_size + needed_space);\n            var new_buffer = new ArrayBuffer(this.buffer_size);\n            new Uint8Array(new_buffer).set(new Uint8Array(this.buffer));\n            this.buffer = new_buffer;\n            this.view = new DataView(new_buffer);\n        }\n    };\n    EncodeBuffer.prototype.get_used_buffer = function () {\n        return new Uint8Array(this.buffer).slice(0, this.offset);\n    };\n    EncodeBuffer.prototype.store_value = function (value, type) {\n        var bSize = type.substring(1);\n        var size = parseInt(bSize) / 8;\n        this.resize_if_necessary(size);\n        var toCall = type[0] === 'f' ? \"setFloat\".concat(bSize) : type[0] === 'i' ? \"setInt\".concat(bSize) : \"setUint\".concat(bSize);\n        this.view[toCall](this.offset, value, true);\n        this.offset += size;\n    };\n    EncodeBuffer.prototype.store_bytes = function (from) {\n        this.resize_if_necessary(from.length);\n        new Uint8Array(this.buffer).set(new Uint8Array(from), this.offset);\n        this.offset += from.length;\n    };\n    return EncodeBuffer;\n}());\nexport { EncodeBuffer };\nvar DecodeBuffer = /** @class */ (function () {\n    function DecodeBuffer(buf) {\n        this.offset = 0;\n        this.buffer_size = buf.length;\n        this.buffer = new ArrayBuffer(buf.length);\n        new Uint8Array(this.buffer).set(buf);\n        this.view = new DataView(this.buffer);\n    }\n    DecodeBuffer.prototype.assert_enough_buffer = function (size) {\n        if (this.offset + size > this.buffer.byteLength) {\n            throw new Error('Error in schema, the buffer is smaller than expected');\n        }\n    };\n    DecodeBuffer.prototype.consume_value = function (type) {\n        var bSize = type.substring(1);\n        var size = parseInt(bSize) / 8;\n        this.assert_enough_buffer(size);\n        var toCall = type[0] === 'f' ? \"getFloat\".concat(bSize) : type[0] === 'i' ? \"getInt\".concat(bSize) : \"getUint\".concat(bSize);\n        var ret = this.view[toCall](this.offset, true);\n        this.offset += size;\n        return ret;\n    };\n    DecodeBuffer.prototype.consume_bytes = function (size) {\n        this.assert_enough_buffer(size);\n        var ret = this.buffer.slice(this.offset, this.offset + size);\n        this.offset += size;\n        return ret;\n    };\n    return DecodeBuffer;\n}());\nexport { DecodeBuffer };\n","var __extends = (this && this.__extends) || (function () {\n    var extendStatics = function (d, b) {\n        extendStatics = Object.setPrototypeOf ||\n            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\n            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\n        return extendStatics(d, b);\n    };\n    return function (d, b) {\n        if (typeof b !== \"function\" && b !== null)\n            throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\n        extendStatics(d, b);\n        function __() { this.constructor = d; }\n        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\n    };\n})();\nimport { integers } from './types.js';\nexport function isArrayLike(value) {\n    // source: https://stackoverflow.com/questions/24048547/checking-if-an-object-is-array-like\n    return (Array.isArray(value) ||\n        (!!value &&\n            typeof value === 'object' &&\n            'length' in value &&\n            typeof (value.length) === 'number' &&\n            (value.length === 0 ||\n                (value.length > 0 &&\n                    (value.length - 1) in value))));\n}\nexport function expect_type(value, type, fieldPath) {\n    if (typeof (value) !== type) {\n        throw new Error(\"Expected \".concat(type, \" not \").concat(typeof (value), \"(\").concat(value, \") at \").concat(fieldPath.join('.')));\n    }\n}\nexport function expect_bigint(value, fieldPath) {\n    var basicType = ['number', 'string', 'bigint', 'boolean'].includes(typeof (value));\n    var strObject = typeof (value) === 'object' && value !== null && 'toString' in value;\n    if (!basicType && !strObject) {\n        throw new Error(\"Expected bigint, number, boolean or string not \".concat(typeof (value), \"(\").concat(value, \") at \").concat(fieldPath.join('.')));\n    }\n}\nexport function expect_same_size(length, expected, fieldPath) {\n    if (length !== expected) {\n        throw new Error(\"Array length \".concat(length, \" does not match schema length \").concat(expected, \" at \").concat(fieldPath.join('.')));\n    }\n}\nexport function expect_enum(value, fieldPath) {\n    if (typeof (value) !== 'object' || value === null) {\n        throw new Error(\"Expected object not \".concat(typeof (value), \"(\").concat(value, \") at \").concat(fieldPath.join('.')));\n    }\n}\n// Validate Schema\nvar VALID_STRING_TYPES = integers.concat(['bool', 'string']);\nvar VALID_OBJECT_KEYS = ['option', 'enum', 'array', 'set', 'map', 'struct'];\nvar ErrorSchema = /** @class */ (function (_super) {\n    __extends(ErrorSchema, _super);\n    function ErrorSchema(schema, expected) {\n        var message = \"Invalid schema: \".concat(JSON.stringify(schema), \" expected \").concat(expected);\n        return _super.call(this, message) || this;\n    }\n    return ErrorSchema;\n}(Error));\nexport { ErrorSchema };\nexport function validate_schema(schema) {\n    if (typeof (schema) === 'string' && VALID_STRING_TYPES.includes(schema)) {\n        return;\n    }\n    if (schema && typeof (schema) === 'object') {\n        var keys = Object.keys(schema);\n        if (keys.length === 1 && VALID_OBJECT_KEYS.includes(keys[0])) {\n            var key = keys[0];\n            if (key === 'option')\n                return validate_schema(schema[key]);\n            if (key === 'enum')\n                return validate_enum_schema(schema[key]);\n            if (key === 'array')\n                return validate_array_schema(schema[key]);\n            if (key === 'set')\n                return validate_schema(schema[key]);\n            if (key === 'map')\n                return validate_map_schema(schema[key]);\n            if (key === 'struct')\n                return validate_struct_schema(schema[key]);\n        }\n    }\n    throw new ErrorSchema(schema, VALID_OBJECT_KEYS.join(', ') + ' or ' + VALID_STRING_TYPES.join(', '));\n}\nfunction validate_enum_schema(schema) {\n    if (!Array.isArray(schema))\n        throw new ErrorSchema(schema, 'Array');\n    for (var _i = 0, schema_1 = schema; _i < schema_1.length; _i++) {\n        var sch = schema_1[_i];\n        if (typeof sch !== 'object' || !('struct' in sch)) {\n            throw new Error('Missing \"struct\" key in enum schema');\n        }\n        if (typeof sch.struct !== 'object' || Object.keys(sch.struct).length !== 1) {\n            throw new Error('The \"struct\" in each enum must have a single key');\n        }\n        validate_schema({ struct: sch.struct });\n    }\n}\nfunction validate_array_schema(schema) {\n    if (typeof schema !== 'object')\n        throw new ErrorSchema(schema, '{ type, len? }');\n    if (schema.len && typeof schema.len !== 'number') {\n        throw new Error(\"Invalid schema: \".concat(schema));\n    }\n    if ('type' in schema)\n        return validate_schema(schema.type);\n    throw new ErrorSchema(schema, '{ type, len? }');\n}\nfunction validate_map_schema(schema) {\n    if (typeof schema === 'object' && 'key' in schema && 'value' in schema) {\n        validate_schema(schema.key);\n        validate_schema(schema.value);\n    }\n    else {\n        throw new ErrorSchema(schema, '{ key, value }');\n    }\n}\nfunction validate_struct_schema(schema) {\n    if (typeof schema !== 'object')\n        throw new ErrorSchema(schema, 'object');\n    for (var key in schema) {\n        validate_schema(schema[key]);\n    }\n}\n","import { integers } from './types.js';\nimport { EncodeBuffer } from './buffer.js';\nimport * as utils from './utils.js';\nvar BorshSerializer = /** @class */ (function () {\n    function BorshSerializer(checkTypes) {\n        this.encoded = new EncodeBuffer();\n        this.fieldPath = ['value'];\n        this.checkTypes = checkTypes;\n    }\n    BorshSerializer.prototype.encode = function (value, schema) {\n        this.encode_value(value, schema);\n        return this.encoded.get_used_buffer();\n    };\n    BorshSerializer.prototype.encode_value = function (value, schema) {\n        if (typeof schema === 'string') {\n            if (integers.includes(schema))\n                return this.encode_integer(value, schema);\n            if (schema === 'string')\n                return this.encode_string(value);\n            if (schema === 'bool')\n                return this.encode_boolean(value);\n        }\n        if (typeof schema === 'object') {\n            if ('option' in schema)\n                return this.encode_option(value, schema);\n            if ('enum' in schema)\n                return this.encode_enum(value, schema);\n            if ('array' in schema)\n                return this.encode_array(value, schema);\n            if ('set' in schema)\n                return this.encode_set(value, schema);\n            if ('map' in schema)\n                return this.encode_map(value, schema);\n            if ('struct' in schema)\n                return this.encode_struct(value, schema);\n        }\n    };\n    BorshSerializer.prototype.encode_integer = function (value, schema) {\n        var size = parseInt(schema.substring(1));\n        if (size <= 32 || schema == 'f64') {\n            this.checkTypes && utils.expect_type(value, 'number', this.fieldPath);\n            this.encoded.store_value(value, schema);\n        }\n        else {\n            this.checkTypes && utils.expect_bigint(value, this.fieldPath);\n            this.encode_bigint(BigInt(value), size);\n        }\n    };\n    BorshSerializer.prototype.encode_bigint = function (value, size) {\n        var buffer_len = size / 8;\n        var buffer = new Uint8Array(buffer_len);\n        for (var i = 0; i < buffer_len; i++) {\n            buffer[i] = Number(value & BigInt(0xff));\n            value = value >> BigInt(8);\n        }\n        this.encoded.store_bytes(new Uint8Array(buffer));\n    };\n    BorshSerializer.prototype.encode_string = function (value) {\n        this.checkTypes && utils.expect_type(value, 'string', this.fieldPath);\n        var _value = value;\n        // encode to utf8 bytes without using TextEncoder\n        var utf8Bytes = [];\n        for (var i = 0; i < _value.length; i++) {\n            var charCode = _value.charCodeAt(i);\n            if (charCode < 0x80) {\n                utf8Bytes.push(charCode);\n            }\n            else if (charCode < 0x800) {\n                utf8Bytes.push(0xc0 | (charCode >> 6), 0x80 | (charCode & 0x3f));\n            }\n            else if (charCode < 0xd800 || charCode >= 0xe000) {\n                utf8Bytes.push(0xe0 | (charCode >> 12), 0x80 | ((charCode >> 6) & 0x3f), 0x80 | (charCode & 0x3f));\n            }\n            else {\n                i++;\n                charCode = 0x10000 + (((charCode & 0x3ff) << 10) | (_value.charCodeAt(i) & 0x3ff));\n                utf8Bytes.push(0xf0 | (charCode >> 18), 0x80 | ((charCode >> 12) & 0x3f), 0x80 | ((charCode >> 6) & 0x3f), 0x80 | (charCode & 0x3f));\n            }\n        }\n        // 4 bytes for length + string bytes\n        this.encoded.store_value(utf8Bytes.length, 'u32');\n        this.encoded.store_bytes(new Uint8Array(utf8Bytes));\n    };\n    BorshSerializer.prototype.encode_boolean = function (value) {\n        this.checkTypes && utils.expect_type(value, 'boolean', this.fieldPath);\n        this.encoded.store_value(value ? 1 : 0, 'u8');\n    };\n    BorshSerializer.prototype.encode_option = function (value, schema) {\n        if (value === null || value === undefined) {\n            this.encoded.store_value(0, 'u8');\n        }\n        else {\n            this.encoded.store_value(1, 'u8');\n            this.encode_value(value, schema.option);\n        }\n    };\n    BorshSerializer.prototype.encode_enum = function (value, schema) {\n        this.checkTypes && utils.expect_enum(value, this.fieldPath);\n        var valueKey = Object.keys(value)[0];\n        for (var i = 0; i < schema[\"enum\"].length; i++) {\n            var valueSchema = schema[\"enum\"][i];\n            if (valueKey === Object.keys(valueSchema.struct)[0]) {\n                this.encoded.store_value(i, 'u8');\n                return this.encode_struct(value, valueSchema);\n            }\n        }\n        throw new Error(\"Enum key (\".concat(valueKey, \") not found in enum schema: \").concat(JSON.stringify(schema), \" at \").concat(this.fieldPath.join('.')));\n    };\n    BorshSerializer.prototype.encode_array = function (value, schema) {\n        if (utils.isArrayLike(value))\n            return this.encode_arraylike(value, schema);\n        if (value instanceof ArrayBuffer)\n            return this.encode_buffer(value, schema);\n        throw new Error(\"Expected Array-like not \".concat(typeof (value), \"(\").concat(value, \") at \").concat(this.fieldPath.join('.')));\n    };\n    BorshSerializer.prototype.encode_arraylike = function (value, schema) {\n        if (schema.array.len) {\n            utils.expect_same_size(value.length, schema.array.len, this.fieldPath);\n        }\n        else {\n            // 4 bytes for length\n            this.encoded.store_value(value.length, 'u32');\n        }\n        // array values\n        for (var i = 0; i < value.length; i++) {\n            this.encode_value(value[i], schema.array.type);\n        }\n    };\n    BorshSerializer.prototype.encode_buffer = function (value, schema) {\n        if (schema.array.len) {\n            utils.expect_same_size(value.byteLength, schema.array.len, this.fieldPath);\n        }\n        else {\n            // 4 bytes for length\n            this.encoded.store_value(value.byteLength, 'u32');\n        }\n        // array values\n        this.encoded.store_bytes(new Uint8Array(value));\n    };\n    BorshSerializer.prototype.encode_set = function (value, schema) {\n        this.checkTypes && utils.expect_type(value, 'object', this.fieldPath);\n        var isSet = value instanceof Set;\n        var values = isSet ? Array.from(value.values()) : Object.values(value);\n        // 4 bytes for length\n        this.encoded.store_value(values.length, 'u32');\n        // set values\n        for (var _i = 0, values_1 = values; _i < values_1.length; _i++) {\n            var value_1 = values_1[_i];\n            this.encode_value(value_1, schema.set);\n        }\n    };\n    BorshSerializer.prototype.encode_map = function (value, schema) {\n        this.checkTypes && utils.expect_type(value, 'object', this.fieldPath);\n        var isMap = value instanceof Map;\n        var keys = isMap ? Array.from(value.keys()) : Object.keys(value);\n        // 4 bytes for length\n        this.encoded.store_value(keys.length, 'u32');\n        // store key/values\n        for (var _i = 0, keys_1 = keys; _i < keys_1.length; _i++) {\n            var key = keys_1[_i];\n            this.encode_value(key, schema.map.key);\n            this.encode_value(isMap ? value.get(key) : value[key], schema.map.value);\n        }\n    };\n    BorshSerializer.prototype.encode_struct = function (value, schema) {\n        this.checkTypes && utils.expect_type(value, 'object', this.fieldPath);\n        for (var _i = 0, _a = Object.keys(schema.struct); _i < _a.length; _i++) {\n            var key = _a[_i];\n            this.fieldPath.push(key);\n            this.encode_value(value[key], schema.struct[key]);\n            this.fieldPath.pop();\n        }\n    };\n    return BorshSerializer;\n}());\nexport { BorshSerializer };\n","import { integers } from './types.js';\nimport { DecodeBuffer } from './buffer.js';\nvar BorshDeserializer = /** @class */ (function () {\n    function BorshDeserializer(bufferArray) {\n        this.buffer = new DecodeBuffer(bufferArray);\n    }\n    BorshDeserializer.prototype.decode = function (schema) {\n        return this.decode_value(schema);\n    };\n    BorshDeserializer.prototype.decode_value = function (schema) {\n        if (typeof schema === 'string') {\n            if (integers.includes(schema))\n                return this.decode_integer(schema);\n            if (schema === 'string')\n                return this.decode_string();\n            if (schema === 'bool')\n                return this.decode_boolean();\n        }\n        if (typeof schema === 'object') {\n            if ('option' in schema)\n                return this.decode_option(schema);\n            if ('enum' in schema)\n                return this.decode_enum(schema);\n            if ('array' in schema)\n                return this.decode_array(schema);\n            if ('set' in schema)\n                return this.decode_set(schema);\n            if ('map' in schema)\n                return this.decode_map(schema);\n            if ('struct' in schema)\n                return this.decode_struct(schema);\n        }\n        throw new Error(\"Unsupported type: \".concat(schema));\n    };\n    BorshDeserializer.prototype.decode_integer = function (schema) {\n        var size = parseInt(schema.substring(1));\n        if (size <= 32 || schema == 'f64') {\n            return this.buffer.consume_value(schema);\n        }\n        return this.decode_bigint(size, schema.startsWith('i'));\n    };\n    BorshDeserializer.prototype.decode_bigint = function (size, signed) {\n        if (signed === void 0) { signed = false; }\n        var buffer_len = size / 8;\n        var buffer = new Uint8Array(this.buffer.consume_bytes(buffer_len));\n        var bits = buffer.reduceRight(function (r, x) { return r + x.toString(16).padStart(2, '0'); }, '');\n        if (signed && buffer[buffer_len - 1]) {\n            return BigInt.asIntN(size, BigInt(\"0x\".concat(bits)));\n        }\n        return BigInt(\"0x\".concat(bits));\n    };\n    BorshDeserializer.prototype.decode_string = function () {\n        var len = this.decode_integer('u32');\n        var buffer = new Uint8Array(this.buffer.consume_bytes(len));\n        // decode utf-8 string without using TextDecoder\n        // first get all bytes to single byte code points\n        var codePoints = [];\n        for (var i = 0; i < len; ++i) {\n            var byte = buffer[i];\n            if (byte < 0x80) {\n                codePoints.push(byte);\n            }\n            else if (byte < 0xE0) {\n                codePoints.push(((byte & 0x1F) << 6) | (buffer[++i] & 0x3F));\n            }\n            else if (byte < 0xF0) {\n                codePoints.push(((byte & 0x0F) << 12) | ((buffer[++i] & 0x3F) << 6) | (buffer[++i] & 0x3F));\n            }\n            else {\n                var codePoint = ((byte & 0x07) << 18) | ((buffer[++i] & 0x3F) << 12) | ((buffer[++i] & 0x3F) << 6) | (buffer[++i] & 0x3F);\n                codePoints.push(codePoint);\n            }\n        }\n        // then decode code points to utf-8\n        return String.fromCodePoint.apply(String, codePoints);\n    };\n    BorshDeserializer.prototype.decode_boolean = function () {\n        return this.buffer.consume_value('u8') > 0;\n    };\n    BorshDeserializer.prototype.decode_option = function (schema) {\n        var option = this.buffer.consume_value('u8');\n        if (option === 1) {\n            return this.decode_value(schema.option);\n        }\n        if (option !== 0) {\n            throw new Error(\"Invalid option \".concat(option));\n        }\n        return null;\n    };\n    BorshDeserializer.prototype.decode_enum = function (schema) {\n        var _a;\n        var valueIndex = this.buffer.consume_value('u8');\n        if (valueIndex > schema[\"enum\"].length) {\n            throw new Error(\"Enum option \".concat(valueIndex, \" is not available\"));\n        }\n        var struct = schema[\"enum\"][valueIndex].struct;\n        var key = Object.keys(struct)[0];\n        return _a = {}, _a[key] = this.decode_value(struct[key]), _a;\n    };\n    BorshDeserializer.prototype.decode_array = function (schema) {\n        var result = [];\n        var len = schema.array.len ? schema.array.len : this.decode_integer('u32');\n        for (var i = 0; i < len; ++i) {\n            result.push(this.decode_value(schema.array.type));\n        }\n        return result;\n    };\n    BorshDeserializer.prototype.decode_set = function (schema) {\n        var len = this.decode_integer('u32');\n        var result = new Set();\n        for (var i = 0; i < len; ++i) {\n            result.add(this.decode_value(schema.set));\n        }\n        return result;\n    };\n    BorshDeserializer.prototype.decode_map = function (schema) {\n        var len = this.decode_integer('u32');\n        var result = new Map();\n        for (var i = 0; i < len; ++i) {\n            var key = this.decode_value(schema.map.key);\n            var value = this.decode_value(schema.map.value);\n            result.set(key, value);\n        }\n        return result;\n    };\n    BorshDeserializer.prototype.decode_struct = function (schema) {\n        var result = {};\n        for (var key in schema.struct) {\n            result[key] = this.decode_value(schema.struct[key]);\n        }\n        return result;\n    };\n    return BorshDeserializer;\n}());\nexport { BorshDeserializer };\n","import { BorshSerializer } from './serialize.js';\nimport { BorshDeserializer } from './deserialize.js';\nimport * as utils from './utils.js';\nexport function serialize(schema, value, validate) {\n    if (validate === void 0) { validate = true; }\n    if (validate)\n        utils.validate_schema(schema);\n    var serializer = new BorshSerializer(validate);\n    return serializer.encode(value, schema);\n}\nexport function deserialize(schema, buffer, validate) {\n    if (validate === void 0) { validate = true; }\n    if (validate)\n        utils.validate_schema(schema);\n    var deserializer = new BorshDeserializer(buffer);\n    return deserializer.decode(schema);\n}\n","import { Schema } from \"borsh\"\n\nexport const nearChainSchema = new (class BorshSchema {\n  Ed25519Signature: Schema = {\n    struct: {\n      data: { array: { type: \"u8\", len: 64 } },\n    },\n  };\n  Secp256k1Signature: Schema = {\n    struct: {\n      data: { array: { type: \"u8\", len: 65 } },\n    },\n  };\n  Signature: Schema = {\n    enum: [\n      { struct: { ed25519Signature: this.Ed25519Signature } },\n      { struct: { secp256k1Signature: this.Secp256k1Signature } },\n    ],\n  };\n  Ed25519Data: Schema = {\n    struct: {\n      data: { array: { type: \"u8\", len: 32 } },\n    },\n  };\n  Secp256k1Data: Schema = {\n    struct: {\n      data: { array: { type: \"u8\", len: 64 } },\n    },\n  };\n  PublicKey: Schema = {\n    enum: [\n      { struct: { ed25519Key: this.Ed25519Data } },\n      { struct: { secp256k1Key: this.Secp256k1Data } },\n    ],\n  };\n  FunctionCallPermission: Schema = {\n    struct: {\n      allowance: { option: \"u128\" },\n      receiverId: \"string\",\n      methodNames: { array: { type: \"string\" } },\n    },\n  };\n  FullAccessPermission: Schema = {\n    struct: {},\n  };\n  AccessKeyPermission: Schema = {\n    enum: [\n      { struct: { functionCall: this.FunctionCallPermission } },\n      { struct: { fullAccess: this.FullAccessPermission } },\n    ],\n  };\n  AccessKey: Schema = {\n    struct: {\n      nonce: \"u64\",\n      permission: this.AccessKeyPermission,\n    },\n  };\n  CreateAccount: Schema = {\n    struct: {},\n  };\n  DeployContract: Schema = {\n    struct: {\n      code: { array: { type: \"u8\" } },\n    },\n  };\n  FunctionCall: Schema = {\n    struct: {\n      methodName: \"string\",\n      args: { array: { type: \"u8\" } },\n      gas: \"u64\",\n      deposit: \"u128\",\n    },\n  };\n  Transfer: Schema = {\n    struct: {\n      deposit: \"u128\",\n    },\n  };\n  Stake: Schema = {\n    struct: {\n      stake: \"u128\",\n      publicKey: this.PublicKey,\n    },\n  };\n  AddKey: Schema = {\n    struct: {\n      publicKey: this.PublicKey,\n      accessKey: this.AccessKey,\n    },\n  };\n  DeleteKey: Schema = {\n    struct: {\n      publicKey: this.PublicKey,\n    },\n  };\n  DeleteAccount: Schema = {\n    struct: {\n      beneficiaryId: \"string\",\n    },\n  };\n  ClassicAction: Schema = {\n    enum: [\n      { struct: { createAccount: this.CreateAccount } },\n      { struct: { deployContract: this.DeployContract } },\n      { struct: { functionCall: this.FunctionCall } },\n      { struct: { transfer: this.Transfer } },\n      { struct: { stake: this.Stake } },\n      { struct: { addKey: this.AddKey } },\n      { struct: { deleteKey: this.DeleteKey } },\n      { struct: { deleteAccount: this.DeleteAccount } },\n    ],\n  };\n  DelegateAction: Schema = {\n    struct: {\n      senderId: \"string\",\n      receiverId: \"string\",\n      actions: { array: { type: this.ClassicAction } },\n      nonce: \"u64\",\n      maxBlockHeight: \"u64\",\n      publicKey: this.PublicKey,\n    },\n  };\n  SignedDelegate: Schema = {\n    struct: {\n      delegateAction: this.DelegateAction,\n      signature: this.Signature,\n    },\n  };\n  Action: Schema = {\n    enum: [\n      { struct: { createAccount: this.CreateAccount } },\n      { struct: { deployContract: this.DeployContract } },\n      { struct: { functionCall: this.FunctionCall } },\n      { struct: { transfer: this.Transfer } },\n      { struct: { stake: this.Stake } },\n      { struct: { addKey: this.AddKey } },\n      { struct: { deleteKey: this.DeleteKey } },\n      { struct: { deleteAccount: this.DeleteAccount } },\n      { struct: { signedDelegate: this.SignedDelegate } },\n    ],\n  };\n  Transaction: Schema = {\n    struct: {\n      signerId: \"string\",\n      publicKey: this.PublicKey,\n      nonce: \"u64\",\n      receiverId: \"string\",\n      blockHash: { array: { type: \"u8\", len: 32 } },\n      actions: { array: { type: this.Action } },\n    },\n  };\n  SignedTransaction: Schema = {\n    struct: {\n      transaction: this.Transaction,\n      signature: this.Signature,\n    },\n  };\n})();\n\nexport const getBorshSchema = () => nearChainSchema;\n","import { serialize as borshSerialize, deserialize as borshDeserialize, Schema } from \"borsh\";\nimport { keyFromString } from \"./crypto.js\";\nimport {base64ToBytes, fromBase58, fromBase64, toBase64} from \"./misc.js\";\nimport { getBorshSchema } from \"@fastnear/borsh-schema\";\n\nexport interface PlainTransaction {\n  signerId: string;\n  publicKey: string;\n  nonce: string | bigint | number;\n  receiverId: string;\n  blockHash: string;\n  actions: Array<any>;\n}\n\nexport interface PlainSignedTransaction {\n  transaction: object;\n  signature: object;\n}\n\n// Function to return a JSON-ready version of the transaction\nexport const txToJson = (tx: PlainTransaction): Record<string, any> => {\n  return JSON.parse(JSON.stringify(tx, (key, value) =>\n    typeof value === 'bigint' ? value.toString() : value\n  ));\n};\n\n// dude let's make this better. head just couldn't find a good name\nexport const txToJsonStringified = (tx: PlainTransaction): string => {\n  return JSON.stringify(txToJson(tx));\n}\n\nexport function mapTransaction(jsonTransaction: PlainTransaction) {\n  return {\n    signerId: jsonTransaction.signerId,\n    publicKey: {\n      ed25519Key: {\n        data: keyFromString(jsonTransaction.publicKey)\n      }\n    },\n    nonce: BigInt(jsonTransaction.nonce),\n    receiverId: jsonTransaction.receiverId,\n    blockHash: fromBase58(jsonTransaction.blockHash),\n    actions: jsonTransaction.actions.map(mapAction)\n  };\n}\n\nexport function serializeTransaction(jsonTransaction: PlainTransaction) {\n  console.log(\"fastnear: serializing transaction\");\n\n  const transaction = mapTransaction(jsonTransaction);\n  console.log(\"fastnear: mapped transaction for borsh:\", transaction);\n\n  return borshSerialize(SCHEMA.Transaction, transaction);\n}\n\nexport function serializeSignedTransaction(jsonTransaction: PlainTransaction, signature) {\n  console.log(\"fastnear: Serializing Signed Transaction\", jsonTransaction);\n  console.log('fastnear: signature', signature)\n  console.log('fastnear: signature length', fromBase58(signature).length)\n\n  const mappedSignedTx = mapTransaction(jsonTransaction)\n  console.log('fastnear: mapped (for borsh schema) signed transaction', mappedSignedTx)\n\n  const plainSignedTransaction: PlainSignedTransaction = {\n    transaction: mappedSignedTx,\n    signature: {\n      ed25519Signature: {\n        data: fromBase58(signature),\n      },\n    },\n  };\n\n  const borshSignedTx = borshSerialize(SCHEMA.SignedTransaction, plainSignedTransaction, true);\n  console.log('fastnear: borsh-serialized signed transaction:', borshSignedTx);\n\n  return borshSignedTx;\n}\n\nexport function mapAction(action: any): object {\n  switch (action.type) {\n    case \"CreateAccount\": {\n      return {\n        createAccount: {},\n      };\n    }\n    case \"DeployContract\": {\n      return {\n        deployContract: {\n          code: base64ToBytes(action.codeBase64),\n        },\n      };\n    }\n    case \"FunctionCall\": {\n      return {\n        functionCall: {\n          methodName: action.methodName,\n          args: (action.argsBase64 !== null && action.argsBase64 !== undefined) ?\n            base64ToBytes(action.argsBase64) :\n            (new TextEncoder().encode(JSON.stringify(action.args))),\n          gas: BigInt(action.gas ?? \"300000000000000\"),\n          deposit: BigInt(action.deposit ?? \"0\"),\n        },\n      };\n    }\n    case \"Transfer\": {\n      return {\n        transfer: {\n          deposit: BigInt(action.deposit),\n        },\n      };\n    }\n    case \"Stake\": {\n      return {\n        stake: {\n          stake: BigInt(action.stake),\n          publicKey: {\n            ed25519Key: {\n              data: keyFromString(action.publicKey),\n            },\n          },\n        },\n      };\n    }\n    case \"AddKey\": {\n      return {\n        addKey: {\n          publicKey: {\n            ed25519Key: {\n              data: keyFromString(action.publicKey),\n            },\n          },\n          accessKey: {\n            nonce: BigInt(action.accessKey.nonce),\n            permission:\n              action.accessKey.permission === \"FullAccess\"\n                ? { fullAccess: {} }\n                : {\n                  functionCall: {\n                    allowance: action.accessKey.allowance\n                      ? BigInt(action.accessKey.allowance)\n                      : null,\n                    receiverId: action.accessKey.receiverId,\n                    methodNames: action.accessKey.methodNames,\n                  },\n                },\n          },\n        },\n      };\n    }\n    case \"DeleteKey\": {\n      return {\n        deleteKey: {\n          publicKey: {\n            ed25519Key: {\n              data: keyFromString(action.publicKey),\n            },\n          },\n        },\n      };\n    }\n    case \"DeleteAccount\": {\n      return {\n        deleteAccount: {\n          beneficiaryId: action.beneficiaryId,\n        },\n      };\n    }\n    case \"SignedDelegate\": {\n      return {\n        signedDelegate: {\n          delegateAction: mapAction(action.delegateAction),\n          signature: {\n            ed25519Signature: fromBase58(action.signature),\n          },\n        },\n      };\n    }\n    default: {\n      throw new Error(\"Not implemented action: \" + action.type);\n    }\n  }\n}\n\nexport const SCHEMA = getBorshSchema();\n","import {\n  lsSet,\n  lsGet,\n  publicKeyFromPrivate,\n} from \"@fastnear/utils\";\nimport {WalletAdapter} from \"@fastnear/wallet-adapter\";\n\nexport const WIDGET_URL = \"https://js.cdn.fastnear.com\";\n\nexport const DEFAULT_NETWORK_ID = \"mainnet\";\nexport const NETWORKS = {\n  testnet: {\n    networkId: \"testnet\",\n    nodeUrl: \"https://rpc.testnet.fastnear.com/\",\n  },\n  mainnet: {\n    networkId: \"mainnet\",\n    nodeUrl: \"https://rpc.mainnet.fastnear.com/\",\n  },\n};\n\nexport interface NetworkConfig {\n  networkId: string;\n  nodeUrl?: string;\n  walletUrl?: string;\n  helperUrl?: string;\n  explorerUrl?: string;\n\n  [key: string]: any;\n}\n\nexport interface AppState {\n  accountId?: string | null;\n  privateKey?: string | null;\n  lastWalletId?: string | null;\n  publicKey?: string | null;\n  accessKeyContractId?: string | null;\n\n  [key: string]: any;\n}\n\nexport interface TxStatus {\n  txId: string;\n  updateTimestamp?: number;\n\n  [key: string]: any;\n}\n\nexport type TxHistory = Record<string, TxStatus>;\n\nexport interface EventListeners {\n  account: Set<(accountId: string) => void>;\n  tx: Set<(tx: TxStatus) => void>;\n}\n\nexport interface UnbroadcastedEvents {\n  account: string[];\n  tx: TxStatus[];\n}\n\nexport interface WalletAdapterState {\n  publicKey?: string | null;\n  privateKey?: string | null;\n  accountId?: string | null;\n  lastWalletId?: string | null;\n  networkId: string;\n}\n\n\n// Load config from localStorage or default to the network's config\nexport let _config: NetworkConfig = lsGet(\"config\") || {\n  ...NETWORKS[DEFAULT_NETWORK_ID]\n};\n\n// Load application state from localStorage\nexport let _state: AppState = lsGet(\"state\") || {};\n\n// Triggered by the wallet adapter\nexport const onAdapterStateUpdate = (state: WalletAdapterState) => {\n  console.log(\"Adapter state update:\", state);\n  const { accountId, lastWalletId, privateKey } = state;\n  update({\n    accountId: accountId || undefined,\n    lastWalletId: lastWalletId || undefined,\n    ...(privateKey ? { privateKey } : {}),\n  });\n}\n\nexport const getWalletAdapterState = (): WalletAdapterState => {\n  return {\n    publicKey: _state.publicKey,\n    accountId: _state.accountId,\n    lastWalletId: _state.lastWalletId,\n    networkId: _config.networkId,\n  };\n}\n\n// We can create an adapter instance here\nexport let _adapter = new WalletAdapter({\n  onStateUpdate: onAdapterStateUpdate,\n  lastState: getWalletAdapterState(),\n  widgetUrl: WIDGET_URL,\n});\n\n// Attempt to set publicKey if we have a privateKey\ntry {\n  _state.publicKey = _state.privateKey\n    ? publicKeyFromPrivate(_state.privateKey)\n    : null;\n} catch (e) {\n  console.error(\"Error parsing private key:\", e);\n  _state.privateKey = null;\n  lsSet(\"nonce\", null);\n}\n\n// Transaction history\nexport let _txHistory: TxHistory = lsGet(\"txHistory\") || {};\n\n\nexport const _unbroadcastedEvents: UnbroadcastedEvents = {\n  account: [],\n  tx: [],\n};\n\n// events / listeners\nexport const events = {\n  _eventListeners: {\n    account: new Set(),\n    tx: new Set(),\n  },\n\n  notifyAccountListeners: (accountId: string) => {\n    if (events._eventListeners.account.size === 0) {\n      _unbroadcastedEvents.account.push(accountId);\n      return;\n    }\n    events._eventListeners.account.forEach((callback: any) => {\n      try {\n        callback(accountId);\n      } catch (e) {\n        console.error(e);\n      }\n    });\n  },\n\n  notifyTxListeners: (tx: TxStatus) => {\n    if (events._eventListeners.tx.size === 0) {\n      _unbroadcastedEvents.tx.push(tx);\n      return;\n    }\n    events._eventListeners.tx.forEach((callback: any) => {\n      try {\n        callback(tx);\n      } catch (e) {\n        console.error(e);\n      }\n    });\n  },\n\n  onAccount: (callback: (accountId: string) => void) => {\n    events._eventListeners.account.add(callback);\n    if (_unbroadcastedEvents.account.length > 0) {\n      const accountEvent = _unbroadcastedEvents.account;\n      _unbroadcastedEvents.account = [];\n      accountEvent.forEach(events.notifyAccountListeners);\n    }\n  },\n\n  onTx: (callback: (tx: TxStatus) => void): void => {\n    events._eventListeners.tx.add(callback);\n    if (_unbroadcastedEvents.tx.length > 0) {\n      const txEvent = _unbroadcastedEvents.tx;\n      _unbroadcastedEvents.tx = [];\n      txEvent.forEach(events.notifyTxListeners);\n    }\n  }\n}\n\n// Mutators\n// @todo: in favor of limiting when out of alpha\n//    but haven't given it enough thought ~ mike\nexport const update = (newState: Partial<AppState>) => {\n  const oldState = _state;\n  _state = {..._state, ...newState};\n\n  lsSet(\"state\", {\n    accountId: _state.accountId,\n    privateKey: _state.privateKey,\n    lastWalletId: _state.lastWalletId,\n    accessKeyContractId: _state.accessKeyContractId,\n  });\n\n  if (\n    newState.hasOwnProperty(\"privateKey\") &&\n    newState.privateKey !== oldState.privateKey\n  ) {\n    _state.publicKey = newState.privateKey\n      ? publicKeyFromPrivate(newState.privateKey as string)\n      : null;\n    lsSet(\"nonce\", null);\n  }\n\n  if (newState.accountId !== oldState.accountId) {\n    events.notifyAccountListeners(newState.accountId as string);\n  }\n\n  if (\n    (newState.hasOwnProperty(\"lastWalletId\") &&\n      newState.lastWalletId !== oldState.lastWalletId) ||\n    (newState.hasOwnProperty(\"accountId\") &&\n      newState.accountId !== oldState.accountId) ||\n    (newState.hasOwnProperty(\"privateKey\") &&\n      newState.privateKey !== oldState.privateKey)\n  ) {\n    _adapter.setState(getWalletAdapterState());\n  }\n}\n\nexport const updateTxHistory = (txStatus: TxStatus) => {\n  const txId = txStatus.txId;\n  _txHistory[txId] = {\n    ...(_txHistory[txId] || {}),\n    ...txStatus,\n    updateTimestamp: Date.now(),\n  };\n  lsSet(\"txHistory\", _txHistory);\n  events.notifyTxListeners(_txHistory[txId]);\n}\n\nexport const getConfig = (): NetworkConfig => {\n  return _config;\n}\n\nexport const getTxHistory = (): TxHistory => {\n  return _txHistory;\n}\n\n// Exposed \"write\" functions\nexport const setConfig = (newConf: NetworkConfig): void => {\n  _config = { ...NETWORKS[newConf.networkId], ...newConf };\n  lsSet(\"config\", _config);\n}\n\nexport const resetTxHistory = (): void => {\n  _txHistory = {};\n  lsSet(\"txHistory\", _txHistory);\n}\n","/**\n * @typedef {Object} WalletState\n * @property {string} [accountId] - NEAR account ID if signed in\n * @property {string} [publicKey] - Public key if available\n * @property {string} [privateKey] - Private key if available\n * @property {string} [lastWalletId] - ID of last used wallet\n * @property {string} [networkId] - ID of last used network\n */\n\n/**\n * @typedef {Object} SignInConfig\n * @property {string} networkId - NEAR network ID ('mainnet' or 'testnet')\n * @property {string} contractId - Contract ID to request access for\n * @property {string} [walletId] - Preferred wallet to use. E.g. 'near', 'here', 'meteor'\n * @property {string} [callbackUrl] - URL to redirect back to after wallet interaction\n */\n\n/**\n * @typedef {Object} SignInResult\n * @property {string} [url] - URL to redirect to if needed\n * @property {string} [accountId] - Account ID if immediately available\n * @property {string} [error] - Error message if sign in failed\n */\nexport interface SignInResult {\n  url?: string;\n  accountId?: string;\n  error?: string;\n}\n\n/**\n * @typedef {Object} Transaction\n * @property {string} [signerId] - Transaction signer account ID\n * @property {string} receiverId - Transaction receiver account ID\n * @property {Object[]} actions - Transaction actions to perform\n */\n\n/**\n * @typedef {Object} TransactionConfig\n * @property {Transaction} transactions - Transaction actions to perform\n * @property {string} [callbackUrl] - URL to redirect back to after wallet interaction\n */\n\n/**\n * @typedef {Object} TransactionResult\n * @property {string} [url] - URL to redirect to if needed\n * @property {string} [hash] - Transaction hash if immediately available\n * @property {string} [error] - Error message if transaction failed\n * Represents the result of attempting to send or execute a transaction.\n */\nexport interface TransactionResult {\n  /** URL to redirect to if needed. */\n  url?: string;\n\n  /** Transaction hash if immediately available. */\n  hash?: string;\n\n  /** Error message if the transaction failed. */\n  error?: string;\n}\n\nexport interface WalletAdapterConstructor {\n  widgetUrl?: string;\n  targetOrigin?: string;\n  onStateUpdate?: (state: any) => void;\n  lastState?: any;\n  callbackUrl?: string;\n}\n\n/**\n * @typedef {Object} WalletAdapterConfig\n * @property {string} [widgetUrl] - URL of the wallet widget (defaults to official hosted version)\n * @property {string} [targetOrigin] - Target origin for postMessage (defaults to '*')\n * @property {string} [lastState] - The last state that was given by WalletAdapter before the redirect or reload.\n * @property {(state: WalletState) => void} [onStateUpdate] - Called when wallet state changes\n * @property {string} [callbackUrl] - Default callback URL for wallet interactions (defaults to current page URL)\n */\n\n/**\n * Interface for interacting with NEAR wallets\n */\nexport class WalletAdapter {\n  /** @type {HTMLIFrameElement} */\n  #iframe: HTMLIFrameElement | null = null;\n\n  /** @type {string} */\n  #targetOrigin;\n\n  /** @type {string} */\n  #widgetUrl;\n\n  /** @type {Map<string, Function>} */\n  #pending = new Map();\n\n  /** @type {WalletState} */\n  #state;\n\n  /** @type {Function} */\n  #onStateUpdate;\n\n  /** @type {string} */\n  #callbackUrl;\n\n  /** @type {string} */\n  static defaultWidgetUrl = \"https://wallet-adapter.fastnear.com\";\n\n  /**\n   * @param {WalletAdapterConfig} [config]\n   */\n  constructor({\n    widgetUrl = WalletAdapter.defaultWidgetUrl,\n    targetOrigin = \"*\",\n    onStateUpdate,\n    lastState,\n    callbackUrl = window.location.href,\n  }: WalletAdapterConstructor = {}) {\n    this.#targetOrigin = targetOrigin;\n    this.#widgetUrl = widgetUrl;\n    this.#onStateUpdate = onStateUpdate;\n    this.#callbackUrl = callbackUrl;\n    this.#state = lastState || {};\n    window.addEventListener(\"message\", this.#handleMessage.bind(this));\n  }\n\n  /**\n   * Creates an iframe for wallet interaction\n   * @param {string} path - Path to load in iframe\n   * @returns {HTMLIFrameElement}\n   */\n  #createIframe(path) {\n    // Remove existing iframe if any\n    if (this.#iframe) {\n      this.#iframe.remove();\n    }\n\n    // Create URL\n    const url = new URL(path, this.#widgetUrl);\n\n    // Create and configure iframe\n    const iframe = document.createElement(\"iframe\");\n    iframe.src = url.toString();\n    iframe.allow = \"usb\";\n    iframe.style.border = \"none\";\n    iframe.style.zIndex = \"10000\";\n    iframe.style.position = \"fixed\";\n    iframe.style.display = \"block\";\n    iframe.style.top = \"0\";\n    iframe.style.left = \"0\";\n    iframe.style.width = \"100%\";\n    iframe.style.height = \"100%\";\n    document.body.appendChild(iframe);\n\n    this.#iframe = iframe;\n    return iframe;\n  }\n\n  /**\n   * Handles messages from the wallet widget\n   * @param {MessageEvent} event\n   */\n  #handleMessage(event) {\n    // Check origin if specified\n    if (this.#targetOrigin !== \"*\" && event.origin !== this.#targetOrigin) {\n      return;\n    }\n\n    const { id, type, action, payload } = event.data;\n    if (type !== \"wallet-adapter\") return;\n\n    // Handle close action\n    if (action === \"close\") {\n      this.#iframe?.remove();\n      this.#iframe = null;\n      return;\n    }\n\n    // Update state if provided\n    if (payload?.state) {\n      this.#state = { ...this.#state, ...payload.state };\n      this.#onStateUpdate?.(this.#state);\n    }\n\n    // Resolve pending promise if any\n    const resolve = this.#pending.get(id) as ((value: SignInResult) => void);\n    if (resolve) {\n      this.#pending.delete(id);\n      this.#iframe?.remove();\n      this.#iframe = null;\n      resolve(payload as SignInResult);\n    }\n  }\n\n  /**\n   * Sends a message to the wallet widget\n   * @param {string} path - Path to load in iframe\n   * @param {string} method - Method to call\n   * @param {Object} params - Parameters to pass\n   * @returns {Promise<any>}\n   */\n  async #sendMessage(path, method, params): Promise<TransactionResult> {\n    return new Promise((resolve) => {\n      const id = Math.random().toString(36).slice(2);\n      this.#pending.set(id, resolve);\n\n      const iframe = this.#createIframe(path);\n\n      iframe.onload = () => {\n        iframe.contentWindow?.postMessage(\n          {\n            type: \"wallet-adapter\",\n            method,\n            params: {\n              id,\n              ...params,\n              state: this.#state,\n              callbackUrl: params.callbackUrl || this.#callbackUrl,\n            },\n          },\n          this.#targetOrigin\n        );\n      };\n    });\n  }\n\n  /**\n   * Get current wallet state\n   * @returns {WalletState}\n   */\n  getState() {\n    return { ...this.#state };\n  }\n\n  /**\n   * Set current wallet state\n   * @param state\n   */\n  setState(state) {\n    this.#state = state;\n  }\n\n  /**\n   * Sign in with a NEAR wallet\n   * @param {SignInConfig} config\n   * @returns {Promise<any>}\n   *\n   * Should be returning SignInResult\n   */\n  async signIn(config): Promise<any> {\n    return this.#sendMessage(\"/login.html\", \"signIn\", config);\n  }\n\n  /**\n   * Send a transaction using connected wallet\n   * @param {TransactionConfig} config\n   * @returns {Promise<TransactionResult>}\n   */\n  async sendTransactions(config): Promise<TransactionResult> {\n    return this.#sendMessage(\"/send.html\", \"sendTransactions\", config);\n  }\n\n  /**\n   * Clean up adapter resources\n   */\n  destroy() {\n    window.removeEventListener(\"message\", this.#handleMessage);\n    this.#iframe?.remove();\n    this.#iframe = null;\n  }\n}\n","import Big from \"big.js\";\nimport {\n  lsSet,\n  lsGet,\n  tryParseJson,\n  fromBase64,\n  toBase64,\n  canSignWithLAK,\n  toBase58,\n  parseJsonFromBytes,\n  signHash,\n  publicKeyFromPrivate,\n  privateKeyFromRandom,\n  serializeTransaction,\n  serializeSignedTransaction, bytesToBase64, PlainTransaction,\n} from \"@fastnear/utils\";\n\nimport {\n  _adapter,\n  _state,\n  DEFAULT_NETWORK_ID,\n  NETWORKS,\n  getTxHistory,\n  update,\n  updateTxHistory,\n} from \"./state.js\";\n\nimport {\n  getConfig,\n  setConfig,\n  resetTxHistory,\n} from \"./state.js\";\n\nimport { sha256 } from \"@noble/hashes/sha2\";\nimport * as reExportAllUtils from \"@fastnear/utils\";\nimport * as stateExports from \"./state.js\";\n\nBig.DP = 27;\nexport const MaxBlockDelayMs = 1000 * 60 * 60 * 6; // 6 hours\n\nexport interface AccessKeyWithError {\n  result: {\n    nonce: number;\n    permission?: any;\n    error?: string;\n  }\n}\n\nexport interface WalletTxResult {\n  url?: string;\n  outcomes?: Array<{ transaction: { hash: string } }>;\n  rejected?: boolean;\n  error?: string;\n}\n\nexport interface BlockView {\n  result: {\n    header: {\n      hash: string;\n      timestamp_nanosec: string;\n    }\n  }\n}\n\n// The structure it's saved to in storage\nexport interface LastKnownBlock {\n  header: {\n    hash: string;\n    timestamp_nanosec: string;\n  }\n}\n\nexport function withBlockId(params: Record<string, any>, blockId?: string) {\n  if (blockId === \"final\" || blockId === \"optimistic\") {\n    return { ...params, finality: blockId };\n  }\n  return blockId ? { ...params, block_id: blockId } : { ...params, finality: \"optimistic\" };\n}\n\nexport async function sendRpc(method: string, params: Record<string, any> | any[]) {\n  const config = getConfig();\n  if (!config?.nodeUrl) {\n    throw new Error(\"fastnear: getConfig() returned invalid config: missing nodeUrl.\");\n  }\n  const response = await fetch(config.nodeUrl, {\n    method: \"POST\",\n    headers: { \"Content-Type\": \"application/json\" },\n    body: JSON.stringify({\n      jsonrpc: \"2.0\",\n      id: `fastnear-${Date.now()}`,\n      method,\n      params,\n    }),\n  });\n  const result = await response.json();\n  if (result.error) {\n    throw new Error(JSON.stringify(result.error));\n  }\n  return result;\n}\n\nexport function afterTxSent(txId: string) {\n  const txHistory = getTxHistory();\n  sendRpc(\"tx\", {\n    tx_hash: txHistory[txId]?.txHash,\n    sender_account_id: txHistory[txId]?.tx?.signerId,\n    wait_until: \"EXECUTED_OPTIMISTIC\",\n  })\n    .then( result => {\n      const successValue = result?.result?.status?.SuccessValue;\n      updateTxHistory({\n        txId,\n        status: \"Executed\",\n        result,\n        successValue: successValue ? tryParseJson(fromBase64(successValue)) : undefined,\n        finalState: true,\n      });\n    })\n    .catch((error) => {\n      updateTxHistory({\n        txId,\n        status: \"ErrorAfterIncluded\",\n        error: tryParseJson(error.message) ?? error.message,\n        finalState: true,\n      });\n    });\n}\n\nexport async function sendTxToRpc(signedTxBase64: string, waitUntil: string | undefined, txId: string) {\n  // default to \"INCLUDED\"\n  // see options: https://docs.near.org/api/rpc/transactions#tx-status-result\n  waitUntil = waitUntil || \"INCLUDED\";\n\n  try {\n    const sendTxRes = await sendRpc(\"send_tx\", {\n      signed_tx_base64: signedTxBase64,\n      wait_until: waitUntil,\n    });\n\n    updateTxHistory({ txId, status: \"Included\", finalState: false });\n    afterTxSent(txId);\n\n    return sendTxRes;\n  } catch (error) {\n    const errorMessage = error instanceof Error ? error.message : \"Unknown error\";\n    updateTxHistory({\n      txId,\n      status: \"Error\",\n      error: tryParseJson(errorMessage) ?? errorMessage,\n      finalState: false,\n    });\n    throw new Error(errorMessage);\n  }\n}\n\nexport interface AccessKeyView {\n  nonce: number;\n  permission: any;\n}\n\n/**\n * Generates a mock transaction ID.\n *\n * This function creates a pseudo-unique transaction ID for testing or\n * non-production use. It combines the current timestamp with a\n * random component for uniqueness.\n *\n * **Note:** This is not cryptographically secure and should not be used\n * for actual transaction processing.\n *\n * @returns {string} A mock transaction ID in the format `tx-{timestamp}-{random}`\n */\nexport function generateTxId(): string {\n  const randomPart = crypto.getRandomValues(new Uint32Array(2)).join(\"\");\n  return `tx-${Date.now()}-${parseInt(randomPart, 10).toString(36)}`;\n}\n\nexport const accountId = () => _state.accountId;\nexport const publicKey = () => _state.publicKey;\n\nexport const config = (newConfig?: Record<string, any>) => {\n  const current = getConfig();\n  if (newConfig) {\n    if (newConfig.networkId && current.networkId !== newConfig.networkId) {\n      setConfig(newConfig.networkId);\n      update({ accountId: null, privateKey: null, lastWalletId: null });\n      lsSet(\"block\", null);\n      resetTxHistory();\n    }\n    setConfig({ ...getConfig(), ...newConfig });\n  }\n  return getConfig();\n};\n\nexport const authStatus = (): string | Record<string, any> => {\n  if (!_state.accountId) {\n    return \"SignedOut\";\n  }\n  return \"SignedIn\";\n};\n\n// this is an intentional stub\n// and it's probably partially done, to help ease future features\n// for now we'll assume each web end user has one keypair in storage\n// for every contract they wish to interact with\n// later, it may be prudent to hold multiple, but until then this function\n// just returns the access key as if it were among others in the array.\n// we're pretending like we really thought about which access key we're returning\n// based on the opts argument. this allows us to fill this logic in later.\nexport const getPublicKeyForContract = (opts?: any) => {\n  return publicKey();\n}\n\n// returns details on the selected:\n// network, wallet, and explorer details as well as\n// sending account, contract, and selected public key\nexport const selected = () => {\n  const network = getConfig().networkId;\n  const nodeUrl = getConfig().nodeUrl;\n  const walletUrl = getConfig().walletUrl;\n  const helperUrl = getConfig().helperUrl;\n  const explorerUrl = getConfig().explorerUrl;\n\n  const account = accountId();\n  const contract = _state.accessKeyContractId;\n  const publicKey = getPublicKeyForContract();\n\n  return {\n    network,\n    nodeUrl,\n    walletUrl,\n    helperUrl,\n    explorerUrl,\n    account,\n    contract,\n    publicKey\n  }\n}\n\nexport const requestSignIn = async ({ contractId }: { contractId: string }) => {\n  const privateKey = privateKeyFromRandom();\n  update({ accessKeyContractId: contractId, accountId: null, privateKey });\n  const pubKey = publicKeyFromPrivate(privateKey);\n\n  const result = await _adapter.signIn({\n    networkId: getConfig().networkId,\n    contractId,\n    publicKey: pubKey,\n  });\n\n  if (result.error) {\n    throw new Error(`Wallet error: ${result.error}`);\n  }\n  if (result.url) {\n    if (typeof window !== \"undefined\") {\n      setTimeout(() => {\n        window.location.href = result.url;\n      }, 100);\n    }\n  } else if (result.accountId) {\n    update({ accountId: result.accountId });\n  }\n};\n\nexport const view = async ({\n                             contractId,\n                             methodName,\n                             args,\n                             argsBase64,\n                             blockId,\n                           }: {\n  contractId: string;\n  methodName: string;\n  args?: any;\n  argsBase64?: string;\n  blockId?: string;\n}) => {\n  const encodedArgs = argsBase64 || (args ? toBase64(JSON.stringify(args)) : \"\");\n  const queryResult = await sendRpc(\n    \"query\",\n    withBlockId(\n      {\n        request_type: \"call_function\",\n        account_id: contractId,\n        method_name: methodName,\n        args_base64: encodedArgs,\n      },\n      blockId\n    )\n  );\n\n  return parseJsonFromBytes(queryResult.result.result);\n};\n\nexport const queryAccount = async ({\n                                accountId,\n                                blockId,\n                              }: {\n  accountId: string;\n  blockId?: string;\n}) => {\n  return sendRpc(\n    \"query\",\n    withBlockId({ request_type: \"view_account\", account_id: accountId }, blockId)\n  );\n};\n\nexport const queryBlock = async ({ blockId }: { blockId?: string }): Promise<BlockView> => {\n  return sendRpc(\"block\", withBlockId({}, blockId));\n};\n\nexport const queryAccessKey = async ({\n                                  accountId,\n                                  publicKey,\n                                  blockId,\n                                }: {\n  accountId: string;\n  publicKey: string;\n  blockId?: string;\n}): Promise<AccessKeyWithError> => {\n  return sendRpc(\n    \"query\",\n    withBlockId(\n      { request_type: \"view_access_key\", account_id: accountId, public_key: publicKey },\n      blockId\n    )\n  );\n};\n\nexport const queryTx = async ({ txHash, accountId }: { txHash: string; accountId: string }) => {\n  return sendRpc(\"tx\", [txHash, accountId]);\n};\n\nexport const localTxHistory = () => {\n  return getTxHistory();\n};\n\nexport const signOut = () => {\n  update({ accountId: null, privateKey: null, contractId: null });\n  setConfig(NETWORKS[DEFAULT_NETWORK_ID]);\n};\n\nexport const sendTx = async ({\n                               receiverId,\n                               actions,\n                               waitUntil,\n                             }: {\n  receiverId: string;\n  actions: any[];\n  waitUntil?: string;\n}) => {\n  const signerId = _state.accountId;\n  if (!signerId) throw new Error(\"Must sign in\");\n\n  const publicKey = _state.publicKey ?? \"\";\n  const privKey = _state.privateKey;\n  // this generates a mock transaction ID so we can keep track of each tx\n  const txId = generateTxId();\n\n  if (!privKey || receiverId !== _state.accessKeyContractId || !canSignWithLAK(actions)) {\n    const jsonTx = { signerId, receiverId, actions };\n    updateTxHistory({ status: \"Pending\", txId, tx: jsonTx, finalState: false });\n\n    const url = new URL(typeof window !== \"undefined\" ? window.location.href : \"\");\n    url.searchParams.set(\"txIds\", txId);\n\n    // preserve existing url params\n    const existingParams = new URLSearchParams(window.location.search);\n    existingParams.forEach((value, key) => {\n      if (!url.searchParams.has(key)) {\n        url.searchParams.set(key, value);\n      }\n    });\n\n    // we're wanting to preserve URL params that we send in\n    // but make sure we're not feeding back error params\n    // from a previous failure\n\n    url.searchParams.delete(\"errorCode\");\n    url.searchParams.delete(\"errorMessage\");\n\n    try {\n      const result: WalletTxResult = await _adapter.sendTransactions({\n        transactions: [jsonTx],\n        callbackUrl: url.toString(),\n      });\n\n      if (result.url) {\n        if (typeof window !== \"undefined\") {\n          setTimeout(() => {\n            window.location.href = result.url!;\n          }, 100);\n        }\n      } else if (result.outcomes?.length) {\n        result.outcomes.forEach((r) =>\n          updateTxHistory({\n            txId,\n            status: \"Executed\",\n            result: r,\n            txHash: r.transaction.hash,\n            finalState: true,\n          })\n        );\n      } else if (result.rejected) {\n        updateTxHistory({ txId, status: \"RejectedByUser\", finalState: true });\n      } else if (result.error) {\n        updateTxHistory({\n          txId,\n          status: \"Error\",\n          error: tryParseJson(result.error),\n          finalState: true,\n        });\n      }\n\n      return result;\n    } catch (err) {\n      console.error('fastnear: error sending tx using adapter:', err)\n      updateTxHistory({\n        txId,\n        status: \"Error\",\n        error: tryParseJson((err as Error).message),\n        finalState: true,\n      });\n\n      return Promise.reject(err);\n    }\n  }\n\n  let nonce = lsGet(\"nonce\") as number | null;\n  if (nonce == null) {\n    const accessKey = await queryAccessKey({ accountId: signerId, publicKey: publicKey });\n    if (accessKey.result.error) {\n      throw new Error(`Access key error: ${accessKey.result.error} when attempting to get nonce for ${signerId} for public key ${publicKey}`);\n    }\n    nonce = accessKey.result.nonce;\n    lsSet(\"nonce\", nonce);\n  }\n\n  let lastKnownBlock = lsGet(\"block\") as LastKnownBlock | null;\n  if (\n    !lastKnownBlock ||\n    parseFloat(lastKnownBlock.header.timestamp_nanosec) / 1e6 + MaxBlockDelayMs < Date.now()\n  ) {\n    const latestBlock = await queryBlock({ blockId: \"final\" });\n    lastKnownBlock = {\n      header: {\n        hash: latestBlock.result.header.hash,\n        timestamp_nanosec: latestBlock.result.header.timestamp_nanosec,\n      },\n    };\n    lsSet(\"block\", lastKnownBlock);\n  }\n\n  nonce += 1;\n  lsSet(\"nonce\", nonce);\n\n  const blockHash = lastKnownBlock.header.hash;\n\n  const plainTransactionObj: PlainTransaction = {\n    signerId,\n    publicKey,\n    nonce,\n    receiverId,\n    blockHash,\n    actions,\n  };\n\n  const txBytes = serializeTransaction(plainTransactionObj);\n  const txHashBytes = sha256(txBytes);\n  const txHash58 = toBase58(txHashBytes);\n\n  const signatureBase58 = signHash(txHashBytes, privKey, { returnBase58: true });\n  const signedTransactionBytes = serializeSignedTransaction(plainTransactionObj, signatureBase58);\n  const signedTxBase64 = bytesToBase64(signedTransactionBytes);\n\n  updateTxHistory({\n    status: \"Pending\",\n    txId,\n    tx: plainTransactionObj,\n    signature: signatureBase58,\n    signedTxBase64,\n    txHash: txHash58,\n    finalState: false,\n  });\n\n  try {\n    return await sendTxToRpc(signedTxBase64, waitUntil, txId);\n  } catch (error) {\n    console.error(\"Error Sending Transaction:\", error, plainTransactionObj, signedTxBase64);\n  }\n};\n\n// exports\nexport const exp = {\n  utils: {}, // we will map this in a moment, giving keys, for IDE hints\n  borsh: reExportAllUtils.exp.borsh,\n  borshSchema: reExportAllUtils.exp.borshSchema.getBorshSchema(),\n};\n\nfor (const key in reExportAllUtils) {\n  exp.utils[key] = reExportAllUtils[key];\n}\n\n// devx\nexport const utils = exp.utils;\n\nexport const state = {}\n\nfor (const key in stateExports) {\n  state[key] = stateExports[key];\n}\n\n// devx\n\nexport const event = state['events'];\ndelete state['events'];\n\n// Wallet redirect handling\ntry {\n  if (typeof window !== \"undefined\") {\n    const url = new URL(window.location.href);\n    const accId = url.searchParams.get(\"account_id\");\n    const pubKey = url.searchParams.get(\"public_key\");\n    const errCode = url.searchParams.get(\"errorCode\");\n    const errMsg = url.searchParams.get(\"errorMessage\");\n    const decodedErrMsg = errMsg ? decodeURIComponent(errMsg) : null;\n\n    const txHashes = url.searchParams.get(\"transactionHashes\");\n    const txIds = url.searchParams.get(\"txIds\");\n\n    if (errCode || errMsg) {\n      console.warn(new Error(`Wallet raises:\\ncode: ${errCode}\\nmessage: ${decodedErrMsg}`));\n    }\n\n    if (accId && pubKey) {\n      if (pubKey === _state.publicKey) {\n        update({ accountId: accId });\n      } else {\n        // it's possible the end user has a URL param that's old. we'll remove the public_key param\n        // if logged out, no need to throw warning\n        if (authStatus() === \"SignedIn\") {\n          console.warn(\"Public key mismatch from wallet redirect\", pubKey, _state.publicKey);\n        }\n        url.searchParams.delete(\"public_key\");\n      }\n    }\n\n    if (txHashes || txIds) {\n      const hashArr = txHashes ? txHashes.split(\",\") : [];\n      const idArr = txIds ? txIds.split(\",\") : [];\n      if (idArr.length > hashArr.length) {\n        idArr.forEach((id) => {\n          updateTxHistory({ txId: id, status: \"RejectedByUser\", finalState: true });\n        });\n      } else if (idArr.length === hashArr.length) {\n        idArr.forEach((id, i) => {\n          updateTxHistory({\n            txId: id,\n            status: \"PendingGotTxHash\",\n            txHash: hashArr[i],\n            finalState: false,\n          });\n          afterTxSent(id);\n        });\n      } else {\n        console.error(new Error(\"Transaction hash mismatch from wallet redirect\"), idArr, hashArr);\n      }\n    }\n\n    // we can consider removing these, but want to be careful because\n    // it can be helpful for a dev to have a URL they can debug with\n    // we won't want to remove information\n\n    // pretty sure txIds can go, especially if you can tell it's been more than 5 minutes or something\n    // public_key sometimes confuses it, so this might only be needed when adding a new access key\n    // and perhaps once we've confirmed that the transaction hashes are getting saved to storage\n    // (not sure about that section of code) then we can get rid of the transactionHashes, too\n\n    url.searchParams.delete(\"txIds\");\n    if (authStatus() === \"SignedOut\") {\n      url.searchParams.delete(\"errorCode\");\n      url.searchParams.delete(\"errorMessage\");\n    }\n    // ^ we've decided these ones make sense to keep\n\n    // I'd like to keep this for posterity. for a bit.\n    // url.searchParams.delete(\"account_id\");\n    // url.searchParams.delete(\"public_key\");\n\n    // url.searchParams.delete(\"all_keys\");\n    // url.searchParams.delete(\"transactionHashes\");\n    // window.history.replaceState({}, \"\", url.toString());\n  }\n} catch (e) {\n  console.error(\"Error handling wallet redirect:\", e);\n}\n\n// action helpers\nexport const actions = {\n  functionCall: ({\n                   methodName,\n                   gas,\n                   deposit,\n                   args,\n                   argsBase64,\n                 }: {\n    methodName: string;\n    gas?: string;\n    deposit?: string;\n    args?: Record<string, any>;\n    argsBase64?: string;\n  }) => ({\n    type: \"FunctionCall\",\n    methodName,\n    args,\n    argsBase64,\n    gas,\n    deposit,\n  }),\n\n  transfer: (yoctoAmount: string) => ({\n    type: \"Transfer\",\n    deposit: yoctoAmount,\n  }),\n\n  stakeNEAR: ({amount, publicKey}: { amount: string; publicKey: string }) => ({\n    type: \"Stake\",\n    stake: amount,\n    publicKey,\n  }),\n\n  addFullAccessKey: ({publicKey}: { publicKey: string }) => ({\n    type: \"AddKey\",\n    publicKey: publicKey,\n    accessKey: {permission: \"FullAccess\"},\n  }),\n\n  addLimitedAccessKey: ({\n                          publicKey,\n                          allowance,\n                          accountId,\n                          methodNames,\n                        }: {\n    publicKey: string;\n    allowance: string;\n    accountId: string;\n    methodNames: string[];\n  }) => ({\n    type: \"AddKey\",\n    publicKey: publicKey,\n    accessKey: {\n      permission: \"FunctionCall\",\n      allowance,\n      receiverId: accountId,\n      methodNames,\n    },\n  }),\n\n  deleteKey: ({publicKey}: { publicKey: string }) => ({\n    type: \"DeleteKey\",\n    publicKey,\n  }),\n\n  deleteAccount: ({beneficiaryId}: { beneficiaryId: string }) => ({\n    type: \"DeleteAccount\",\n    beneficiaryId,\n  }),\n\n  createAccount: () => ({\n    type: \"CreateAccount\",\n  }),\n\n  deployContract: ({codeBase64}: { codeBase64: string }) => ({\n    type: \"DeployContract\",\n    codeBase64,\n  }),\n};\n"]}