@taquito/signer 23.0.2 → 23.1.0

package/dist/taquito-signer.es6.js

@@ -3,13 +3,14 @@ import { b58DecodeAndCheckPrefix, PrefixV2, b58Encode, compareArrays, InvalidPub
 import toBuffer from 'typedarray-to-buffer';
 import { hash } from '@stablelib/blake2b';
 import { generateKeyPairFromSeed, sign } from '@stablelib/ed25519';
-import elliptic, { ec } from 'elliptic';
-import KeyPair from 'elliptic/lib/elliptic/ec/key';
-import { ParameterValidationError, UnsupportedActionError, InvalidHexStringError, InvalidKeyError, InvalidDerivationPathError, ProhibitedActionError } from '@taquito/core';
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { p256 } from '@noble/curves/nist.js';
+import { ParameterValidationError, UnsupportedActionError, InvalidHexStringError, InvalidDerivationPathError, InvalidKeyError, ProhibitedActionError } from '@taquito/core';
 import pbkdf2 from 'pbkdf2';
 import * as Bip39 from 'bip39';
 import { HMAC } from '@stablelib/hmac';
 import { SHA512 } from '@stablelib/sha512';
+import { p256 as p256$1 } from '@noble/curves/nist';
 import BN from 'bn.js';
 import { bls12_381 } from '@noble/curves/bls12-381';
 
@@ -231,6 +232,7 @@ class InvalidPassphraseError extends ParameterValidationError {
     }
 }
 
