@taquito/signer 23.0.0-beta.0 → 23.0.0

package/dist/taquito-signer.es6.js

@@ -1,15 +1,17 @@
 import { openSecretBox } from '@stablelib/nacl';
-import { hash } from '@stablelib/blake2b';
-import { isValidPrefix, invalidDetail, ValidationResult, Prefix, b58cdecode, prefix, buf2hex, b58cencode, hex2buf, mergebuf } from '@taquito/utils';
+import { b58DecodeAndCheckPrefix, PrefixV2, b58Encode, compareArrays, InvalidPublicKeyError, BLS12_381_DST, POP_DST, hex2buf, mergebuf, buf2hex } from '@taquito/utils';
 import toBuffer from 'typedarray-to-buffer';
+import { hash } from '@stablelib/blake2b';
 import { generateKeyPairFromSeed, sign } from '@stablelib/ed25519';
-import { InvalidKeyError, InvalidHexStringError, ParameterValidationError, UnsupportedActionError, InvalidDerivationPathError } from '@taquito/core';
 import elliptic, { ec } from 'elliptic';
+import KeyPair from 'elliptic/lib/elliptic/ec/key';
+import { ParameterValidationError, UnsupportedActionError, InvalidHexStringError, InvalidKeyError, InvalidDerivationPathError, ProhibitedActionError } from '@taquito/core';
 import pbkdf2 from 'pbkdf2';
 import * as Bip39 from 'bip39';
 import { HMAC } from '@stablelib/hmac';
 import { SHA512 } from '@stablelib/sha512';
 import BN from 'bn.js';
+import { bls12_381 } from '@noble/curves/bls12-381';
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -38,15 +40,29 @@ function __awaiter(thisArg, _arguments, P, generator) {
     });
 }
 
+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
@@ -54,188 +70,97 @@ class Tz1 {
      * @param decrypt Decrypt function
      * @throws {@link InvalidKeyError}
      */
-    constructor(key, encrypted, decrypt) {
-        this.key = key;
-        const keyPrefix = key.substring(0, encrypted ? 5 : 4);
-        if (!isValidPrefix(keyPrefix)) {
-            throw new InvalidKeyError(`${invalidDetail(ValidationResult.NO_PREFIX_MATCHED)} expecting either '${Prefix.EDESK}' or '${Prefix.EDSK}'.`);
-        }
-        this._key = decrypt(b58cdecode(this.key, prefix[keyPrefix]));
-        this._publicKey = this._key.slice(32);
-        if (!this._key) {
-            throw new InvalidKeyError('unable to decode');
+    constructor(key, decrypt) {
+        _EdKey_keyPair.set(this, void 0);
+        const tmp = b58DecodeAndCheckPrefix(key, [
+            PrefixV2.Ed25519SecretKey,
+            PrefixV2.Ed25519EncryptedSeed,
+            PrefixV2.Ed25519Seed,
+        ]);
+        let [keyData] = tmp;
+        const [, prefix] = tmp;
+        if (prefix === PrefixV2.Ed25519SecretKey) {
+            __classPrivateFieldSet(this, _EdKey_keyPair, {
+                secretKey: keyData,
+                publicKey: keyData.slice(32),
+            }, "f");
         }
-        this.isInit = this.init();
-    }
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._key.length !== 64) {
-                const { publicKey, secretKey } = generateKeyPairFromSeed(new Uint8Array(this._key));
-                this._publicKey = publicKey;
-                this._key = secretKey;
+        else {
+            if (prefix === PrefixV2.Ed25519EncryptedSeed) {
+                if (decrypt !== undefined) {
+                    keyData = decrypt(keyData);
+                }
+                else {
+                    throw new Error('decryption function is not provided');
+                }
             }
-            return true;
-        });
+            __classPrivateFieldSet(this, _EdKey_keyPair, 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 = sign(new Uint8Array(this._key), new Uint8Array(bytesHash));
-            const signatureBuffer = toBuffer(signature);
-            const sbytes = bytes + buf2hex(signatureBuffer);
-            return {
-                bytes,
-                sig: b58cencode(signature, prefix.sig),
-                prefixSig: b58cencode(signature, prefix.edsig),
-                sbytes,
-            };
-        });
+    sign(bytes) {
+        const hash$1 = hash(bytes, 32);
+        const signature = sign(__classPrivateFieldGet(this, _EdKey_keyPair, "f").secretKey, hash$1);
+        return {
+            rawSignature: signature,
+            sig: b58Encode(signature, PrefixV2.GenericSignature),
+            prefixSig: b58Encode(signature, PrefixV2.Ed25519Signature),
+        };
     }
     /**
      * @returns Encoded public key
      */
     publicKey() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.isInit;
-            return b58cencode(this._publicKey, prefix['edpk']);
-        });
-    }
-    /**
-     * @returns Encoded public key hash
-     */
-    publicKeyHash() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.isInit;
-            return b58cencode(hash(new Uint8Array(this._publicKey), 20), 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 } = generateKeyPairFromSeed(new Uint8Array(key).slice(0, 32));
-            key = toBuffer(secretKey);
-            return b58cencode(key, prefix[`edsk`]);
-        });
+        return b58Encode(__classPrivateFieldGet(this, _EdKey_keyPair, "f").secretKey, PrefixV2.Ed25519SecretKey);
     }
 }
