@taquito/signer 23.0.0-beta.0 → 23.0.0

package/dist/taquito-signer.umd.js

@@ -1,8 +1,8 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@stablelib/nacl'), require('@stablelib/blake2b'), require('@taquito/utils'), require('typedarray-to-buffer'), require('@stablelib/ed25519'), require('@taquito/core'), require('elliptic'), require('pbkdf2'), require('bip39'), require('@stablelib/hmac'), require('@stablelib/sha512'), require('bn.js')) :
-    typeof define === 'function' && define.amd ? define(['exports', '@stablelib/nacl', '@stablelib/blake2b', '@taquito/utils', 'typedarray-to-buffer', '@stablelib/ed25519', '@taquito/core', 'elliptic', 'pbkdf2', 'bip39', '@stablelib/hmac', '@stablelib/sha512', 'bn.js'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.taquitoSigner = {}, global.nacl, global.blake2b, global.utils, global.toBuffer, global.ed25519$1, global.core, global.elliptic, global.pbkdf2, global.Bip39, global.hmac, global.sha512, global.BN));
-})(this, (function (exports, nacl, blake2b, utils, toBuffer, ed25519$1, core, elliptic, pbkdf2, Bip39, hmac, sha512, BN) { 'use strict';
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@stablelib/nacl'), require('@taquito/utils'), require('typedarray-to-buffer'), require('@stablelib/blake2b'), require('@stablelib/ed25519'), require('elliptic'), require('elliptic/lib/elliptic/ec/key'), require('@taquito/core'), require('pbkdf2'), require('bip39'), require('@stablelib/hmac'), require('@stablelib/sha512'), require('bn.js'), require('@noble/curves/bls12-381')) :
+    typeof define === 'function' && define.amd ? define(['exports', '@stablelib/nacl', '@taquito/utils', 'typedarray-to-buffer', '@stablelib/blake2b', '@stablelib/ed25519', 'elliptic', 'elliptic/lib/elliptic/ec/key', '@taquito/core', 'pbkdf2', 'bip39', '@stablelib/hmac', '@stablelib/sha512', 'bn.js', '@noble/curves/bls12-381'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.taquitoSigner = {}, global.nacl, global.utils, global.toBuffer, global.blake2b, global.ed25519$1, global.elliptic, global.KeyPair, global.core, global.pbkdf2, global.Bip39, global.hmac, global.sha512, global.BN, global.bls12381));
+})(this, (function (exports, nacl, utils, toBuffer, blake2b, ed25519$1, elliptic, KeyPair, core, pbkdf2, Bip39, hmac, sha512, BN, bls12381) { 'use strict';
 
     function _interopNamespaceDefault(e) {
         var n = Object.create(null);
@@ -50,15 +50,29 @@
         });
     }
 
+    function __classPrivateFieldGet(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);
+    }
+
+    function __classPrivateFieldSet(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;
+    }
+
     typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
         var e = new Error(message);
         return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
     };
 
+    var _EdKey_keyPair, _EdPublicKey_key;
     /**
      * @description Provide signing logic for ed25519 curve based key (tz1)
      */
