@ssv-labs/ssv-sdk 0.1.2 → 1.0.1

package/dist/{KeyShares-DEqBZits.mjs → KeyShares-Dlp4Pa3b.mjs}

@@ -2,10 +2,6 @@ import bls from "bls-eth-wasm";
 import crypto$1 from "crypto";
 import { keccak256, toHex, sha256 as sha256$1, toBytes, fromHex, getAddress } from "viem";
 import { ValidatorConstraint, registerDecorator, IsNotEmpty, IsDefined, IsInt, IsString, validateSync, IsOptional, IsNumber, Length, ValidateNested } from "class-validator";
-var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
-function getDefaultExportFromCjs(x) {
-  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
-}
 (async () => {
   await bls.init(bls.BLS12_381);
 })();
@@ -64,6 +60,10 @@ class OwnerNonceFormatError extends SSVKeysException {
     this.data = data;
   }
 }
+var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : {};
+function getDefaultExportFromCjs(x) {
+  return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x;
+}
 var forge$C = {
   // default options
   options: {
@@ -1326,6 +1326,9 @@ util$1.format = function(format) {
           parts.push("<?>");
         }
         break;
+      // FIXME: do proper formatting for numbers, etc
+      //case 'f':
+      //case 'd':
       case "%":
         parts.push("%");
         break;
@@ -2736,6 +2739,7 @@ asn1$8.Type = {
   GENERALIZEDTIME: 24,
   BMPSTRING: 30
 };
+asn1$8.maxDepth = 256;
 asn1$8.create = function(tagClass, type, constructed, value, options) {
   if (forge$w.util.isArray(value)) {
     var tmp = [];
@@ -2877,6 +2881,9 @@ asn1$8.fromDer = function(bytes, options) {
   if (!("decodeBitStrings" in options)) {
     options.decodeBitStrings = true;
   }
+  if (!("maxDepth" in options)) {
+    options.maxDepth = asn1$8.maxDepth;
+  }
   if (typeof bytes === "string") {
     bytes = forge$w.util.createBuffer(bytes);
   }
@@ -2891,6 +2898,9 @@ asn1$8.fromDer = function(bytes, options) {
   return value;
 };
 function _fromDer(bytes, remaining, depth, options) {
+  if (depth >= options.maxDepth) {
+    throw new Error("ASN.1 parsing error: Max depth exceeded.");
+  }
   var start;
   _checkBufferLength(bytes, remaining, 2);
   var b1 = bytes.getByte();
@@ -3066,6 +3076,9 @@ asn1$8.oidToDer = function(oid) {
     last = true;
     valueBytes = [];
     value = parseInt(values[i], 10);
+    if (value > 4294967295) {
+      throw new Error("OID value too large; max is 32-bits.");
+    }
     do {
       b = value & 127;
       value = value >>> 7;
@@ -3090,8 +3103,11 @@ asn1$8.derToOid = function(bytes) {
   oid = Math.floor(b / 40) + "." + b % 40;
   var value = 0;
   while (bytes.length() > 0) {
+    if (value > 70368744177663) {
+      throw new Error("OID value too large; max is 53-bits.");
+    }
     b = bytes.getByte();
-    value = value << 7;
+    value = value * 128;
     if (b & 128) {
       value += b & 127;
     } else {
@@ -3252,19 +3268,40 @@ asn1$8.validate = function(obj, v, capture, errors) {
       if (v.value && forge$w.util.isArray(v.value)) {
         var j = 0;
         for (var i = 0; rval && i < v.value.length; ++i) {
-          rval = v.value[i].optional || false;
-          if (obj.value[j]) {
-            rval = asn1$8.validate(obj.value[j], v.value[i], capture, errors);
-            if (rval) {
-              ++j;
-            } else if (v.value[i].optional) {
+          var schemaItem = v.value[i];
+          rval = !!schemaItem.optional;
+          var objChild = obj.value[j];
+          if (!objChild) {
+            if (!schemaItem.optional) {
+              rval = false;
+              if (errors) {
+                errors.push("[" + v.name + '] Missing required element. Expected tag class "' + schemaItem.tagClass + '", type "' + schemaItem.type + '"');
+              }
+            }
+            continue;
+          }
+          var schemaHasTag = typeof schemaItem.tagClass !== "undefined" && typeof schemaItem.type !== "undefined";
+          if (schemaHasTag && (objChild.tagClass !== schemaItem.tagClass || objChild.type !== schemaItem.type)) {
+            if (schemaItem.optional) {
               rval = true;
+              continue;
+            } else {
+              rval = false;
+              if (errors) {
+                errors.push("[" + v.name + "] Tag mismatch. Expected (" + schemaItem.tagClass + "," + schemaItem.type + "), got (" + objChild.tagClass + "," + objChild.type + ")");
+              }
+              break;
             }
           }
-          if (!rval && errors) {
-            errors.push(
-              "[" + v.name + '] Tag class "' + v.tagClass + '", type "' + v.type + '" expected value length "' + v.value.length + '", got "' + obj.value.length + '"'
-            );
+          var childRval = asn1$8.validate(objChild, schemaItem, capture, errors);
+          if (childRval) {
+            ++j;
+            rval = true;
+          } else if (schemaItem.optional) {
+            rval = true;
+          } else {
+            rval = false;
+            break;
           }
         }
       }
@@ -7172,7 +7209,7 @@ var digestInfoValidator = {
       constructed: false,
       capture: "algorithmIdentifier"
     }, {
-      // NULL paramters
+      // NULL parameters
       name: "DigestInfo.DigestAlgorithm.parameters",
       tagClass: asn1$7.Class.UNIVERSAL,
       type: asn1$7.Type.NULL,
@@ -7685,7 +7722,7 @@ pki$4.setRsaPublicKey = pki$4.rsa.setPublicKey = function(n, e) {
           if (oid === forge$h.oids.md2 || oid === forge$h.oids.md5) {
             if (!("parameters" in capture)) {
               throw new Error(
-                "ASN.1 object does not contain a valid RSASSA-PKCS1-v1_5 DigestInfo value. Missing algorithm identifer NULL parameters."
+                "ASN.1 object does not contain a valid RSASSA-PKCS1-v1_5 DigestInfo value. Missing algorithm identifier NULL parameters."
               );
             }
           }
@@ -9841,6 +9878,7 @@ var _readSignatureParameters = function(oid, obj, fillDefaults) {
 var _createSignatureDigest = function(options) {
   switch (oids[options.signatureOid]) {
     case "sha1WithRSAEncryption":
+    // deprecated alias
     case "sha1WithRSASignature":
       return forge$b.md.sha1.create();
     case "md5WithRSAEncryption":
@@ -9866,6 +9904,7 @@ var _verifySignature = function(options) {
   var scheme;
   switch (cert.signatureOid) {
     case oids.sha1WithRSAEncryption:
+    // deprecated alias
     case oids.sha1WithRSASignature:
       break;
     case oids["RSASSA-PSS"]:
@@ -10356,13 +10395,18 @@ pki$2.certificateExtensionFromAsn1 = function(ext) {
         };
         e.altNames.push(altName);
         switch (gn.type) {
+          // rfc822Name
           case 1:
+          // dNSName
           case 2:
+          // uniformResourceIdentifier (URI)
           case 6:
             break;
+          // IPAddress
           case 7:
             altName.ip = forge$b.util.bytesToIP(gn.value);
             break;
+          // registeredID
           case 8:
             altName.oid = asn1$4.derToOid(gn.value);
             break;
@@ -11516,6 +11560,7 @@ var pfxValidator = {
             capture: "macAlgorithm"
           }, {
             name: "PFX.macData.mac.digestAlgorithm.parameters",
+            optional: true,
             tagClass: asn1$3.Class.UNIVERSAL,
             captureAsn1: "macAlgorithmParameters"
           }]
@@ -11794,6 +11839,8 @@ p12.pkcs12FromAsn1 = function(obj, strict, password) {
     if (macValue.getBytes() !== capture.macDigest) {
       throw new Error("PKCS#12 MAC could not be verified. Invalid password?");
     }
+  } else if (Array.isArray(obj.value) && obj.value.length > 2) {
+    throw new Error("Invalid PKCS#12. macData field present but MAC was not validated.");
   }
   _decodeAuthenticatedSafe(pfx, data.value, strict, password);
   return pfx;
@@ -11914,6 +11961,7 @@ function _decodeSafeContents(safeContents, strict, password) {
             "Unable to decrypt PKCS#8 ShroudedKeyBag, wrong password?"
           );
         }
+      /* fall through */
       case pki$1.oids.keyBag:
         try {
           bag.key = pki$1.privateKeyFromAsn1(bagAsn1);
@@ -11922,6 +11970,7 @@ function _decodeSafeContents(safeContents, strict, password) {
           bag.asn1 = bagAsn1;
         }
         continue;
+      /* Nothing more to do. */
       case pki$1.oids.certBag:
         validator = certBagValidator;
         decoder = function() {
@@ -17419,7 +17468,10 @@ class ForgeEncrypt {
     }
     try {
       const encryptedBytes = lib.util.decode64(encryptedData);
-      const decrypted = this.privateKey.decrypt(encryptedBytes, "RSAES-PKCS1-V1_5");
+      const decrypted = this.privateKey.decrypt(
+        encryptedBytes,
+        "RSAES-PKCS1-V1_5"
+      );
       return decrypted;
     } catch (error) {
       return false;
@@ -17484,12 +17536,16 @@ const OperatorPublicKeyValidator$1 = (publicKey) => {
     let decodedPublicKey = "";
     if (!publicKey.startsWith(begin)) {
       if (publicKey.length < 98) {
-        throw new Error("The length of the operator public key must be at least 98 characters.");
+        throw new Error(
+          "The length of the operator public key must be at least 98 characters."
+        );
       }
       try {
         decodedPublicKey = lib.util.decode64(publicKey).trim();
       } catch (error) {
-        throw new Error("Failed to decode the operator public key. Ensure it's correctly base64 encoded.");
+        throw new Error(
+          "Failed to decode the operator public key. Ensure it's correctly base64 encoded."
+        );
       }
       if (!decodedPublicKey.startsWith(begin)) {
         throw new Error(`Operator public key does not start with '${begin}'`);
@@ -17504,12 +17560,16 @@ const OperatorPublicKeyValidator$1 = (publicKey) => {
       const content = decodedPublicKey.slice(begin.length, publicKey.length - end.length).trim();
       decodedOperator = lib.util.decode64(content);
     } catch {
-      throw new Error("Failed to decode the RSA public key. Ensure it's correctly base64 encoded.");
+      throw new Error(
+        "Failed to decode the RSA public key. Ensure it's correctly base64 encoded."
+      );
     }
     try {
       encrypt.setPublicKey(decodedOperator);
     } catch {
-      throw new Error("Invalid operator key format, make sure the operator exists in the network.");
+      throw new Error(
+        "Invalid operator key format, make sure the operator exists in the network."
+      );
     }
   } catch (error) {
     throw new OperatorPublicKeyError(
@@ -17553,7 +17613,10 @@ class Threshold {
    */
   async create(privateKeyString, operatorIds) {
     if (!privateKeyString.startsWith("0x")) {
-      throw new PrivateKeyFormatError(privateKeyString, "The private key must be provided in the 0x format.");
+      throw new PrivateKeyFormatError(
+        privateKeyString,
+        "The private key must be provided in the 0x format."
+      );
     }
     operatorIds.map((operatorId) => {
       if (!Number.isInteger(operatorId)) {
@@ -17574,7 +17637,9 @@ class Threshold {
     if (!bls.deserializeHexStrToSecretKey) {
       await bls.init(bls.BLS12_381);
     }
-    this.privateKey = bls.deserializeHexStrToSecretKey(privateKeyString.replace("0x", ""));
+    this.privateKey = bls.deserializeHexStrToSecretKey(
+      privateKeyString.replace("0x", "")
+    );
     this.publicKey = this.privateKey.getPublicKey();
     msk.push(this.privateKey);
     mpk.push(this.publicKey);
@@ -17608,7 +17673,7 @@ class Threshold {
   }
 }
 var scrypt = { exports: {} };
-(function(module, exports) {
+(function(module, exports$1) {
   (function(root) {
     const MAX_VALUE = 2147483647;
     function SHA256(m) {
@@ -17948,6 +18013,7 @@ var scrypt = { exports: {} };
             arraycopy(B, Bi, XY, 0, Yi);
             state = 1;
             i1 = 0;
+          // Fall through
           case 1:
             steps = N - i1;
             if (steps > limit) {
@@ -17974,6 +18040,7 @@ var scrypt = { exports: {} };
             }
             i1 = 0;
             state = 2;
+          // Fall through
           case 2:
             steps = N - i1;
             if (steps > limit) {
@@ -18070,11 +18137,17 @@ class EthereumKeyStore {
   privateKey = "";
   constructor(keyStoreData) {
     if (!keyStoreData) {
-      throw new KeyStoreDataFormatError(keyStoreData, "Key store data should be JSON or string");
+      throw new KeyStoreDataFormatError(
+        keyStoreData,
+        "Key store data should be JSON or string"
+      );
     }
     this.keyStoreData = typeof keyStoreData === "string" ? JSON.parse(keyStoreData) : keyStoreData;
     if (!this.keyStoreData.version) {
-      throw new KeyStoreInvalidError(this.keyStoreData, "Invalid keystore file");
+      throw new KeyStoreInvalidError(
+        this.keyStoreData,
+        "Invalid keystore file"
+      );
     }
   }
   // getPublicKey(): string {
@@ -18114,15 +18187,32 @@ class EthereumKeyStore {
     const dklen = kdfparams.dklen;
     let derivedKey;
     if (json.crypto.kdf === "scrypt") {
-      derivedKey = scryptExports.syncScrypt(Buffer.from(password), salt, kdfparams.n, kdfparams.r, kdfparams.p, dklen);
+      derivedKey = scryptExports.syncScrypt(
+        Buffer.from(password),
+        salt,
+        kdfparams.n,
+        kdfparams.r,
+        kdfparams.p,
+        dklen
+      );
     } else if (json.crypto.kdf === "pbkdf2") {
-      if (kdfparams.prf !== "hmac-sha256") throw new EthereumWalletError("Unsupported PBKDF2 params");
-      derivedKey = crypto$1.pbkdf2Sync(Buffer.from(password), salt, kdfparams.c, dklen, "sha256");
+      if (kdfparams.prf !== "hmac-sha256")
+        throw new EthereumWalletError("Unsupported PBKDF2 params");
+      derivedKey = crypto$1.pbkdf2Sync(
+        Buffer.from(password),
+        salt,
+        kdfparams.c,
+        dklen,
+        "sha256"
+      );
     } else {
       throw new EthereumWalletError("Unsupported kdf type");
     }
     const ciphertext = Buffer.from(json.crypto.ciphertext, "hex");
-    const macCheck = Buffer.concat([Buffer.from(derivedKey.slice(16, 32)), ciphertext]);
+    const macCheck = Buffer.concat([
+      Buffer.from(derivedKey.slice(16, 32)),
+      ciphertext
+    ]);
     const mac = keccak256(toHex(macCheck)).replace(/^0x/, "");
     if (mac !== json.crypto.mac.toLowerCase()) {
       throw new EthereumWalletError("Invalid password");
@@ -18151,12 +18241,21 @@ class EthereumKeyStore {
       if (prf !== "hmac-sha256") {
         throw new EthereumWalletError("Unsupported parameters to PBKDF2");
       }
-      derivedKey = crypto$1.pbkdf2Sync(Buffer.from(password), salt, c, dklen, "sha256");
+      derivedKey = crypto$1.pbkdf2Sync(
+        Buffer.from(password),
+        salt,
+        c,
+        dklen,
+        "sha256"
+      );
     } else {
       throw new EthereumWalletError("Unsupported key derivation scheme");
     }
     const ciphertext = Buffer.from(cipher.message, "hex");
-    const checksumBuffer = Buffer.concat([Buffer.from(derivedKey.slice(16, 32)), ciphertext]);
+    const checksumBuffer = Buffer.concat([
+      Buffer.from(derivedKey.slice(16, 32)),
+      ciphertext
+    ]);
     const hashFn = checksum.function === "sha256" ? sha256$1 : keccak256;
     const calculatedMac = hashFn(toHex(checksumBuffer));
     if (calculatedMac.replace(/^0x/, "") !== checksum.message.toLowerCase()) {
@@ -18191,7 +18290,9 @@ class Encryption {
       OperatorPublicKeyValidator$1(operatorPublicKey);
       const forgeEncrypt = new ForgeEncrypt();
       forgeEncrypt.setPublicKey(operatorPublicKey);
-      const encryptedPrivateKey = forgeEncrypt.encrypt(this.shares[idx].privateKey);
+      const encryptedPrivateKey = forgeEncrypt.encrypt(
+        this.shares[idx].privateKey
+      );
       if (!encryptedPrivateKey) {
         throw new OperatorPublicKeyError(
           {
@@ -18282,10 +18383,18 @@ const operatorSortedList = (operators) => {
   const validatedOperators = operators.map((operator) => {
     const id = parseInt(`${operator.id}`, 10);
     if (isNaN(id)) {
-      throw new OperatorsCountsMismatchError(ids, operatorKeys, `Invalid operator ID: ${operator.id}`);
+      throw new OperatorsCountsMismatchError(
+        ids,
+        operatorKeys,
+        `Invalid operator ID: ${operator.id}`
+      );
     }
     if (!operator.operatorKey) {
-      throw new OperatorsCountsMismatchError(ids, operatorKeys, `Operator key is missing for operator ID: ${id}`);
+      throw new OperatorsCountsMismatchError(
+        ids,
+        operatorKeys,
+        `Operator key is missing for operator ID: ${id}`
+      );
     }
     return { ...operator, id };
   });
@@ -18307,14 +18416,18 @@ class SingleSharesSignatureInvalid extends SSVKeysException {
   }
 }
 const hexArrayToBytes = (hexArr) => {
-  const uint8Array = new Uint8Array(hexArr.flatMap((hex) => Array.from(toBytes(hex))));
+  const uint8Array = new Uint8Array(
+    hexArr.flatMap((hex) => Array.from(toBytes(hex)))
+  );
   return Buffer.from(uint8Array);
 };
 const buildSignature = async (dataToSign, privateKeyHex) => {
   if (!bls.deserializeHexStrToSecretKey) {
     await bls.init(bls.BLS12_381);
   }
-  const privateKey = bls.deserializeHexStrToSecretKey(privateKeyHex.replace("0x", ""));
+  const privateKey = bls.deserializeHexStrToSecretKey(
+    privateKeyHex.replace("0x", "")
+  );
   const messageHash = keccak256(toBytes(dataToSign));
   const messageBytes = fromHex(messageHash, "bytes");
   const signature = privateKey.sign(messageBytes);
@@ -18322,12 +18435,19 @@ const buildSignature = async (dataToSign, privateKeyHex) => {
   return `0x${signatureHex}`;
 };
 const validateSignature = async (signedData, signatureHex, publicKey) => {
-  const blsPublicKey = bls.deserializeHexStrToPublicKey(publicKey.replace("0x", ""));
-  const signature = bls.deserializeHexStrToSignature(signatureHex.replace("0x", ""));
+  const blsPublicKey = bls.deserializeHexStrToPublicKey(
+    publicKey.replace("0x", "")
+  );
+  const signature = bls.deserializeHexStrToSignature(
+    signatureHex.replace("0x", "")
+  );
   const messageHashHex = keccak256(toBytes(signedData));
   const messageHashBytes = fromHex(messageHashHex, "bytes");
   if (!blsPublicKey.verify(signature, messageHashBytes)) {
-    throw new SingleSharesSignatureInvalid(signatureHex, "Single shares signature is invalid");
+    throw new SingleSharesSignatureInvalid(
+      signatureHex,
+      "Single shares signature is invalid"
+    );
   }
 };
 const privateToPublicKey = async (privateKey) => {
@@ -18349,11 +18469,17 @@ let OpeatorsListValidatorConstraint = class {
     const operatorIds = /* @__PURE__ */ new Set(), operatorPublicKeys = /* @__PURE__ */ new Set();
     for (const operator of operatorsList || []) {
       if (operatorIds.has(operator.id)) {
-        throw new DuplicatedOperatorIdError(operator, `The operator ID '${operator.id}' is duplicated in the list`);
+        throw new DuplicatedOperatorIdError(
+          operator,
+          `The operator ID '${operator.id}' is duplicated in the list`
+        );
       }
       operatorIds.add(operator.id);
       if (operatorPublicKeys.has(operator.operatorKey)) {
-        throw new DuplicatedOperatorPublicKeyError(operator, `The public key for operator ID ${operator.id} is duplicated in the list`);
+        throw new DuplicatedOperatorPublicKeyError(
+          operator,
+          `The public key for operator ID ${operator.id} is duplicated in the list`
+        );
       }
       operatorPublicKeys.add(operator.operatorKey);
     }
@@ -18391,10 +18517,15 @@ let PublicKeyValidatorConstraint = class {
       if (typeof value === "string") {
         bls.deserializeHexStrToPublicKey(value.replace("0x", ""));
       } else {
-        value.forEach((item) => bls.deserializeHexStrToPublicKey(item.replace("0x", "")));
+        value.forEach(
+          (item) => bls.deserializeHexStrToPublicKey(item.replace("0x", ""))
+        );
       }
     } catch (e) {
-      throw new BLSDeserializeError(value, "Failed to BLS deserialize validator public key");
+      throw new BLSDeserializeError(
+        value,
+        "Failed to BLS deserialize validator public key"
+      );
     }
     return true;
   }
@@ -18434,7 +18565,10 @@ let OwnerAddressValidatorConstraint = class {
     try {
       getAddress(value);
     } catch {
-      throw new OwnerAddressFormatError(value, "Owner address is not a valid Ethereum address");
+      throw new OwnerAddressFormatError(
+        value,
+        "Owner address is not a valid Ethereum address"
+      );
     }
     return true;
   }
@@ -18467,7 +18601,10 @@ var __decorateClass$5 = (decorators, target, key, kind) => {
 let OwnerNonceValidatorConstraint = class {
   validate(value) {
     if (!Number.isInteger(value) || value < 0) {
-      throw new OwnerNonceFormatError(value, "Owner nonce is not positive integer");
+      throw new OwnerNonceFormatError(
+        value,
+        "Owner nonce is not positive integer"
+      );
     }
     return true;
   }
@@ -18504,12 +18641,20 @@ let MatchLengthValidatorConstraint = class {
     if (!Array.isArray(value)) {
       Object.values(value).forEach((arr) => {
         if (relatedLength !== arr.length) {
-          throw new OperatorsCountsMismatchError(args.object[relatedPropertyName], value, customError.message);
+          throw new OperatorsCountsMismatchError(
+            args.object[relatedPropertyName],
+            value,
+            customError.message
+          );
         }
       });
     } else {
       if (relatedLength !== value.length) {
-        throw new OperatorsCountsMismatchError(args.object[relatedPropertyName], value, customError.message);
+        throw new OperatorsCountsMismatchError(
+          args.object[relatedPropertyName],
+          value,
+          customError.message
+        );
       }
     }
     return true;
@@ -18689,7 +18834,10 @@ const _KeySharesItem = class _KeySharesItem2 {
   async buildPayload(metaData, toSignatureData) {
     const { ownerAddress, ownerNonce, privateKey } = toSignatureData;
     if (!Number.isInteger(ownerNonce) || ownerNonce < 0) {
-      throw new OwnerNonceFormatError(ownerNonce, "Owner nonce is not positive integer");
+      throw new OwnerNonceFormatError(
+        ownerNonce,
+        "Owner nonce is not positive integer"
+      );
     }
     let address;
     try {
@@ -18702,10 +18850,15 @@ const _KeySharesItem = class _KeySharesItem2 {
     }
     const payload = this.payload.build({
       publicKey: metaData.publicKey,
-      operatorIds: operatorSortedList(metaData.operators).map((operator) => operator.id),
+      operatorIds: operatorSortedList(metaData.operators).map(
+        (operator) => operator.id
+      ),
       encryptedShares: metaData.encryptedShares
     });
-    const signature = await buildSignature(`${address}:${ownerNonce}`, privateKey);
+    const signature = await buildSignature(
+      `${address}:${ownerNonce}`,
+      privateKey
+    );
     const signSharesBytes = hexArrayToBytes([signature, payload.sharesData]);
     payload.sharesData = `0x${signSharesBytes.toString("hex")}`;
     await this.validateSingleShares(payload.sharesData, {
@@ -18718,11 +18871,18 @@ const _KeySharesItem = class _KeySharesItem2 {
   async validateSingleShares(shares, fromSignatureData) {
     const { ownerAddress, ownerNonce, publicKey } = fromSignatureData;
     if (!Number.isInteger(ownerNonce) || ownerNonce < 0) {
-      throw new OwnerNonceFormatError(ownerNonce, "Owner nonce is not positive integer");
+      throw new OwnerNonceFormatError(
+        ownerNonce,
+        "Owner nonce is not positive integer"
+      );
     }
     const address = getAddress(ownerAddress);
     const signaturePt = shares.replace("0x", "").substring(0, SIGNATURE_LENGTH);
-    await validateSignature(`${address}:${ownerNonce}`, `0x${signaturePt}`, publicKey);
+    await validateSignature(
+      `${address}:${ownerNonce}`,
+      `0x${signaturePt}`,
+      publicKey
+    );
   }
   /**
    * Build shares from bytes string and operators list length
@@ -18739,7 +18899,9 @@ const _KeySharesItem = class _KeySharesItem2 {
     const sharesPt = bytes.slice(2 + SIGNATURE_LENGTH);
     const pkSplit = sharesPt.substring(0, operatorCount * PUBLIC_KEY_LENGTH);
     const pkBytes = toBytes("0x" + pkSplit);
-    const sharesPublicKeys = this.splitArray(operatorCount, pkBytes).map((item) => toHex(item));
+    const sharesPublicKeys = this.splitArray(operatorCount, pkBytes).map(
+      (item) => toHex(item)
+    );
     const eSplit = bytes.substring(operatorCount * PUBLIC_KEY_LENGTH);
     const eBytes = toBytes("0x" + eSplit);
     const encryptedKeys = this.splitArray(operatorCount, eBytes).map(
@@ -18841,7 +19003,10 @@ class SSVKeys {
    */
   async createThreshold(privateKey, operators) {
     const sortedOperators = operatorSortedList(operators);
-    this.threshold = await new Threshold().create(privateKey, sortedOperators.map((item) => item.id));
+    this.threshold = await new Threshold().create(
+      privateKey,
+      sortedOperators.map((item) => item.id)
+    );
     return this.threshold;
   }
   /**
@@ -18851,7 +19016,9 @@ class SSVKeys {
    */
   async encryptShares(operators, shares) {
     const sortedOperators = operatorSortedList(operators);
-    const decodedOperatorPublicKeys = sortedOperators.map((item) => Buffer.from(item.operatorKey, "base64").toString());
+    const decodedOperatorPublicKeys = sortedOperators.map(
+      (item) => Buffer.from(item.operatorKey, "base64").toString()
+    );
     return new Encryption(decodedOperatorPublicKeys, shares).encrypt();
   }
   /**
@@ -18887,7 +19054,10 @@ class SSVKeys {
     let signatureErrorMessage = "";
     let errorMessage = "";
     try {
-      const restoredShares = keySharesItem.buildSharesFromBytes(shares, operatorsCount);
+      const restoredShares = keySharesItem.buildSharesFromBytes(
+        shares,
+        operatorsCount
+      );
       const { sharesPublicKeys, encryptedKeys } = restoredShares;
       restoredSharesPublicKeys = sharesPublicKeys;
       restoredSharesEncryptedKeys = encryptedKeys;
@@ -18897,7 +19067,11 @@ class SSVKeys {
       errorMessage = "Can not extract shares from bytes";
     }
     if (!sharesError && !errorMessage) {
-      const signatureData = { ownerNonce, publicKey: validatorPublicKey, ownerAddress };
+      const signatureData = {
+        ownerNonce,
+        publicKey: validatorPublicKey,
+        ownerAddress
+      };
       try {
         await keySharesItem.validateSingleShares(shares, signatureData);
       } catch (e) {
@@ -18920,12 +19094,14 @@ class SSVKeys {
       isSharesValid: !sharesError,
       sharesPublicKeys: restoredSharesPublicKeys,
       encryptedKeys: restoredSharesEncryptedKeys,
-      memo: !!sharesError || !!signatureError ? [{
-        message: errorMessage,
-        error: sharesError || signatureError,
-        data: `${sharesErrorMessage}${signatureErrorMessage ? ". " + signatureErrorMessage : ""}`,
-        blockNumber
-      }] : []
+      memo: !!sharesError || !!signatureError ? [
+        {
+          message: errorMessage,
+          error: sharesError || signatureError,
+          data: `${sharesErrorMessage}${signatureErrorMessage ? ". " + signatureErrorMessage : ""}`,
+          blockNumber
+        }
+      ] : []
     };
   }
 }
@@ -18944,19 +19120,19 @@ var constants = {
   MAX_SAFE_INTEGER: MAX_SAFE_INTEGER$1
 };
 var re$1 = { exports: {} };
-(function(module, exports) {
+(function(module, exports$1) {
   const {
     MAX_SAFE_COMPONENT_LENGTH: MAX_SAFE_COMPONENT_LENGTH2,
     MAX_SAFE_BUILD_LENGTH: MAX_SAFE_BUILD_LENGTH2,
     MAX_LENGTH: MAX_LENGTH2
   } = constants;
   const debug2 = debug_1;
-  exports = module.exports = {};
-  const re2 = exports.re = [];
-  const safeRe = exports.safeRe = [];
-  const src = exports.src = [];
-  const safeSrc = exports.safeSrc = [];
-  const t2 = exports.t = {};
+  exports$1 = module.exports = {};
+  const re2 = exports$1.re = [];
+  const safeRe = exports$1.safeRe = [];
+  const src = exports$1.src = [];
+  const safeSrc = exports$1.safeSrc = [];
+  const t2 = exports$1.t = {};
   let R = 0;
   const LETTERDASHNUMBER = "[a-zA-Z0-9-]";
   const safeRegexReplacements = [
@@ -19009,18 +19185,18 @@ var re$1 = { exports: {} };
   createToken("COERCERTLFULL", src[t2.COERCEFULL], true);
   createToken("LONETILDE", "(?:~>?)");
   createToken("TILDETRIM", `(\\s*)${src[t2.LONETILDE]}\\s+`, true);
-  exports.tildeTrimReplace = "$1~";
+  exports$1.tildeTrimReplace = "$1~";
   createToken("TILDE", `^${src[t2.LONETILDE]}${src[t2.XRANGEPLAIN]}$`);
   createToken("TILDELOOSE", `^${src[t2.LONETILDE]}${src[t2.XRANGEPLAINLOOSE]}$`);
   createToken("LONECARET", "(?:\\^)");
   createToken("CARETTRIM", `(\\s*)${src[t2.LONECARET]}\\s+`, true);
-  exports.caretTrimReplace = "$1^";
+  exports$1.caretTrimReplace = "$1^";
   createToken("CARET", `^${src[t2.LONECARET]}${src[t2.XRANGEPLAIN]}$`);
   createToken("CARETLOOSE", `^${src[t2.LONECARET]}${src[t2.XRANGEPLAINLOOSE]}$`);
   createToken("COMPARATORLOOSE", `^${src[t2.GTLT]}\\s*(${src[t2.LOOSEPLAIN]})$|^$`);
   createToken("COMPARATOR", `^${src[t2.GTLT]}\\s*(${src[t2.FULLPLAIN]})$|^$`);
   createToken("COMPARATORTRIM", `(\\s*)${src[t2.GTLT]}\\s*(${src[t2.LOOSEPLAIN]}|${src[t2.XRANGEPLAIN]})`, true);
-  exports.comparatorTrimReplace = "$1$2$3";
+  exports$1.comparatorTrimReplace = "$1$2$3";
   createToken("HYPHENRANGE", `^\\s*(${src[t2.XRANGEPLAIN]})\\s+-\\s+(${src[t2.XRANGEPLAIN]})\\s*$`);
   createToken("HYPHENRANGELOOSE", `^\\s*(${src[t2.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t2.XRANGEPLAINLOOSE]})\\s*$`);
   createToken("STAR", "(<|>)?=?\\s*\\*");
@@ -19225,6 +19401,8 @@ let SemVer$2 = class SemVer {
         this.inc("patch", identifier, identifierBase);
         this.inc("pre", identifier, identifierBase);
         break;
+      // If the input is a non-prerelease version, this acts the same as
+      // prepatch.
       case "prerelease":
         if (this.prerelease.length === 0) {
           this.inc("patch", identifier, identifierBase);
@@ -19258,6 +19436,8 @@ let SemVer$2 = class SemVer {
         }
         this.prerelease = [];
         break;
+      // This probably shouldn't be used publicly.
+      // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
       case "pre": {
         const base = Number(identifierBase) ? 1 : 0;
         if (this.prerelease.length === 0) {
@@ -19414,10 +19594,10 @@ __decorateClass([
 ], _KeyShares.prototype, "shares");
 let KeyShares = _KeyShares;
 export {
-  KeySharesItem as K,
+  KeyShares as K,
   OperatorPublicKeyError as O,
   SSVKeys as S,
-  KeyShares as a,
-  SSVKeysException as b,
-  OperatorsCountsMismatchError as c
+  KeySharesItem as a,
+  OperatorsCountsMismatchError as b,
+  SSVKeysException as c
 };