+var _ECKey_keyPair, _ECPublicKey_key;
 const pref = {
     p256: {
         pk: PrefixV2.P256PublicKey,
@@ -247,27 +249,10 @@ const pref = {
         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 {
+class ECKey {
     /**
      *
      * @param key Encoded private key
@@ -275,6 +260,7 @@ class ECKey extends ECKeyBase {
      * @throws {@link InvalidKeyError}
      */
     constructor(key, decrypt) {
+        _ECKey_keyPair.set(this, void 0);
         const [keyData, prefix] = b58DecodeAndCheckPrefix(key, [
             PrefixV2.Secp256k1EncryptedSecretKey,
             PrefixV2.P256EncryptedSecretKey,
@@ -300,7 +286,13 @@ class ECKey extends ECKeyBase {
                     return [keyData, 'p256'];
             }
         })();
-        super(new elliptic.ec(curve).keyFromPrivate(decKey));
+        __classPrivateFieldSet(this, _ECKey_keyPair, {
+            curve,
+            secretKey: decKey,
+            publicKey: curve === 'secp256k1'
+                ? secp256k1.getPublicKey(decKey, true)
+                : p256.getPublicKey(decKey, true),
+        }, "f");
     }
     /**
      *
@@ -309,68 +301,71 @@ class ECKey extends ECKeyBase {
      */
     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);
+        let signature;
+        if (__classPrivateFieldGet(this, _ECKey_keyPair, "f").curve === 'secp256k1') {
+            signature = secp256k1
+                .sign(hash$1, __classPrivateFieldGet(this, _ECKey_keyPair, "f").secretKey, {
+                lowS: true, // Use canonical signatures (prevents malleability)
+            })
+                .toBytes('compact');
+        }
+        else {
+            signature = p256
+                .sign(hash$1, __classPrivateFieldGet(this, _ECKey_keyPair, "f").secretKey, {
+                lowS: true, // Use canonical signatures (prevents malleability)
+            })
+                .toBytes('compact');
+        }
         return {
             rawSignature: signature,
             sig: b58Encode(signature, PrefixV2.GenericSignature),
-            prefixSig: b58Encode(signature, pref[this.curve()].sig),
+            prefixSig: b58Encode(signature, pref[__classPrivateFieldGet(this, _ECKey_keyPair, "f").curve].sig),
         };
     }
     /**
      * @returns Encoded public key
      */
     publicKey() {
-        return new ECPublicKey(this.keyPair.ec.keyFromPublic(this.keyPair));
+        return new ECPublicKey(__classPrivateFieldGet(this, _ECKey_keyPair, "f").publicKey, __classPrivateFieldGet(this, _ECKey_keyPair, "f").curve);
     }
     /**
      * @returns Encoded private key
      */
     secretKey() {
-        return b58Encode(new Uint8Array(this.keyPair.getPrivate().toArray()), pref[this.curve()].sk);
+        return b58Encode(__classPrivateFieldGet(this, _ECKey_keyPair, "f").secretKey, pref[__classPrivateFieldGet(this, _ECKey_keyPair, "f").curve].sk);
     }
 }
-function isKeyPair(src) {
-    return src instanceof KeyPair;
-}
-class ECPublicKey extends ECKeyBase {
+_ECKey_keyPair = new WeakMap();
+class ECPublicKey {
     constructor(src, curve) {
-        const key = (() => {
-            if (isKeyPair(src)) {
-                return src;
+        _ECPublicKey_key.set(this, void 0);
+        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 {
-                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);
+                throw new InvalidCurveError('missing curve type');
             }
         })();
-        super(key);
+        // For ECPublicKey, we don't need the private key, so we pass an empty array
+        // The public key is stored separately
+        __classPrivateFieldSet(this, _ECPublicKey_key, key, "f");
+        this.curve = crv;
     }
     compare(other) {
         if (other instanceof ECPublicKey) {
-            if (this.curve() === other.curve()) {
-                const compress = this.curve() === 'secp256k1';
+            if (this.curve === other.curve) {
+                const compress = this.curve === 'secp256k1';
                 return compareArrays(this.bytes(compress), other.bytes(compress));
             }
-            else if (this.curve() === 'secp256k1') {
+            else if (this.curve === 'secp256k1') {
                 return -1;
             }
             else {
@@ -383,23 +378,37 @@ class ECPublicKey extends ECKeyBase {
     }
     hash() {
         const key = this.bytes();
-        return b58Encode(hash(key, 20), pref[this.curve()].pkh);
+        return b58Encode(hash(key, 20), pref[this.curve].pkh);
     }
     bytes(compress = true) {
-        return new Uint8Array(this.keyPair.getPublic(compress, 'array'));
+        // @noble/curves supports both compressed and uncompressed formats
+        // We need to convert the stored public key to the requested format
+        if (this.curve === 'secp256k1') {
+            // For secp256k1, we need to get the public key from the stored bytes and convert format
+            const point = secp256k1.Point.fromHex(__classPrivateFieldGet(this, _ECPublicKey_key, "f"));
+            return point.toBytes(compress);
+        }
+        else {
+            // For p256, we need to get the public key from the stored bytes and convert format
+            const point = p256.Point.fromHex(__classPrivateFieldGet(this, _ECPublicKey_key, "f"));
+            return point.toBytes(compress);
+        }
     }
     toProtocol() {
         const key = this.bytes();
         const res = new Uint8Array(key.length + 1);
-        res[0] = pref[this.curve()].tag;
+        res[0] = pref[this.curve].tag;
         res.set(key, 1);
         return res;
     }
     toString() {
         const key = this.bytes();
-        return b58Encode(key, pref[this.curve()].pk);
+        return b58Encode(key, pref[this.curve].pk);
     }
 }
+_ECPublicKey_key = new WeakMap();
+
+const Hard = 0x80000000;
 
 function parseHex(s) {
     const res = [];
@@ -414,24 +423,104 @@ function parseHex(s) {
     return new Uint8Array(res);
 }
 
+/* eslint-disable @typescript-eslint/no-this-alias */
+// MinSeedSize is the minimal allowed seed byte length
+const minSeedSize$1 = 16;
+// MaxSeedSize is the maximal allowed seed byte length
+const maxSeedSize$1 = 64;
+const ed25519Key = 'ed25519 seed';
+let PrivateKey$1 = class PrivateKey {
+    /**
+     *
+     * @param priv generated keypair 0->32 private key 32->n public key
+     * @param chainCode new HMAC hash with new key
+     */
+    constructor(priv, chainCode) {
+        this.priv = priv;
+        this.chainCode = chainCode;
+    }
+    /**
+     *
+     * @param seedSrc result of Bip39.mnemonicToSeed
+     * @returns instance of PrivateKey
+     * @throws {@link InvalidSeedLengthError}
+     */
+    static fromSeed(seedSrc) {
+        const seed = typeof seedSrc === 'string' ? parseHex(seedSrc) : seedSrc;
+        if (seed.length < minSeedSize$1 || seed.length > maxSeedSize$1) {
+            throw new InvalidSeedLengthError(seed.length);
+        }
+        const key = new TextEncoder().encode(ed25519Key);
+        const sum = new HMAC(SHA512, key).update(seed).digest();
+        return new PrivateKey(generateKeyPairFromSeed(sum.subarray(0, 32)).secretKey, sum.subarray(32));
+    }
+    /**
+     *
+     * @returns slice(0, 32) of current priv for new seed for next derived priv
+     */
+    seed() {
+        return this.priv.subarray(0, 32);
+    }
+    /**
+     * @index current derivation path item ie: 1729'
+     * @returns derivation path child of original private key pair
+     */
+    derive(index) {
+        if ((index & Hard) === 0) {
+            throw new InvalidDerivationPathError(index.toString(), ': Non-hardened derivation path.');
+        }
+        const data = new Uint8Array(37);
+        data.set(this.seed(), 1);
+        new DataView(data.buffer).setUint32(33, index);
+        const sum = new HMAC(SHA512, this.chainCode).update(data).digest();
+        return new PrivateKey(generateKeyPairFromSeed(sum.subarray(0, 32)).secretKey, sum.subarray(32));
+    }
+    /**
+     * @param path array of numbers pre adjusted for hardened paths ie: 44' -> 2^31 + 44
+     * @returns final child of full derivation path private key pair
+     */
+    derivePath(path) {
+        let key = this;
+        for (const index of path) {
+            key = key.derive(index);
+        }
+        return key;
+    }
+};
+
+var ed25519 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    PrivateKey: PrivateKey$1
+});
+
 /* eslint-disable @typescript-eslint/no-this-alias */
 const seedKey = {
     p256: 'Nist256p1 seed',
     secp256k1: 'Bitcoin seed',
 };
 // MinSeedSize is the minimal allowed seed byte length
-const minSeedSize$1 = 16;
+const minSeedSize = 16;
 // MaxSeedSize is the maximal allowed seed byte length
-const maxSeedSize$1 = 64;
-let PrivateKey$1 = class PrivateKey {
+const maxSeedSize = 64;
+class PrivateKey {
     /**
      *
-     * @param priv key pair priv (BN) pub (curve.base.BasePint) if applicable
+     * @param priv { secretKey: BN, curve: 'p256' | 'secp256k1' }
      * @param chainCode slice 32->n HMAC hash key and seedkey (first instance curve default seedKey. after hmac value slice 32->n)
      */
     constructor(priv, chainCode) {
+        this.priv = priv;
         this.chainCode = chainCode;
-        this.keyPair = priv;
+        const privateKeyBytes = priv.secretKey.toArray('be', 32);
+        const privateKeyUint8 = new Uint8Array(privateKeyBytes);
+        const publicKey = priv.curve === 'secp256k1'
+            ? secp256k1.getPublicKey(privateKeyUint8, true) // compressed public key
+            : p256$1.getPublicKey(privateKeyUint8, true); // compressed public key
+        this.keyPair = {
+            curve: priv.curve,
+            secretKey: priv.secretKey,
+            publicKey: publicKey,
+        };
     }
     /**
      * @param seedSrc result of Bip39.mnemonicToSeed
@@ -440,17 +529,23 @@ let PrivateKey$1 = class PrivateKey {
      * @throws {@link InvalidBitSize} | {@link InvalidCurveError} | {@link InvalidSeedLengthError}
      */
     static fromSeed(seedSrc, curve) {
-        var _a, _b;
         let seed = typeof seedSrc === 'string' ? parseHex(seedSrc) : seedSrc;
-        if (seed.length < minSeedSize$1 || seed.length > maxSeedSize$1) {
+        if (seed.length < minSeedSize || seed.length > maxSeedSize) {
             throw new InvalidSeedLengthError(seed.length);
         }
         if (!Object.prototype.hasOwnProperty.call(seedKey, curve)) {
             throw new InvalidCurveError(`Unsupported curve "${curve}" expecting either "p256" or "secp256k1"`);
         }
-        const c = new ec(curve);
-        if (((_a = c.n) === null || _a === void 0 ? void 0 : _a.bitLength()) !== 256) {
-            throw new InvalidBitSize(`Invalid curve "${curve}" with bit size "${(_b = c.n) === null || _b === void 0 ? void 0 : _b.bitLength()}" expecting bit size "256"`);
+        // Get curve order for validation
+        let curveOrder;
+        if (curve === 'secp256k1') {
+            curveOrder = new BN(secp256k1.Point.CURVE().n.toString());
+        }
+        else {
+            curveOrder = new BN(p256$1.Point.CURVE().n.toString());
+        }
+        if (curveOrder.bitLength() !== 256) {
+            throw new InvalidBitSize(`Invalid curve "${curve}" with bit size "${curveOrder.bitLength()}" expecting bit size "256"`);
         }
         const key = new TextEncoder().encode(seedKey[curve]);
         let d = null;
@@ -460,16 +555,14 @@ let PrivateKey$1 = class PrivateKey {
             const sum = new HMAC(SHA512, key).update(seed).digest();
             d = new BN(sum.subarray(0, 32));
             chain = sum.subarray(32);
-            if (d.isZero() || d.cmp(c.n) >= 0) {
+            if (d.isZero() || d.cmp(curveOrder) >= 0) {
                 seed = sum;
             }
             else {
                 i++;
             }
         }
-        const keyPair = c.keyPair({});
-        keyPair.priv = d;
-        return new PrivateKey(keyPair, chain);
+        return new PrivateKey({ curve, secretKey: d }, chain);
     }
     /**
      *
@@ -480,10 +573,10 @@ let PrivateKey$1 = class PrivateKey {
         const data = new Uint8Array(37);
         if ((index & Hard) !== 0) {
             // hardened derivation
-            data.set(this.keyPair.getPrivate().toArray(), 1);
+            data.set(this.keyPair.secretKey.toArray(), 1);
         }
         else {
-            data.set(this.keyPair.getPublic().encodeCompressed(), 0);
+            data.set(this.keyPair.publicKey, 0);
         }
         new DataView(data.buffer).setUint32(33, index);
         let d = new BN(0);
@@ -493,8 +586,16 @@ let PrivateKey$1 = class PrivateKey {
             const sum = new HMAC(SHA512, this.chainCode).update(data).digest();
             d = new BN(sum.subarray(0, 32));
             chain = sum.subarray(32);
-            if (this.keyPair.ec.n && d.cmp(this.keyPair.ec.n) < 0) {
-                d = d.add(this.keyPair.getPrivate()).mod(this.keyPair.ec.n);
+            // Get curve order for comparison
+            let curveOrder;
+            if (this.keyPair.curve === 'secp256k1') {
+                curveOrder = new BN(secp256k1.Point.CURVE().n.toString());
+            }
+            else {
+                curveOrder = new BN(p256$1.Point.CURVE().n.toString());
+            }
+            if (d.cmp(curveOrder) < 0) {
+                d = d.add(this.keyPair.secretKey).mod(curveOrder);
                 if (!d.isZero()) {
                     i++;
                 }
@@ -502,9 +603,7 @@ let PrivateKey$1 = class PrivateKey {
             data.set(chain, 1);
             data[0] = 1;
         }
-        const keyPair = this.keyPair.ec.keyPair({});
-        keyPair.priv = d;
-        return new PrivateKey(keyPair, chain);
+        return new PrivateKey({ curve: this.keyPair.curve, secretKey: d }, chain);
     }
     /**
      *
@@ -524,23 +623,22 @@ let PrivateKey$1 = class PrivateKey {
      * @throws {@link InvalidKeyError}
      */
     bytes() {
-        if (!this.keyPair.priv) {
+        if (!this.keyPair.secretKey) {
             throw new InvalidKeyError('missing private key');
         }
         // pad to 32 bytes as toArray() length argument seems to be ignored (BN bug)
-        const src = this.keyPair.priv.toArray();
+        const src = this.keyPair.secretKey.toArray();
         const out = new Uint8Array(32);
         out.set(src, out.length - src.length);
         return out;
     }
-};
+}
 
 var ecdsa = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    PrivateKey: PrivateKey$1
+    PrivateKey: PrivateKey
 });
 
-const Hard = 0x80000000;
 class Path extends Array {
     static from(iterable) {
         return super.from(iterable).map((x) => x >>> 0);
@@ -576,76 +674,6 @@ class Path extends Array {
     }
 }
 
-/* eslint-disable @typescript-eslint/no-this-alias */
-// MinSeedSize is the minimal allowed seed byte length
-const minSeedSize = 16;
-// MaxSeedSize is the maximal allowed seed byte length
-const maxSeedSize = 64;
-const ed25519Key = 'ed25519 seed';
-class PrivateKey {
-    /**
-     *
-     * @param priv generated keypair 0->32 private key 32->n public key
-     * @param chainCode new HMAC hash with new key
-     */
-    constructor(priv, chainCode) {
-        this.priv = priv;
-        this.chainCode = chainCode;
-    }
-    /**
-     *
-     * @param seedSrc result of Bip39.mnemonicToSeed
-     * @returns instance of PrivateKey
-     * @throws {@link InvalidSeedLengthError}
-     */
-    static fromSeed(seedSrc) {
-        const seed = typeof seedSrc === 'string' ? parseHex(seedSrc) : seedSrc;
-        if (seed.length < minSeedSize || seed.length > maxSeedSize) {
-            throw new InvalidSeedLengthError(seed.length);
-        }
-        const key = new TextEncoder().encode(ed25519Key);
-        const sum = new HMAC(SHA512, key).update(seed).digest();
-        return new PrivateKey(generateKeyPairFromSeed(sum.subarray(0, 32)).secretKey, sum.subarray(32));
-    }
-    /**
-     *
-     * @returns slice(0, 32) of current priv for new seed for next derived priv
-     */
-    seed() {
-        return this.priv.subarray(0, 32);
-    }
-    /**
-     * @index current derivation path item ie: 1729'
-     * @returns derivation path child of original private key pair
-     */
-    derive(index) {
-        if ((index & Hard) === 0) {
-            throw new InvalidDerivationPathError(index.toString(), ': Non-hardened derivation path.');
-        }
-        const data = new Uint8Array(37);
-        data.set(this.seed(), 1);
-        new DataView(data.buffer).setUint32(33, index);
-        const sum = new HMAC(SHA512, this.chainCode).update(data).digest();
-        return new PrivateKey(generateKeyPairFromSeed(sum.subarray(0, 32)).secretKey, sum.subarray(32));
-    }
-    /**
-     * @param path array of numbers pre adjusted for hardened paths ie: 44' -> 2^31 + 44
-     * @returns final child of full derivation path private key pair
-     */
-    derivePath(path) {
-        let key = this;
-        for (const index of path) {
-            key = key.derive(index);
-        }
-        return key;
-    }
-}
-
-var ed25519 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    PrivateKey: PrivateKey
-});
-
 // bip32 when supported add to @param curve bip25519
 /**
  *
@@ -660,16 +688,16 @@ const generateSecretKey = (seed, derivationPath, curve) => {
     let node;
     switch (curve) {
         case 'ed25519': {
-            node = PrivateKey.fromSeed(seed).derivePath(path);
+            node = PrivateKey$1.fromSeed(seed).derivePath(path);
             const sk = b58Encode(node.seed().slice(0, 32), PrefixV2.Ed25519Seed);
             return sk;
         }
         case 'secp256k1':
         case 'p256': {
             const prefixType = curve === 'secp256k1' ? PrefixV2.Secp256k1SecretKey : PrefixV2.P256SecretKey;
-            let privKey = PrivateKey$1.fromSeed(seed, curve);
+            let privKey = PrivateKey.fromSeed(seed, curve);
             privKey = privKey.derivePath(path);
-            const uint8arr = new Uint8Array(privKey.keyPair.getPrivate().toArray());
+            const uint8arr = new Uint8Array(privKey.keyPair.secretKey.toArray());
             const sk = b58Encode(uint8arr, prefixType);
             return sk;
         }
@@ -772,51 +800,6 @@ class BLSPublicKey {
 }
 _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
- *
- * @warn The JSON faucets are no longer available on https://teztnets.com/
- * @param toolkit The toolkit instance to attach a signer
- * @param privateKeyOrEmail Key to load in memory
- * @param passphrase If the key is encrypted passphrase to decrypt it
- * @param mnemonic Faucet mnemonic
- * @param secret Faucet secret
- */
-function importKey(toolkit, privateKeyOrEmail, passphrase, mnemonic, secret) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (privateKeyOrEmail && passphrase && mnemonic && secret) {
-            const signer = InMemorySigner.fromFundraiser(privateKeyOrEmail, passphrase, mnemonic);
-            toolkit.setProvider({ signer });
-            const pkh = yield signer.publicKeyHash();
-            let op;
-            try {
-                op = yield toolkit.tz.activate(pkh, secret);
-            }
-            catch (ex) {
-                const isInvalidActivationError = ex && ex.body && /Invalid activation/.test(ex.body);
-                if (!isInvalidActivationError) {
-                    throw ex;
-                }
-            }
-            if (op) {
-                yield op.confirmation();
-            }
-        }
-        else {
-            // Fallback to regular import
-            const signer = yield InMemorySigner.fromSecretKey(privateKeyOrEmail, passphrase);
-            toolkit.setProvider({ signer });
-        }
-    });
-}
-
-// IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
-const VERSION = {
-    "commitHash": "20b6624f217ec85f28023ca02b2d3b73777a8df9",
-    "version": "23.0.2"
-};
-
 var _InMemorySigner_key;
 /**
  * @description A local implementation of the signer. Will represent a Tezos account and be able to produce signature in its behalf
@@ -997,5 +980,11 @@ function publicKeyFromString(src) {
     }
 }
 
-export { ecdsa as ECDSA, ed25519 as Ed25519, Hard, InMemorySigner, InvalidPassphraseError, Path, VERSION, generateSecretKey, importKey, publicKeyFromString };
+// IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
+const VERSION = {
+    "commitHash": "c77fe4b0989665d8b5cfd15a7cc977499021f6fd",
+    "version": "23.1.0"
+};
+
+export { ecdsa as ECDSA, ed25519 as Ed25519, Hard, InMemorySigner, InvalidPassphraseError, Path, VERSION, generateSecretKey, publicKeyFromString };
 //# sourceMappingURL=taquito-signer.es6.js.map

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

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