@ssv-labs/ssv-sdk 0.1.3 → 1.0.1

package/dist/{KeyShares-ClzHwMUy.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;
@@ -9875,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":
@@ -9900,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"]:
@@ -10390,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;
@@ -11951,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);
@@ -11959,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() {
@@ -17456,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;
@@ -17521,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}'`);
@@ -17541,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(
@@ -17590,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)) {
@@ -17611,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);
@@ -17985,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) {
@@ -18011,6 +18040,7 @@ var scrypt = { exports: {} };
             }
             i1 = 0;
             state = 2;
+          // Fall through
           case 2:
             steps = N - i1;
             if (steps > limit) {
@@ -18107,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 {
@@ -18151,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");
@@ -18188,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()) {
@@ -18228,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(
           {
@@ -18319,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 };
   });
@@ -18344,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);
@@ -18359,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) => {
@@ -18386,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);
     }
@@ -18428,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;
   }
@@ -18471,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;
   }
@@ -18504,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;
   }
@@ -18541,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;
@@ -18726,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 {
@@ -18739,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, {
@@ -18755,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
@@ -18776,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(
@@ -18878,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;
   }
   /**
@@ -18888,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();
   }
   /**
@@ -18924,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;
@@ -18934,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) {
@@ -18957,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
+        }
+      ] : []
     };
   }
 }
@@ -19262,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);
@@ -19295,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) {
@@ -19451,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
 };