-
-const pref = {
-    p256: {
-        pk: prefix['p2pk'],
-        sk: prefix['p2sk'],
-        pkh: prefix.tz3,
-        sig: prefix.p2sig,
-    },
-    secp256k1: {
-        pk: prefix['sppk'],
-        sk: prefix['spsk'],
-        pkh: prefix.tz2,
-        sig: 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 (!isValidPrefix(keyPrefix)) {
-            throw new InvalidKeyError(invalidDetail(ValidationResult.NO_PREFIX_MATCHED) +
-                ` expecting one of the following prefix '${Prefix.SPSK}', '${Prefix.SPESK}', '${Prefix.P2SK}' or '${Prefix.P2ESK}'.`);
-        }
-        this._key = decrypt(b58cdecode(this.key, 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, _] = b58DecodeAndCheckPrefix(src, [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: b58cencode(signature, prefix.sig),
-                prefixSig: b58cencode(signature, pref[this.curve].sig),
-                sbytes,
-            };
-        });
+    compare(other) {
+        if (other instanceof EdPublicKey) {
+            return compareArrays(this.bytes(), other.bytes());
+        }
+        else {
+            throw new InvalidPublicKeyError('EdDSA key expected');
+        }
     }
-    /**
-     * @returns Encoded public key
-     */
-    publicKey() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return b58cencode(this._publicKey, pref[this.curve].pk);
-        });
+    hash() {
+        return b58Encode(hash(__classPrivateFieldGet(this, _EdPublicKey_key, "f"), 20), PrefixV2.Ed25519PublicKeyHash);
     }
-    /**
-     * @returns Encoded public key hash
-     */
-    publicKeyHash() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return b58cencode(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 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 InvalidHexStringError(ss);
-        }
-        res.push(x);
+    toString() {
+        return b58Encode(__classPrivateFieldGet(this, _EdPublicKey_key, "f"), PrefixV2.Ed25519PublicKey);
     }
-    return new Uint8Array(res);
 }
