@taquito/signer 24.2.0 → 24.3.0-beta.1

package/dist/lib/derivation-tools/ecdsa.js

@@ -43,7 +43,7 @@ class PrivateKey {
      * @param seedSrc result of Bip39.mnemonicToSeed
      * @param curve known supported curve p256 or secp256k1
      * @returns instance of PrivateKey non-HD keys derived
-     * @throws {@link InvalidBitSize} | {@link InvalidCurveError} | {@link InvalidSeedLengthError}
+     * @throws InvalidBitSize | InvalidCurveError | InvalidSeedLengthError
      */
     static fromSeed(seedSrc, curve) {
         let seed = typeof seedSrc === 'string' ? (0, utils_1.parseHex)(seedSrc) : seedSrc;
@@ -137,7 +137,7 @@ class PrivateKey {
     /**
      *
      * @returns Uint8Array (if contains a private key)
-     * @throws {@link InvalidKeyError}
+     * @throws InvalidKeyError
      */
     bytes() {
         if (!this.keyPair.secretKey) {

package/dist/lib/derivation-tools/ed25519.js

@@ -28,7 +28,7 @@ class PrivateKey {
      *
      * @param seedSrc result of Bip39.mnemonicToSeed
      * @returns instance of PrivateKey
-     * @throws {@link InvalidSeedLengthError}
+     * @throws InvalidSeedLengthError
      */
     static fromSeed(seedSrc) {
         const seed = typeof seedSrc === 'string' ? (0, utils_1.parseHex)(seedSrc) : seedSrc;
@@ -47,7 +47,7 @@ class PrivateKey {
         return this.priv.subarray(0, 32);
     }
     /**
-     * @index current derivation path item ie: 1729'
+     \* @remarks index: current derivation path item ie: 1729'
      * @returns derivation path child of original private key pair
      */
     derive(index) {

package/dist/lib/ec-key.js

@@ -35,14 +35,14 @@ const pref = {
     },
 };
 /**
- * @description Provide signing logic for elliptic curve based key (tz2, tz3)
+ * Provide signing logic for elliptic curve based key (tz2, tz3)
  */
 class ECKey {
     /**
      *
      * @param key Encoded private key
      * @param decrypt Decrypt function
-     * @throws {@link InvalidKeyError}
+     * @throws InvalidKeyError
      */
     constructor(key, decrypt) {
         _ECKey_keyPair.set(this, void 0);

package/dist/lib/ed-key.js

@@ -17,7 +17,7 @@ const blake2b_1 = require("@stablelib/blake2b");
 const ed25519_1 = require("@stablelib/ed25519");
 const utils_1 = require("@taquito/utils");
 /**
- * @description Provide signing logic for ed25519 curve based key (tz1)
+ * Provide signing logic for ed25519 curve based key (tz1)
  */
 class EdKey {
     /**
@@ -25,7 +25,7 @@ class EdKey {
      * @param key Encoded private key
      * @param encrypted Is the private key encrypted
      * @param decrypt Decrypt function
-     * @throws {@link InvalidKeyError}
+     * @throws InvalidKeyError
      */
     constructor(key, decrypt) {
         _EdKey_keyPair.set(this, void 0);

package/dist/lib/errors.js

@@ -4,20 +4,19 @@ exports.InvalidPassphraseError = exports.ToBeImplemented = exports.InvalidSeedLe
 const core_1 = require("@taquito/core");
 /**
  *  @category Error
- *  @description Error that indicates an invalid Mnemonic being passed or used
+ *  Error that indicates an invalid Mnemonic being passed or used
  */
 class InvalidMnemonicError extends core_1.ParameterValidationError {
-    constructor(mnemonic) {
+    constructor(_mnemonic) {
         super();
-        this.mnemonic = mnemonic;
         this.name = 'InvalidMnemonicError';
-        this.message = `Invalid mnemonic "${mnemonic}"`;
+        this.message = 'Invalid mnemonic';
     }
 }
 exports.InvalidMnemonicError = InvalidMnemonicError;
 /**
  *  @category Error
- *  @description Error that indicates a curve with incorrect bit size being passed or used
+ *  Error that indicates a curve with incorrect bit size being passed or used
  */
 class InvalidBitSize extends core_1.ParameterValidationError {
     constructor(message) {
@@ -29,7 +28,7 @@ class InvalidBitSize extends core_1.ParameterValidationError {
 exports.InvalidBitSize = InvalidBitSize;
 /**
  *  @category Error
- *  @description Error that indicates an unsupported cureve being passed or used
+ *  Error that indicates an unsupported cureve being passed or used
  */
 class InvalidCurveError extends core_1.ParameterValidationError {
     constructor(message) {
@@ -41,7 +40,7 @@ class InvalidCurveError extends core_1.ParameterValidationError {
 exports.InvalidCurveError = InvalidCurveError;
 /**
  *  @category Error
- *  @description Error that indicates a seed with invalid length being passed or used
+ *  Error that indicates a seed with invalid length being passed or used
  */
 class InvalidSeedLengthError extends core_1.ParameterValidationError {
     constructor(seedLength) {
@@ -54,7 +53,7 @@ class InvalidSeedLengthError extends core_1.ParameterValidationError {
 exports.InvalidSeedLengthError = InvalidSeedLengthError;
 /**
  *  @category Error
- *  @description Error that indicates a feature still under developement
+ *  Error that indicates a feature still under developement
  */
 class ToBeImplemented extends core_1.UnsupportedActionError {
     constructor() {
@@ -66,7 +65,7 @@ class ToBeImplemented extends core_1.UnsupportedActionError {
 exports.ToBeImplemented = ToBeImplemented;
 /**
  *  @category Error
- *  @description Error that indicates an invalid passphrase being passed or used
+ *  Error that indicates an invalid passphrase being passed or used
  */
 class InvalidPassphraseError extends core_1.ParameterValidationError {
     constructor(message) {

package/dist/lib/helpers.js

@@ -13,7 +13,7 @@ const errors_1 = require("./errors");
  * @param derivationPath Tezos Requirement 44'/1729' for HD key address default 44'/1729'/0'/0'
  * @param curve 'ed25519' | 'secp256k1' | 'p256''
  * @returns final Derivation of HD keys tezos Secret key
- * @throws {@link InvalidCurveError} | {@link ToBeImplemented}
+ * @throws InvalidCurveError | ToBeImplemented
  */
 const generateSecretKey = (seed, derivationPath, curve) => {
     const path = derivation_tools_1.Path.fromString(derivationPath);

package/dist/lib/in-memory-signer.js

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
@@ -36,40 +27,33 @@ const core_1 = require("@taquito/core");
 const key_interface_1 = require("./key-interface");
 const bls_key_1 = require("./bls-key");
 /**
- * @description A local implementation of the signer. Will represent a Tezos account and be able to produce signature in its behalf
+ * A local implementation of the signer. Will represent a Tezos account and be able to produce signature in its behalf
  *
- * @warn If running in production and dealing with tokens that have real value, it is strongly recommended to use a HSM backed signer so that private key material is not stored in memory or on disk
- * @throws {@link InvalidMnemonicError}
+ * @remarks If running in production and dealing with tokens that have real value, it is strongly recommended to use a HSM backed signer so that private key material is not stored in memory or on disk
+ * @throws InvalidMnemonicError
  */
 class InMemorySigner {
     static fromFundraiser(email, password, mnemonic) {
         if (!Bip39.validateMnemonic(mnemonic)) {
-            throw new errors_1.InvalidMnemonicError(mnemonic);
+            throw new errors_1.InvalidMnemonicError();
         }
         const seed = Bip39.mnemonicToSeedSync(mnemonic, `${email}${password}`);
         const key = (0, utils_1.b58Encode)(seed.subarray(0, 32), utils_1.PrefixV2.Ed25519Seed);
         return new InMemorySigner(key);
     }
-    static fromSecretKey(key, passphrase) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new InMemorySigner(key, passphrase);
-        });
+    static async fromSecretKey(key, passphrase) {
+        return new InMemorySigner(key, passphrase);
     }
     /**
      *
-     * @description Instantiation of an InMemorySigner instance from a mnemonic
-     * @param mnemonic 12-24 word mnemonic
-     * @param password password used to encrypt the mnemonic to seed value
-     * @param derivationPath default 44'/1729'/0'/0' (44'/1729' mandatory)
-     * @param curve currently only supported for tz1, tz2, tz3 addresses. soon bip25519
+     * Instantiation of an InMemorySigner instance from a mnemonic
      * @returns InMemorySigner
-     * @throws {@link InvalidMnemonicError}
+     * @throws InvalidMnemonicError
      */
     static fromMnemonic({ mnemonic, password = '', derivationPath = "44'/1729'/0'/0'", curve = 'ed25519', }) {
         // check if curve is defined if not default tz1
         if (!Bip39.validateMnemonic(mnemonic)) {
-            // avoiding exposing mnemonic again in case of mistake making invalid
-            throw new errors_1.InvalidMnemonicError(mnemonic);
+            throw new errors_1.InvalidMnemonicError();
         }
         const seed = Bip39.mnemonicToSeedSync(mnemonic, password);
         const sk = (0, helpers_1.generateSecretKey)(seed, derivationPath, curve);
@@ -79,7 +63,7 @@ class InMemorySigner {
      *
      * @param key Encoded private key
      * @param passphrase Passphrase to decrypt the private key if it is encrypted
-     * @throws {@link InvalidKeyError}
+     * @throws InvalidKeyError
      *
      */
     constructor(key, passphrase) {
@@ -100,7 +84,7 @@ class InMemorySigner {
                 const [, pre] = (0, utils_1.b58DecodeAndCheckPrefix)(key, keyPrefixes);
                 return pre;
             }
-            catch (_a) {
+            catch {
                 throw new core_1.InvalidKeyError(`Invalid private key, expecting one of the following prefixes '${keyPrefixes}'.`);
             }
         })();
@@ -149,33 +133,29 @@ class InMemorySigner {
     }
     /**
      *
-     * @param bytes Bytes to sign
+     * @param message Bytes to sign
      * @param watermark Watermark to append to the bytes
      */
-    sign(message, watermark) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const msg = typeof message == 'string' ? (0, utils_1.hex2buf)(message) : message;
-            const watermarkMsg = watermark !== undefined ? (0, utils_1.mergebuf)(watermark, msg) : msg;
-            const { rawSignature, sig: signature, prefixSig: prefixedSignature, } = yield __classPrivateFieldGet(this, _InMemorySigner_key, "f").sign(watermarkMsg);
-            return {
-                bytes: (0, utils_1.buf2hex)(msg),
-                sig: signature,
-                prefixSig: prefixedSignature,
-                sbytes: (0, utils_1.buf2hex)((0, utils_1.mergebuf)(msg, 
-                // bls only Signature_prefix ff03 ref:https://octez.tezos.com/docs/shell/p2p_api.html#signature-prefix-tag-255 & https://octez.tezos.com/docs/shell/p2p_api.html#bls-prefix-tag-3
-                (0, key_interface_1.isPOP)(__classPrivateFieldGet(this, _InMemorySigner_key, "f")) ? (0, utils_1.mergebuf)(new Uint8Array([255, 3]), rawSignature) : rawSignature)),
-            };
-        });
+    async sign(message, watermark) {
+        const msg = typeof message == 'string' ? (0, utils_1.hex2buf)(message) : message;
+        const watermarkMsg = watermark !== undefined ? (0, utils_1.mergebuf)(watermark, msg) : msg;
+        const { rawSignature, sig: signature, prefixSig: prefixedSignature, } = await __classPrivateFieldGet(this, _InMemorySigner_key, "f").sign(watermarkMsg);
+        return {
+            bytes: (0, utils_1.buf2hex)(msg),
+            sig: signature,
+            prefixSig: prefixedSignature,
+            sbytes: (0, utils_1.buf2hex)((0, utils_1.mergebuf)(msg, 
+            // bls only Signature_prefix ff03 ref:https://octez.tezos.com/docs/shell/p2p_api.html#signature-prefix-tag-255 & https://octez.tezos.com/docs/shell/p2p_api.html#bls-prefix-tag-3
+            (0, key_interface_1.isPOP)(__classPrivateFieldGet(this, _InMemorySigner_key, "f")) ? (0, utils_1.mergebuf)(new Uint8Array([255, 3]), rawSignature) : rawSignature)),
+        };
     }
-    provePossession() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if ((0, key_interface_1.isPOP)(__classPrivateFieldGet(this, _InMemorySigner_key, "f"))) {
-                return __classPrivateFieldGet(this, _InMemorySigner_key, "f").provePossession();
-            }
-            else {
-                throw new core_1.ProhibitedActionError('Only BLS keys can prove possession');
-            }
-        });
+    async provePossession() {
+        if ((0, key_interface_1.isPOP)(__classPrivateFieldGet(this, _InMemorySigner_key, "f"))) {
+            return __classPrivateFieldGet(this, _InMemorySigner_key, "f").provePossession();
+        }
+        else {
+            throw new core_1.ProhibitedActionError('Only BLS keys can prove possession');
+        }
     }
     get canProvePossession() {
         return (0, key_interface_1.isPOP)(__classPrivateFieldGet(this, _InMemorySigner_key, "f"));

package/dist/lib/version.js

@@ -3,6 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT!
 exports.VERSION = {
-    "commitHash": "105a7b15cfb862a0732c204e0e9741098d697775",
-    "version": "24.2.0"
+    "commitHash": "05df48fee92f846cba793920d6fa829afd6a1847",
+    "version": "24.3.0-beta.1"
 };

package/dist/taquito-signer.es6.js

@@ -31,16 +31,6 @@ PERFORMANCE OF THIS SOFTWARE.
 /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
 
 
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
 function __classPrivateFieldGet(receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
@@ -61,7 +51,7 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 
 var _EdKey_keyPair, _EdPublicKey_key;
 /**
- * @description Provide signing logic for ed25519 curve based key (tz1)
+ * Provide signing logic for ed25519 curve based key (tz1)
  */
 class EdKey {
     /**
@@ -69,7 +59,7 @@ class EdKey {
      * @param key Encoded private key
      * @param encrypted Is the private key encrypted
      * @param decrypt Decrypt function
-     * @throws {@link InvalidKeyError}
+     * @throws InvalidKeyError
      */
     constructor(key, decrypt) {
         _EdKey_keyPair.set(this, void 0);
@@ -165,19 +155,18 @@ _EdPublicKey_key = new WeakMap();
 
 /**
  *  @category Error
- *  @description Error that indicates an invalid Mnemonic being passed or used
+ *  Error that indicates an invalid Mnemonic being passed or used
  */
 class InvalidMnemonicError extends ParameterValidationError {
-    constructor(mnemonic) {
+    constructor(_mnemonic) {
         super();
-        this.mnemonic = mnemonic;
         this.name = 'InvalidMnemonicError';
-        this.message = `Invalid mnemonic "${mnemonic}"`;
+        this.message = 'Invalid mnemonic';
     }
 }
 /**
  *  @category Error
- *  @description Error that indicates a curve with incorrect bit size being passed or used
+ *  Error that indicates a curve with incorrect bit size being passed or used
  */
 class InvalidBitSize extends ParameterValidationError {
     constructor(message) {
@@ -188,7 +177,7 @@ class InvalidBitSize extends ParameterValidationError {
 }
 /**
  *  @category Error
- *  @description Error that indicates an unsupported cureve being passed or used
+ *  Error that indicates an unsupported cureve being passed or used
  */
 class InvalidCurveError extends ParameterValidationError {
     constructor(message) {
@@ -199,7 +188,7 @@ class InvalidCurveError extends ParameterValidationError {
 }
 /**
  *  @category Error
- *  @description Error that indicates a seed with invalid length being passed or used
+ *  Error that indicates a seed with invalid length being passed or used
  */
 class InvalidSeedLengthError extends ParameterValidationError {
     constructor(seedLength) {
@@ -211,7 +200,7 @@ class InvalidSeedLengthError extends ParameterValidationError {
 }
 /**
  *  @category Error
- *  @description Error that indicates a feature still under developement
+ *  Error that indicates a feature still under developement
  */
 class ToBeImplemented extends UnsupportedActionError {
     constructor() {
@@ -222,7 +211,7 @@ class ToBeImplemented extends UnsupportedActionError {
 }
 /**
  *  @category Error
- *  @description Error that indicates an invalid passphrase being passed or used
+ *  Error that indicates an invalid passphrase being passed or used
  */
 class InvalidPassphraseError extends ParameterValidationError {
     constructor(message) {
@@ -250,14 +239,14 @@ const pref = {
     },
 };
 /**
- * @description Provide signing logic for elliptic curve based key (tz2, tz3)
+ * Provide signing logic for elliptic curve based key (tz2, tz3)
  */
 class ECKey {
     /**
      *
      * @param key Encoded private key
      * @param decrypt Decrypt function
-     * @throws {@link InvalidKeyError}
+     * @throws InvalidKeyError
      */
     constructor(key, decrypt) {
         _ECKey_keyPair.set(this, void 0);
@@ -443,7 +432,7 @@ let PrivateKey$1 = class PrivateKey {
      *
      * @param seedSrc result of Bip39.mnemonicToSeed
      * @returns instance of PrivateKey
-     * @throws {@link InvalidSeedLengthError}
+     * @throws InvalidSeedLengthError
      */
     static fromSeed(seedSrc) {
         const seed = typeof seedSrc === 'string' ? parseHex(seedSrc) : seedSrc;
@@ -462,7 +451,7 @@ let PrivateKey$1 = class PrivateKey {
         return this.priv.subarray(0, 32);
     }
     /**
-     * @index current derivation path item ie: 1729'
+     \* @remarks index: current derivation path item ie: 1729'
      * @returns derivation path child of original private key pair
      */
     derive(index) {
@@ -526,7 +515,7 @@ class PrivateKey {
      * @param seedSrc result of Bip39.mnemonicToSeed
      * @param curve known supported curve p256 or secp256k1
      * @returns instance of PrivateKey non-HD keys derived
-     * @throws {@link InvalidBitSize} | {@link InvalidCurveError} | {@link InvalidSeedLengthError}
+     * @throws InvalidBitSize | InvalidCurveError | InvalidSeedLengthError
      */
     static fromSeed(seedSrc, curve) {
         let seed = typeof seedSrc === 'string' ? parseHex(seedSrc) : seedSrc;
@@ -620,7 +609,7 @@ class PrivateKey {
     /**
      *
      * @returns Uint8Array (if contains a private key)
-     * @throws {@link InvalidKeyError}
+     * @throws InvalidKeyError
      */
     bytes() {
         if (!this.keyPair.secretKey) {
@@ -681,7 +670,7 @@ class Path extends Array {
  * @param derivationPath Tezos Requirement 44'/1729' for HD key address default 44'/1729'/0'/0'
  * @param curve 'ed25519' | 'secp256k1' | 'p256''
  * @returns final Derivation of HD keys tezos Secret key
- * @throws {@link InvalidCurveError} | {@link ToBeImplemented}
+ * @throws InvalidCurveError | ToBeImplemented
  */
 const generateSecretKey = (seed, derivationPath, curve) => {
     const path = Path.fromString(derivationPath);
@@ -802,40 +791,33 @@ _BLSPublicKey_key = new WeakMap();
 
 var _InMemorySigner_key;
 /**
- * @description A local implementation of the signer. Will represent a Tezos account and be able to produce signature in its behalf
+ * A local implementation of the signer. Will represent a Tezos account and be able to produce signature in its behalf
  *
- * @warn If running in production and dealing with tokens that have real value, it is strongly recommended to use a HSM backed signer so that private key material is not stored in memory or on disk
- * @throws {@link InvalidMnemonicError}
+ * @remarks If running in production and dealing with tokens that have real value, it is strongly recommended to use a HSM backed signer so that private key material is not stored in memory or on disk
+ * @throws InvalidMnemonicError
  */
 class InMemorySigner {
     static fromFundraiser(email, password, mnemonic) {
         if (!Bip39.validateMnemonic(mnemonic)) {
-            throw new InvalidMnemonicError(mnemonic);
+            throw new InvalidMnemonicError();
         }
         const seed = Bip39.mnemonicToSeedSync(mnemonic, `${email}${password}`);
         const key = b58Encode(seed.subarray(0, 32), PrefixV2.Ed25519Seed);
         return new InMemorySigner(key);
     }
-    static fromSecretKey(key, passphrase) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new InMemorySigner(key, passphrase);
-        });
+    static async fromSecretKey(key, passphrase) {
+        return new InMemorySigner(key, passphrase);
     }
     /**
      *
-     * @description Instantiation of an InMemorySigner instance from a mnemonic
-     * @param mnemonic 12-24 word mnemonic
-     * @param password password used to encrypt the mnemonic to seed value
-     * @param derivationPath default 44'/1729'/0'/0' (44'/1729' mandatory)
-     * @param curve currently only supported for tz1, tz2, tz3 addresses. soon bip25519
+     * Instantiation of an InMemorySigner instance from a mnemonic
      * @returns InMemorySigner
-     * @throws {@link InvalidMnemonicError}
+     * @throws InvalidMnemonicError
      */
     static fromMnemonic({ mnemonic, password = '', derivationPath = "44'/1729'/0'/0'", curve = 'ed25519', }) {
         // check if curve is defined if not default tz1
         if (!Bip39.validateMnemonic(mnemonic)) {
-            // avoiding exposing mnemonic again in case of mistake making invalid
-            throw new InvalidMnemonicError(mnemonic);
+            throw new InvalidMnemonicError();
         }
         const seed = Bip39.mnemonicToSeedSync(mnemonic, password);
         const sk = generateSecretKey(seed, derivationPath, curve);
@@ -845,7 +827,7 @@ class InMemorySigner {
      *
      * @param key Encoded private key
      * @param passphrase Passphrase to decrypt the private key if it is encrypted
-     * @throws {@link InvalidKeyError}
+     * @throws InvalidKeyError
      *
      */
     constructor(key, passphrase) {
@@ -866,7 +848,7 @@ class InMemorySigner {
                 const [, pre] = b58DecodeAndCheckPrefix(key, keyPrefixes);
                 return pre;
             }
-            catch (_a) {
+            catch {
                 throw new InvalidKeyError(`Invalid private key, expecting one of the following prefixes '${keyPrefixes}'.`);
             }
         })();
@@ -915,33 +897,29 @@ class InMemorySigner {
     }
     /**
      *
-     * @param bytes Bytes to sign
+     * @param message Bytes to sign
      * @param watermark Watermark to append to the bytes
      */
-    sign(message, watermark) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const msg = typeof message == 'string' ? hex2buf(message) : message;
-            const watermarkMsg = watermark !== undefined ? mergebuf(watermark, msg) : msg;
-            const { rawSignature, sig: signature, prefixSig: prefixedSignature, } = yield __classPrivateFieldGet(this, _InMemorySigner_key, "f").sign(watermarkMsg);
-            return {
-                bytes: buf2hex(msg),
-                sig: signature,
-                prefixSig: prefixedSignature,
-                sbytes: buf2hex(mergebuf(msg, 
-                // bls only Signature_prefix ff03 ref:https://octez.tezos.com/docs/shell/p2p_api.html#signature-prefix-tag-255 & https://octez.tezos.com/docs/shell/p2p_api.html#bls-prefix-tag-3
-                isPOP(__classPrivateFieldGet(this, _InMemorySigner_key, "f")) ? mergebuf(new Uint8Array([255, 3]), rawSignature) : rawSignature)),
-            };
-        });
+    async sign(message, watermark) {
+        const msg = typeof message == 'string' ? hex2buf(message) : message;
+        const watermarkMsg = watermark !== undefined ? mergebuf(watermark, msg) : msg;
+        const { rawSignature, sig: signature, prefixSig: prefixedSignature, } = await __classPrivateFieldGet(this, _InMemorySigner_key, "f").sign(watermarkMsg);
+        return {
+            bytes: buf2hex(msg),
+            sig: signature,
+            prefixSig: prefixedSignature,
+            sbytes: buf2hex(mergebuf(msg, 
+            // bls only Signature_prefix ff03 ref:https://octez.tezos.com/docs/shell/p2p_api.html#signature-prefix-tag-255 & https://octez.tezos.com/docs/shell/p2p_api.html#bls-prefix-tag-3
+            isPOP(__classPrivateFieldGet(this, _InMemorySigner_key, "f")) ? mergebuf(new Uint8Array([255, 3]), rawSignature) : rawSignature)),
+        };
     }
-    provePossession() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (isPOP(__classPrivateFieldGet(this, _InMemorySigner_key, "f"))) {
-                return __classPrivateFieldGet(this, _InMemorySigner_key, "f").provePossession();
-            }
-            else {
-                throw new ProhibitedActionError('Only BLS keys can prove possession');
-            }
-        });
+    async provePossession() {
+        if (isPOP(__classPrivateFieldGet(this, _InMemorySigner_key, "f"))) {
+            return __classPrivateFieldGet(this, _InMemorySigner_key, "f").provePossession();
+        }
+        else {
+            throw new ProhibitedActionError('Only BLS keys can prove possession');
+        }
     }
     get canProvePossession() {
         return isPOP(__classPrivateFieldGet(this, _InMemorySigner_key, "f"));
@@ -987,8 +965,8 @@ function publicKeyFromString(src) {
 
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT!
 const VERSION = {
-    "commitHash": "105a7b15cfb862a0732c204e0e9741098d697775",
-    "version": "24.2.0"
+    "commitHash": "05df48fee92f846cba793920d6fa829afd6a1847",
+    "version": "24.3.0-beta.1"
 };
 
 export { ecdsa as ECDSA, ed25519 as Ed25519, Hard, InMemorySigner, InvalidPassphraseError, Path, VERSION, generateSecretKey, publicKeyFromString };

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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}