@taquito/signer 23.0.0-beta.1 → 23.0.1

package/dist/lib/bls-key.js

@@ -10,9 +10,9 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _BLSKey_key, _BLSKey_publicKey;
+var _BLSKey_key, _BLSKey_publicKey, _BLSPublicKey_key;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BLSKey = void 0;
+exports.BLSPublicKey = exports.BLSKey = void 0;
 const utils_1 = require("@taquito/utils");
 const bls12_381_1 = require("@noble/curves/bls12-381");
 const blake2b_1 = require("@stablelib/blake2b");
@@ -44,11 +44,11 @@ class BLSKey {
     signDst(message, dst) {
         const point = bls.hash(message, dst);
         const sig = bls.sign(point, this.sk()).toBytes();
-        return Promise.resolve({
+        return {
             rawSignature: sig,
             sig: (0, utils_1.b58Encode)(sig, utils_1.PrefixV2.GenericSignature),
             prefixSig: (0, utils_1.b58Encode)(sig, utils_1.PrefixV2.BLS12_381Signature),
-        });
+        };
     }
     sign(message) {
         return this.signDst(message, utils_1.BLS12_381_DST);
@@ -57,17 +57,48 @@ class BLSKey {
         return this.signDst(__classPrivateFieldGet(this, _BLSKey_publicKey, "f"), utils_1.POP_DST);
     }
     publicKey() {
-        const res = (0, utils_1.b58Encode)(__classPrivateFieldGet(this, _BLSKey_publicKey, "f"), utils_1.PrefixV2.BLS12_381PublicKey);
-        return Promise.resolve(res);
-    }
-    publicKeyHash() {
-        const res = (0, utils_1.b58Encode)((0, blake2b_1.hash)(__classPrivateFieldGet(this, _BLSKey_publicKey, "f"), 20), utils_1.PrefixV2.BLS12_381PublicKeyHash);
-        return Promise.resolve(res);
+        return new BLSPublicKey(__classPrivateFieldGet(this, _BLSKey_publicKey, "f"));
     }
     secretKey() {
-        const res = (0, utils_1.b58Encode)(__classPrivateFieldGet(this, _BLSKey_key, "f"), utils_1.PrefixV2.BLS12_381SecretKey);
-        return Promise.resolve(res);
+        return (0, utils_1.b58Encode)(__classPrivateFieldGet(this, _BLSKey_key, "f"), utils_1.PrefixV2.BLS12_381SecretKey);
     }
 }
 exports.BLSKey = BLSKey;
 _BLSKey_key = new WeakMap(), _BLSKey_publicKey = new WeakMap();
+class BLSPublicKey {
+    constructor(src) {
+        _BLSPublicKey_key.set(this, void 0);
+        if (typeof src === 'string') {
+            const [key, _] = (0, utils_1.b58DecodeAndCheckPrefix)(src, [utils_1.PrefixV2.BLS12_381PublicKey]);
+            __classPrivateFieldSet(this, _BLSPublicKey_key, key, "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _BLSPublicKey_key, src, "f");
+        }
+    }
+    compare(other) {
+        if (other instanceof BLSPublicKey) {
+            return (0, utils_1.compareArrays)(this.bytes(), other.bytes());
+        }
+        else {
+            throw new utils_1.InvalidPublicKeyError('BLS key expected');
+        }
+    }
+    hash() {
+        return (0, utils_1.b58Encode)((0, blake2b_1.hash)(__classPrivateFieldGet(this, _BLSPublicKey_key, "f"), 20), utils_1.PrefixV2.BLS12_381PublicKeyHash);
+    }
+    bytes() {
+        return __classPrivateFieldGet(this, _BLSPublicKey_key, "f");
+    }
+    toProtocol() {
+        const res = new Uint8Array(__classPrivateFieldGet(this, _BLSPublicKey_key, "f").length + 1);
+        res[0] = 3;
+        res.set(__classPrivateFieldGet(this, _BLSPublicKey_key, "f"), 1);
+        return res;
+    }
+    toString() {
+        return (0, utils_1.b58Encode)(__classPrivateFieldGet(this, _BLSPublicKey_key, "f"), utils_1.PrefixV2.BLS12_381PublicKey);
+    }
+}
+exports.BLSPublicKey = BLSPublicKey;
+_BLSPublicKey_key = new WeakMap();

package/dist/lib/ec-key.js

@@ -1,39 +1,48 @@
 "use strict";
-var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _ECKey_key, _ECKey_publicKey, _ECKey_curve;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ECKey = void 0;
+exports.ECPublicKey = exports.ECKey = void 0;
 const blake2b_1 = require("@stablelib/blake2b");
 const utils_1 = require("@taquito/utils");
 const elliptic_1 = require("elliptic");
+const key_1 = require("elliptic/lib/elliptic/ec/key");
+const errors_1 = require("./errors");
 const pref = {
     p256: {
         pk: utils_1.PrefixV2.P256PublicKey,
         sk: utils_1.PrefixV2.P256SecretKey,
         pkh: utils_1.PrefixV2.P256PublicKeyHash,
         sig: utils_1.PrefixV2.P256Signature,
+        tag: 2,
     },
     secp256k1: {
         pk: utils_1.PrefixV2.Secp256k1PublicKey,
         sk: utils_1.PrefixV2.Secp256k1SecretKey,
         pkh: utils_1.PrefixV2.Secp256k1PublicKeyHash,
         sig: utils_1.PrefixV2.Secp256k1Signature,
+        tag: 1,
     },
 };
+class ECKeyBase {
+    constructor(keyPair) {
+        this.keyPair = keyPair;
+    }
+    curve() {
+        switch (this.keyPair.ec.curve) {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            case elliptic_1.default.curves.secp256k1.curve:
+                return 'secp256k1';
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            case elliptic_1.default.curves.p256.curve:
+                return 'p256';
+            default:
+                throw new errors_1.InvalidCurveError('unknown curve');
+        }
+    }
+}
 /**
  * @description Provide signing logic for elliptic curve based key (tz2, tz3)
  */
-class ECKey {
+class ECKey extends ECKeyBase {
     /**
      *
      * @param key Encoded private key
@@ -41,43 +50,32 @@ class ECKey {
      * @throws {@link InvalidKeyError}
      */
     constructor(key, decrypt) {
-        var _a;
-        _ECKey_key.set(this, void 0);
-        _ECKey_publicKey.set(this, void 0);
-        _ECKey_curve.set(this, void 0);
-        const tmp = (0, utils_1.b58DecodeAndCheckPrefix)(key, [
+        const [keyData, prefix] = (0, utils_1.b58DecodeAndCheckPrefix)(key, [
             utils_1.PrefixV2.Secp256k1EncryptedSecretKey,
             utils_1.PrefixV2.P256EncryptedSecretKey,
             utils_1.PrefixV2.Secp256k1SecretKey,
             utils_1.PrefixV2.P256SecretKey,
         ]);
-        _a = this, [({ set value(_b) { __classPrivateFieldSet(_a, _ECKey_key, _b, "f"); } }).value] = tmp;
-        const [, prefix] = tmp;
-        switch (prefix) {
-            case utils_1.PrefixV2.Secp256k1EncryptedSecretKey:
-            case utils_1.PrefixV2.P256EncryptedSecretKey:
-                if (decrypt !== undefined) {
-                    __classPrivateFieldSet(this, _ECKey_key, decrypt(__classPrivateFieldGet(this, _ECKey_key, "f")), "f");
-                }
-                else {
-                    throw new Error('decryption function is not provided');
-                }
-                if (prefix === utils_1.PrefixV2.Secp256k1EncryptedSecretKey) {
-                    __classPrivateFieldSet(this, _ECKey_curve, 'secp256k1', "f");
-                }
-                else {
-                    __classPrivateFieldSet(this, _ECKey_curve, 'p256', "f");
-                }
-                break;
-            case utils_1.PrefixV2.Secp256k1SecretKey:
-                __classPrivateFieldSet(this, _ECKey_curve, 'secp256k1', "f");
-                break;
-            default:
-                __classPrivateFieldSet(this, _ECKey_curve, 'p256', "f");
-                break;
-        }
-        const keyPair = new elliptic_1.default.ec(__classPrivateFieldGet(this, _ECKey_curve, "f")).keyFromPrivate(__classPrivateFieldGet(this, _ECKey_key, "f"));
-        __classPrivateFieldSet(this, _ECKey_publicKey, new Uint8Array(keyPair.getPublic(true, 'array')), "f"); // compress
+        const [decKey, curve] = (() => {
+            switch (prefix) {
+                case utils_1.PrefixV2.Secp256k1EncryptedSecretKey:
+                case utils_1.PrefixV2.P256EncryptedSecretKey:
+                    if (decrypt === undefined) {
+                        throw new Error('decryption function is not provided');
+                    }
+                    else {
+                        return [
+                            decrypt(keyData),
+                            prefix === utils_1.PrefixV2.Secp256k1EncryptedSecretKey ? 'secp256k1' : 'p256',
+                        ];
+                    }
+                case utils_1.PrefixV2.Secp256k1SecretKey:
+                    return [keyData, 'secp256k1'];
+                default:
+                    return [keyData, 'p256'];
+            }
+        })();
+        super(new elliptic_1.default.ec(curve).keyFromPrivate(decKey));
     }
     /**
      *
@@ -86,37 +84,96 @@ class ECKey {
      */
     sign(bytes) {
         const hash = (0, blake2b_1.hash)(bytes, 32);
-        const key = new elliptic_1.default.ec(__classPrivateFieldGet(this, _ECKey_curve, "f")).keyFromPrivate(__classPrivateFieldGet(this, _ECKey_key, "f"));
-        const sig = key.sign(hash, { canonical: true });
+        const sig = this.keyPair.sign(hash, { canonical: true });
         const signature = new Uint8Array(64);
         const r = sig.r.toArray();
         const s = sig.s.toArray();
         signature.set(r, 32 - r.length);
         signature.set(s, 64 - s.length);
-        return Promise.resolve({
+        return {
             rawSignature: signature,
             sig: (0, utils_1.b58Encode)(signature, utils_1.PrefixV2.GenericSignature),
-            prefixSig: (0, utils_1.b58Encode)(signature, pref[__classPrivateFieldGet(this, _ECKey_curve, "f")].sig),
-        });
+            prefixSig: (0, utils_1.b58Encode)(signature, pref[this.curve()].sig),
+        };
     }
     /**
      * @returns Encoded public key
      */
     publicKey() {
-        return Promise.resolve((0, utils_1.b58Encode)(__classPrivateFieldGet(this, _ECKey_publicKey, "f"), pref[__classPrivateFieldGet(this, _ECKey_curve, "f")].pk));
-    }
-    /**
-     * @returns Encoded public key hash
-     */
-    publicKeyHash() {
-        return Promise.resolve((0, utils_1.b58Encode)((0, blake2b_1.hash)(new Uint8Array(__classPrivateFieldGet(this, _ECKey_publicKey, "f")), 20), pref[__classPrivateFieldGet(this, _ECKey_curve, "f")].pkh));
+        return new ECPublicKey(this.keyPair.ec.keyFromPublic(this.keyPair));
     }
     /**
      * @returns Encoded private key
      */
     secretKey() {
-        return Promise.resolve((0, utils_1.b58Encode)(__classPrivateFieldGet(this, _ECKey_key, "f"), pref[__classPrivateFieldGet(this, _ECKey_curve, "f")].sk));
+        return (0, utils_1.b58Encode)(new Uint8Array(this.keyPair.getPrivate().toArray()), pref[this.curve()].sk);
     }
 }
 exports.ECKey = ECKey;
-_ECKey_key = new WeakMap(), _ECKey_publicKey = new WeakMap(), _ECKey_curve = new WeakMap();
+function isKeyPair(src) {
+    return src instanceof key_1.default;
+}
+class ECPublicKey extends ECKeyBase {
+    constructor(src, curve) {
+        const key = (() => {
+            if (isKeyPair(src)) {
+                return src;
+            }
+            else {
+                const [key, crv] = (() => {
+                    if (typeof src === 'string') {
+                        const [key, pre] = (0, utils_1.b58DecodeAndCheckPrefix)(src, [
+                            utils_1.PrefixV2.Secp256k1PublicKey,
+                            utils_1.PrefixV2.P256PublicKey,
+                        ]);
+                        return [key, pre === utils_1.PrefixV2.Secp256k1PublicKey ? 'secp256k1' : 'p256'];
+                    }
+                    else if (curve !== undefined) {
+                        return [src, curve];
+                    }
+                    else {
+                        throw new errors_1.InvalidCurveError('missing curve type');
+                    }
+                })();
+                return new elliptic_1.default.ec(crv).keyFromPublic(key);
+            }
+        })();
+        super(key);
+    }
+    compare(other) {
+        if (other instanceof ECPublicKey) {
+            if (this.curve() === other.curve()) {
+                const compress = this.curve() === 'secp256k1';
+                return (0, utils_1.compareArrays)(this.bytes(compress), other.bytes(compress));
+            }
+            else if (this.curve() === 'secp256k1') {
+                return -1;
+            }
+            else {
+                return 1;
+            }
+        }
+        else {
+            throw new utils_1.InvalidPublicKeyError('ECDSA key expected');
+        }
+    }
+    hash() {
+        const key = this.bytes();
+        return (0, utils_1.b58Encode)((0, blake2b_1.hash)(key, 20), pref[this.curve()].pkh);
+    }
+    bytes(compress = true) {
+        return new Uint8Array(this.keyPair.getPublic(compress, 'array'));
+    }
+    toProtocol() {
+        const key = this.bytes();
+        const res = new Uint8Array(key.length + 1);
+        res[0] = pref[this.curve()].tag;
+        res.set(key, 1);
+        return res;
+    }
+    toString() {
+        const key = this.bytes();
+        return (0, utils_1.b58Encode)(key, pref[this.curve()].pk);
+    }
+}
+exports.ECPublicKey = ECPublicKey;

package/dist/lib/ed-key.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
@@ -19,9 +10,9 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _EdKey_secretKey, _EdKey_publicKey;
+var _EdKey_keyPair, _EdPublicKey_key;
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EdKey = void 0;
+exports.EdPublicKey = exports.EdKey = void 0;
 const blake2b_1 = require("@stablelib/blake2b");
 const ed25519_1 = require("@stablelib/ed25519");
 const utils_1 = require("@taquito/utils");
@@ -37,8 +28,7 @@ class EdKey {
      * @throws {@link InvalidKeyError}
      */
     constructor(key, decrypt) {
-        _EdKey_secretKey.set(this, void 0);
-        _EdKey_publicKey.set(this, void 0);
+        _EdKey_keyPair.set(this, void 0);
         const tmp = (0, utils_1.b58DecodeAndCheckPrefix)(key, [
             utils_1.PrefixV2.Ed25519SecretKey,
             utils_1.PrefixV2.Ed25519EncryptedSeed,
@@ -47,8 +37,10 @@ class EdKey {
         let [keyData] = tmp;
         const [, prefix] = tmp;
         if (prefix === utils_1.PrefixV2.Ed25519SecretKey) {
-            __classPrivateFieldSet(this, _EdKey_secretKey, keyData, "f");
-            __classPrivateFieldSet(this, _EdKey_publicKey, keyData.slice(32), "f");
+            __classPrivateFieldSet(this, _EdKey_keyPair, {
+                secretKey: keyData,
+                publicKey: keyData.slice(32),
+            }, "f");
         }
         else {
             if (prefix === utils_1.PrefixV2.Ed25519EncryptedSeed) {
@@ -59,9 +51,7 @@ class EdKey {
                     throw new Error('decryption function is not provided');
                 }
             }
-            const { publicKey, secretKey } = (0, ed25519_1.generateKeyPairFromSeed)(keyData);
-            __classPrivateFieldSet(this, _EdKey_publicKey, publicKey, "f");
-            __classPrivateFieldSet(this, _EdKey_secretKey, secretKey, "f");
+            __classPrivateFieldSet(this, _EdKey_keyPair, (0, ed25519_1.generateKeyPairFromSeed)(keyData), "f");
         }
     }
     /**
@@ -70,34 +60,63 @@ class EdKey {
      * @param bytesHash Blake2b hash of the bytes to sign
      */
     sign(bytes) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const hash = (0, blake2b_1.hash)(bytes, 32);
-            const signature = (0, ed25519_1.sign)(__classPrivateFieldGet(this, _EdKey_secretKey, "f"), hash);
-            return Promise.resolve({
-                rawSignature: signature,
-                sig: (0, utils_1.b58Encode)(signature, utils_1.PrefixV2.GenericSignature),
-                prefixSig: (0, utils_1.b58Encode)(signature, utils_1.PrefixV2.Ed25519Signature),
-            });
-        });
+        const hash = (0, blake2b_1.hash)(bytes, 32);
+        const signature = (0, ed25519_1.sign)(__classPrivateFieldGet(this, _EdKey_keyPair, "f").secretKey, hash);
+        return {
+            rawSignature: signature,
+            sig: (0, utils_1.b58Encode)(signature, utils_1.PrefixV2.GenericSignature),
+            prefixSig: (0, utils_1.b58Encode)(signature, utils_1.PrefixV2.Ed25519Signature),
+        };
     }
     /**
      * @returns Encoded public key
      */
     publicKey() {
-        return Promise.resolve((0, utils_1.b58Encode)(__classPrivateFieldGet(this, _EdKey_publicKey, "f"), utils_1.PrefixV2.Ed25519PublicKey));
-    }
-    /**
-     * @returns Encoded public key hash
-     */
-    publicKeyHash() {
-        return Promise.resolve((0, utils_1.b58Encode)((0, blake2b_1.hash)(__classPrivateFieldGet(this, _EdKey_publicKey, "f"), 20), utils_1.PrefixV2.Ed25519PublicKeyHash));
+        return new EdPublicKey(__classPrivateFieldGet(this, _EdKey_keyPair, "f").publicKey);
     }
     /**
      * @returns Encoded private key
      */
     secretKey() {
-        return Promise.resolve((0, utils_1.b58Encode)(__classPrivateFieldGet(this, _EdKey_secretKey, "f"), utils_1.PrefixV2.Ed25519SecretKey));
+        return (0, utils_1.b58Encode)(__classPrivateFieldGet(this, _EdKey_keyPair, "f").secretKey, utils_1.PrefixV2.Ed25519SecretKey);
     }
 }
 exports.EdKey = EdKey;
-_EdKey_secretKey = new WeakMap(), _EdKey_publicKey = new WeakMap();
+_EdKey_keyPair = new WeakMap();
+class EdPublicKey {
+    constructor(src) {
+        _EdPublicKey_key.set(this, void 0);
+        if (typeof src === 'string') {
+            const [key, _] = (0, utils_1.b58DecodeAndCheckPrefix)(src, [utils_1.PrefixV2.Ed25519PublicKey]);
+            __classPrivateFieldSet(this, _EdPublicKey_key, key, "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _EdPublicKey_key, src, "f");
+        }
+    }
+    compare(other) {
+        if (other instanceof EdPublicKey) {
+            return (0, utils_1.compareArrays)(this.bytes(), other.bytes());
+        }
+        else {
+            throw new utils_1.InvalidPublicKeyError('EdDSA key expected');
+        }
+    }
+    hash() {
+        return (0, utils_1.b58Encode)((0, blake2b_1.hash)(__classPrivateFieldGet(this, _EdPublicKey_key, "f"), 20), utils_1.PrefixV2.Ed25519PublicKeyHash);
+    }
+    bytes() {
+        return __classPrivateFieldGet(this, _EdPublicKey_key, "f");
+    }
+    toProtocol() {
+        const res = new Uint8Array(__classPrivateFieldGet(this, _EdPublicKey_key, "f").length + 1);
+        res[0] = 0;
+        res.set(__classPrivateFieldGet(this, _EdPublicKey_key, "f"), 1);
+        return res;
+    }
+    toString() {
+        return (0, utils_1.b58Encode)(__classPrivateFieldGet(this, _EdPublicKey_key, "f"), utils_1.PrefixV2.Ed25519PublicKey);
+    }
+}
+exports.EdPublicKey = EdPublicKey;
+_EdPublicKey_key = new WeakMap();

package/dist/lib/taquito-signer.js

@@ -36,6 +36,7 @@ var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (
 var _InMemorySigner_key;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InMemorySigner = exports.InvalidPassphraseError = exports.VERSION = void 0;
+exports.publicKeyFromString = publicKeyFromString;
 /**
  * @packageDocumentation
  * @module @taquito/signer
@@ -203,20 +204,38 @@ class InMemorySigner {
      * @returns Encoded public key
      */
     publicKey() {
-        return __classPrivateFieldGet(this, _InMemorySigner_key, "f").publicKey();
+        return Promise.resolve(String(__classPrivateFieldGet(this, _InMemorySigner_key, "f").publicKey()));
     }
     /**
      * @returns Encoded public key hash
      */
     publicKeyHash() {
-        return __classPrivateFieldGet(this, _InMemorySigner_key, "f").publicKeyHash();
+        return Promise.resolve(__classPrivateFieldGet(this, _InMemorySigner_key, "f").publicKey().hash());
     }
     /**
      * @returns Encoded private key
      */
     secretKey() {
-        return __classPrivateFieldGet(this, _InMemorySigner_key, "f").secretKey();
+        return Promise.resolve(__classPrivateFieldGet(this, _InMemorySigner_key, "f").secretKey());
     }
 }
 exports.InMemorySigner = InMemorySigner;
 _InMemorySigner_key = new WeakMap();
+function publicKeyFromString(src) {
+    const [keyData, pre] = (0, utils_1.b58DecodeAndCheckPrefix)(src, [
+        utils_1.PrefixV2.Ed25519PublicKey,
+        utils_1.PrefixV2.Secp256k1PublicKey,
+        utils_1.PrefixV2.P256PublicKey,
+        utils_1.PrefixV2.BLS12_381PublicKey,
+    ]);
+    switch (pre) {
+        case utils_1.PrefixV2.Ed25519PublicKey:
+            return new ed_key_1.EdPublicKey(keyData);
+        case utils_1.PrefixV2.Secp256k1PublicKey:
+            return new ec_key_1.ECPublicKey(keyData, 'secp256k1');
+        case utils_1.PrefixV2.P256PublicKey:
+            return new ec_key_1.ECPublicKey(keyData, 'p256');
+        case utils_1.PrefixV2.BLS12_381PublicKey:
+            return new bls_key_1.BLSPublicKey(keyData);
+    }
+}

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": "10b3de10de15ae68d47b1fca922d3129d2f79641",
-    "version": "23.0.0-beta.1"
+    "commitHash": "c26a3d67ae3694c157f4f56fb5bf85ca3c495a9b",
+    "version": "23.0.1"
 };