+_EdPublicKey_key = new WeakMap();
 
 /**
  *  @category Error
@@ -306,6 +231,189 @@ class InvalidPassphraseError extends ParameterValidationError {
     }
 }
 
+const pref = {
+    p256: {
+        pk: PrefixV2.P256PublicKey,
+        sk: PrefixV2.P256SecretKey,
+        pkh: PrefixV2.P256PublicKeyHash,
+        sig: PrefixV2.P256Signature,
+        tag: 2,
+    },
+    secp256k1: {
+        pk: PrefixV2.Secp256k1PublicKey,
+        sk: PrefixV2.Secp256k1SecretKey,
+        pkh: PrefixV2.Secp256k1PublicKeyHash,
+        sig: 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] = b58DecodeAndCheckPrefix(key, [
+            PrefixV2.Secp256k1EncryptedSecretKey,
+            PrefixV2.P256EncryptedSecretKey,
+            PrefixV2.Secp256k1SecretKey,
+            PrefixV2.P256SecretKey,
+        ]);
+        const [decKey, curve] = (() => {
+            switch (prefix) {
+                case PrefixV2.Secp256k1EncryptedSecretKey:
+                case PrefixV2.P256EncryptedSecretKey:
+                    if (decrypt === undefined) {
+                        throw new Error('decryption function is not provided');
+                    }
+                    else {
+                        return [
+                            decrypt(keyData),
+                            prefix === PrefixV2.Secp256k1EncryptedSecretKey ? 'secp256k1' : 'p256',
+                        ];
+                    }
+                case 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$1 = hash(bytes, 32);
+        const sig = this.keyPair.sign(hash$1, { 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: b58Encode(signature, PrefixV2.GenericSignature),
+            prefixSig: 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 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] = b58DecodeAndCheckPrefix(src, [
+                            PrefixV2.Secp256k1PublicKey,
+                            PrefixV2.P256PublicKey,
+                        ]);
+                        return [key, pre === 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 compareArrays(this.bytes(compress), other.bytes(compress));
+            }
+            else if (this.curve() === 'secp256k1') {
+                return -1;
+            }
+            else {
+                return 1;
+            }
+        }
+        else {
+            throw new InvalidPublicKeyError('ECDSA key expected');
+        }
+    }
+    hash() {
+        const key = this.bytes();
+        return b58Encode(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 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 InvalidHexStringError(ss);
+        }
+        res.push(x);
+    }
+    return new Uint8Array(res);
+}
+
 /* eslint-disable @typescript-eslint/no-this-alias */
 const seedKey = {
     p256: 'Nist256p1 seed',
@@ -553,16 +661,16 @@ const generateSecretKey = (seed, derivationPath, curve) => {
     switch (curve) {
         case 'ed25519': {
             node = PrivateKey.fromSeed(seed).derivePath(path);
-            const sk = b58cencode(node.seed().slice(0, 32), prefix.edsk2);
+            const sk = b58Encode(node.seed().slice(0, 32), PrefixV2.Ed25519Seed);
             return sk;
         }
         case 'secp256k1':
         case 'p256': {
-            const prefixType = curve === 'secp256k1' ? prefix.spsk : prefix.p2sk;
+            const prefixType = curve === 'secp256k1' ? PrefixV2.Secp256k1SecretKey : PrefixV2.P256SecretKey;
             let privKey = PrivateKey$1.fromSeed(seed, curve);
             privKey = privKey.derivePath(path);
             const uint8arr = new Uint8Array(privKey.keyPair.getPrivate().toArray());
-            const sk = b58cencode(uint8arr, prefixType);
+            const sk = b58Encode(uint8arr, prefixType);
             return sk;
         }
         case 'bip25519': {
@@ -574,6 +682,96 @@ const generateSecretKey = (seed, derivationPath, curve) => {
     }
 };
 
+function isPOP(k) {
+    return 'provePossession' in k;
+}
+
+var _BLSKey_key, _BLSKey_publicKey, _BLSPublicKey_key;
+const bls = bls12_381.longSignatures; // AKA MinPK
+class BLSKey {
+    constructor(key, decrypt) {
+        _BLSKey_key.set(this, void 0);
+        _BLSKey_publicKey.set(this, void 0);
+        const tmp = b58DecodeAndCheckPrefix(key, [
+            PrefixV2.BLS12_381EncryptedSecretKey,
+            PrefixV2.BLS12_381SecretKey,
+        ]);
+        let [keyData] = tmp;
+        const [, prefix] = tmp;
+        if (prefix === 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: b58Encode(sig, PrefixV2.GenericSignature),
+            prefixSig: b58Encode(sig, PrefixV2.BLS12_381Signature),
+        };
+    }
+    sign(message) {
+        return this.signDst(message, BLS12_381_DST);
+    }
+    provePossession() {
+        return this.signDst(__classPrivateFieldGet(this, _BLSKey_publicKey, "f"), POP_DST);
+    }
+    publicKey() {
+        return new BLSPublicKey(__classPrivateFieldGet(this, _BLSKey_publicKey, "f"));
+    }
+    secretKey() {
+        return b58Encode(__classPrivateFieldGet(this, _BLSKey_key, "f"), 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, _] = b58DecodeAndCheckPrefix(src, [PrefixV2.BLS12_381PublicKey]);
+            __classPrivateFieldSet(this, _BLSPublicKey_key, key, "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _BLSPublicKey_key, src, "f");
+        }
+    }
+    compare(other) {
+        if (other instanceof BLSPublicKey) {
+            return compareArrays(this.bytes(), other.bytes());
+        }
+        else {
+            throw new InvalidPublicKeyError('BLS key expected');
+        }
+    }
+    hash() {
+        return b58Encode(hash(__classPrivateFieldGet(this, _BLSPublicKey_key, "f"), 20), 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 b58Encode(__classPrivateFieldGet(this, _BLSPublicKey_key, "f"), 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
@@ -615,10 +813,11 @@ function importKey(toolkit, privateKeyOrEmail, passphrase, mnemonic, secret) {
 
 // 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
  *
@@ -631,7 +830,7 @@ class InMemorySigner {
             throw new InvalidMnemonicError(mnemonic);
         }
         const seed = Bip39.mnemonicToSeedSync(mnemonic, `${email}${password}`);
-        const key = b58cencode(seed.slice(0, 32), prefix.edsk2);
+        const key = b58Encode(seed.subarray(0, 32), PrefixV2.Ed25519Seed);
         return new InMemorySigner(key);
     }
     static fromSecretKey(key, passphrase) {
@@ -667,34 +866,63 @@ class InMemorySigner {
      *
      */
     constructor(key, passphrase) {
-        const encrypted = key.substring(2, 3) === 'e';
-        let decrypt = (k) => k;
+        _InMemorySigner_key.set(this, void 0);
+        const keyPrefixes = [
+            PrefixV2.Ed25519EncryptedSeed,
+            PrefixV2.Ed25519Seed,
+            PrefixV2.Ed25519SecretKey,
+            PrefixV2.Secp256k1EncryptedSecretKey,
+            PrefixV2.Secp256k1SecretKey,
+            PrefixV2.P256EncryptedSecretKey,
+            PrefixV2.P256SecretKey,
+            PrefixV2.BLS12_381EncryptedSecretKey,
+            PrefixV2.BLS12_381SecretKey,
+        ];
+        const pre = (() => {
+            try {
+                const [, pre] = b58DecodeAndCheckPrefix(key, keyPrefixes);
+                return pre;
+            }
+            catch (_a) {
+                throw new InvalidKeyError(`Invalid private key, expecting one of the following prefixes '${keyPrefixes}'.`);
+            }
+        })();
+        const encrypted = pre === PrefixV2.Ed25519EncryptedSeed ||
+            pre === PrefixV2.Secp256k1EncryptedSecretKey ||
+            pre === PrefixV2.P256EncryptedSecretKey ||
+            pre === 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 openSecretBox(new Uint8Array(encryptionKey), new Uint8Array(24), new Uint8Array(encryptedSk));
+                const res = 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 PrefixV2.Ed25519EncryptedSeed:
+            case PrefixV2.Ed25519Seed:
+            case PrefixV2.Ed25519SecretKey:
+                __classPrivateFieldSet(this, _InMemorySigner_key, new EdKey(key, decrypt), "f");
                 break;
-            case 'spsk':
-            case 'spes':
-                this._key = new Tz2(key, encrypted, decrypt);
+            case PrefixV2.Secp256k1EncryptedSecretKey:
+            case PrefixV2.Secp256k1SecretKey:
+            case PrefixV2.P256EncryptedSecretKey:
+            case PrefixV2.P256SecretKey:
+                __classPrivateFieldSet(this, _InMemorySigner_key, new ECKey(key, decrypt), "f");
                 break;
-            case 'p2sk':
-            case 'p2es':
-                this._key = new Tz3(key, encrypted, decrypt);
+            case PrefixV2.BLS12_381EncryptedSecretKey:
+            case PrefixV2.BLS12_381SecretKey:
+                __classPrivateFieldSet(this, _InMemorySigner_key, new BLSKey(key, decrypt), "f");
                 break;
-            default:
-                throw new InvalidKeyError(`${invalidDetail(ValidationResult.NO_PREFIX_MATCHED)} expecting one of the following '${Prefix.EDESK}', '${Prefix.EDSK}', '${Prefix.SPSK}', '${Prefix.SPESK}', '${Prefix.P2SK}' or '${Prefix.P2ESK}'.`);
         }
     }
     /**
@@ -702,41 +930,72 @@ class InMemorySigner {
      * @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* () {
-            let bb = hex2buf(bytes);
-            if (typeof watermark !== 'undefined') {
-                bb = mergebuf(watermark, bb);
+            const msg = typeof message == 'string' ? hex2buf(message) : message;
+            const watermarkMsg = watermark !== undefined ? mergebuf(watermark, msg) : msg;
+            const { rawSignature, sig: signature, prefixSig: prefixedSignature, } = yield __classPrivateFieldGet(this, _InMemorySigner_key, "f").sign(watermarkMsg);
+            return {
+                bytes: buf2hex(msg),
+                sig: signature,
+                prefixSig: prefixedSignature,
+                sbytes: buf2hex(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")) ? mergebuf(new Uint8Array([255, 3]), rawSignature) : rawSignature)),
+            };
+        });
+    }
+    provePossession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (isPOP(__classPrivateFieldGet(this, _InMemorySigner_key, "f"))) {
+                return __classPrivateFieldGet(this, _InMemorySigner_key, "f").provePossession();
+            }
+            else {
+                throw new ProhibitedActionError('Only BLS keys can prove possession');
             }
-            const bytesHash = 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] = b58DecodeAndCheckPrefix(src, [
+        PrefixV2.Ed25519PublicKey,
+        PrefixV2.Secp256k1PublicKey,
+        PrefixV2.P256PublicKey,
+        PrefixV2.BLS12_381PublicKey,
+    ]);
+    switch (pre) {
+        case PrefixV2.Ed25519PublicKey:
+            return new EdPublicKey(keyData);
+        case PrefixV2.Secp256k1PublicKey:
+            return new ECPublicKey(keyData, 'secp256k1');
+        case PrefixV2.P256PublicKey:
+            return new ECPublicKey(keyData, 'p256');
+        case PrefixV2.BLS12_381PublicKey:
+            return new BLSPublicKey(keyData);
     }
 }
 
-export { ecdsa as ECDSA, ed25519 as Ed25519, Hard, InMemorySigner, InvalidPassphraseError, Path, VERSION, generateSecretKey, importKey };
+export { ecdsa as ECDSA, ed25519 as Ed25519, Hard, InMemorySigner, InvalidPassphraseError, Path, VERSION, generateSecretKey, importKey, publicKeyFromString };
 //# sourceMappingURL=taquito-signer.es6.js.map