@ledgerhq/hw-app-eth 6.21.3 → 6.22.3

package/lib-es/Eth.js

@@ -45,31 +45,9 @@ var __values = (this && this.__values) || function(o) {
     };
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
-/********************************************************************************
- *   Ledger Node JS API
- *   (c) 2016-2017 Ledger
- *
- *  Licensed under the Apache License, Version 2.0 (the "License");
- *  you may not use this file except in compliance with the License.
- *  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- *  Unless required by applicable law or agreed to in writing, software
- *  distributed under the License is distributed on an "AS IS" BASIS,
- *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- *  See the License for the specific language governing permissions and
- *  limitations under the License.
- ********************************************************************************/
-// FIXME drop:
-import { splitPath, foreach } from "./utils";
-import { log } from "@ledgerhq/logs";
-import { EthAppPleaseEnableContractData } from "@ledgerhq/errors";
-import { BigNumber } from "bignumber.js";
-import { ethers } from "ethers";
-import { byContractAddressAndChainId } from "./erc20";
-import { loadInfosForContractMethod } from "./contracts";
-import { getNFTInfo, loadNftPlugin } from "./nfts";
+import { decodeTxInfo } from "./utils";
+import ledgerService from "./services/ledger";
+import { EthAppNftNotSupported, EthAppPleaseEnableContractData, } from "./errors";
 var starkQuantizationTypeMap = {
     eth: 1,
     erc20: 2,
@@ -77,6 +55,21 @@ var starkQuantizationTypeMap = {
     erc20mintable: 4,
     erc721mintable: 5
 };
+function splitPath(path) {
+    var result = [];
+    var components = path.split("/");
+    components.forEach(function (element) {
+        var number = parseInt(element, 10);
+        if (isNaN(number)) {
+            return; // FIXME shouldn't it throws instead?
+        }
+        if (element.length > 1 && element[element.length - 1] === "'") {
+            number += 0x80000000;
+        }
+        result.push(number);
+    });
+    return result;
+}
 function hexBuffer(str) {
     return Buffer.from(str.startsWith("0x") ? str.slice(2) : str, "hex");
 }
@@ -164,263 +157,222 @@ var Eth = /** @class */ (function () {
         });
     };
     /**
-     * This commands provides a trusted description of an ERC 20 token
-     * to associate a contract address with a ticker and number of decimals.
-     *
-     * It shall be run immediately before performing a transaction involving a contract
-     * calling this contract address to display the proper token information to the user if necessary.
-     *
-     * @param {*} info: a blob from "erc20.js" utilities that contains all token information.
+     * You can sign a transaction and retrieve v, r, s given the raw transaction and the BIP 32 path of the account to sign.
      *
+     * @param path: the BIP32 path to sign the transaction on
+     * @param rawTxHex: the raw ethereum transaction in hexadecimal to sign
+     * @param resolution: resolution is an object with all "resolved" metadata necessary to allow the device to clear sign information. This includes: ERC20 token information, plugins, contracts, NFT signatures,... You must explicitly provide something to avoid having a warning. By default, you can use Ledger's service or your own resolution service. See services/types.js for the contract. Setting the value to "null" will fallback everything to blind signing but will still allow the device to sign the transaction.
      * @example
-     * import { byContractAddressAndChainId } from "@ledgerhq/hw-app-eth/erc20"
-     * const zrxInfo = byContractAddressAndChainId("0xe41d2489571d322189246dafa5ebde1f4699f498", chainId)
-     * if (zrxInfo) await appEth.provideERC20TokenInformation(zrxInfo)
-     * const signed = await appEth.signTransaction(path, rawTxHex)
+     import ledgerService from "@ledgerhq/hw-app-eth/lib/services/ledger"
+     const tx = "e8018504e3b292008252089428ee52a8f3d6e5d15f8b131996950d7f296c7952872bd72a2487400080"; // raw tx to sign
+     const resolution = await ledgerService.resolveTransaction(tx);
+     const result = eth.signTransaction("44'/60'/0'/0/0", tx, resolution);
+     console.log(result);
      */
