@taquito/signer 23.0.3 → 24.0.0-beta.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('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';
+    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('@noble/curves/secp256k1'), require('@noble/curves/nist.js'), require('@taquito/core'), require('pbkdf2'), require('bip39'), require('@stablelib/hmac'), require('@stablelib/sha512'), require('@noble/curves/nist'), 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', '@noble/curves/secp256k1', '@noble/curves/nist.js', '@taquito/core', 'pbkdf2', 'bip39', '@stablelib/hmac', '@stablelib/sha512', '@noble/curves/nist', '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.secp256k1, global.nist, global.core, global.pbkdf2, global.Bip39, global.hmac, global.sha512, global.nist, global.BN, global.bls12381));
+})(this, (function (exports, nacl, utils, toBuffer, blake2b, ed25519$1, secp256k1, nist_js, core, pbkdf2, Bip39, hmac, sha512, nist, BN, bls12381) { 'use strict';
 
     function _interopNamespaceDefault(e) {
         var n = Object.create(null);
@@ -37,7 +37,7 @@
     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) {
@@ -241,6 +241,7 @@
         }
     }
 
+    var _ECKey_keyPair, _ECPublicKey_key;
     const pref = {
         p256: {
             pk: utils.PrefixV2.P256PublicKey,
@@ -257,27 +258,10 @@
             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
@@ -285,6 +269,7 @@
          * @throws {@link InvalidKeyError}
          */
         constructor(key, decrypt) {
+            _ECKey_keyPair.set(this, void 0);
             const [keyData, prefix] = utils.b58DecodeAndCheckPrefix(key, [
                 utils.PrefixV2.Secp256k1EncryptedSecretKey,
                 utils.PrefixV2.P256EncryptedSecretKey,
@@ -310,7 +295,13 @@
                         return [keyData, 'p256'];
                 }
             })();
-            super(new elliptic.ec(curve).keyFromPrivate(decKey));
+            __classPrivateFieldSet(this, _ECKey_keyPair, {
+                curve,
+                secretKey: decKey,
+                publicKey: curve === 'secp256k1'
+                    ? secp256k1.secp256k1.getPublicKey(decKey, true)
+                    : nist_js.p256.getPublicKey(decKey, true),
+            }, "f");
         }
         /**
          *
@@ -319,68 +310,71 @@
          */
         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);
+            let signature;
+            if (__classPrivateFieldGet(this, _ECKey_keyPair, "f").curve === 'secp256k1') {
+                signature = secp256k1.secp256k1
+                    .sign(hash, __classPrivateFieldGet(this, _ECKey_keyPair, "f").secretKey, {
+                    lowS: true, // Use canonical signatures (prevents malleability)
+                })
+                    .toBytes('compact');
+            }
+            else {
+                signature = nist_js.p256
+                    .sign(hash, __classPrivateFieldGet(this, _ECKey_keyPair, "f").secretKey, {
+                    lowS: true, // Use canonical signatures (prevents malleability)
+                })
+                    .toBytes('compact');
+            }
             return {
                 rawSignature: signature,
                 sig: utils.b58Encode(signature, utils.PrefixV2.GenericSignature),
-                prefixSig: utils.b58Encode(signature, pref[this.curve()].sig),
+                prefixSig: utils.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 utils.b58Encode(new Uint8Array(this.keyPair.getPrivate().toArray()), pref[this.curve()].sk);
+            return utils.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] = 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 {
-                    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);
+                    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 utils.compareArrays(this.bytes(compress), other.bytes(compress));
                 }
-                else if (this.curve() === 'secp256k1') {
+                else if (this.curve === 'secp256k1') {
                     return -1;
                 }
                 else {
@@ -393,23 +387,37 @@
         }
         hash() {
             const key = this.bytes();
-            return utils.b58Encode(blake2b.hash(key, 20), pref[this.curve()].pkh);
+            return utils.b58Encode(blake2b.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.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 = nist_js.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 utils.b58Encode(key, pref[this.curve()].pk);
+            return utils.b58Encode(key, pref[this.curve].pk);
         }
     }
+    _ECPublicKey_key = new WeakMap();
+
+    const Hard = 0x80000000;
 
     function parseHex(s) {
         const res = [];
@@ -424,24 +432,104 @@
         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.HMAC(sha512.SHA512, key).update(seed).digest();
+            return new PrivateKey(ed25519$1.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 core.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.HMAC(sha512.SHA512, this.chainCode).update(data).digest();
+            return new PrivateKey(ed25519$1.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.secp256k1.getPublicKey(privateKeyUint8, true) // compressed public key
+                : nist.p256.getPublicKey(privateKeyUint8, true); // compressed public key
+            this.keyPair = {
+                curve: priv.curve,
+                secretKey: priv.secretKey,
+                publicKey: publicKey,
+            };
         }
         /**
          * @param seedSrc result of Bip39.mnemonicToSeed
@@ -450,17 +538,23 @@
          * @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 elliptic.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.secp256k1.Point.CURVE().n.toString());
+            }
+            else {
+                curveOrder = new BN(nist.p256.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;
@@ -470,16 +564,14 @@
                 const sum = new hmac.HMAC(sha512.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);
         }
         /**
          *
@@ -490,10 +582,10 @@
             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);
@@ -503,8 +595,16 @@
                 const sum = new hmac.HMAC(sha512.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.secp256k1.Point.CURVE().n.toString());
+                }
+                else {
+                    curveOrder = new BN(nist.p256.Point.CURVE().n.toString());
+                }
+                if (d.cmp(curveOrder) < 0) {
+                    d = d.add(this.keyPair.secretKey).mod(curveOrder);
                     if (!d.isZero()) {
                         i++;
                     }
@@ -512,9 +612,7 @@
                 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);
         }
         /**
          *
@@ -534,23 +632,22 @@
          * @throws {@link InvalidKeyError}
          */
         bytes() {
-            if (!this.keyPair.priv) {
+            if (!this.keyPair.secretKey) {
                 throw new core.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);
@@ -586,76 +683,6 @@
         }
     }
 
-    /* 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.HMAC(sha512.SHA512, key).update(seed).digest();
-            return new PrivateKey(ed25519$1.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 core.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.HMAC(sha512.SHA512, this.chainCode).update(data).digest();
-            return new PrivateKey(ed25519$1.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
     /**
      *
@@ -670,16 +697,16 @@
         let node;
         switch (curve) {
             case 'ed25519': {
-                node = PrivateKey.fromSeed(seed).derivePath(path);
+                node = PrivateKey$1.fromSeed(seed).derivePath(path);
                 const sk = utils.b58Encode(node.seed().slice(0, 32), utils.PrefixV2.Ed25519Seed);
                 return sk;
             }
             case 'secp256k1':
             case 'p256': {
                 const prefixType = curve === 'secp256k1' ? utils.PrefixV2.Secp256k1SecretKey : utils.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 = utils.b58Encode(uint8arr, prefixType);
                 return sk;
             }
@@ -782,51 +809,6 @@
     }
     _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
@@ -1007,6 +989,12 @@
         }
     }
 
+    // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
+    const VERSION = {
+        "commitHash": "7912b77f57f943dff619383900bd46a7a593a244",
+        "version": "24.0.0-beta.0"
+    };
+
     exports.ECDSA = ecdsa;
     exports.Ed25519 = ed25519;
     exports.Hard = Hard;
@@ -1015,7 +1003,6 @@
     exports.Path = Path;
     exports.VERSION = VERSION;
     exports.generateSecretKey = generateSecretKey;
-    exports.importKey = importKey;
     exports.publicKeyFromString = publicKeyFromString;
 
 }));

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/derivation-tools/ecdsa.d.ts

@@ -1,20 +1,26 @@
-import { ec, curve } from 'elliptic';
-import { ExtendedPrivateKey } from './index';
+import { ExtendedPrivateKey } from './types';
 import BN from 'bn.js';
 export type CurveName = 'p256' | 'secp256k1';
-interface KeyPair extends ec.KeyPair {
-    priv: BN | null;
-    pub: curve.base.BasePoint | null;
-}
 export declare class PrivateKey implements ExtendedPrivateKey {
+    readonly priv: {
+        curve: CurveName;
+        secretKey: BN;
+    };
     readonly chainCode: Uint8Array;
-    readonly keyPair: KeyPair;
+    readonly keyPair: {
+        curve: CurveName;
+        secretKey: BN;
+        publicKey: Uint8Array;
+    };
     /**
      *
-     * @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: ec.KeyPair, chainCode: Uint8Array);
+    constructor(priv: {
+        curve: CurveName;
+        secretKey: BN;
+    }, chainCode: Uint8Array);
     /**
      * @param seedSrc result of Bip39.mnemonicToSeed
      * @param curve known supported curve p256 or secp256k1
@@ -41,4 +47,3 @@ export declare class PrivateKey implements ExtendedPrivateKey {
      */
     bytes(): Uint8Array;
 }
-export {};