-    class Tz1 {
+    class EdKey {
         /**
          *
          * @param key Encoded private key
@@ -66,188 +80,97 @@
          * @param decrypt Decrypt function
          * @throws {@link InvalidKeyError}
          */
-        constructor(key, encrypted, decrypt) {
-            this.key = key;
-            const keyPrefix = key.substring(0, encrypted ? 5 : 4);
-            if (!utils.isValidPrefix(keyPrefix)) {
-                throw new core.InvalidKeyError(`${utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED)} expecting either '${utils.Prefix.EDESK}' or '${utils.Prefix.EDSK}'.`);
+        constructor(key, decrypt) {
+            _EdKey_keyPair.set(this, void 0);
+            const tmp = utils.b58DecodeAndCheckPrefix(key, [
+                utils.PrefixV2.Ed25519SecretKey,
+                utils.PrefixV2.Ed25519EncryptedSeed,
+                utils.PrefixV2.Ed25519Seed,
+            ]);
+            let [keyData] = tmp;
+            const [, prefix] = tmp;
+            if (prefix === utils.PrefixV2.Ed25519SecretKey) {
+                __classPrivateFieldSet(this, _EdKey_keyPair, {
+                    secretKey: keyData,
+                    publicKey: keyData.slice(32),
+                }, "f");
             }
-            this._key = decrypt(utils.b58cdecode(this.key, utils.prefix[keyPrefix]));
-            this._publicKey = this._key.slice(32);
-            if (!this._key) {
-                throw new core.InvalidKeyError('unable to decode');
-            }
-            this.isInit = this.init();
-        }
-        init() {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (this._key.length !== 64) {
-                    const { publicKey, secretKey } = ed25519$1.generateKeyPairFromSeed(new Uint8Array(this._key));
-                    this._publicKey = publicKey;
-                    this._key = secretKey;
+            else {
+                if (prefix === utils.PrefixV2.Ed25519EncryptedSeed) {
+                    if (decrypt !== undefined) {
+                        keyData = decrypt(keyData);
+                    }
+                    else {
+                        throw new Error('decryption function is not provided');
+                    }
                 }
-                return true;
-            });
+                __classPrivateFieldSet(this, _EdKey_keyPair, ed25519$1.generateKeyPairFromSeed(keyData), "f");
+            }
         }
         /**
          *
          * @param bytes Bytes to sign
          * @param bytesHash Blake2b hash of the bytes to sign
          */
-        sign(bytes, bytesHash) {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield this.isInit;
-                const signature = ed25519$1.sign(new Uint8Array(this._key), new Uint8Array(bytesHash));
-                const signatureBuffer = toBuffer(signature);
-                const sbytes = bytes + utils.buf2hex(signatureBuffer);
-                return {
-                    bytes,
-                    sig: utils.b58cencode(signature, utils.prefix.sig),
-                    prefixSig: utils.b58cencode(signature, utils.prefix.edsig),
-                    sbytes,
-                };
-            });
+        sign(bytes) {
+            const hash = blake2b.hash(bytes, 32);
+            const signature = ed25519$1.sign(__classPrivateFieldGet(this, _EdKey_keyPair, "f").secretKey, hash);
+            return {
+                rawSignature: signature,
+                sig: utils.b58Encode(signature, utils.PrefixV2.GenericSignature),
+                prefixSig: utils.b58Encode(signature, utils.PrefixV2.Ed25519Signature),
+            };
         }
         /**
          * @returns Encoded public key
          */
         publicKey() {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield this.isInit;
-                return utils.b58cencode(this._publicKey, utils.prefix['edpk']);
-            });
-        }
-        /**
-         * @returns Encoded public key hash
-         */
-        publicKeyHash() {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield this.isInit;
-                return utils.b58cencode(blake2b.hash(new Uint8Array(this._publicKey), 20), utils.prefix.tz1);
-            });
+            return new EdPublicKey(__classPrivateFieldGet(this, _EdKey_keyPair, "f").publicKey);
         }
         /**
          * @returns Encoded private key
          */
         secretKey() {
-            return __awaiter(this, void 0, void 0, function* () {
-                yield this.isInit;
-                let key = this._key;
-                const { secretKey } = ed25519$1.generateKeyPairFromSeed(new Uint8Array(key).slice(0, 32));
-                key = toBuffer(secretKey);
-                return utils.b58cencode(key, utils.prefix[`edsk`]);
-            });
+            return utils.b58Encode(__classPrivateFieldGet(this, _EdKey_keyPair, "f").secretKey, utils.PrefixV2.Ed25519SecretKey);
         }
     }