-    Eth.prototype.provideERC20TokenInformation = function (_a) {
-        var data = _a.data;
-        return provideERC20TokenInformation(this.transport, data);
-    };
-    /**
-     * You can sign a transaction and retrieve v, r, s given the raw transaction and the BIP 32 path of the account to sign
-     * @example
-     eth.signTransaction("44'/60'/0'/0/0", "e8018504e3b292008252089428ee52a8f3d6e5d15f8b131996950d7f296c7952872bd72a2487400080").then(result => ...)
-     */
-    Eth.prototype.signTransaction = function (path, rawTxHex) {
+    Eth.prototype.signTransaction = function (path, rawTxHex, resolution) {
         return __awaiter(this, void 0, void 0, function () {
-            var paths, offset, rawTx, VALID_TYPES, txType, rlpData, toSend, response, rlpTx, vrsOffset, chainId, chainIdTruncated, rlpDecoded, decodedTx, rlpVrs, sizeOfListLen, chainIdSrc, chainIdTruncatedBuf, _loop_1, provideForContract, selector, nftPluginPayload, infos, plugin, payload, signature, erc20OfInterest, abi, contract, args, erc20OfInterest_1, erc20OfInterest_1_1, address, e_1_1;
-            var e_1, _a;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
+            var _a, _b, plugin, e_1_1, _c, _d, _e, payload, signature, e_2_1, _f, _g, nft, e_3_1, _h, _j, data, e_4_1, rawTx, _k, vrsOffset, txType, chainId, chainIdTruncated, paths, response, offset, _loop_1, this_1, response_byte, v, oneByteChainId, ecc_parity, r, s;
+            var e_1, _l, e_2, _m, e_3, _o, e_4, _p;
+            return __generator(this, function (_q) {
+                switch (_q.label) {
                     case 0:
-                        paths = splitPath(path);
-                        offset = 0;
-                        rawTx = Buffer.from(rawTxHex, "hex");
-                        VALID_TYPES = [1, 2];
-                        txType = VALID_TYPES.includes(rawTx[0]) ? rawTx[0] : null;
-                        rlpData = txType === null ? rawTx : rawTx.slice(1, rawTxHex.length);
-                        toSend = [];
-                        rlpTx = ethers.utils.RLP.decode(rlpData).map(function (hex) {
-                            return Buffer.from(hex.slice(2), "hex");
-                        });
-                        vrsOffset = 0;
-                        chainId = new BigNumber(0);
-                        chainIdTruncated = 0;
-                        rlpDecoded = ethers.utils.RLP.decode(rlpData);
-                        if (txType === 2) {
-                            // EIP1559
-                            decodedTx = {
-                                data: rlpDecoded[7],
-                                to: rlpDecoded[5],
-                                chainId: rlpTx[0]
-                            };
-                        }
-                        else if (txType === 1) {
-                            // EIP2930
-                            decodedTx = {
-                                data: rlpDecoded[6],
-                                to: rlpDecoded[4],
-                                chainId: rlpTx[0]
-                            };
-                        }
-                        else {
-                            // Legacy tx
-                            decodedTx = {
-                                data: rlpDecoded[5],
-                                to: rlpDecoded[3],
-                                // Default to 1 for non EIP 155 txs
-                                chainId: rlpTx.length > 6 ? rlpTx[6] : Buffer.from("0x01", "hex")
-                            };
-                        }
-                        if (txType === null && rlpTx.length > 6) {
-                            rlpVrs = Buffer.from(ethers.utils.RLP.encode(rlpTx.slice(-3)).slice(2), "hex");
-                            vrsOffset = rawTx.length - (rlpVrs.length - 1);
-                            // First byte > 0xf7 means the length of the list length doesn't fit in a single byte.
-                            if (rlpVrs[0] > 0xf7) {
-                                // Increment vrsOffset to account for that extra byte.
-                                vrsOffset++;
-                                sizeOfListLen = rlpVrs[0] - 0xf7;
-                                // Increase rlpOffset by the size of the list length.
-                                vrsOffset += sizeOfListLen - 1;
-                            }
-                        }
-                        chainIdSrc = decodedTx.chainId;
-                        if (chainIdSrc) {
-                            // Using BigNumber because chainID could be any uint256.
-                            chainId = new BigNumber(chainIdSrc.toString("hex"), 16);
-                            chainIdTruncatedBuf = Buffer.alloc(4);
-                            if (chainIdSrc.length > 4) {
-                                chainIdSrc.copy(chainIdTruncatedBuf);
-                            }
-                            else {
-                                chainIdSrc.copy(chainIdTruncatedBuf, 4 - chainIdSrc.length);
-                            }
-                            chainIdTruncated = chainIdTruncatedBuf.readUInt32BE(0);
-                        }
-                        _loop_1 = function () {
-                            var maxChunkSize = offset === 0 ? 150 - 1 - paths.length * 4 : 150;
-                            var chunkSize = offset + maxChunkSize > rawTx.length
-                                ? rawTx.length - offset
-                                : maxChunkSize;
-                            if (vrsOffset != 0 && offset + chunkSize >= vrsOffset) {
-                                // Make sure that the chunk doesn't end right on the EIP 155 marker if set
-                                chunkSize = rawTx.length - offset;
-                            }
-                            var buffer = Buffer.alloc(offset === 0 ? 1 + paths.length * 4 + chunkSize : chunkSize);
-                            if (offset === 0) {
-                                buffer[0] = paths.length;
-                                paths.forEach(function (element, index) {
-                                    buffer.writeUInt32BE(element, 1 + 4 * index);
-                                });
-                                rawTx.copy(buffer, 1 + 4 * paths.length, offset, offset + chunkSize);
-                            }
-                            else {
-                                rawTx.copy(buffer, 0, offset, offset + chunkSize);
-                            }
-                            toSend.push(buffer);
-                            offset += chunkSize;
-                        };
-                        while (offset !== rawTx.length) {
-                            _loop_1();
-                        }
-                        provideForContract = function (address) { return __awaiter(_this, void 0, void 0, function () {
-                            var nftInfo, erc20Info;
-                            return __generator(this, function (_a) {
-                                switch (_a.label) {
-                                    case 0: return [4 /*yield*/, getNFTInfo(address, chainIdTruncated, this.loadConfig)];
-                                    case 1:
-                                        nftInfo = _a.sent();
-                                        if (!nftInfo) return [3 /*break*/, 3];
-                                        log("ethereum", "loading nft info for " +
-                                            nftInfo.contractAddress +
-                                            " (" +
-                                            nftInfo.collectionName +
-                                            ")");
-                                        return [4 /*yield*/, provideNFTInformation(this.transport, nftInfo.data)];
-                                    case 2:
-                                        _a.sent();
-                                        return [3 /*break*/, 5];
-                                    case 3:
-                                        erc20Info = byContractAddressAndChainId(address, chainIdTruncated);
-                                        if (!erc20Info) return [3 /*break*/, 5];
-                                        log("ethereum", "loading erc20token info for " +
-                                            erc20Info.contractAddress +
-                                            " (" +
-                                            erc20Info.ticker +
-                                            ")");
-                                        return [4 /*yield*/, provideERC20TokenInformation(this.transport, erc20Info.data)];
-                                    case 4:
-                                        _a.sent();
-                                        _a.label = 5;
-                                    case 5: return [2 /*return*/];
-                                }
-                            });
-                        }); };
-                        if (!(decodedTx.data.length >= 10)) return [3 /*break*/, 18];
-                        selector = decodedTx.data.substring(0, 10);
-                        return [4 /*yield*/, loadNftPlugin(decodedTx.to, selector, chainIdTruncated, this.loadConfig)];
+                        if (!(resolution === undefined)) return [3 /*break*/, 2];
+                        console.warn("hw-app-eth: signTransaction(path, rawTxHex, resolution): " +
+                            "please provide the 'resolution' parameter. " +
+                            "See https://github.com/LedgerHQ/ledgerjs/blob/master/packages/hw-app-eth/README.md " +
+                            "– the previous signature is deprecated and providing the 3rd 'resolution' parameter explicitly will become mandatory so you have the control on the resolution and the fallback mecanism (e.g. fallback to blind signing or not)." +
+                            "// Possible solution:\n" +
+                            " + import ledgerService from '@ledgerhq/hw-app-eth/lib/services/ledger';\n" +
+                            " + const resolution = await ledgerService.resolveTransaction(rawTxHex);");
+                        return [4 /*yield*/, ledgerService
+                                .resolveTransaction(rawTxHex, this.loadConfig, {
+                                externalPlugins: true,
+                                erc20: true
+                            })["catch"](function (e) {
+                                console.warn("an error occurred in resolveTransaction => fallback to blind signing: " +
+                                    String(e));
+                                return null;
+                            })];
                     case 1:
-                        nftPluginPayload = _b.sent();
-                        if (!nftPluginPayload) return [3 /*break*/, 3];
-                        return [4 /*yield*/, setPlugin(this.transport, nftPluginPayload)];
+                        resolution = _q.sent();
+                        _q.label = 2;
                     case 2:
-                        _b.sent();
-                        return [3 /*break*/, 16];
-                    case 3: return [4 /*yield*/, loadInfosForContractMethod(decodedTx.to, selector, chainIdTruncated, this.loadConfig)];
+                        if (!resolution) return [3 /*break*/, 31];
+                        _q.label = 3;
+                    case 3:
+                        _q.trys.push([3, 8, 9, 10]);
+                        _a = __values(resolution.plugin), _b = _a.next();
+                        _q.label = 4;
                     case 4:
-                        infos = _b.sent();
-                        if (!infos) return [3 /*break*/, 15];
-                        plugin = infos.plugin, payload = infos.payload, signature = infos.signature, erc20OfInterest = infos.erc20OfInterest, abi = infos.abi;
-                        if (!plugin) return [3 /*break*/, 6];
-                        log("ethereum", "loading plugin for " + selector);
-                        return [4 /*yield*/, setExternalPlugin(this.transport, payload, signature)];
+                        if (!!_b.done) return [3 /*break*/, 7];
+                        plugin = _b.value;
+                        return [4 /*yield*/, setPlugin(this.transport, plugin)];
                     case 5:
-                        _b.sent();
-                        _b.label = 6;
+                        _q.sent();
+                        _q.label = 6;
                     case 6:
-                        if (!(erc20OfInterest && erc20OfInterest.length && abi)) return [3 /*break*/, 14];
-                        contract = new ethers.utils.Interface(abi);
-                        args = contract.parseTransaction(decodedTx).args;
-                        _b.label = 7;
-                    case 7:
-                        _b.trys.push([7, 12, 13, 14]);
-                        erc20OfInterest_1 = __values(erc20OfInterest), erc20OfInterest_1_1 = erc20OfInterest_1.next();
-                        _b.label = 8;
+                        _b = _a.next();
+                        return [3 /*break*/, 4];
+                    case 7: return [3 /*break*/, 10];
                     case 8:
-                        if (!!erc20OfInterest_1_1.done) return [3 /*break*/, 11];
-                        path = erc20OfInterest_1_1.value;
-                        address = path.split(".").reduce(function (value, seg) {
-                            if (seg === "-1" && Array.isArray(value)) {
-                                return value[value.length - 1];
-                            }
-                            return value[seg];
-                        }, args);
-                        return [4 /*yield*/, provideForContract(address)];
+                        e_1_1 = _q.sent();
+                        e_1 = { error: e_1_1 };
+                        return [3 /*break*/, 10];
                     case 9:
-                        _b.sent();
-                        _b.label = 10;
+                        try {
+                            if (_b && !_b.done && (_l = _a["return"])) _l.call(_a);
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                        return [7 /*endfinally*/];
                     case 10:
-                        erc20OfInterest_1_1 = erc20OfInterest_1.next();
-                        return [3 /*break*/, 8];
-                    case 11: return [3 /*break*/, 14];
+                        _q.trys.push([10, 15, 16, 17]);
+                        _c = __values(resolution.externalPlugin), _d = _c.next();
+                        _q.label = 11;
+                    case 11:
+                        if (!!_d.done) return [3 /*break*/, 14];
+                        _e = _d.value, payload = _e.payload, signature = _e.signature;
+                        return [4 /*yield*/, setExternalPlugin(this.transport, payload, signature)];
                     case 12:
-                        e_1_1 = _b.sent();
-                        e_1 = { error: e_1_1 };
-                        return [3 /*break*/, 14];
+                        _q.sent();
+                        _q.label = 13;
                     case 13:
+                        _d = _c.next();
+                        return [3 /*break*/, 11];
+                    case 14: return [3 /*break*/, 17];
+                    case 15:
+                        e_2_1 = _q.sent();
+                        e_2 = { error: e_2_1 };
+                        return [3 /*break*/, 17];
+                    case 16:
                         try {
-                            if (erc20OfInterest_1_1 && !erc20OfInterest_1_1.done && (_a = erc20OfInterest_1["return"])) _a.call(erc20OfInterest_1);
+                            if (_d && !_d.done && (_m = _c["return"])) _m.call(_c);
                         }
-                        finally { if (e_1) throw e_1.error; }
+                        finally { if (e_2) throw e_2.error; }
                         return [7 /*endfinally*/];
-                    case 14: return [3 /*break*/, 16];
-                    case 15:
-                        log("ethereum", "no infos for selector " + selector);
-                        _b.label = 16;
-                    case 16: return [4 /*yield*/, provideForContract(decodedTx.to)];
                     case 17:
-                        _b.sent();
-                        _b.label = 18;
-                    case 18: return [2 /*return*/, foreach(toSend, function (data, i) {
-                            return _this.transport
-                                .send(0xe0, 0x04, i === 0 ? 0x00 : 0x80, 0x00, data)
-                                .then(function (apduResponse) {
-                                response = apduResponse;
-                            });
-                        }).then(function () {
-                            var response_byte = response.slice(0, 1)[0];
-                            var v = "";
-                            if (chainId.times(2).plus(35).plus(1).isGreaterThan(255)) {
-                                var oneByteChainId = (chainIdTruncated * 2 + 35) % 256;
-                                var ecc_parity = Math.abs(response_byte - oneByteChainId);
-                                if (txType != null) {
-                                    // For EIP2930 and EIP1559 tx, v is simply the parity.
-                                    v = ecc_parity % 2 == 1 ? "00" : "01";
-                                }
-                                else {
-                                    // Legacy type transaction with a big chain ID
-                                    v = chainId.times(2).plus(35).plus(ecc_parity).toString(16);
+                        _q.trys.push([17, 22, 23, 24]);
+                        _f = __values(resolution.nfts), _g = _f.next();
+                        _q.label = 18;
+                    case 18:
+                        if (!!_g.done) return [3 /*break*/, 21];
+                        nft = _g.value;
+                        return [4 /*yield*/, provideNFTInformation(this.transport, Buffer.from(nft, "hex"))];
+                    case 19:
+                        _q.sent();
+                        _q.label = 20;
+                    case 20:
+                        _g = _f.next();
+                        return [3 /*break*/, 18];
+                    case 21: return [3 /*break*/, 24];
+                    case 22:
+                        e_3_1 = _q.sent();
+                        e_3 = { error: e_3_1 };
+                        return [3 /*break*/, 24];
+                    case 23:
+                        try {
+                            if (_g && !_g.done && (_o = _f["return"])) _o.call(_f);
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                        return [7 /*endfinally*/];
+                    case 24:
+                        _q.trys.push([24, 29, 30, 31]);
+                        _h = __values(resolution.erc20Tokens), _j = _h.next();
+                        _q.label = 25;
+                    case 25:
+                        if (!!_j.done) return [3 /*break*/, 28];
+                        data = _j.value;
+                        return [4 /*yield*/, provideERC20TokenInformation(this.transport, Buffer.from(data, "hex"))];
+                    case 26:
+                        _q.sent();
+                        _q.label = 27;
+                    case 27:
+                        _j = _h.next();
+                        return [3 /*break*/, 25];
+                    case 28: return [3 /*break*/, 31];
+                    case 29:
+                        e_4_1 = _q.sent();
+                        e_4 = { error: e_4_1 };
+                        return [3 /*break*/, 31];
+                    case 30:
+                        try {
+                            if (_j && !_j.done && (_p = _h["return"])) _p.call(_h);
+                        }
+                        finally { if (e_4) throw e_4.error; }
+                        return [7 /*endfinally*/];
+                    case 31:
+                        rawTx = Buffer.from(rawTxHex, "hex");
+                        _k = decodeTxInfo(rawTx), vrsOffset = _k.vrsOffset, txType = _k.txType, chainId = _k.chainId, chainIdTruncated = _k.chainIdTruncated;
+                        paths = splitPath(path);
+                        offset = 0;
+                        _loop_1 = function () {
+                            var first, maxChunkSize, chunkSize, buffer;
+                            return __generator(this, function (_r) {
+                                switch (_r.label) {
+                                    case 0:
+                                        first = offset === 0;
+                                        maxChunkSize = first ? 150 - 1 - paths.length * 4 : 150;
+                                        chunkSize = offset + maxChunkSize > rawTx.length
+                                            ? rawTx.length - offset
+                                            : maxChunkSize;
+                                        if (vrsOffset != 0 && offset + chunkSize >= vrsOffset) {
+                                            // Make sure that the chunk doesn't end right on the EIP 155 marker if set
+                                            chunkSize = rawTx.length - offset;
+                                        }
+                                        buffer = Buffer.alloc(first ? 1 + paths.length * 4 + chunkSize : chunkSize);
+                                        if (first) {
+                                            buffer[0] = paths.length;
+                                            paths.forEach(function (element, index) {
+                                                buffer.writeUInt32BE(element, 1 + 4 * index);
+                                            });
+                                            rawTx.copy(buffer, 1 + 4 * paths.length, offset, offset + chunkSize);
+                                        }
+                                        else {
+                                            rawTx.copy(buffer, 0, offset, offset + chunkSize);
+                                        }
+                                        return [4 /*yield*/, this_1.transport
+                                                .send(0xe0, 0x04, first ? 0x00 : 0x80, 0x00, buffer)["catch"](function (e) {
+                                                throw remapTransactionRelatedErrors(e);
+                                            })];
+                                    case 1:
+                                        response = _r.sent();
+                                        offset += chunkSize;
+                                        return [2 /*return*/];
                                 }
+                            });
+                        };
+                        this_1 = this;
+                        _q.label = 32;
+                    case 32:
+                        if (!(offset !== rawTx.length)) return [3 /*break*/, 34];
+                        return [5 /*yield**/, _loop_1()];
+                    case 33:
+                        _q.sent();
+                        return [3 /*break*/, 32];
+                    case 34:
+                        response_byte = response[0];
+                        v = "";
+                        if (chainId.times(2).plus(35).plus(1).isGreaterThan(255)) {
+                            oneByteChainId = (chainIdTruncated * 2 + 35) % 256;
+                            ecc_parity = Math.abs(response_byte - oneByteChainId);
+                            if (txType != null) {
+                                // For EIP2930 and EIP1559 tx, v is simply the parity.
+                                v = ecc_parity % 2 == 1 ? "00" : "01";
                             }
                             else {
-                                v = response_byte.toString(16);
-                            }
-                            // Make sure v has is prefixed with a 0 if its length is odd ("1" -> "01").
-                            if (v.length % 2 == 1) {
-                                v = "0" + v;
+                                // Legacy type transaction with a big chain ID
+                                v = chainId.times(2).plus(35).plus(ecc_parity).toString(16);
                             }
-                            var r = response.slice(1, 1 + 32).toString("hex");
-                            var s = response.slice(1 + 32, 1 + 32 + 32).toString("hex");
-                            return {
-                                v: v,
-                                r: r,
-                                s: s
-                            };
-                        }, function (e) {
-                            throw remapTransactionRelatedErrors(e);
-                        })];
+                        }
+                        else {
+                            v = response_byte.toString(16);
+                        }
+                        // Make sure v has is prefixed with a 0 if its length is odd ("1" -> "01").
+                        if (v.length % 2 == 1) {
+                            v = "0" + v;
+                        }
+                        r = response.slice(1, 1 + 32).toString("hex");
+                        s = response.slice(1 + 32, 1 + 32 + 32).toString("hex");
+                        return [2 /*return*/, { v: v, r: r, s: s }];
                 }
             });
         });
@@ -451,50 +403,58 @@ var Eth = /** @class */ (function () {
     })
      */
     Eth.prototype.signPersonalMessage = function (path, messageHex) {
-        var _this = this;
-        var paths = splitPath(path);
-        var offset = 0;
-        var message = Buffer.from(messageHex, "hex");
-        var toSend = [];
-        var response;
-        var _loop_2 = function () {
-            var maxChunkSize = offset === 0 ? 150 - 1 - paths.length * 4 - 4 : 150;
-            var chunkSize = offset + maxChunkSize > message.length
-                ? message.length - offset
-                : maxChunkSize;
-            var buffer = Buffer.alloc(offset === 0 ? 1 + paths.length * 4 + 4 + chunkSize : chunkSize);
-            if (offset === 0) {
-                buffer[0] = paths.length;
-                paths.forEach(function (element, index) {
-                    buffer.writeUInt32BE(element, 1 + 4 * index);
-                });
-                buffer.writeUInt32BE(message.length, 1 + 4 * paths.length);
-                message.copy(buffer, 1 + 4 * paths.length + 4, offset, offset + chunkSize);
-            }
-            else {
-                message.copy(buffer, 0, offset, offset + chunkSize);
-            }
-            toSend.push(buffer);
-            offset += chunkSize;
-        };
-        while (offset !== message.length) {
-            _loop_2();
-        }
-        return foreach(toSend, function (data, i) {
-            return _this.transport
-                .send(0xe0, 0x08, i === 0 ? 0x00 : 0x80, 0x00, data)
-                .then(function (apduResponse) {
-                response = apduResponse;
+        return __awaiter(this, void 0, void 0, function () {
+            var paths, offset, message, response, _loop_2, this_2, v, r, s;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        paths = splitPath(path);
+                        offset = 0;
+                        message = Buffer.from(messageHex, "hex");
+                        _loop_2 = function () {
+                            var maxChunkSize, chunkSize, buffer;
+                            return __generator(this, function (_b) {
+                                switch (_b.label) {
+                                    case 0:
+                                        maxChunkSize = offset === 0 ? 150 - 1 - paths.length * 4 - 4 : 150;
+                                        chunkSize = offset + maxChunkSize > message.length
+                                            ? message.length - offset
+                                            : maxChunkSize;
+                                        buffer = Buffer.alloc(offset === 0 ? 1 + paths.length * 4 + 4 + chunkSize : chunkSize);
+                                        if (offset === 0) {
+                                            buffer[0] = paths.length;
+                                            paths.forEach(function (element, index) {
+                                                buffer.writeUInt32BE(element, 1 + 4 * index);
+                                            });
+                                            buffer.writeUInt32BE(message.length, 1 + 4 * paths.length);
+                                            message.copy(buffer, 1 + 4 * paths.length + 4, offset, offset + chunkSize);
+                                        }
+                                        else {
+                                            message.copy(buffer, 0, offset, offset + chunkSize);
+                                        }
+                                        return [4 /*yield*/, this_2.transport.send(0xe0, 0x08, offset === 0 ? 0x00 : 0x80, 0x00, buffer)];
+                                    case 1:
+                                        response = _b.sent();
+                                        offset += chunkSize;
+                                        return [2 /*return*/];
+                                }
+                            });
+                        };
+                        this_2 = this;
+                        _a.label = 1;
+                    case 1:
+                        if (!(offset !== message.length)) return [3 /*break*/, 3];
+                        return [5 /*yield**/, _loop_2()];
+                    case 2:
+                        _a.sent();
+                        return [3 /*break*/, 1];
+                    case 3:
+                        v = response[0];
+                        r = response.slice(1, 1 + 32).toString("hex");
+                        s = response.slice(1 + 32, 1 + 32 + 32).toString("hex");
+                        return [2 /*return*/, { v: v, r: r, s: s }];
+                }
             });
-        }).then(function () {
-            var v = response[0];
-            var r = response.slice(1, 1 + 32).toString("hex");
-            var s = response.slice(1 + 32, 1 + 32 + 32).toString("hex");
-            return {
-                v: v,
-                r: r,
-                s: s
-            };
         });
     };
     /**
@@ -990,22 +950,17 @@ var Eth = /** @class */ (function () {
             throw e;
         });
     };
-    /**
-     * Set the name of the external plugin that should be used to parse the next transaction
-     *
-     * @param pluginName string containing the name of the plugin, must have length between 1 and 30 bytes
-     * @return True if the method was executed successfully
-     */
+    Eth.prototype.provideERC20TokenInformation = function (_a) {
+        var data = _a.data;
+        console.warn("hw-app-eth: eth.provideERC20TokenInformation is deprecated. signTransaction solves this for you when providing it in `resolution`.");
+        return provideERC20TokenInformation(this.transport, data);
+    };
     Eth.prototype.setExternalPlugin = function (pluginName, contractAddress, selector) {
+        console.warn("hw-app-eth: eth.setExternalPlugin is deprecated. signTransaction solves this for you when providing it in `resolution`.");
         return setExternalPlugin(this.transport, pluginName, selector);
     };
-    /**
-     * Set the plugin (internal or external) that should be used to parse the next transaction
-     *
-     * @param data string containing the payload and signature that will be parsed and verified by the device.
-     * @return True if the method was executed successfully
-     */
     Eth.prototype.setPlugin = function (data) {
+        console.warn("hw-app-eth: eth.setPlugin is deprecated. signTransaction solves this for you when providing it in `resolution`.");
         return setPlugin(this.transport, data);
     };
     return Eth;
@@ -1029,8 +984,8 @@ function provideNFTInformation(transport, data) {
             return false;
         }
         if (e && e.statusCode === 0x6d00) {
-            // ignore older version of ETH app
-            return false;
+            // older version of ETH app => error because we don't allow blind sign when NFT is explicitly requested to be resolved.
+            throw new EthAppNftNotSupported();
         }
         throw e;
     });