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

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('pbkdf2'), require('bip39'), require('@stablelib/hmac'), require('@stablelib/sha512'), require('@taquito/core'), 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', 'pbkdf2', 'bip39', '@stablelib/hmac', '@stablelib/sha512', '@taquito/core', '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.pbkdf2, global.Bip39, global.hmac, global.sha512, global.core, global.BN, global.bls12381));
+})(this, (function (exports, nacl, utils, toBuffer, blake2b, ed25519$1, elliptic, pbkdf2, Bip39, hmac, sha512, core, 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_secretKey, _EdKey_publicKey;
     /**
      * @description Provide signing logic for ed25519 curve based key (tz1)
      */
-    class Tz1 {
+    class EdKey {
         /**
          *
          * @param key Encoded private key
@@ -66,92 +80,84 @@
          * @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}'.`);
-            }
-            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');
+        constructor(key, decrypt) {
+            _EdKey_secretKey.set(this, void 0);
+            _EdKey_publicKey.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_secretKey, keyData, "f");
+                __classPrivateFieldSet(this, _EdKey_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 } = 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;
-            });
+                const { publicKey, secretKey } = ed25519$1.generateKeyPairFromSeed(keyData);
+                __classPrivateFieldSet(this, _EdKey_publicKey, publicKey, "f");
+                __classPrivateFieldSet(this, _EdKey_secretKey, secretKey, "f");
+            }
         }
         /**
          *
          * @param bytes Bytes to sign
          * @param bytesHash Blake2b hash of the bytes to sign
          */
-        sign(bytes, bytesHash) {
+        sign(bytes) {
             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,
-                };
+                const hash = blake2b.hash(bytes, 32);
+                const signature = ed25519$1.sign(__classPrivateFieldGet(this, _EdKey_secretKey, "f"), hash);
+                return Promise.resolve({
+                    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']);
-            });
+            return Promise.resolve(utils.b58Encode(__classPrivateFieldGet(this, _EdKey_publicKey, "f"), utils.PrefixV2.Ed25519PublicKey));
         }
         /**
          * @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 Promise.resolve(utils.b58Encode(blake2b.hash(__classPrivateFieldGet(this, _EdKey_publicKey, "f"), 20), utils.PrefixV2.Ed25519PublicKeyHash));
         }
         /**
          * @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 Promise.resolve(utils.b58Encode(__classPrivateFieldGet(this, _EdKey_secretKey, "f"), utils.PrefixV2.Ed25519SecretKey));
         }
     }
+    _EdKey_secretKey = new WeakMap(), _EdKey_publicKey = new WeakMap();
 
+    var _ECKey_key, _ECKey_publicKey, _ECKey_curve;
     const pref = {
         p256: {
-            pk: utils.prefix['p2pk'],
-            sk: utils.prefix['p2sk'],
-            pkh: utils.prefix.tz3,
-            sig: utils.prefix.p2sig,
+            pk: utils.PrefixV2.P256PublicKey,
+            sk: utils.PrefixV2.P256SecretKey,
+            pkh: utils.PrefixV2.P256PublicKeyHash,
+            sig: utils.PrefixV2.P256Signature,
         },
         secp256k1: {
-            pk: utils.prefix['sppk'],
-            sk: utils.prefix['spsk'],
-            pkh: utils.prefix.tz2,
-            sig: utils.prefix.spsig,
+            pk: utils.PrefixV2.Secp256k1PublicKey,
+            sk: utils.PrefixV2.Secp256k1SecretKey,
+            pkh: utils.PrefixV2.Secp256k1PublicKeyHash,
+            sig: utils.PrefixV2.Secp256k1Signature,
         },
     };
     /**
@@ -160,81 +166,89 @@
     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}'.`);
+        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 = utils.b58DecodeAndCheckPrefix(key, [
+                utils.PrefixV2.Secp256k1EncryptedSecretKey,
+                utils.PrefixV2.P256EncryptedSecretKey,
+                utils.PrefixV2.Secp256k1SecretKey,
+                utils.PrefixV2.P256SecretKey,
+            ]);
+            _a = this, [({ set value(_b) { __classPrivateFieldSet(_a, _ECKey_key, _b, "f"); } }).value] = tmp;
+            const [, prefix] = tmp;
+            switch (prefix) {
+                case utils.PrefixV2.Secp256k1EncryptedSecretKey:
+                case utils.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.PrefixV2.Secp256k1EncryptedSecretKey) {
+                        __classPrivateFieldSet(this, _ECKey_curve, 'secp256k1', "f");
+                    }
+                    else {
+                        __classPrivateFieldSet(this, _ECKey_curve, 'p256', "f");
+                    }
+                    break;
+                case utils.PrefixV2.Secp256k1SecretKey:
+                    __classPrivateFieldSet(this, _ECKey_curve, 'secp256k1', "f");
+                    break;
+                default:
+                    __classPrivateFieldSet(this, _ECKey_curve, 'p256', "f");
+                    break;
             }
-            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))));
+            const keyPair = new elliptic.ec(__classPrivateFieldGet(this, _ECKey_curve, "f")).keyFromPrivate(__classPrivateFieldGet(this, _ECKey_key, "f"));
+            __classPrivateFieldSet(this, _ECKey_publicKey, new Uint8Array(keyPair.getPublic(true, 'array')), "f"); // compress
         }
         /**
          *
          * @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,
-                };
+        sign(bytes) {
+            const hash = blake2b.hash(bytes, 32);
+            const key = new elliptic.ec(__classPrivateFieldGet(this, _ECKey_curve, "f")).keyFromPrivate(__classPrivateFieldGet(this, _ECKey_key, "f"));
+            const sig = key.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({
+                rawSignature: signature,
+                sig: utils.b58Encode(signature, utils.PrefixV2.GenericSignature),
+                prefixSig: utils.b58Encode(signature, pref[__classPrivateFieldGet(this, _ECKey_curve, "f")].sig),
             });
         }
         /**
          * @returns Encoded public key
          */
         publicKey() {
-            return __awaiter(this, void 0, void 0, function* () {
-                return utils.b58cencode(this._publicKey, pref[this.curve].pk);
-            });
+            return Promise.resolve(utils.b58Encode(__classPrivateFieldGet(this, _ECKey_publicKey, "f"), pref[__classPrivateFieldGet(this, _ECKey_curve, "f")].pk));
         }
         /**
          * @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);
-            });
+            return Promise.resolve(utils.b58Encode(blake2b.hash(new Uint8Array(__classPrivateFieldGet(this, _ECKey_publicKey, "f")), 20), pref[__classPrivateFieldGet(this, _ECKey_curve, "f")].pkh));
         }
         /**
          * @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);
-            });
+            return Promise.resolve(utils.b58Encode(__classPrivateFieldGet(this, _ECKey_key, "f"), pref[__classPrivateFieldGet(this, _ECKey_curve, "f")].sk));
         }
     }
-    /**
-     * @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');
+    _ECKey_key = new WeakMap(), _ECKey_publicKey = new WeakMap(), _ECKey_curve = new WeakMap();
 
     function parseHex(s) {
         const res = [];
@@ -565,16 +579,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 +600,66 @@
         }
     };
 
+    function isPOP(k) {
+        return 'provePossession' in k;
+    }
+
+    var _BLSKey_key, _BLSKey_publicKey;
+    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 Promise.resolve({
+                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() {
+            const res = utils.b58Encode(__classPrivateFieldGet(this, _BLSKey_publicKey, "f"), utils.PrefixV2.BLS12_381PublicKey);
+            return Promise.resolve(res);
+        }
+        publicKeyHash() {
+            const res = utils.b58Encode(blake2b.hash(__classPrivateFieldGet(this, _BLSKey_publicKey, "f"), 20), utils.PrefixV2.BLS12_381PublicKeyHash);
+            return Promise.resolve(res);
+        }
+        secretKey() {
+            const res = utils.b58Encode(__classPrivateFieldGet(this, _BLSKey_key, "f"), utils.PrefixV2.BLS12_381SecretKey);
+            return Promise.resolve(res);
+        }
+    }
+    _BLSKey_key = new WeakMap(), _BLSKey_publicKey = 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 +701,11 @@
 
     // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
     const VERSION = {
-        "commitHash": "7af2138a9e5c5b230c4b4c726f35c2f2e67b721c",
-        "version": "23.0.0-beta.0"
+        "commitHash": "10b3de10de15ae68d47b1fca922d3129d2f79641",
+        "version": "23.0.0-beta.1"
     };
 
+    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 +718,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 +754,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,41 +818,54 @@
          * @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 __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 __classPrivateFieldGet(this, _InMemorySigner_key, "f").publicKeyHash();
         }
         /**
          * @returns Encoded private key
          */
         secretKey() {
-            return __awaiter(this, void 0, void 0, function* () {
-                return this._key.secretKey();
-            });
+            return __classPrivateFieldGet(this, _InMemorySigner_key, "f").secretKey();
         }
     }
+    _InMemorySigner_key = new WeakMap();
 
     exports.ECDSA = ecdsa;
     exports.Ed25519 = ed25519;

package/dist/taquito-signer.umd.js.map

@@ -1 +1 @@
-{"version":3,"file":"taquito-signer.umd.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"taquito-signer.umd.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/dist/types/bls-key.d.ts

@@ -0,0 +1,13 @@
+import { SigningKeyWithProofOfPossession } from './key-interface';
+import { RawSignResult } from '@taquito/taquito';
+export declare class BLSKey implements SigningKeyWithProofOfPossession {
+    #private;
+    constructor(key: string, decrypt?: (k: Uint8Array) => Uint8Array);
+    private sk;
+    private signDst;
+    sign(message: Uint8Array): Promise<RawSignResult>;
+    provePossession(): Promise<RawSignResult>;
+    publicKey(): Promise<string>;
+    publicKeyHash(): Promise<string>;
+    secretKey(): Promise<string>;
+}

package/dist/types/ec-key.d.ts

@@ -1,31 +1,23 @@
+import { SigningKey } from './key-interface';
+import { RawSignResult } from '@taquito/taquito';
 /**
  * @description Provide signing logic for elliptic curve based key (tz2, tz3)
  */
-export declare class ECKey {
-    private curve;
-    private key;
-    private _key;
-    private _publicKey;
+export declare class ECKey implements SigningKey {
+    #private;
     /**
      *
-     * @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: 'p256' | 'secp256k1', key: string, encrypted: boolean, decrypt: (k: any) => any);
+    constructor(key: string, decrypt?: (k: Uint8Array) => Uint8Array);
     /**
      *
      * @param bytes Bytes to sign
      * @param bytesHash Blake2b hash of the bytes to sign
      */
-    sign(bytes: string, bytesHash: Uint8Array): Promise<{
-        bytes: string;
-        sig: string;
-        prefixSig: string;
-        sbytes: string;
-    }>;
+    sign(bytes: Uint8Array): Promise<RawSignResult>;
     /**
      * @returns Encoded public key
      */
@@ -39,11 +31,3 @@ export declare class ECKey {
      */
     secretKey(): Promise<string>;
 }
-/**
- * @description Tz3 key class using the p256 curve
- */
-export declare const Tz3: new (key: string, encrypted: boolean, decrypt: (k: any) => any) => ECKey;
-/**
- * @description Tz2 key class using the secp256k1 curve
- */
-export declare const Tz2: new (key: string, encrypted: boolean, decrypt: (k: any) => any) => ECKey;