@taquito/signer 23.0.0-beta.1 → 23.0.1

package/dist/taquito-signer.es6.js

@@ -1,14 +1,15 @@
 import { openSecretBox } from '@stablelib/nacl';
-import { b58DecodeAndCheckPrefix, PrefixV2, b58Encode, BLS12_381_DST, POP_DST, hex2buf, mergebuf, buf2hex } from '@taquito/utils';
+import { b58DecodeAndCheckPrefix, PrefixV2, b58Encode, compareArrays, InvalidPublicKeyError, BLS12_381_DST, POP_DST, hex2buf, mergebuf, buf2hex } from '@taquito/utils';
 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 pbkdf2 from 'pbkdf2';
 import * as Bip39 from 'bip39';
 import { HMAC } from '@stablelib/hmac';
 import { SHA512 } from '@stablelib/sha512';
-import { InvalidHexStringError, ParameterValidationError, UnsupportedActionError, InvalidKeyError, InvalidDerivationPathError, ProhibitedActionError } from '@taquito/core';
 import BN from 'bn.js';
 import { bls12_381 } from '@noble/curves/bls12-381';
 
@@ -57,7 +58,7 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
     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)
  */
@@ -70,8 +71,7 @@ class EdKey {
      * @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 = b58DecodeAndCheckPrefix(key, [
             PrefixV2.Ed25519SecretKey,
             PrefixV2.Ed25519EncryptedSeed,
@@ -80,8 +80,10 @@ class EdKey {
         let [keyData] = tmp;
         const [, prefix] = tmp;
         if (prefix === 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 === PrefixV2.Ed25519EncryptedSeed) {
@@ -92,9 +94,7 @@ class EdKey {
                     throw new Error('decryption function is not provided');
                 }
             }
-            const { publicKey, secretKey } = generateKeyPairFromSeed(keyData);
-            __classPrivateFieldSet(this, _EdKey_publicKey, publicKey, "f");
-            __classPrivateFieldSet(this, _EdKey_secretKey, secretKey, "f");
+            __classPrivateFieldSet(this, _EdKey_keyPair, generateKeyPairFromSeed(keyData), "f");
         }
     }
     /**
@@ -103,154 +103,64 @@ class EdKey {
      * @param bytesHash Blake2b hash of the bytes to sign
      */
     sign(bytes) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const hash$1 = hash(bytes, 32);
-            const signature = sign(__classPrivateFieldGet(this, _EdKey_secretKey, "f"), hash$1);
-            return Promise.resolve({
-                rawSignature: signature,
-                sig: b58Encode(signature, PrefixV2.GenericSignature),
-                prefixSig: b58Encode(signature, PrefixV2.Ed25519Signature),
-            });
-        });
+        const hash$1 = hash(bytes, 32);
+        const signature = sign(__classPrivateFieldGet(this, _EdKey_keyPair, "f").secretKey, hash$1);
+        return {
+            rawSignature: signature,
+            sig: b58Encode(signature, PrefixV2.GenericSignature),
+            prefixSig: b58Encode(signature, PrefixV2.Ed25519Signature),
+        };
     }
     /**
      * @returns Encoded public key
      */
     publicKey() {
-        return Promise.resolve(b58Encode(__classPrivateFieldGet(this, _EdKey_publicKey, "f"), PrefixV2.Ed25519PublicKey));
-    }
-    /**
-     * @returns Encoded public key hash
-     */
-    publicKeyHash() {
-        return Promise.resolve(b58Encode(hash(__classPrivateFieldGet(this, _EdKey_publicKey, "f"), 20), PrefixV2.Ed25519PublicKeyHash));
+        return new EdPublicKey(__classPrivateFieldGet(this, _EdKey_keyPair, "f").publicKey);
     }
     /**
      * @returns Encoded private key
      */
     secretKey() {
-        return Promise.resolve(b58Encode(__classPrivateFieldGet(this, _EdKey_secretKey, "f"), PrefixV2.Ed25519SecretKey));
+        return b58Encode(__classPrivateFieldGet(this, _EdKey_keyPair, "f").secretKey, PrefixV2.Ed25519SecretKey);
     }
 }
