@taquito/ledger-signer 24.2.0 → 24.3.0-beta.1

package/dist/lib/errors.js

@@ -4,7 +4,7 @@ exports.InvalidDerivationTypeError = exports.PublicKeyHashRetrievalError = expor
 const core_1 = require("@taquito/core");
 /**
  *  @category Error
- *  @description Error that indicates an invalid or unparseable ledger response
+ *  Error that indicates an invalid or unparseable ledger response
  */
 class InvalidLedgerResponseError extends core_1.TaquitoError {
     constructor(message) {
@@ -16,7 +16,7 @@ class InvalidLedgerResponseError extends core_1.TaquitoError {
 exports.InvalidLedgerResponseError = InvalidLedgerResponseError;
 /**
  *  @category Error
- *  @description Error that indicates a failure when trying to retrieve a Public Key from Ledger signer
+ *  Error that indicates a failure when trying to retrieve a Public Key from Ledger signer
  */
 class PublicKeyRetrievalError extends core_1.TaquitoError {
     constructor(cause) {
@@ -29,7 +29,7 @@ class PublicKeyRetrievalError extends core_1.TaquitoError {
 exports.PublicKeyRetrievalError = PublicKeyRetrievalError;
 /**
  *  @category Error
- *  @description Error that indicates a failure when trying to retrieve a Public Key Hash from Ledger signer
+ *  Error that indicates a failure when trying to retrieve a Public Key Hash from Ledger signer
  */
 class PublicKeyHashRetrievalError extends core_1.TaquitoError {
     constructor() {
@@ -41,7 +41,7 @@ class PublicKeyHashRetrievalError extends core_1.TaquitoError {
 exports.PublicKeyHashRetrievalError = PublicKeyHashRetrievalError;
 /**
  *  @category Error
- *  @description Error that indicates an invalid derivation type being passed or used
+ *  Error that indicates an invalid derivation type being passed or used
  */
 class InvalidDerivationTypeError extends core_1.ParameterValidationError {
     constructor(derivationType) {

package/dist/lib/taquito-ledger-signer.js

@@ -3,15 +3,6 @@
  * @packageDocumentation
  * @module @taquito/ledger-signer
  */
-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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LedgerSigner = exports.VERSION = exports.HDPathTemplate = exports.InvalidDerivationTypeError = exports.DerivationType = exports.InvalidDerivationPathError = void 0;
 const utils_1 = require("@taquito/utils");
@@ -38,7 +29,7 @@ var version_1 = require("./version");
 Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return version_1.VERSION; } });
 /**
  *
- * @description Implementation of the Signer interface that will allow signing operation from a Ledger Nano device
+ * Implementation of the Signer interface that will allow signing operation from a Ledger Nano device
  *
  * @param transport A transport instance from LedgerJS libraries depending on the platform used (e.g. Web, Node)
  * @param path The ledger derivation path (default is "44'/1729'/0'/0'")
@@ -88,96 +79,84 @@ class LedgerSigner {
             throw new errors_1.InvalidDerivationTypeError(derivationType.toString());
         }
     }
-    publicKeyHash() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this._publicKeyHash) {
-                yield this.publicKey();
-            }
-            if (this._publicKeyHash) {
-                return this._publicKeyHash;
-            }
-            throw new errors_1.PublicKeyHashRetrievalError();
-        });
+    async publicKeyHash() {
+        if (!this._publicKeyHash) {
+            await this.publicKey();
+        }
+        if (this._publicKeyHash) {
+            return this._publicKeyHash;
+        }
+        throw new errors_1.PublicKeyHashRetrievalError();
     }
-    publicKey() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._publicKey) {
-                return this._publicKey;
-            }
-            const responseLedger = yield this.getLedgerPublicKey();
-            const publicKeyLength = responseLedger[0];
-            const rawPublicKey = responseLedger.slice(1, 1 + publicKeyLength);
-            const compressedPublicKey = (0, utils_2.compressPublicKey)(rawPublicKey, this.derivationType);
-            const prefixes = this.getPrefixes();
-            const publicKey = (0, utils_1.b58Encode)(compressedPublicKey, prefixes.prefPk);
-            const publicKeyHash = (0, utils_1.b58Encode)((0, blake2b_1.hash)(compressedPublicKey, 20), prefixes.prefPkh);
-            this._publicKey = publicKey;
-            this._publicKeyHash = publicKeyHash;
-            return publicKey;
-        });
+    async publicKey() {
+        if (this._publicKey) {
+            return this._publicKey;
+        }
+        const responseLedger = await this.getLedgerPublicKey();
+        const publicKeyLength = responseLedger[0];
+        const rawPublicKey = responseLedger.slice(1, 1 + publicKeyLength);
+        const compressedPublicKey = (0, utils_2.compressPublicKey)(rawPublicKey, this.derivationType);
+        const prefixes = this.getPrefixes();
+        const publicKey = (0, utils_1.b58Encode)(compressedPublicKey, prefixes.prefPk);
+        const publicKeyHash = (0, utils_1.b58Encode)((0, blake2b_1.hash)(compressedPublicKey, 20), prefixes.prefPkh);
+        this._publicKey = publicKey;
+        this._publicKeyHash = publicKeyHash;
+        return publicKey;
     }
-    getLedgerPublicKey() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                let ins = this.INS_PROMPT_PUBLIC_KEY;
-                if (this.prompt === false) {
-                    ins = this.INS_GET_PUBLIC_KEY;
-                }
-                const responseLedger = yield this.transport.send(this.CLA, ins, this.FIRST_MESSAGE_SEQUENCE, this.derivationType, (0, utils_2.transformPathToBuffer)(this.path));
-                return responseLedger;
-            }
-            catch (error) {
-                throw new errors_1.PublicKeyRetrievalError(error);
+    async getLedgerPublicKey() {
+        try {
+            let ins = this.INS_PROMPT_PUBLIC_KEY;
+            if (this.prompt === false) {
+                ins = this.INS_GET_PUBLIC_KEY;
             }
-        });
+            const responseLedger = await this.transport.send(this.CLA, ins, this.FIRST_MESSAGE_SEQUENCE, this.derivationType, (0, utils_2.transformPathToBuffer)(this.path));
+            return responseLedger;
+        }
+        catch (error) {
+            throw new errors_1.PublicKeyRetrievalError(error);
+        }
     }
-    secretKey() {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new core_1.ProhibitedActionError('Secret key cannot be exposed');
-        });
+    async secretKey() {
+        throw new core_1.ProhibitedActionError('Secret key cannot be exposed');
     }
-    sign(bytes, watermark) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const watermarkedBytes = (0, utils_2.appendWatermark)(bytes, watermark);
-            const watermarkedBytes2buff = Buffer.from(watermarkedBytes, 'hex');
-            let messageToSend = [];
-            messageToSend.push((0, utils_2.transformPathToBuffer)(this.path));
-            messageToSend = (0, utils_2.chunkOperation)(messageToSend, watermarkedBytes2buff);
-            const ledgerResponse = yield this.signWithLedger(messageToSend);
-            let signature;
-            if (this.derivationType === DerivationType.ED25519 ||
-                this.derivationType === DerivationType.BIP32_ED25519) {
-                signature = ledgerResponse.slice(0, ledgerResponse.length - 2).toString('hex');
-            }
-            else {
-                if (!(0, utils_2.validateResponse)(ledgerResponse)) {
-                    throw new errors_1.InvalidLedgerResponseError('Invalid signature return by ledger unable to parse the response');
-                }
-                const idxLengthRVal = 3; // Third element of response is length of r value
-                const rValue = (0, utils_2.extractValue)(idxLengthRVal, ledgerResponse);
-                const idxLengthSVal = rValue.idxValueStart + rValue.length + 1;
-                const sValue = (0, utils_2.extractValue)(idxLengthSVal, ledgerResponse);
-                const signatureBuffer = Buffer.concat([rValue.buffer, sValue.buffer]);
-                signature = signatureBuffer.toString('hex');
+    async sign(bytes, watermark) {
+        const watermarkedBytes = (0, utils_2.appendWatermark)(bytes, watermark);
+        const watermarkedBytes2buff = Buffer.from(watermarkedBytes, 'hex');
+        let messageToSend = [];
+        messageToSend.push((0, utils_2.transformPathToBuffer)(this.path));
+        messageToSend = (0, utils_2.chunkOperation)(messageToSend, watermarkedBytes2buff);
+        const ledgerResponse = await this.signWithLedger(messageToSend);
+        let signature;
+        if (this.derivationType === DerivationType.ED25519 ||
+            this.derivationType === DerivationType.BIP32_ED25519) {
+            signature = ledgerResponse.slice(0, ledgerResponse.length - 2).toString('hex');
+        }
+        else {
+            if (!(0, utils_2.validateResponse)(ledgerResponse)) {
+                throw new errors_1.InvalidLedgerResponseError('Invalid signature return by ledger unable to parse the response');
             }
-            return {
-                bytes,
-                sig: (0, utils_1.b58Encode)(signature, utils_1.PrefixV2.GenericSignature),
-                prefixSig: (0, utils_1.b58Encode)(signature, this.getPrefixes().prefSig),
-                sbytes: bytes + signature,
-            };
-        });
+            const idxLengthRVal = 3; // Third element of response is length of r value
+            const rValue = (0, utils_2.extractValue)(idxLengthRVal, ledgerResponse);
+            const idxLengthSVal = rValue.idxValueStart + rValue.length + 1;
+            const sValue = (0, utils_2.extractValue)(idxLengthSVal, ledgerResponse);
+            const signatureBuffer = Buffer.concat([rValue.buffer, sValue.buffer]);
+            signature = signatureBuffer.toString('hex');
+        }
+        return {
+            bytes,
+            sig: (0, utils_1.b58Encode)(signature, utils_1.PrefixV2.GenericSignature),
+            prefixSig: (0, utils_1.b58Encode)(signature, this.getPrefixes().prefSig),
+            sbytes: bytes + signature,
+        };
     }
-    signWithLedger(message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // first element of the message represents the path
-            let ledgerResponse = yield this.transport.send(this.CLA, this.INS_SIGN, this.FIRST_MESSAGE_SEQUENCE, this.derivationType, message[0]);
-            for (let i = 1; i < message.length; i++) {
-                const p1 = i === message.length - 1 ? this.LAST_MESSAGE_SEQUENCE : this.OTHER_MESSAGE_SEQUENCE;
-                ledgerResponse = yield this.transport.send(this.CLA, this.INS_SIGN, p1, this.derivationType, message[i]);
-            }
-            return ledgerResponse;
-        });
+    async signWithLedger(message) {
+        // first element of the message represents the path
+        let ledgerResponse = await this.transport.send(this.CLA, this.INS_SIGN, this.FIRST_MESSAGE_SEQUENCE, this.derivationType, message[0]);
+        for (let i = 1; i < message.length; i++) {
+            const p1 = i === message.length - 1 ? this.LAST_MESSAGE_SEQUENCE : this.OTHER_MESSAGE_SEQUENCE;
+            ledgerResponse = await this.transport.send(this.CLA, this.INS_SIGN, p1, this.derivationType, message[i]);
+        }
+        return ledgerResponse;
     }
     getPrefixes() {
         if (this.derivationType === DerivationType.ED25519 ||

package/dist/lib/utils.js

@@ -13,7 +13,7 @@ exports.extractValue = extractValue;
 const MAX_CHUNK_SIZE = 230;
 /**
  *
- * @description Convert the path to a buffer that will be used as LC and CDATA in the APDU send to the ledger device (https://github.com/obsidiansystems/ledger-app-tezos/blob/master/APDUs.md)
+ * Convert the path to a buffer that will be used as LC and CDATA in the APDU send to the ledger device (https://github.com/obsidiansystems/ledger-app-tezos/blob/master/APDUs.md)
  *
  * @param path The ledger derivation path (default is "44'/1729'/0'/0'")
  * @returns A buffer where the first element is the length of the path (default is 4), then 3 bytes for each number of the path to which is added 0x8000000
@@ -40,7 +40,7 @@ function transformPathToBuffer(path) {
 }
 /**
  *
- * @description Converts uncompressed ledger key to standard tezos binary representation
+ * Converts uncompressed ledger key to standard tezos binary representation
  */
 function compressPublicKey(publicKey, curve) {
     if (curve === 0x00 || curve === 0x03) {
@@ -62,7 +62,7 @@ function appendWatermark(bytes, watermark) {
 }
 /**
  *
- * @description In order not to exceed the data length allowed by the Ledger device, split the operation into buffers of 230 bytes (max) and add them to the message to send to the Ledger
+ * In order not to exceed the data length allowed by the Ledger device, split the operation into buffers of 230 bytes (max) and add them to the message to send to the Ledger
  * @param messageToSend The message to send to the Ledger device
  * @param operation The operation which will be chunk if its length is over 230 bytes
  * @returns The instruction to send to the Ledger device
@@ -80,7 +80,7 @@ function chunkOperation(messageToSend, operation) {
 }
 /**
  *
- * @description Verify if the signature returned by the ledger for tz2 and tz3 is valid
+ * Verify if the signature returned by the ledger for tz2 and tz3 is valid
  * @param response The signature returned by the Ledger (return from the signWithLedger function)
  * @returns True if valid, false otherwise
  */
@@ -108,7 +108,7 @@ function validateResponse(response) {
 }
 /**
  *
- * @description Extract a part of the response returned by the Ledger
+ * Extract a part of the response returned by the Ledger
  * @param idxLength The index in the response from the Ledger that corresponds to the length of the part to extract
  * @param response The signature returned by the Ledger (return from the signWithLedger function)
  * @returns An object that contains the extracted buffer, the index where it starts in the response and the length of the extracted part

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-ledger-signer.es6.js

@@ -1,40 +1,8 @@
-import { PrefixV2, b58Encode } from '@taquito/utils';
+import { b58Encode, PrefixV2 } from '@taquito/utils';
 import { hash } from '@stablelib/blake2b';
 import { ParameterValidationError, TaquitoError, InvalidDerivationPathError, ProhibitedActionError } from '@taquito/core';
 export { InvalidDerivationPathError } from '@taquito/core';
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-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, 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());
-    });
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
 /*
  * Some code in this file is adapted from sotez
  * Copyright (c) 2018 Andrew Kishino
@@ -42,7 +10,7 @@ typeof SuppressedError === "function" ? SuppressedError : function (error, suppr
 const MAX_CHUNK_SIZE = 230;
 /**
  *
- * @description Convert the path to a buffer that will be used as LC and CDATA in the APDU send to the ledger device (https://github.com/obsidiansystems/ledger-app-tezos/blob/master/APDUs.md)
+ * Convert the path to a buffer that will be used as LC and CDATA in the APDU send to the ledger device (https://github.com/obsidiansystems/ledger-app-tezos/blob/master/APDUs.md)
  *
  * @param path The ledger derivation path (default is "44'/1729'/0'/0'")
  * @returns A buffer where the first element is the length of the path (default is 4), then 3 bytes for each number of the path to which is added 0x8000000
@@ -69,7 +37,7 @@ function transformPathToBuffer(path) {
 }
 /**
  *
- * @description Converts uncompressed ledger key to standard tezos binary representation
+ * Converts uncompressed ledger key to standard tezos binary representation
  */
 function compressPublicKey(publicKey, curve) {
     if (curve === 0x00 || curve === 0x03) {
@@ -91,7 +59,7 @@ function appendWatermark(bytes, watermark) {
 }
 /**
  *
- * @description In order not to exceed the data length allowed by the Ledger device, split the operation into buffers of 230 bytes (max) and add them to the message to send to the Ledger
+ * In order not to exceed the data length allowed by the Ledger device, split the operation into buffers of 230 bytes (max) and add them to the message to send to the Ledger
  * @param messageToSend The message to send to the Ledger device
  * @param operation The operation which will be chunk if its length is over 230 bytes
  * @returns The instruction to send to the Ledger device
@@ -109,7 +77,7 @@ function chunkOperation(messageToSend, operation) {
 }
 /**
  *
- * @description Verify if the signature returned by the ledger for tz2 and tz3 is valid
+ * Verify if the signature returned by the ledger for tz2 and tz3 is valid
  * @param response The signature returned by the Ledger (return from the signWithLedger function)
  * @returns True if valid, false otherwise
  */
@@ -137,7 +105,7 @@ function validateResponse(response) {
 }
 /**
  *
- * @description Extract a part of the response returned by the Ledger
+ * Extract a part of the response returned by the Ledger
  * @param idxLength The index in the response from the Ledger that corresponds to the length of the part to extract
  * @param response The signature returned by the Ledger (return from the signWithLedger function)
  * @returns An object that contains the extracted buffer, the index where it starts in the response and the length of the extracted part
@@ -157,7 +125,7 @@ function extractValue(idxLength, response) {
 
 /**
  *  @category Error
- *  @description Error that indicates an invalid or unparseable ledger response
+ *  Error that indicates an invalid or unparseable ledger response
  */
 class InvalidLedgerResponseError extends TaquitoError {
     constructor(message) {
@@ -168,7 +136,7 @@ class InvalidLedgerResponseError extends TaquitoError {
 }
 /**
  *  @category Error
- *  @description Error that indicates a failure when trying to retrieve a Public Key from Ledger signer
+ *  Error that indicates a failure when trying to retrieve a Public Key from Ledger signer
  */
 class PublicKeyRetrievalError extends TaquitoError {
     constructor(cause) {
@@ -180,7 +148,7 @@ class PublicKeyRetrievalError extends TaquitoError {
 }
 /**
  *  @category Error
- *  @description Error that indicates a failure when trying to retrieve a Public Key Hash from Ledger signer
+ *  Error that indicates a failure when trying to retrieve a Public Key Hash from Ledger signer
  */
 class PublicKeyHashRetrievalError extends TaquitoError {
     constructor() {
@@ -191,7 +159,7 @@ class PublicKeyHashRetrievalError extends TaquitoError {
 }
 /**
  *  @category Error
- *  @description Error that indicates an invalid derivation type being passed or used
+ *  Error that indicates an invalid derivation type being passed or used
  */
 class InvalidDerivationTypeError extends ParameterValidationError {
     constructor(derivationType) {
@@ -204,8 +172,8 @@ class InvalidDerivationTypeError extends ParameterValidationError {
 
 // 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"
 };
 
 /**
@@ -224,7 +192,7 @@ const HDPathTemplate = (account) => {
 };
 /**
  *
- * @description Implementation of the Signer interface that will allow signing operation from a Ledger Nano device
+ * Implementation of the Signer interface that will allow signing operation from a Ledger Nano device
  *
  * @param transport A transport instance from LedgerJS libraries depending on the platform used (e.g. Web, Node)
  * @param path The ledger derivation path (default is "44'/1729'/0'/0'")
@@ -274,96 +242,84 @@ class LedgerSigner {
             throw new InvalidDerivationTypeError(derivationType.toString());
         }
     }
-    publicKeyHash() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this._publicKeyHash) {
-                yield this.publicKey();
-            }
-            if (this._publicKeyHash) {
-                return this._publicKeyHash;
-            }
-            throw new PublicKeyHashRetrievalError();
-        });
+    async publicKeyHash() {
+        if (!this._publicKeyHash) {
+            await this.publicKey();
+        }
+        if (this._publicKeyHash) {
+            return this._publicKeyHash;
+        }
+        throw new PublicKeyHashRetrievalError();
     }
-    publicKey() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this._publicKey) {
-                return this._publicKey;
-            }
-            const responseLedger = yield this.getLedgerPublicKey();
-            const publicKeyLength = responseLedger[0];
-            const rawPublicKey = responseLedger.slice(1, 1 + publicKeyLength);
-            const compressedPublicKey = compressPublicKey(rawPublicKey, this.derivationType);
-            const prefixes = this.getPrefixes();
-            const publicKey = b58Encode(compressedPublicKey, prefixes.prefPk);
-            const publicKeyHash = b58Encode(hash(compressedPublicKey, 20), prefixes.prefPkh);
-            this._publicKey = publicKey;
-            this._publicKeyHash = publicKeyHash;
-            return publicKey;
-        });
+    async publicKey() {
+        if (this._publicKey) {
+            return this._publicKey;
+        }
+        const responseLedger = await this.getLedgerPublicKey();
+        const publicKeyLength = responseLedger[0];
+        const rawPublicKey = responseLedger.slice(1, 1 + publicKeyLength);
+        const compressedPublicKey = compressPublicKey(rawPublicKey, this.derivationType);
+        const prefixes = this.getPrefixes();
+        const publicKey = b58Encode(compressedPublicKey, prefixes.prefPk);
+        const publicKeyHash = b58Encode(hash(compressedPublicKey, 20), prefixes.prefPkh);
+        this._publicKey = publicKey;
+        this._publicKeyHash = publicKeyHash;
+        return publicKey;
     }
-    getLedgerPublicKey() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                let ins = this.INS_PROMPT_PUBLIC_KEY;
-                if (this.prompt === false) {
-                    ins = this.INS_GET_PUBLIC_KEY;
-                }
-                const responseLedger = yield this.transport.send(this.CLA, ins, this.FIRST_MESSAGE_SEQUENCE, this.derivationType, transformPathToBuffer(this.path));
-                return responseLedger;
-            }
-            catch (error) {
-                throw new PublicKeyRetrievalError(error);
+    async getLedgerPublicKey() {
+        try {
+            let ins = this.INS_PROMPT_PUBLIC_KEY;
+            if (this.prompt === false) {
+                ins = this.INS_GET_PUBLIC_KEY;
             }
-        });
+            const responseLedger = await this.transport.send(this.CLA, ins, this.FIRST_MESSAGE_SEQUENCE, this.derivationType, transformPathToBuffer(this.path));
+            return responseLedger;
+        }
+        catch (error) {
+            throw new PublicKeyRetrievalError(error);
+        }
     }
-    secretKey() {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new ProhibitedActionError('Secret key cannot be exposed');
-        });
+    async secretKey() {
+        throw new ProhibitedActionError('Secret key cannot be exposed');
     }
-    sign(bytes, watermark) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const watermarkedBytes = appendWatermark(bytes, watermark);
-            const watermarkedBytes2buff = Buffer.from(watermarkedBytes, 'hex');
-            let messageToSend = [];
-            messageToSend.push(transformPathToBuffer(this.path));
-            messageToSend = chunkOperation(messageToSend, watermarkedBytes2buff);
-            const ledgerResponse = yield this.signWithLedger(messageToSend);
-            let signature;
-            if (this.derivationType === DerivationType.ED25519 ||
-                this.derivationType === DerivationType.BIP32_ED25519) {
-                signature = ledgerResponse.slice(0, ledgerResponse.length - 2).toString('hex');
-            }
-            else {
-                if (!validateResponse(ledgerResponse)) {
-                    throw new InvalidLedgerResponseError('Invalid signature return by ledger unable to parse the response');
-                }
-                const idxLengthRVal = 3; // Third element of response is length of r value
-                const rValue = extractValue(idxLengthRVal, ledgerResponse);
-                const idxLengthSVal = rValue.idxValueStart + rValue.length + 1;
-                const sValue = extractValue(idxLengthSVal, ledgerResponse);
-                const signatureBuffer = Buffer.concat([rValue.buffer, sValue.buffer]);
-                signature = signatureBuffer.toString('hex');
+    async sign(bytes, watermark) {
+        const watermarkedBytes = appendWatermark(bytes, watermark);
+        const watermarkedBytes2buff = Buffer.from(watermarkedBytes, 'hex');
+        let messageToSend = [];
+        messageToSend.push(transformPathToBuffer(this.path));
+        messageToSend = chunkOperation(messageToSend, watermarkedBytes2buff);
+        const ledgerResponse = await this.signWithLedger(messageToSend);
+        let signature;
+        if (this.derivationType === DerivationType.ED25519 ||
+            this.derivationType === DerivationType.BIP32_ED25519) {
+            signature = ledgerResponse.slice(0, ledgerResponse.length - 2).toString('hex');
+        }
+        else {
+            if (!validateResponse(ledgerResponse)) {
+                throw new InvalidLedgerResponseError('Invalid signature return by ledger unable to parse the response');
             }
-            return {
-                bytes,
-                sig: b58Encode(signature, PrefixV2.GenericSignature),
-                prefixSig: b58Encode(signature, this.getPrefixes().prefSig),
-                sbytes: bytes + signature,
-            };
-        });
+            const idxLengthRVal = 3; // Third element of response is length of r value
+            const rValue = extractValue(idxLengthRVal, ledgerResponse);
+            const idxLengthSVal = rValue.idxValueStart + rValue.length + 1;
+            const sValue = extractValue(idxLengthSVal, ledgerResponse);
+            const signatureBuffer = Buffer.concat([rValue.buffer, sValue.buffer]);
+            signature = signatureBuffer.toString('hex');
+        }
+        return {
+            bytes,
+            sig: b58Encode(signature, PrefixV2.GenericSignature),
+            prefixSig: b58Encode(signature, this.getPrefixes().prefSig),
+            sbytes: bytes + signature,
+        };
     }
-    signWithLedger(message) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // first element of the message represents the path
-            let ledgerResponse = yield this.transport.send(this.CLA, this.INS_SIGN, this.FIRST_MESSAGE_SEQUENCE, this.derivationType, message[0]);
-            for (let i = 1; i < message.length; i++) {
-                const p1 = i === message.length - 1 ? this.LAST_MESSAGE_SEQUENCE : this.OTHER_MESSAGE_SEQUENCE;
-                ledgerResponse = yield this.transport.send(this.CLA, this.INS_SIGN, p1, this.derivationType, message[i]);
-            }
-            return ledgerResponse;
-        });
+    async signWithLedger(message) {
+        // first element of the message represents the path
+        let ledgerResponse = await this.transport.send(this.CLA, this.INS_SIGN, this.FIRST_MESSAGE_SEQUENCE, this.derivationType, message[0]);
+        for (let i = 1; i < message.length; i++) {
+            const p1 = i === message.length - 1 ? this.LAST_MESSAGE_SEQUENCE : this.OTHER_MESSAGE_SEQUENCE;
+            ledgerResponse = await this.transport.send(this.CLA, this.INS_SIGN, p1, this.derivationType, message[i]);
+        }
+        return ledgerResponse;
     }
     getPrefixes() {
         if (this.derivationType === DerivationType.ED25519 ||

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

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