-
-    const pref = {
-        p256: {
-            pk: utils.prefix['p2pk'],
-            sk: utils.prefix['p2sk'],
-            pkh: utils.prefix.tz3,
-            sig: utils.prefix.p2sig,
-        },
-        secp256k1: {
-            pk: utils.prefix['sppk'],
-            sk: utils.prefix['spsk'],
-            pkh: utils.prefix.tz2,
-            sig: utils.prefix.spsig,
-        },
-    };
-    /**
-     * @description Provide signing logic for elliptic curve based key (tz2, tz3)
-     */
-    class ECKey {
-        /**
-         *
-         * @param curve Curve to use with the key
-         * @param key Encoded private key
-         * @param encrypted Is the private key encrypted
-         * @param decrypt Decrypt function
-         * @throws {@link InvalidKeyError}
-         */
-        constructor(curve, key, encrypted, decrypt) {
-            this.curve = curve;
-            this.key = key;
-            const keyPrefix = key.substring(0, encrypted ? 5 : 4);
-            if (!utils.isValidPrefix(keyPrefix)) {
-                throw new core.InvalidKeyError(utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED) +
-                    ` expecting one of the following prefix '${utils.Prefix.SPSK}', '${utils.Prefix.SPESK}', '${utils.Prefix.P2SK}' or '${utils.Prefix.P2ESK}'.`);
-            }
-            this._key = decrypt(utils.b58cdecode(this.key, utils.prefix[keyPrefix]));
-            const keyPair = new elliptic.ec(this.curve).keyFromPrivate(this._key);
-            const keyPairY = keyPair.getPublic().getY().toArray();
-            const parityByte = keyPairY.length < 32 ? keyPairY[keyPairY.length - 1] : keyPairY[31];
-            const pref = parityByte % 2 ? 3 : 2;
-            const pad = new Array(32).fill(0);
-            this._publicKey = toBuffer(new Uint8Array([pref].concat(pad.concat(keyPair.getPublic().getX().toArray()).slice(-32))));
+    _EdKey_keyPair = new WeakMap();
+    class EdPublicKey {
+        constructor(src) {
+            _EdPublicKey_key.set(this, void 0);
+            if (typeof src === 'string') {
+                const [key, _] = utils.b58DecodeAndCheckPrefix(src, [utils.PrefixV2.Ed25519PublicKey]);
+                __classPrivateFieldSet(this, _EdPublicKey_key, key, "f");
+            }
+            else {
+                __classPrivateFieldSet(this, _EdPublicKey_key, src, "f");
+            }
         }
-        /**
-         *
-         * @param bytes Bytes to sign
-         * @param bytesHash Blake2b hash of the bytes to sign
-         */
-        sign(bytes, bytesHash) {
-            return __awaiter(this, void 0, void 0, function* () {
-                const key = new elliptic.ec(this.curve).keyFromPrivate(this._key);
-                const sig = key.sign(bytesHash, { canonical: true });
-                const signature = sig.r.toString('hex', 64) + sig.s.toString('hex', 64);
-                const sbytes = bytes + signature;
-                return {
-                    bytes,
-                    sig: utils.b58cencode(signature, utils.prefix.sig),
-                    prefixSig: utils.b58cencode(signature, pref[this.curve].sig),
-                    sbytes,
-                };
-            });
+        compare(other) {
+            if (other instanceof EdPublicKey) {
+                return utils.compareArrays(this.bytes(), other.bytes());
+            }
+            else {
+                throw new utils.InvalidPublicKeyError('EdDSA key expected');
+            }
         }
-        /**
-         * @returns Encoded public key
-         */
-        publicKey() {
-            return __awaiter(this, void 0, void 0, function* () {
-                return utils.b58cencode(this._publicKey, pref[this.curve].pk);
-            });
+        hash() {
+            return utils.b58Encode(blake2b.hash(__classPrivateFieldGet(this, _EdPublicKey_key, "f"), 20), utils.PrefixV2.Ed25519PublicKeyHash);
         }
-        /**
-         * @returns Encoded public key hash
-         */
-        publicKeyHash() {
-            return __awaiter(this, void 0, void 0, function* () {
-                return utils.b58cencode(blake2b.hash(new Uint8Array(this._publicKey), 20), pref[this.curve].pkh);
-            });
+        bytes() {
+            return __classPrivateFieldGet(this, _EdPublicKey_key, "f");
         }
-        /**
-         * @returns Encoded private key
-         */
-        secretKey() {
-            return __awaiter(this, void 0, void 0, function* () {
-                const key = this._key;
-                return utils.b58cencode(key, pref[this.curve].sk);
-            });
+        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;
         }
-    }
-    /**
-     * @description Tz3 key class using the p256 curve
-     */
-    const Tz3 = ECKey.bind(null, 'p256');
-    /**
-     * @description Tz2 key class using the secp256k1 curve
-     */
-    const Tz2 = ECKey.bind(null, 'secp256k1');
-
-    function parseHex(s) {
-        const res = [];
-        for (let i = 0; i < s.length; i += 2) {
-            const ss = s.slice(i, i + 2);
-            const x = parseInt(ss, 16);
-            if (Number.isNaN(x)) {
-                throw new core.InvalidHexStringError(ss);
-            }
-            res.push(x);
+        toString() {
+            return utils.b58Encode(__classPrivateFieldGet(this, _EdPublicKey_key, "f"), utils.PrefixV2.Ed25519PublicKey);
         }
-        return new Uint8Array(res);
     }
+    _EdPublicKey_key = new WeakMap();
 
     /**
      *  @category Error
@@ -318,6 +241,189 @@
         }
     }
 
+    const pref = {
+        p256: {
+            pk: utils.PrefixV2.P256PublicKey,
+            sk: utils.PrefixV2.P256SecretKey,
+            pkh: utils.PrefixV2.P256PublicKeyHash,
+            sig: utils.PrefixV2.P256Signature,
+            tag: 2,
+        },
+        secp256k1: {
+            pk: utils.PrefixV2.Secp256k1PublicKey,
+            sk: utils.PrefixV2.Secp256k1SecretKey,
+            pkh: utils.PrefixV2.Secp256k1PublicKeyHash,
+            sig: utils.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.curves.secp256k1.curve:
+                    return 'secp256k1';
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                case elliptic.curves.p256.curve:
+                    return 'p256';
+                default:
+                    throw new InvalidCurveError('unknown curve');
+            }
+        }
+    }
+    /**
+     * @description Provide signing logic for elliptic curve based key (tz2, tz3)
+     */
+    class ECKey extends ECKeyBase {
+        /**
+         *
+         * @param key Encoded private key
+         * @param decrypt Decrypt function
+         * @throws {@link InvalidKeyError}
+         */
+        constructor(key, decrypt) {
+            const [keyData, prefix] = utils.b58DecodeAndCheckPrefix(key, [
+                utils.PrefixV2.Secp256k1EncryptedSecretKey,
+                utils.PrefixV2.P256EncryptedSecretKey,
+                utils.PrefixV2.Secp256k1SecretKey,
+                utils.PrefixV2.P256SecretKey,
+            ]);
+            const [decKey, curve] = (() => {
+                switch (prefix) {
+                    case utils.PrefixV2.Secp256k1EncryptedSecretKey:
+                    case utils.PrefixV2.P256EncryptedSecretKey:
+                        if (decrypt === undefined) {
+                            throw new Error('decryption function is not provided');
+                        }
+                        else {
+                            return [
+                                decrypt(keyData),
+                                prefix === utils.PrefixV2.Secp256k1EncryptedSecretKey ? 'secp256k1' : 'p256',
+                            ];
+                        }
+                    case utils.PrefixV2.Secp256k1SecretKey:
+                        return [keyData, 'secp256k1'];
+                    default:
+                        return [keyData, 'p256'];
+                }
+            })();
+            super(new elliptic.ec(curve).keyFromPrivate(decKey));
+        }
+        /**
+         *
+         * @param bytes Bytes to sign
+         * @param bytesHash Blake2b hash of the bytes to sign
+         */
+        sign(bytes) {
+            const hash = blake2b.hash(bytes, 32);
+            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 {
+                rawSignature: signature,
+                sig: utils.b58Encode(signature, utils.PrefixV2.GenericSignature),
+                prefixSig: utils.b58Encode(signature, pref[this.curve()].sig),
+            };
+        }
+        /**
+         * @returns Encoded public key
+         */
+        publicKey() {
+            return new ECPublicKey(this.keyPair.ec.keyFromPublic(this.keyPair));
+        }
+        /**
+         * @returns Encoded private key
+         */
+        secretKey() {
+            return utils.b58Encode(new Uint8Array(this.keyPair.getPrivate().toArray()), pref[this.curve()].sk);
+        }
+    }
+    function isKeyPair(src) {
+        return src instanceof KeyPair;
+    }
+    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] = utils.b58DecodeAndCheckPrefix(src, [
+                                utils.PrefixV2.Secp256k1PublicKey,
+                                utils.PrefixV2.P256PublicKey,
+                            ]);
+                            return [key, pre === utils.PrefixV2.Secp256k1PublicKey ? 'secp256k1' : 'p256'];
+                        }
+                        else if (curve !== undefined) {
+                            return [src, curve];
+                        }
+                        else {
+                            throw new InvalidCurveError('missing curve type');
+                        }
+                    })();
+                    return new elliptic.ec(crv).keyFromPublic(key);
+                }
+            })();
+            super(key);
+        }
+        compare(other) {
+            if (other instanceof ECPublicKey) {
+                if (this.curve() === other.curve()) {
+                    const compress = this.curve() === 'secp256k1';
+                    return utils.compareArrays(this.bytes(compress), other.bytes(compress));
+                }
+                else if (this.curve() === 'secp256k1') {
+                    return -1;
+                }
+                else {
+                    return 1;
+                }
+            }
+            else {
+                throw new utils.InvalidPublicKeyError('ECDSA key expected');
+            }
+        }
+        hash() {
+            const key = this.bytes();
+            return utils.b58Encode(blake2b.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 utils.b58Encode(key, pref[this.curve()].pk);
+        }
+    }
+
+    function parseHex(s) {
+        const res = [];
+        for (let i = 0; i < s.length; i += 2) {
+            const ss = s.slice(i, i + 2);
+            const x = parseInt(ss, 16);
+            if (Number.isNaN(x)) {
+                throw new core.InvalidHexStringError(ss);
+            }
+            res.push(x);
+        }
+        return new Uint8Array(res);
+    }
+
     /* eslint-disable @typescript-eslint/no-this-alias */
     const seedKey = {
         p256: 'Nist256p1 seed',
@@ -565,16 +671,16 @@
         switch (curve) {
             case 'ed25519': {
                 node = PrivateKey.fromSeed(seed).derivePath(path);
-                const sk = utils.b58cencode(node.seed().slice(0, 32), utils.prefix.edsk2);
+                const sk = utils.b58Encode(node.seed().slice(0, 32), utils.PrefixV2.Ed25519Seed);
                 return sk;
             }
             case 'secp256k1':
             case 'p256': {
-                const prefixType = curve === 'secp256k1' ? utils.prefix.spsk : utils.prefix.p2sk;
+                const prefixType = curve === 'secp256k1' ? utils.PrefixV2.Secp256k1SecretKey : utils.PrefixV2.P256SecretKey;
                 let privKey = PrivateKey$1.fromSeed(seed, curve);
                 privKey = privKey.derivePath(path);
                 const uint8arr = new Uint8Array(privKey.keyPair.getPrivate().toArray());
-                const sk = utils.b58cencode(uint8arr, prefixType);
+                const sk = utils.b58Encode(uint8arr, prefixType);
                 return sk;
             }
             case 'bip25519': {
@@ -586,6 +692,96 @@
         }
     };
 
+    function isPOP(k) {
+        return 'provePossession' in k;
+    }
+
+    var _BLSKey_key, _BLSKey_publicKey, _BLSPublicKey_key;
+    const bls = bls12381.bls12_381.longSignatures; // AKA MinPK
+    class BLSKey {
+        constructor(key, decrypt) {
+            _BLSKey_key.set(this, void 0);
+            _BLSKey_publicKey.set(this, void 0);
+            const tmp = utils.b58DecodeAndCheckPrefix(key, [
+                utils.PrefixV2.BLS12_381EncryptedSecretKey,
+                utils.PrefixV2.BLS12_381SecretKey,
+            ]);
+            let [keyData] = tmp;
+            const [, prefix] = tmp;
+            if (prefix === utils.PrefixV2.BLS12_381EncryptedSecretKey) {
+                if (decrypt !== undefined) {
+                    keyData = decrypt(keyData);
+                }
+                else {
+                    throw new Error('decryption function is not provided');
+                }
+            }
+            __classPrivateFieldSet(this, _BLSKey_key, keyData, "f");
+            __classPrivateFieldSet(this, _BLSKey_publicKey, bls.getPublicKey(this.sk()).toBytes(), "f");
+        }
+        sk() {
+            return new Uint8Array(__classPrivateFieldGet(this, _BLSKey_key, "f")).reverse();
+        }
+        signDst(message, dst) {
+            const point = bls.hash(message, dst);
+            const sig = bls.sign(point, this.sk()).toBytes();
+            return {
+                rawSignature: sig,
+                sig: utils.b58Encode(sig, utils.PrefixV2.GenericSignature),
+                prefixSig: utils.b58Encode(sig, utils.PrefixV2.BLS12_381Signature),
+            };
+        }
+        sign(message) {
+            return this.signDst(message, utils.BLS12_381_DST);
+        }
+        provePossession() {
+            return this.signDst(__classPrivateFieldGet(this, _BLSKey_publicKey, "f"), utils.POP_DST);
+        }
+        publicKey() {
+            return new BLSPublicKey(__classPrivateFieldGet(this, _BLSKey_publicKey, "f"));
+        }
+        secretKey() {
+            return utils.b58Encode(__classPrivateFieldGet(this, _BLSKey_key, "f"), utils.PrefixV2.BLS12_381SecretKey);
+        }
+    }
+    _BLSKey_key = new WeakMap(), _BLSKey_publicKey = new WeakMap();
+    class BLSPublicKey {
+        constructor(src) {
+            _BLSPublicKey_key.set(this, void 0);
+            if (typeof src === 'string') {
+                const [key, _] = utils.b58DecodeAndCheckPrefix(src, [utils.PrefixV2.BLS12_381PublicKey]);
+                __classPrivateFieldSet(this, _BLSPublicKey_key, key, "f");
+            }
+            else {
+                __classPrivateFieldSet(this, _BLSPublicKey_key, src, "f");
+            }
+        }
+        compare(other) {
+            if (other instanceof BLSPublicKey) {
+                return utils.compareArrays(this.bytes(), other.bytes());
+            }
+            else {
+                throw new utils.InvalidPublicKeyError('BLS key expected');
+            }
+        }
+        hash() {
+            return utils.b58Encode(blake2b.hash(__classPrivateFieldGet(this, _BLSPublicKey_key, "f"), 20), utils.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 utils.b58Encode(__classPrivateFieldGet(this, _BLSPublicKey_key, "f"), utils.PrefixV2.BLS12_381PublicKey);
+        }
+    }
+    _BLSPublicKey_key = new WeakMap();
+
     /**
      *
      * @description Import a key to sign operation with the side-effect of setting the Tezos instance to use the InMemorySigner provider
@@ -627,10 +823,11 @@
 
     // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
     const VERSION = {
-        "commitHash": "7af2138a9e5c5b230c4b4c726f35c2f2e67b721c",
-        "version": "23.0.0-beta.0"
+        "commitHash": "9065acc1b41ec205a49e64b54ef89f50bafa6210",
+        "version": "23.0.0"
     };
 
+    var _InMemorySigner_key;
     /**
      * @description A local implementation of the signer. Will represent a Tezos account and be able to produce signature in its behalf
      *
@@ -643,7 +840,7 @@
                 throw new InvalidMnemonicError(mnemonic);
             }
             const seed = Bip39__namespace.mnemonicToSeedSync(mnemonic, `${email}${password}`);
-            const key = utils.b58cencode(seed.slice(0, 32), utils.prefix.edsk2);
+            const key = utils.b58Encode(seed.subarray(0, 32), utils.PrefixV2.Ed25519Seed);
             return new InMemorySigner(key);
         }
         static fromSecretKey(key, passphrase) {
@@ -679,34 +876,63 @@
          *
          */
         constructor(key, passphrase) {
-            const encrypted = key.substring(2, 3) === 'e';
-            let decrypt = (k) => k;
+            _InMemorySigner_key.set(this, void 0);
+            const keyPrefixes = [
+                utils.PrefixV2.Ed25519EncryptedSeed,
+                utils.PrefixV2.Ed25519Seed,
+                utils.PrefixV2.Ed25519SecretKey,
+                utils.PrefixV2.Secp256k1EncryptedSecretKey,
+                utils.PrefixV2.Secp256k1SecretKey,
+                utils.PrefixV2.P256EncryptedSecretKey,
+                utils.PrefixV2.P256SecretKey,
+                utils.PrefixV2.BLS12_381EncryptedSecretKey,
+                utils.PrefixV2.BLS12_381SecretKey,
+            ];
+            const pre = (() => {
+                try {
+                    const [, pre] = utils.b58DecodeAndCheckPrefix(key, keyPrefixes);
+                    return pre;
+                }
+                catch (_a) {
+                    throw new core.InvalidKeyError(`Invalid private key, expecting one of the following prefixes '${keyPrefixes}'.`);
+                }
+            })();
+            const encrypted = pre === utils.PrefixV2.Ed25519EncryptedSeed ||
+                pre === utils.PrefixV2.Secp256k1EncryptedSecretKey ||
+                pre === utils.PrefixV2.P256EncryptedSecretKey ||
+                pre === utils.PrefixV2.BLS12_381EncryptedSecretKey;
+            let decrypt;
             if (encrypted) {
                 if (!passphrase) {
                     throw new InvalidPassphraseError('No passphrase provided to decrypt encrypted key');
                 }
-                decrypt = (constructedKey) => {
-                    const salt = toBuffer(constructedKey.slice(0, 8));
-                    const encryptedSk = constructedKey.slice(8);
+                decrypt = (data) => {
+                    const salt = toBuffer(data.slice(0, 8));
+                    const encryptedSk = data.slice(8);
                     const encryptionKey = pbkdf2.pbkdf2Sync(passphrase, salt, 32768, 32, 'sha512');
-                    return nacl.openSecretBox(new Uint8Array(encryptionKey), new Uint8Array(24), new Uint8Array(encryptedSk));
+                    const res = nacl.openSecretBox(new Uint8Array(encryptionKey), new Uint8Array(24), new Uint8Array(encryptedSk));
+                    if (!res) {
+                        throw new Error("can't decrypt secret key");
+                    }
+                    return res;
                 };
             }
-            switch (key.substring(0, 4)) {
-                case 'edes':
-                case 'edsk':
-                    this._key = new Tz1(key, encrypted, decrypt);
+            switch (pre) {
+                case utils.PrefixV2.Ed25519EncryptedSeed:
+                case utils.PrefixV2.Ed25519Seed:
+                case utils.PrefixV2.Ed25519SecretKey:
+                    __classPrivateFieldSet(this, _InMemorySigner_key, new EdKey(key, decrypt), "f");
                     break;
-                case 'spsk':
-                case 'spes':
-                    this._key = new Tz2(key, encrypted, decrypt);
+                case utils.PrefixV2.Secp256k1EncryptedSecretKey:
+                case utils.PrefixV2.Secp256k1SecretKey:
+                case utils.PrefixV2.P256EncryptedSecretKey:
+                case utils.PrefixV2.P256SecretKey:
+                    __classPrivateFieldSet(this, _InMemorySigner_key, new ECKey(key, decrypt), "f");
                     break;
-                case 'p2sk':
-                case 'p2es':
-                    this._key = new Tz3(key, encrypted, decrypt);
+                case utils.PrefixV2.BLS12_381EncryptedSecretKey:
+                case utils.PrefixV2.BLS12_381SecretKey:
+                    __classPrivateFieldSet(this, _InMemorySigner_key, new BLSKey(key, decrypt), "f");
                     break;
-                default:
-                    throw new core.InvalidKeyError(`${utils.invalidDetail(utils.ValidationResult.NO_PREFIX_MATCHED)} expecting one of the following '${utils.Prefix.EDESK}', '${utils.Prefix.EDSK}', '${utils.Prefix.SPSK}', '${utils.Prefix.SPESK}', '${utils.Prefix.P2SK}' or '${utils.Prefix.P2ESK}'.`);
             }
         }
         /**
@@ -714,39 +940,70 @@
          * @param bytes Bytes to sign
          * @param watermark Watermark to append to the bytes
          */
-        sign(bytes, watermark) {
+        sign(message, watermark) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const msg = typeof message == 'string' ? utils.hex2buf(message) : message;
+                const watermarkMsg = watermark !== undefined ? utils.mergebuf(watermark, msg) : msg;
+                const { rawSignature, sig: signature, prefixSig: prefixedSignature, } = yield __classPrivateFieldGet(this, _InMemorySigner_key, "f").sign(watermarkMsg);
+                return {
+                    bytes: utils.buf2hex(msg),
+                    sig: signature,
+                    prefixSig: prefixedSignature,
+                    sbytes: utils.buf2hex(utils.mergebuf(msg, 
+                    // bls only Signature_prefix ff03 ref:https://octez.tezos.com/docs/shell/p2p_api.html#signature-prefix-tag-255 & https://octez.tezos.com/docs/shell/p2p_api.html#bls-prefix-tag-3
+                    isPOP(__classPrivateFieldGet(this, _InMemorySigner_key, "f")) ? utils.mergebuf(new Uint8Array([255, 3]), rawSignature) : rawSignature)),
+                };
+            });
+        }
+        provePossession() {
             return __awaiter(this, void 0, void 0, function* () {
-                let bb = utils.hex2buf(bytes);
-                if (typeof watermark !== 'undefined') {
-                    bb = utils.mergebuf(watermark, bb);
+                if (isPOP(__classPrivateFieldGet(this, _InMemorySigner_key, "f"))) {
+                    return __classPrivateFieldGet(this, _InMemorySigner_key, "f").provePossession();
+                }
+                else {
+                    throw new core.ProhibitedActionError('Only BLS keys can prove possession');
                 }
-                const bytesHash = blake2b.hash(bb, 32);
-                return this._key.sign(bytes, bytesHash);
             });
         }
+        get canProvePossession() {
+            return isPOP(__classPrivateFieldGet(this, _InMemorySigner_key, "f"));
+        }
         /**
          * @returns Encoded public key
          */
         publicKey() {
-            return __awaiter(this, void 0, void 0, function* () {
-                return this._key.publicKey();
-            });
+            return Promise.resolve(String(__classPrivateFieldGet(this, _InMemorySigner_key, "f").publicKey()));
         }
         /**
          * @returns Encoded public key hash
          */
         publicKeyHash() {
-            return __awaiter(this, void 0, void 0, function* () {
-                return this._key.publicKeyHash();
-            });
+            return Promise.resolve(__classPrivateFieldGet(this, _InMemorySigner_key, "f").publicKey().hash());
         }
         /**
          * @returns Encoded private key
          */
         secretKey() {
-            return __awaiter(this, void 0, void 0, function* () {
-                return this._key.secretKey();
-            });
+            return Promise.resolve(__classPrivateFieldGet(this, _InMemorySigner_key, "f").secretKey());
+        }
+    }
+    _InMemorySigner_key = new WeakMap();
+    function publicKeyFromString(src) {
+        const [keyData, pre] = utils.b58DecodeAndCheckPrefix(src, [
+            utils.PrefixV2.Ed25519PublicKey,
+            utils.PrefixV2.Secp256k1PublicKey,
+            utils.PrefixV2.P256PublicKey,
+            utils.PrefixV2.BLS12_381PublicKey,
+        ]);
+        switch (pre) {
+            case utils.PrefixV2.Ed25519PublicKey:
+                return new EdPublicKey(keyData);
+            case utils.PrefixV2.Secp256k1PublicKey:
+                return new ECPublicKey(keyData, 'secp256k1');
+            case utils.PrefixV2.P256PublicKey:
+                return new ECPublicKey(keyData, 'p256');
+            case utils.PrefixV2.BLS12_381PublicKey:
+                return new BLSPublicKey(keyData);
         }
     }
 
@@ -759,6 +1016,7 @@
     exports.VERSION = VERSION;
     exports.generateSecretKey = generateSecretKey;
     exports.importKey = importKey;
+    exports.publicKeyFromString = publicKeyFromString;
 
 }));
 //# sourceMappingURL=taquito-signer.umd.js.map