-_EdKey_secretKey = new WeakMap(), _EdKey_publicKey = new WeakMap();
-
-var _ECKey_key, _ECKey_publicKey, _ECKey_curve;
-const pref = {
-    p256: {
-        pk: PrefixV2.P256PublicKey,
-        sk: PrefixV2.P256SecretKey,
-        pkh: PrefixV2.P256PublicKeyHash,
-        sig: PrefixV2.P256Signature,
-    },
-    secp256k1: {
-        pk: PrefixV2.Secp256k1PublicKey,
-        sk: PrefixV2.Secp256k1SecretKey,
-        pkh: PrefixV2.Secp256k1PublicKeyHash,
-        sig: 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 = b58DecodeAndCheckPrefix(key, [
-            PrefixV2.Secp256k1EncryptedSecretKey,
-            PrefixV2.P256EncryptedSecretKey,
-            PrefixV2.Secp256k1SecretKey,
-            PrefixV2.P256SecretKey,
-        ]);
-        _a = this, [({ set value(_b) { __classPrivateFieldSet(_a, _ECKey_key, _b, "f"); } }).value] = tmp;
-        const [, prefix] = tmp;
-        switch (prefix) {
-            case PrefixV2.Secp256k1EncryptedSecretKey:
-            case 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 === PrefixV2.Secp256k1EncryptedSecretKey) {
-                    __classPrivateFieldSet(this, _ECKey_curve, 'secp256k1', "f");
-                }
-                else {
-                    __classPrivateFieldSet(this, _ECKey_curve, 'p256', "f");
-                }
-                break;
-            case 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, _] = b58DecodeAndCheckPrefix(src, [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$1 = hash(bytes, 32);
-        const key = new elliptic.ec(__classPrivateFieldGet(this, _ECKey_curve, "f")).keyFromPrivate(__classPrivateFieldGet(this, _ECKey_key, "f"));
-        const sig = key.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);
-        return Promise.resolve({
-            rawSignature: signature,
-            sig: b58Encode(signature, PrefixV2.GenericSignature),
-            prefixSig: b58Encode(signature, pref[__classPrivateFieldGet(this, _ECKey_curve, "f")].sig),
-        });
+    compare(other) {
+        if (other instanceof EdPublicKey) {
+            return compareArrays(this.bytes(), other.bytes());
+        }
+        else {
+            throw new InvalidPublicKeyError('EdDSA key expected');
+        }
     }
-    /**
-     * @returns Encoded public key
-     */
-    publicKey() {
-        return Promise.resolve(b58Encode(__classPrivateFieldGet(this, _ECKey_publicKey, "f"), pref[__classPrivateFieldGet(this, _ECKey_curve, "f")].pk));
+    hash() {
+        return b58Encode(hash(__classPrivateFieldGet(this, _EdPublicKey_key, "f"), 20), PrefixV2.Ed25519PublicKeyHash);
     }
-    /**
-     * @returns Encoded public key hash
-     */
-    publicKeyHash() {
-        return Promise.resolve(b58Encode(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(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 InvalidHexStringError(ss);
-        }
-        res.push(x);
+    toString() {
+        return b58Encode(__classPrivateFieldGet(this, _EdPublicKey_key, "f"), PrefixV2.Ed25519PublicKey);
     }
-    return new Uint8Array(res);
 }
+_EdPublicKey_key = new WeakMap();
 
 /**
  *  @category Error
@@ -321,6 +231,189 @@ class InvalidPassphraseError extends ParameterValidationError {
     }
 }
 
+const pref = {
+    p256: {
+        pk: PrefixV2.P256PublicKey,
+        sk: PrefixV2.P256SecretKey,
+        pkh: PrefixV2.P256PublicKeyHash,
+        sig: PrefixV2.P256Signature,
+        tag: 2,
+    },
+    secp256k1: {
+        pk: PrefixV2.Secp256k1PublicKey,
+        sk: PrefixV2.Secp256k1SecretKey,
+        pkh: PrefixV2.Secp256k1PublicKeyHash,
+        sig: 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] = b58DecodeAndCheckPrefix(key, [
+            PrefixV2.Secp256k1EncryptedSecretKey,
+            PrefixV2.P256EncryptedSecretKey,
+            PrefixV2.Secp256k1SecretKey,
+            PrefixV2.P256SecretKey,
+        ]);
+        const [decKey, curve] = (() => {
+            switch (prefix) {
+                case PrefixV2.Secp256k1EncryptedSecretKey:
+                case PrefixV2.P256EncryptedSecretKey:
+                    if (decrypt === undefined) {
+                        throw new Error('decryption function is not provided');
+                    }
+                    else {
+                        return [
+                            decrypt(keyData),
+                            prefix === PrefixV2.Secp256k1EncryptedSecretKey ? 'secp256k1' : 'p256',
+                        ];
+                    }
+                case 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$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);
+        return {
+            rawSignature: signature,
+            sig: b58Encode(signature, PrefixV2.GenericSignature),
+            prefixSig: 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 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] = 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);
+            }
+        })();
+        super(key);
+    }
+    compare(other) {
+        if (other instanceof ECPublicKey) {
+            if (this.curve() === other.curve()) {
+                const compress = this.curve() === 'secp256k1';
+                return compareArrays(this.bytes(compress), other.bytes(compress));
+            }
+            else if (this.curve() === 'secp256k1') {
+                return -1;
+            }
+            else {
+                return 1;
+            }
+        }
+        else {
+            throw new InvalidPublicKeyError('ECDSA key expected');
+        }
+    }
+    hash() {
+        const key = this.bytes();
+        return b58Encode(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 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 InvalidHexStringError(ss);
+        }
+        res.push(x);
+    }
+    return new Uint8Array(res);
+}
+
 /* eslint-disable @typescript-eslint/no-this-alias */
 const seedKey = {
     p256: 'Nist256p1 seed',
@@ -593,7 +686,7 @@ function isPOP(k) {
     return 'provePossession' in k;
 }
 
-var _BLSKey_key, _BLSKey_publicKey;
+var _BLSKey_key, _BLSKey_publicKey, _BLSPublicKey_key;
 const bls = bls12_381.longSignatures; // AKA MinPK
 class BLSKey {
     constructor(key, decrypt) {
@@ -622,11 +715,11 @@ class BLSKey {
     signDst(message, dst) {
         const point = bls.hash(message, dst);
         const sig = bls.sign(point, this.sk()).toBytes();
-        return Promise.resolve({
+        return {
             rawSignature: sig,
             sig: b58Encode(sig, PrefixV2.GenericSignature),
             prefixSig: b58Encode(sig, PrefixV2.BLS12_381Signature),
-        });
+        };
     }
     sign(message) {
         return this.signDst(message, BLS12_381_DST);
@@ -635,19 +728,49 @@ class BLSKey {
         return this.signDst(__classPrivateFieldGet(this, _BLSKey_publicKey, "f"), POP_DST);
     }
     publicKey() {
-        const res = b58Encode(__classPrivateFieldGet(this, _BLSKey_publicKey, "f"), PrefixV2.BLS12_381PublicKey);
-        return Promise.resolve(res);
-    }
-    publicKeyHash() {
-        const res = b58Encode(hash(__classPrivateFieldGet(this, _BLSKey_publicKey, "f"), 20), PrefixV2.BLS12_381PublicKeyHash);
-        return Promise.resolve(res);
+        return new BLSPublicKey(__classPrivateFieldGet(this, _BLSKey_publicKey, "f"));
     }
     secretKey() {
-        const res = b58Encode(__classPrivateFieldGet(this, _BLSKey_key, "f"), PrefixV2.BLS12_381SecretKey);
-        return Promise.resolve(res);
+        return b58Encode(__classPrivateFieldGet(this, _BLSKey_key, "f"), 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, _] = b58DecodeAndCheckPrefix(src, [PrefixV2.BLS12_381PublicKey]);
+            __classPrivateFieldSet(this, _BLSPublicKey_key, key, "f");
+        }
+        else {
+            __classPrivateFieldSet(this, _BLSPublicKey_key, src, "f");
+        }
+    }
+    compare(other) {
+        if (other instanceof BLSPublicKey) {
+            return compareArrays(this.bytes(), other.bytes());
+        }
+        else {
+            throw new InvalidPublicKeyError('BLS key expected');
+        }
+    }
+    hash() {
+        return b58Encode(hash(__classPrivateFieldGet(this, _BLSPublicKey_key, "f"), 20), 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 b58Encode(__classPrivateFieldGet(this, _BLSPublicKey_key, "f"), PrefixV2.BLS12_381PublicKey);
+    }
+}
+_BLSPublicKey_key = new WeakMap();
 
 /**
  *
@@ -690,8 +813,8 @@ function importKey(toolkit, privateKeyOrEmail, passphrase, mnemonic, secret) {
 
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT OR CHECKIN!
 const VERSION = {
-    "commitHash": "10b3de10de15ae68d47b1fca922d3129d2f79641",
-    "version": "23.0.0-beta.1"
+    "commitHash": "c26a3d67ae3694c157f4f56fb5bf85ca3c495a9b",
+    "version": "23.0.1"
 };
 
 var _InMemorySigner_key;
@@ -839,22 +962,40 @@ class InMemorySigner {
      * @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] = b58DecodeAndCheckPrefix(src, [
+        PrefixV2.Ed25519PublicKey,
+        PrefixV2.Secp256k1PublicKey,
+        PrefixV2.P256PublicKey,
+        PrefixV2.BLS12_381PublicKey,
+    ]);
+    switch (pre) {
+        case PrefixV2.Ed25519PublicKey:
+            return new EdPublicKey(keyData);
+        case PrefixV2.Secp256k1PublicKey:
+            return new ECPublicKey(keyData, 'secp256k1');
+        case PrefixV2.P256PublicKey:
+            return new ECPublicKey(keyData, 'p256');
+        case PrefixV2.BLS12_381PublicKey:
+            return new BLSPublicKey(keyData);
+    }
+}
 
-export { ecdsa as ECDSA, ed25519 as Ed25519, Hard, InMemorySigner, InvalidPassphraseError, Path, VERSION, generateSecretKey, importKey };
+export { ecdsa as ECDSA, ed25519 as Ed25519, Hard, InMemorySigner, InvalidPassphraseError, Path, VERSION, generateSecretKey, importKey, 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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}