@taquito/signer 23.0.3 → 24.0.0-beta.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';
 
@@ -27,7 +28,7 @@ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
 
 
 function __awaiter(thisArg, _arguments, P, generator) {
@@ -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": "42048d039f6d4345fc59d04b03650bcb8e27bb62",
-    "version": "23.0.3"
-};
-
 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": "7912b77f57f943dff619383900bd46a7a593a244",
+    "version": "24.0.0-beta.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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}