@taquito/signer 23.0.0-beta.1 → 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('@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';
+    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);
@@ -68,7 +68,7 @@
         return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
     };
 
-    var _EdKey_secretKey, _EdKey_publicKey;
+    var _EdKey_keyPair, _EdPublicKey_key;
     /**
      * @description Provide signing logic for ed25519 curve based key (tz1)
      */
@@ -81,8 +81,7 @@
          * @throws {@link InvalidKeyError}
          */
         constructor(key, decrypt) {
-            _EdKey_secretKey.set(this, void 0);
-            _EdKey_publicKey.set(this, void 0);
+            _EdKey_keyPair.set(this, void 0);
             const tmp = utils.b58DecodeAndCheckPrefix(key, [
                 utils.PrefixV2.Ed25519SecretKey,
                 utils.PrefixV2.Ed25519EncryptedSeed,
@@ -91,8 +90,10 @@
             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");
+                __classPrivateFieldSet(this, _EdKey_keyPair, {
+                    secretKey: keyData,
+                    publicKey: keyData.slice(32),
+                }, "f");
             }
             else {
                 if (prefix === utils.PrefixV2.Ed25519EncryptedSeed) {
@@ -103,9 +104,7 @@
                         throw new Error('decryption function is not provided');
                     }
                 }
-                const { publicKey, secretKey } = ed25519$1.generateKeyPairFromSeed(keyData);
-                __classPrivateFieldSet(this, _EdKey_publicKey, publicKey, "f");
-                __classPrivateFieldSet(this, _EdKey_secretKey, secretKey, "f");
+                __classPrivateFieldSet(this, _EdKey_keyPair, ed25519$1.generateKeyPairFromSeed(keyData), "f");
             }
         }
         /**
@@ -114,154 +113,64 @@
          * @param bytesHash Blake2b hash of the bytes to sign
          */
         sign(bytes) {
-            return __awaiter(this, void 0, void 0, function* () {
-                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),
-                });
-            });
+            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 Promise.resolve(utils.b58Encode(__classPrivateFieldGet(this, _EdKey_publicKey, "f"), utils.PrefixV2.Ed25519PublicKey));
-        }
-        /**
-         * @returns Encoded public key hash
-         */
-        publicKeyHash() {
-            return Promise.resolve(utils.b58Encode(blake2b.hash(__classPrivateFieldGet(this, _EdKey_publicKey, "f"), 20), utils.PrefixV2.Ed25519PublicKeyHash));
+            return new EdPublicKey(__classPrivateFieldGet(this, _EdKey_keyPair, "f").publicKey);
         }
         /**
          * @returns Encoded private key
          */
         secretKey() {
-            return Promise.resolve(utils.b58Encode(__classPrivateFieldGet(this, _EdKey_secretKey, "f"), utils.PrefixV2.Ed25519SecretKey));
+            return utils.b58Encode(__classPrivateFieldGet(this, _EdKey_keyPair, "f").secretKey, utils.PrefixV2.Ed25519SecretKey);
         }
     }
-    _EdKey_secretKey = new WeakMap(), _EdKey_publicKey = new WeakMap();
-
-    var _ECKey_key, _ECKey_publicKey, _ECKey_curve;
-    const pref = {
-        p256: {
-            pk: utils.PrefixV2.P256PublicKey,
-            sk: utils.PrefixV2.P256SecretKey,
-            pkh: utils.PrefixV2.P256PublicKeyHash,
-            sig: utils.PrefixV2.P256Signature,
-        },
-        secp256k1: {
-            pk: utils.PrefixV2.Secp256k1PublicKey,
-            sk: utils.PrefixV2.Secp256k1SecretKey,
-            pkh: utils.PrefixV2.Secp256k1PublicKeyHash,
-            sig: utils.PrefixV2.Secp256k1Signature,
-        },
-    };
-    /**
-     * @description Provide signing logic for elliptic curve based key (tz2, tz3)
-     */
-    class ECKey {
-        /**
-         *
-         * @param key Encoded private key
-         * @param decrypt Decrypt function
-         * @throws {@link InvalidKeyError}
-         */
-        constructor(key, decrypt) {
-            var _a;
-            _ECKey_key.set(this, void 0);
-            _ECKey_publicKey.set(this, void 0);
-            _ECKey_curve.set(this, void 0);
-            const tmp = 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;
+    _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");
             }
-            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) {
-            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),
-            });
+        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 Promise.resolve(utils.b58Encode(__classPrivateFieldGet(this, _ECKey_publicKey, "f"), pref[__classPrivateFieldGet(this, _ECKey_curve, "f")].pk));
+        hash() {
+            return utils.b58Encode(blake2b.hash(__classPrivateFieldGet(this, _EdPublicKey_key, "f"), 20), utils.PrefixV2.Ed25519PublicKeyHash);
         }
