@ssv-labs/ssv-sdk 0.1.3 → 1.0.1

package/dist/{KeyShares-B_4l2THg.js → KeyShares-Bk9uzOlK.js}

@@ -3,10 +3,6 @@ const bls = require("bls-eth-wasm");
 const crypto$1 = require("crypto");
 const viem = require("viem");
 const classValidator = require("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);
 })();
@@ -65,6 +61,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: {
@@ -1327,6 +1327,9 @@ util$1.format = function(format) {
           parts.push("<?>");
         }
         break;
+      // FIXME: do proper formatting for numbers, etc
+      //case 'f':
+      //case 'd':
       case "%":
         parts.push("%");
         break;
@@ -9876,6 +9879,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":
@@ -9901,6 +9905,7 @@ var _verifySignature = function(options) {
   var scheme;
   switch (cert.signatureOid) {
     case oids.sha1WithRSAEncryption:
+    // deprecated alias
     case oids.sha1WithRSASignature:
       break;
     case oids["RSASSA-PSS"]:
@@ -10391,13 +10396,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;
@@ -11952,6 +11962,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);
@@ -11960,6 +11971,7 @@ function _decodeSafeContents(safeContents, strict, password) {
           bag.asn1 = bagAsn1;
         }
         continue;
+      /* Nothing more to do. */
       case pki$1.oids.certBag:
         validator = certBagValidator;
         decoder = function() {
@@ -17457,7 +17469,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;
@@ -17522,12 +17537,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}'`);
@@ -17542,12 +17561,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(
@@ -17591,7 +17614,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)) {
@@ -17612,7 +17638,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);
@@ -17986,6 +18014,7 @@ var scrypt = { exports: {} };
             arraycopy(B, Bi, XY, 0, Yi);
             state = 1;
             i1 = 0;
+          // Fall through
           case 1:
             steps = N - i1;
             if (steps > limit) {
@@ -18012,6 +18041,7 @@ var scrypt = { exports: {} };
             }
             i1 = 0;
             state = 2;
+          // Fall through
           case 2:
             steps = N - i1;
             if (steps > limit) {
@@ -18108,11 +18138,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 {
@@ -18152,15 +18188,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 = viem.keccak256(viem.toHex(macCheck)).replace(/^0x/, "");
     if (mac !== json.crypto.mac.toLowerCase()) {
       throw new EthereumWalletError("Invalid password");
@@ -18189,12 +18242,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" ? viem.sha256 : viem.keccak256;
     const calculatedMac = hashFn(viem.toHex(checksumBuffer));
     if (calculatedMac.replace(/^0x/, "") !== checksum.message.toLowerCase()) {
@@ -18229,7 +18291,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(
           {
@@ -18320,10 +18384,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 };
   });
@@ -18345,14 +18417,18 @@ class SingleSharesSignatureInvalid extends SSVKeysException {
   }
 }
 const hexArrayToBytes = (hexArr) => {
-  const uint8Array = new Uint8Array(hexArr.flatMap((hex) => Array.from(viem.toBytes(hex))));
+  const uint8Array = new Uint8Array(
+    hexArr.flatMap((hex) => Array.from(viem.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 = viem.keccak256(viem.toBytes(dataToSign));
   const messageBytes = viem.fromHex(messageHash, "bytes");
   const signature = privateKey.sign(messageBytes);
@@ -18360,12 +18436,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 = viem.keccak256(viem.toBytes(signedData));
   const messageHashBytes = viem.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) => {
@@ -18387,11 +18470,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);
     }
@@ -18429,10 +18518,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;
   }
@@ -18472,7 +18566,10 @@ let OwnerAddressValidatorConstraint = class {
     try {
       viem.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;
   }
@@ -18505,7 +18602,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;
   }
@@ -18542,12 +18642,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;
@@ -18727,7 +18835,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 {
@@ -18740,10 +18851,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, {
@@ -18756,11 +18872,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 = viem.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
@@ -18777,7 +18900,9 @@ const _KeySharesItem = class _KeySharesItem2 {
     const sharesPt = bytes.slice(2 + SIGNATURE_LENGTH);
     const pkSplit = sharesPt.substring(0, operatorCount * PUBLIC_KEY_LENGTH);
     const pkBytes = viem.toBytes("0x" + pkSplit);
-    const sharesPublicKeys = this.splitArray(operatorCount, pkBytes).map((item) => viem.toHex(item));
+    const sharesPublicKeys = this.splitArray(operatorCount, pkBytes).map(
+      (item) => viem.toHex(item)
+    );
     const eSplit = bytes.substring(operatorCount * PUBLIC_KEY_LENGTH);
     const eBytes = viem.toBytes("0x" + eSplit);
     const encryptedKeys = this.splitArray(operatorCount, eBytes).map(
@@ -18879,7 +19004,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;
   }
   /**
@@ -18889,7 +19017,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();
   }
   /**
@@ -18925,7 +19055,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;
@@ -18935,7 +19068,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) {
@@ -18958,12 +19095,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
+        }
+      ] : []
     };
   }
 }
@@ -19263,6 +19402,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);
@@ -19296,6 +19437,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) {