@taquito/utils 23.0.0-beta.0 → 23.0.0-beta.1

package/dist/lib/validators.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValidationResult = void 0;
-exports.isValidPrefix = isValidPrefix;
+exports.isValidPrefixedValue = isValidPrefixedValue;
 exports.validateAddress = validateAddress;
 exports.validateChain = validateChain;
 exports.validateContractAddress = validateContractAddress;
@@ -11,75 +11,60 @@ exports.validatePublicKey = validatePublicKey;
 exports.validateOperation = validateOperation;
 exports.validateProtocol = validateProtocol;
 exports.validateBlock = validateBlock;
-exports.validateSpendingKey = validateSpendingKey;
 exports.invalidDetail = invalidDetail;
+exports.validateSpendingKey = validateSpendingKey;
 exports.validateSmartRollupAddress = validateSmartRollupAddress;
 const constants_1 = require("./constants");
-const bs58check_1 = require("bs58check");
-var ValidationResult;
-(function (ValidationResult) {
-    ValidationResult[ValidationResult["NO_PREFIX_MATCHED"] = 0] = "NO_PREFIX_MATCHED";
-    ValidationResult[ValidationResult["INVALID_CHECKSUM"] = 1] = "INVALID_CHECKSUM";
-    ValidationResult[ValidationResult["INVALID_LENGTH"] = 2] = "INVALID_LENGTH";
-    ValidationResult[ValidationResult["VALID"] = 3] = "VALID";
-})(ValidationResult || (exports.ValidationResult = ValidationResult = {}));
-function isValidPrefix(value) {
-    if (typeof value !== 'string') {
-        return false;
-    }
-    return value in constants_1.prefix;
+const taquito_utils_1 = require("./taquito-utils");
+const core_1 = require("@taquito/core");
+var core_2 = require("@taquito/core");
+Object.defineProperty(exports, "ValidationResult", { enumerable: true, get: function () { return core_2.ValidationResult; } });
+/**
+ * @description Used to check if a value has one of the allowed prefixes.
+ * @returns true if the value has one of the allowed prefixes, false otherwise
+ * @example
+ * ```
+ * import { isValidPrefixedValue } from '@taquito/utils';
+ * const value = 'tz1L9r8mWmRPndRhuvMCWESLGSVeFzQ9NAWx'
+ * const isValid = isValidPrefixedValue(value, [PrefixV2.Ed25519PublicKeyHash])
+ * console.log(isValid) // true
+ * ```
+ */
+function isValidPrefixedValue(value, prefixes) {
+    return validatePrefixedValue(value, prefixes) === taquito_utils_1.ValidationResult.VALID;
 }
 /**
  * @description This function is called by the validation functions ([[validateAddress]], [[validateChain]], [[validateContractAddress]], [[validateKeyHash]], [[validateSignature]], [[validatePublicKey]]).
- * Verify if the value has the right prefix or return `NO_PREFIX_MATCHED`,
- * decode the value using base58 and return `INVALID_CHECKSUM` if it fails,
- * check if the length of the value matches the prefix type or return `INVALID_LENGTH`.
- * If all checks pass, return `VALID`.
- *
+ * Verify if the value can be decoded or return `1` (INVALID_CHECKSUM) / `5` (INVALID_ENCODING), then check if the prefix is valid or allowed or return `0` (NO_PREFIX_MATCHED) / `4` (PREFIX_NOT_ALLOWED)
+ * If all checks pass, return `3` (VALID).
  * @param value Value to validate
  * @param prefixes prefix the value should have
+ * @returns 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
+ * @example
+ * ```
+ * import { validatePrefixedValue } from '@taquito/utils';
+ * const value = 'tz1L9r8mWmRPndRhuvMCWESLGSVeFzQ9NAWx'
+ * const validation = validatePrefixedValue(value, [PrefixV2.Ed25519PublicKeyHash])
+ * console.log(validation) // 3
+ * ```
  */
 function validatePrefixedValue(value, prefixes) {
-    const match = new RegExp(`^(${prefixes.join('|')})`).exec(value);
-    if (!match || match.length === 0) {
-        return ValidationResult.NO_PREFIX_MATCHED;
-    }
-    const prefixKey = match[0];
-    if (!isValidPrefix(prefixKey)) {
-        return ValidationResult.NO_PREFIX_MATCHED;
-    }
-    // Check whether annotation exist before starting validation
-    if (value.includes('%')) {
-        value = value.split('%')[0];
+    try {
+        (0, taquito_utils_1.b58DecodeAndCheckPrefix)(value, prefixes);
     }
-    const kt1Regex = /^(KT1\w{33})$/;
-    if (!kt1Regex.test(value) && prefixKey === 'KT1') {
-        return ValidationResult.INVALID_CHECKSUM;
+    catch (err) {
+        if (err instanceof core_1.ParameterValidationError && err.result !== undefined) {
+            return err.result;
+        }
+        return taquito_utils_1.ValidationResult.OTHER;
     }
-    // decodeUnsafe return undefined if decoding fail
-    let decoded = bs58check_1.default.decodeUnsafe(value);
-    if (!decoded) {
-        return ValidationResult.INVALID_CHECKSUM;
-    }
-    decoded = decoded.slice(constants_1.prefix[prefixKey].length);
-    if (decoded.length !== constants_1.prefixLength[prefixKey]) {
-        return ValidationResult.INVALID_LENGTH;
-    }
-    return ValidationResult.VALID;
+    return taquito_utils_1.ValidationResult.VALID;
 }
-const implicitPrefix = [constants_1.Prefix.TZ1, constants_1.Prefix.TZ2, constants_1.Prefix.TZ3, constants_1.Prefix.TZ4];
-const contractPrefix = [constants_1.Prefix.KT1];
-const signaturePrefix = [constants_1.Prefix.EDSIG, constants_1.Prefix.P2SIG, constants_1.Prefix.SPSIG, constants_1.Prefix.SIG];
-const pkPrefix = [constants_1.Prefix.EDPK, constants_1.Prefix.SPPK, constants_1.Prefix.P2PK, constants_1.Prefix.BLPK];
-const operationPrefix = [constants_1.Prefix.O];
-const protocolPrefix = [constants_1.Prefix.P];
-const blockPrefix = [constants_1.Prefix.B];
-const smartRollupPrefix = [constants_1.Prefix.SR1];
 /**
  * @description Used to check if an address or a contract address is valid.
  *
  * @returns
- * 0 (NO_PREFIX_MATCHED), 1 (INVALID_CHECKSUM), 2 (INVALID_LENGTH) or 3 (VALID).
+ * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
  *
  * @example
  * ```
@@ -91,13 +76,14 @@ const smartRollupPrefix = [constants_1.Prefix.SR1];
  * ```
  */
 function validateAddress(value) {
-    return validatePrefixedValue(value, [...implicitPrefix, ...contractPrefix, ...smartRollupPrefix]);
+    const [addr] = (0, taquito_utils_1.splitAddress)(value !== null && value !== void 0 ? value : '');
+    return validatePrefixedValue(addr, taquito_utils_1.addressPrefixes);
 }
 /**
  * @description Used to check if a chain id is valid.
  *
  * @returns
- * 0 (NO_PREFIX_MATCHED), 1 (INVALID_CHECKSUM), 2 (INVALID_LENGTH) or 3 (VALID).
+ * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
  *
  * @example
  * ```
@@ -109,13 +95,13 @@ function validateAddress(value) {
  * ```
  */
 function validateChain(value) {
-    return validatePrefixedValue(value, [constants_1.Prefix.NET]);
+    return validatePrefixedValue(value, [constants_1.PrefixV2.ChainID]);
 }
 /**
  * @description Used to check if a contract address is valid.
  *
  * @returns
- * 0 (NO_PREFIX_MATCHED), 1 (INVALID_CHECKSUM), 2 (INVALID_LENGTH) or 3 (VALID).
+ * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
  *
  * @example
  * ```
@@ -127,13 +113,13 @@ function validateChain(value) {
  * ```
  */
 function validateContractAddress(value) {
-    return validatePrefixedValue(value, contractPrefix);
+    return validatePrefixedValue(value, [constants_1.PrefixV2.ContractHash]);
 }
 /**
  * @description Used to check if a key hash is valid.
  *
  * @returns
- * 0 (NO_PREFIX_MATCHED), 1 (INVALID_CHECKSUM), 2 (INVALID_LENGTH) or 3 (VALID).
+ * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
  *
  * @example
  * ```
@@ -145,13 +131,13 @@ function validateContractAddress(value) {
  * ```
  */
 function validateKeyHash(value) {
-    return validatePrefixedValue(value, implicitPrefix);
+    return validatePrefixedValue(value, taquito_utils_1.publicKeyHashPrefixes);
 }
 /**
  * @description Used to check if a signature is valid.
  *
  * @returns
- * 0 (NO_PREFIX_MATCHED), 1 (INVALID_CHECKSUM), 2 (INVALID_LENGTH) or 3 (VALID).
+ * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
  *
  * @example
  * ```
@@ -163,13 +149,13 @@ function validateKeyHash(value) {
  * ```
  */
 function validateSignature(value) {
-    return validatePrefixedValue(value, signaturePrefix);
+    return validatePrefixedValue(value, taquito_utils_1.signaturePrefixes);
 }
 /**
  * @description Used to check if a public key is valid.
  *
  * @returns
- * 0 (NO_PREFIX_MATCHED), 1 (INVALID_CHECKSUM), 2 (INVALID_LENGTH) or 3 (VALID).
+ * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
  *
  * @example
  * ```
@@ -181,13 +167,13 @@ function validateSignature(value) {
  * ```
  */
 function validatePublicKey(value) {
-    return validatePrefixedValue(value, pkPrefix);
+    return validatePrefixedValue(value, taquito_utils_1.publicKeyPrefixes);
 }
 /**
  * @description Used to check if an operation hash is valid.
  *
  * @returns
- * 0 (NO_PREFIX_MATCHED), 1 (INVALID_CHECKSUM), 2 (INVALID_LENGTH) or 3 (VALID).
+ * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
  *
  * @example
  * ```
@@ -199,13 +185,13 @@ function validatePublicKey(value) {
  * ```
  */
 function validateOperation(value) {
-    return validatePrefixedValue(value, operationPrefix);
+    return validatePrefixedValue(value, [constants_1.PrefixV2.OperationHash]);
 }
 /**
  * @description Used to check if a protocol hash is valid.
  *
  * @returns
- * 0 (NO_PREFIX_MATCHED), 1 (INVALID_CHECKSUM), 2 (INVALID_LENGTH) or 3 (VALID).
+ * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
  *
  * @example
  * ```
@@ -217,13 +203,13 @@ function validateOperation(value) {
  * ```
  */
 function validateProtocol(value) {
-    return validatePrefixedValue(value, protocolPrefix);
+    return validatePrefixedValue(value, [constants_1.PrefixV2.ProtocolHash]);
 }
 /**
  * @description Used to check if a block hash is valid.
  *
  * @returns
- * 0 (NO_PREFIX_MATCHED), 1 (INVALID_CHECKSUM), 2 (INVALID_LENGTH) or 3 (VALID).
+ * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
  *
  * @example
  * ```
@@ -235,28 +221,33 @@ function validateProtocol(value) {
  * ```
  */
 function validateBlock(value) {
-    return validatePrefixedValue(value, blockPrefix);
+    return validatePrefixedValue(value, [constants_1.PrefixV2.BlockHash]);
 }
 /**
- * @description Used to check if a spending key is valid.
- * @returns 0 (NO_PREFIX_MATCHED), 1 (INVALID_CHECKSUM), 2 (INVALID_LENGTH) or 3 (VALID).
- *
+ * @deprecated this function will be removed in the next minor release
+ * @description generates a readable error string from a validation result
  */
-function validateSpendingKey(value) {
-    return validatePrefixedValue(value, [constants_1.Prefix.SASK]);
-}
 function invalidDetail(validation) {
     switch (validation) {
-        case ValidationResult.NO_PREFIX_MATCHED:
+        case taquito_utils_1.ValidationResult.NO_PREFIX_MATCHED:
             return 'with unsupported prefix';
-        case ValidationResult.INVALID_CHECKSUM:
+        case taquito_utils_1.ValidationResult.INVALID_CHECKSUM:
             return 'failed checksum';
-        case ValidationResult.INVALID_LENGTH:
+        case taquito_utils_1.ValidationResult.INVALID_LENGTH:
             return 'with incorrect length';
         default:
             return '';
     }
 }
+/**
+ * @description Used to check if a spending key is valid.
+ * @returns
+ * 0 = NO_PREFIX_MATCHED, 1 = INVALID_CHECKSUM, 2 = INVALID_LENGTH, 3 = VALID, 4 = PREFIX_NOT_ALLOWED, 5 = INVALID_ENCODING, 6 = OTHER,
+ *
+ */
+function validateSpendingKey(value) {
+    return validatePrefixedValue(value, [constants_1.PrefixV2.SaplingSpendingKey]);
+}
 function validateSmartRollupAddress(value) {
-    return validatePrefixedValue(value, [...smartRollupPrefix]);
+    return validatePrefixedValue(value, [constants_1.PrefixV2.SmartRollupHash]);
 }

package/dist/lib/verify-signature.js

@@ -1,20 +1,23 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.POP_DST = exports.BLS12_381_DST = void 0;
 exports.verifySignature = verifySignature;
 exports.validatePkAndExtractPrefix = validatePkAndExtractPrefix;
 const ed25519_1 = require("@stablelib/ed25519");
 const blake2b_1 = require("@stablelib/blake2b");
 const taquito_utils_1 = require("./taquito-utils");
 const elliptic_1 = require("elliptic");
-const typedarray_to_buffer_1 = require("typedarray-to-buffer");
 const core_1 = require("@taquito/core");
+const bls12_381_1 = require("@noble/curves/bls12-381");
+exports.BLS12_381_DST = 'BLS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_POP_';
+exports.POP_DST = 'BLS_POP_BLS12381G2_XMD:SHA-256_SSWU_RO_POP_';
 /**
  * @description Verify signature of a payload
- *
- * @param messageBytes The forged message including the magic byte (11 for block,
- *        12 for preattestation, 13 for attestation, 3 for generic, 5 for the PACK format of michelson)
+ * @param message The forged message including the magic byte (11 for block, 12 for preattestation, 13 for attestation, 3 for generic, 5 for the PACK format of michelson) in string or Uint8Array
  * @param publicKey The public key to verify the signature against
  * @param signature The signature to verify
+ * @param watermark Optional if not included in the message
+ * @param pop Optional if verifying proof of possession signature
  * @returns A boolean indicating if the signature matches
  * @throws {@link InvalidPublicKeyError} | {@link InvalidSignatureError} | {@link InvalidMessageError}
  * @example
@@ -27,35 +30,67 @@ const core_1 = require("@taquito/core");
  * ```
  *
  */
-function verifySignature(messageBytes, publicKey, signature, watermark) {
-    const pkPrefix = validatePkAndExtractPrefix(publicKey);
-    const sigPrefix = validateSigAndExtractPrefix(signature);
-    const decodedPublicKey = (0, taquito_utils_1.b58cdecode)(publicKey, taquito_utils_1.prefix[pkPrefix]);
-    const decodedSig = (0, taquito_utils_1.b58cdecode)(signature, taquito_utils_1.prefix[sigPrefix]);
-    let messageBuf = (0, taquito_utils_1.hex2buf)(validateMessageNotEmpty(messageBytes));
-    if (typeof watermark !== 'undefined') {
-        messageBuf = (0, taquito_utils_1.mergebuf)(watermark, messageBuf);
+function verifySignature(message, publicKey, signature, watermark, pop) {
+    const [pk, pre] = (() => {
+        try {
+            return (0, taquito_utils_1.b58DecodeAndCheckPrefix)(publicKey, taquito_utils_1.publicKeyPrefixes);
+        }
+        catch (err) {
+            if (err instanceof core_1.ParameterValidationError) {
+                throw new core_1.InvalidPublicKeyError(publicKey, err.result);
+            }
+            else {
+                throw err;
+            }
+        }
+    })();
+    const sig = (() => {
+        try {
+            const [sig] = (0, taquito_utils_1.b58DecodeAndCheckPrefix)(signature, taquito_utils_1.signaturePrefixes);
+            return sig;
+        }
+        catch (err) {
+            if (err instanceof core_1.ParameterValidationError) {
+                throw new core_1.InvalidSignatureError(signature, err.result);
+            }
+            else {
+                throw err;
+            }
+        }
+    })();
+    let msg;
+    if (typeof message === 'string') {
+        msg = (0, taquito_utils_1.hex2buf)(message);
     }
-    const bytesHash = (0, blake2b_1.hash)(messageBuf, 32);
-    if (pkPrefix === taquito_utils_1.Prefix.EDPK) {
-        return verifyEdSignature(decodedSig, bytesHash, decodedPublicKey);
+    else {
+        msg = message;
     }
-    else if (pkPrefix === taquito_utils_1.Prefix.SPPK) {
-        return verifySpSignature(decodedSig, bytesHash, decodedPublicKey);
+    if (msg.length === 0) {
+        throw new core_1.InvalidMessageError((0, taquito_utils_1.buf2hex)(msg), `can't be empty`);
     }
-    else if (pkPrefix === taquito_utils_1.Prefix.P2PK) {
-        return verifyP2Signature(decodedSig, bytesHash, decodedPublicKey);
+    if (typeof watermark !== 'undefined') {
+        msg = (0, taquito_utils_1.mergebuf)(watermark, msg);
     }
-    else {
-        return false;
+    if (pop) {
+        return verifyBLSPopSignature(sig, msg, pk);
     }
-}
-function validateMessageNotEmpty(message) {
-    if (message === '') {
-        throw new core_1.InvalidMessageError(message, `can't be empty`);
+    else {
+        switch (pre) {
+            case taquito_utils_1.PrefixV2.P256PublicKey:
+                return verifyP2Signature(sig, msg, pk);
+            case taquito_utils_1.PrefixV2.Secp256k1PublicKey:
+                return verifySpSignature(sig, msg, pk);
+            case taquito_utils_1.PrefixV2.Ed25519PublicKey:
+                return verifyEdSignature(sig, msg, pk);
+            default:
+                return verifyBLSSignature(sig, msg, pk);
+        }
     }
-    return message;
 }
+/**
+ * @deprecated use b58DecodeAndCheckPrefix instead, this function will be removed in the next minor release
+ * @description validates a public key and extracts the prefix
+ */
 function validatePkAndExtractPrefix(publicKey) {
     if (publicKey === '') {
         throw new core_1.InvalidPublicKeyError(publicKey, `can't be empty`);
@@ -67,43 +102,50 @@ function validatePkAndExtractPrefix(publicKey) {
     }
     return pkPrefix;
 }
-function validateSigAndExtractPrefix(signature) {
-    const signaturePrefix = signature.startsWith('sig')
-        ? signature.substring(0, 3)
-        : signature.substring(0, 5);
-    const validation = (0, taquito_utils_1.validateSignature)(signature);
-    if (validation !== taquito_utils_1.ValidationResult.VALID) {
-        throw new core_1.InvalidSignatureError(signature, (0, taquito_utils_1.invalidDetail)(validation));
-    }
-    return signaturePrefix;
-}
-function verifyEdSignature(decodedSig, bytesHash, decodedPublicKey) {
+function verifyEdSignature(sig, msg, publicKey) {
+    const hash = (0, blake2b_1.hash)(msg, 32);
     try {
-        return (0, ed25519_1.verify)(decodedPublicKey, bytesHash, decodedSig);
+        return (0, ed25519_1.verify)(publicKey, hash, sig);
     }
-    catch (e) {
+    catch (_a) {
         return false;
     }
 }
-function verifySpSignature(decodedSig, bytesHash, decodedPublicKey) {
-    const key = new elliptic_1.default.ec('secp256k1').keyFromPublic(decodedPublicKey);
-    return verifySpOrP2Sig(decodedSig, bytesHash, key);
+function verifySpSignature(sig, msg, publicKey) {
+    const key = new elliptic_1.default.ec('secp256k1').keyFromPublic(publicKey);
+    return verifySpOrP2Sig(sig, msg, key);
 }
-function verifyP2Signature(decodedSig, bytesHash, decodedPublicKey) {
-    const key = new elliptic_1.default.ec('p256').keyFromPublic(decodedPublicKey);
-    return verifySpOrP2Sig(decodedSig, bytesHash, key);
+function verifyP2Signature(sig, msg, publicKey) {
+    const key = new elliptic_1.default.ec('p256').keyFromPublic(publicKey);
+    return verifySpOrP2Sig(sig, msg, key);
 }
-function verifySpOrP2Sig(decodedSig, bytesHash, key) {
-    const hexSig = (0, taquito_utils_1.buf2hex)((0, typedarray_to_buffer_1.default)(decodedSig));
-    const match = hexSig.match(/([a-f\d]{64})/gi);
-    if (match) {
-        try {
-            const [r, s] = match;
-            return key.verify(bytesHash, { r, s });
-        }
-        catch (e) {
-            return false;
-        }
+function verifySpOrP2Sig(sig, msg, key) {
+    const r = sig.slice(0, 32);
+    const s = sig.slice(32);
+    const hash = (0, blake2b_1.hash)(msg, 32);
+    try {
+        return key.verify(hash, { r, s });
+    }
+    catch (_a) {
+        return false;
+    }
+}
+const bls = bls12_381_1.bls12_381.longSignatures; // AKA MinPK
+function verifyBLSSignature(sig, msg, publicKey) {
+    try {
+        const point = bls.hash(msg, exports.BLS12_381_DST);
+        return bls.verify(sig, point, publicKey);
+    }
+    catch (_a) {
+        return false;
+    }
+}
+function verifyBLSPopSignature(sig, msg, publicKey) {
+    try {
+        const point = bls.hash(msg, exports.POP_DST);
+        return bls.verify(sig, point, publicKey);
+    }
+    catch (_a) {
+        return false;
     }
-    return false;
 }

package/dist/lib/version.js

@@ -3,6 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
 exports.VERSION = {
-    "commitHash": "7af2138a9e5c5b230c4b4c726f35c2f2e67b721c",
-    "version": "23.0.0-beta.0"
+    "commitHash": "10b3de10de15ae68d47b1fca922d3129d2f79641",
+    "version": "23.0.0-beta.1"
 };