-        /**
-         * @returns Encoded public key hash
-         */
-        publicKeyHash() {
-            return Promise.resolve(utils.b58Encode(blake2b.hash(new Uint8Array(__classPrivateFieldGet(this, _ECKey_publicKey, "f")), 20), pref[__classPrivateFieldGet(this, _ECKey_curve, "f")].pkh));
+        bytes() {
+            return __classPrivateFieldGet(this, _EdPublicKey_key, "f");
         }
-        /**
-         * @returns Encoded private key
-         */
-        secretKey() {
-            return Promise.resolve(utils.b58Encode(__classPrivateFieldGet(this, _ECKey_key, "f"), pref[__classPrivateFieldGet(this, _ECKey_curve, "f")].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;
         }
-    }
-    _ECKey_key = new WeakMap(), _ECKey_publicKey = new WeakMap(), _ECKey_curve = new WeakMap();
-
-    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
@@ -332,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',
@@ -604,7 +696,7 @@
         return 'provePossession' in k;
     }
 
-    var _BLSKey_key, _BLSKey_publicKey;
+    var _BLSKey_key, _BLSKey_publicKey, _BLSPublicKey_key;
     const bls = bls12381.bls12_381.longSignatures; // AKA MinPK
     class BLSKey {
         constructor(key, decrypt) {
@@ -633,11 +725,11 @@
         signDst(message, dst) {
             const point = bls.hash(message, dst);
             const sig = bls.sign(point, this.sk()).toBytes();
-            return Promise.resolve({
+            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);
@@ -646,19 +738,49 @@
             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);
+            return new BLSPublicKey(__classPrivateFieldGet(this, _BLSKey_publicKey, "f"));
         }
         secretKey() {
-            const res = utils.b58Encode(__classPrivateFieldGet(this, _BLSKey_key, "f"), utils.PrefixV2.BLS12_381SecretKey);
-            return Promise.resolve(res);
+            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();
 
     /**
      *
@@ -701,8 +823,8 @@
 
     // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
     const VERSION = {
-        "commitHash": "10b3de10de15ae68d47b1fca922d3129d2f79641",
-        "version": "23.0.0-beta.1"
+        "commitHash": "9065acc1b41ec205a49e64b54ef89f50bafa6210",
+        "version": "23.0.0"
     };
 
     var _InMemorySigner_key;
@@ -850,22 +972,40 @@
          * @returns Encoded public key
          */
         publicKey() {
-            return __classPrivateFieldGet(this, _InMemorySigner_key, "f").publicKey();
+            return Promise.resolve(String(__classPrivateFieldGet(this, _InMemorySigner_key, "f").publicKey()));
         }
         /**
          * @returns Encoded public key hash
          */
         publicKeyHash() {
-            return __classPrivateFieldGet(this, _InMemorySigner_key, "f").publicKeyHash();
+            return Promise.resolve(__classPrivateFieldGet(this, _InMemorySigner_key, "f").publicKey().hash());
         }
         /**
          * @returns Encoded private key
          */
         secretKey() {
-            return __classPrivateFieldGet(this, _InMemorySigner_key, "f").secretKey();
+            return Promise.resolve(__classPrivateFieldGet(this, _InMemorySigner_key, "f").secretKey());
         }
     }
     _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);
+        }
+    }
 
     exports.ECDSA = ecdsa;
     exports.Ed25519 = ed25519;
@@ -876,6 +1016,7 @@
     exports.VERSION = VERSION;
     exports.generateSecretKey = generateSecretKey;
     exports.importKey = importKey;
+    exports.publicKeyFromString = publicKeyFromString;
 
 }));
 //# sourceMappingURL=taquito-signer.umd.js.map

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

@@ -1,13 +1,21 @@
-import { SigningKeyWithProofOfPossession } from './key-interface';
-import { RawSignResult } from '@taquito/taquito';
+import { PublicKey, SigningKeyWithProofOfPossession } from './key-interface';
+import { RawSignResult } from '@taquito/core';
 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>;
+    sign(message: Uint8Array): RawSignResult;
+    provePossession(): RawSignResult;
+    publicKey(): PublicKey;
+    secretKey(): string;
+}
+export declare class BLSPublicKey implements PublicKey {
+    #private;
+    constructor(src: string | Uint8Array);
+    compare(other: PublicKey): number;
+    hash(): string;
+    bytes(): Uint8Array;
+    toProtocol(): Uint8Array;
+    toString(): string;
 }

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

@@ -1,10 +1,16 @@
-import { SigningKey } from './key-interface';
-import { RawSignResult } from '@taquito/taquito';
+import elliptic from 'elliptic';
+import { SigningKey, PublicKey } from './key-interface';
+import { RawSignResult } from '@taquito/core';
+type Curve = 'p256' | 'secp256k1';
+declare class ECKeyBase {
+    readonly keyPair: elliptic.ec.KeyPair;
+    constructor(keyPair: elliptic.ec.KeyPair);
+    curve(): Curve;
+}
 /**
  * @description Provide signing logic for elliptic curve based key (tz2, tz3)
  */
-export declare class ECKey implements SigningKey {
-    #private;
+export declare class ECKey extends ECKeyBase implements SigningKey {
     /**
      *
      * @param key Encoded private key
@@ -17,17 +23,24 @@ export declare class ECKey implements SigningKey {
      * @param bytes Bytes to sign
      * @param bytesHash Blake2b hash of the bytes to sign
      */
-    sign(bytes: Uint8Array): Promise<RawSignResult>;
+    sign(bytes: Uint8Array): RawSignResult;
     /**
      * @returns Encoded public key
      */
-    publicKey(): Promise<string>;
-    /**
-     * @returns Encoded public key hash
-     */
-    publicKeyHash(): Promise<string>;
+    publicKey(): PublicKey;
     /**
      * @returns Encoded private key
      */
-    secretKey(): Promise<string>;
+    secretKey(): string;
+}
+export declare class ECPublicKey extends ECKeyBase implements PublicKey {
+    constructor(src: string);
+    constructor(src: elliptic.ec.KeyPair);
+    constructor(src: Uint8Array, curve: Curve);
+    compare(other: PublicKey): number;
+    hash(): string;
+    bytes(compress?: boolean): Uint8Array;
+    toProtocol(): Uint8Array;
+    toString(): string;
 }
+export {};