@shapeshiftoss/hdwallet-trezor 1.55.4-alpha.1 → 1.55.5

package/dist/trezor.js

@@ -1,10 +1,51 @@
-import * as core from "@shapeshiftoss/hdwallet-core";
-import _ from "lodash";
-import * as Btc from "./bitcoin";
-import * as Eth from "./ethereum";
-import { handleError } from "./utils";
-export function isTrezor(wallet) {
-    return _.isObject(wallet) && wallet._isTrezor;
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TrezorHDWallet = exports.TrezorHDWalletInfo = void 0;
+exports.isTrezor = isTrezor;
+exports.info = info;
+exports.create = create;
+const core = __importStar(require("@shapeshiftoss/hdwallet-core"));
+const lodash_1 = __importDefault(require("lodash"));
+const Btc = __importStar(require("./bitcoin"));
+const Eth = __importStar(require("./ethereum"));
+const utils_1 = require("./utils");
+function isTrezor(wallet) {
+    return lodash_1.default.isObject(wallet) && wallet._isTrezor;
 }
 function describeETHPath(path) {
     const pathStr = core.addressNListToBIP32(path);
@@ -36,6 +77,7 @@ function describeETHPath(path) {
     };
 }
 function describeUTXOPath(path, coin, scriptType) {
+    var _a;
     const pathStr = core.addressNListToBIP32(path);
     const unknown = {
         verbose: pathStr,
@@ -65,11 +107,11 @@ function describeUTXOPath(path, coin, scriptType) {
         return unknown;
     const wholeAccount = path.length === 3;
     let script = scriptType
-        ? {
+        ? (_a = {
             [core.BTCInputScriptType.SpendAddress]: " (Legacy)",
             [core.BTCInputScriptType.SpendP2SHWitness]: "",
             [core.BTCInputScriptType.SpendWitness]: " (Segwit Native)",
-        }[scriptType] ?? ""
+        }[scriptType]) !== null && _a !== void 0 ? _a : ""
         : "";
     switch (coin) {
         case "Bitcoin":
@@ -108,20 +150,28 @@ function describeUTXOPath(path, coin, scriptType) {
         };
     }
 }
-export class TrezorHDWalletInfo {
-    _supportsBTCInfo = true;
-    _supportsETHInfo = true;
+class TrezorHDWalletInfo {
+    constructor() {
+        this._supportsBTCInfo = true;
+        this._supportsETHInfo = true;
+    }
     getVendor() {
         return "Trezor";
     }
-    async btcSupportsCoin(coin) {
-        return Btc.btcSupportsCoin(coin);
+    btcSupportsCoin(coin) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Btc.btcSupportsCoin(coin);
+        });
     }
-    async btcSupportsScriptType(coin, scriptType) {
-        return Btc.btcSupportsScriptType(coin, scriptType);
+    btcSupportsScriptType(coin, scriptType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Btc.btcSupportsScriptType(coin, scriptType);
+        });
     }
-    async btcSupportsSecureTransfer() {
-        return Btc.btcSupportsSecureTransfer();
+    btcSupportsSecureTransfer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Btc.btcSupportsSecureTransfer();
+        });
     }
     btcSupportsNativeShapeShift() {
         return Btc.btcSupportsNativeShapeShift();
@@ -132,17 +182,23 @@ export class TrezorHDWalletInfo {
     btcIsSameAccount(msg) {
         return Btc.btcIsSameAccount(msg);
     }
-    async ethSupportsNetwork(chain_id) {
-        return Eth.ethSupportsNetwork(chain_id);
+    ethSupportsNetwork(chain_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Eth.ethSupportsNetwork(chain_id);
+        });
     }
-    async ethSupportsSecureTransfer() {
-        return Eth.ethSupportsSecureTransfer();
+    ethSupportsSecureTransfer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Eth.ethSupportsSecureTransfer();
+        });
     }
     ethSupportsNativeShapeShift() {
         return Eth.ethSupportsNativeShapeShift();
     }
-    async ethSupportsEIP1559() {
-        return await Eth.ethSupportsEIP1559();
+    ethSupportsEIP1559() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield Eth.ethSupportsEIP1559();
+        });
     }
     ethGetAccountPaths(msg) {
         return Eth.ethGetAccountPaths(msg);
@@ -191,10 +247,7 @@ export class TrezorHDWalletInfo {
             addressNList[0] === 0x80000000 + 49 ||
             addressNList[0] === 0x80000000 + 84) {
             addressNList[2] += 1;
-            return {
-                ...msg,
-                addressNList,
-            };
+            return Object.assign(Object.assign({}, msg), { addressNList });
         }
         return undefined;
     }
@@ -206,186 +259,219 @@ export class TrezorHDWalletInfo {
         }
         if (addressNList[0] === 0x80000000 + 44) {
             addressNList[4] += 1;
-            return {
-                ...msg,
-                addressNList,
-                hardenedPath: core.hardenedPath(addressNList),
-                relPath: core.relativePath(addressNList),
-            };
+            return Object.assign(Object.assign({}, msg), { addressNList, hardenedPath: core.hardenedPath(addressNList), relPath: core.relativePath(addressNList) });
         }
         return undefined;
     }
 }
-export class TrezorHDWallet {
-    _supportsETHInfo = true;
-    _supportsBTCInfo = true;
-    _supportsBTC = true;
-    _supportsETH = true;
-    _supportsEthSwitchChain = true;
-    _supportsAvalanche = true;
-    _supportsOptimism = false;
-    _supportsBSC = false;
-    _supportsPolygon = false;
-    _supportsGnosis = false;
-    _supportsArbitrum = true;
-    _supportsArbitrumNova = true;
-    _supportsBase = true;
-    _supportsKavaInfo = true;
-    _supportsTerraInfo = true;
-    _isTrezor = true;
-    transport;
-    featuresCache;
-    info;
+exports.TrezorHDWalletInfo = TrezorHDWalletInfo;
+class TrezorHDWallet {
     constructor(transport) {
+        this._supportsETHInfo = true;
+        this._supportsBTCInfo = true;
+        this._supportsBTC = true;
+        this._supportsETH = true;
+        this._supportsEthSwitchChain = true;
+        this._supportsAvalanche = true;
+        this._supportsOptimism = false;
+        this._supportsBSC = false;
+        this._supportsPolygon = false;
+        this._supportsGnosis = false;
+        this._supportsArbitrum = true;
+        this._supportsArbitrumNova = true;
+        this._supportsBase = true;
+        this._supportsKavaInfo = true;
+        this._supportsTerraInfo = true;
+        this._isTrezor = true;
         this.transport = transport;
         this.info = new TrezorHDWalletInfo();
     }
-    async initialize() {
-        return;
+    initialize() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return;
+        });
     }
-    async isInitialized() {
-        const features = await this.getFeatures(/*cached*/ true);
-        return features.initialized;
+    isInitialized() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const features = yield this.getFeatures(/*cached*/ true);
+            return features.initialized;
+        });
     }
-    async getDeviceID() {
-        const { device: { deviceID: transportId }, } = this.transport;
-        if (transportId)
-            return transportId;
-        const features = await this.getFeatures(/*cached*/ true);
-        return features.device_id;
+    getDeviceID() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { device: { deviceID: transportId }, } = this.transport;
+            if (transportId)
+                return transportId;
+            const features = yield this.getFeatures(/*cached*/ true);
+            return features.device_id;
+        });
     }
-    async getFirmwareVersion() {
-        const features = await this.getFeatures(/*cached*/ true);
-        return `v${features.major_version}.${features.minor_version}.${features.patch_version}`;
+    getFirmwareVersion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const features = yield this.getFeatures(/*cached*/ true);
+            return `v${features.major_version}.${features.minor_version}.${features.patch_version}`;
+        });
     }
     getVendor() {
         return "Trezor";
     }
-    async getModel() {
-        const features = await this.getFeatures(/*cached*/ true);
-        return "Trezor " + features.model;
+    getModel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const features = yield this.getFeatures(/*cached*/ true);
+            return "Trezor " + features.model;
+        });
     }
-    async getLabel() {
-        const features = await this.getFeatures(/*cached*/ true);
-        return typeof features.label === "string" ? features.label : "";
+    getLabel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const features = yield this.getFeatures(/*cached*/ true);
+            return typeof features.label === "string" ? features.label : "";
+        });
     }
-    async getFeatures(cached = false) {
-        if (cached && this.featuresCache)
-            return this.featuresCache;
-        const res = await this.transport.call("getFeatures", {});
-        handleError(this.transport, res, "Could not get Trezor features");
-        this.cacheFeatures(res.payload);
-        return res.payload;
+    getFeatures() {
+        return __awaiter(this, arguments, void 0, function* (cached = false) {
+            if (cached && this.featuresCache)
+                return this.featuresCache;
+            const res = yield this.transport.call("getFeatures", {});
+            (0, utils_1.handleError)(this.transport, res, "Could not get Trezor features");
+            this.cacheFeatures(res.payload);
+            return res.payload;
+        });
     }
     cacheFeatures(features) {
         this.featuresCache = features;
     }
-    async getPublicKeys(msg) {
-        if (!msg.length)
-            return [];
-        const res = await this.transport.call("getPublicKey", {
-            bundle: msg.map((request) => {
-                return {
-                    path: request.addressNList,
-                    coin: request.coin || "Bitcoin",
-                    crossChain: true,
-                };
-            }),
-        });
-        handleError(this.transport, res, "Could not load xpubs from Trezor");
-        return res.payload.map((result, i) => {
-            const scriptType = msg[i].scriptType;
-            switch (scriptType) {
-                case core.BTCInputScriptType.SpendP2SHWitness:
-                case core.BTCInputScriptType.SpendWitness: {
-                    const xpub = result.xpubSegwit;
-                    if (!xpub)
-                        throw new Error("unable to get public key");
-                    return {
-                        xpub,
-                    };
-                }
-                case core.BTCInputScriptType.SpendAddress:
-                default: {
-                    const xpub = result.xpub;
-                    if (!xpub)
-                        throw new Error("unable to get public key");
+    getPublicKeys(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!msg.length)
+                return [];
+            const res = yield this.transport.call("getPublicKey", {
+                bundle: msg.map((request) => {
                     return {
-                        xpub,
+                        path: request.addressNList,
+                        coin: request.coin || "Bitcoin",
+                        crossChain: true,
                     };
+                }),
+            });
+            (0, utils_1.handleError)(this.transport, res, "Could not load xpubs from Trezor");
+            return res.payload.map((result, i) => {
+                const scriptType = msg[i].scriptType;
+                switch (scriptType) {
+                    case core.BTCInputScriptType.SpendP2SHWitness:
+                    case core.BTCInputScriptType.SpendWitness: {
+                        const xpub = result.xpubSegwit;
+                        if (!xpub)
+                            throw new Error("unable to get public key");
+                        return {
+                            xpub,
+                        };
+                    }
+                    case core.BTCInputScriptType.SpendAddress:
+                    default: {
+                        const xpub = result.xpub;
+                        if (!xpub)
+                            throw new Error("unable to get public key");
+                        return {
+                            xpub,
+                        };
+                    }
                 }
-            }
+            });
         });
     }
-    async isLocked() {
-        const features = await this.getFeatures(false);
-        if (features.pin_protection && !features.pin_cached)
-            return true;
-        if (features.passphrase_protection && !features.passphrase_cached)
-            return true;
-        return false;
+    isLocked() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const features = yield this.getFeatures(false);
+            if (features.pin_protection && !features.pin_cached)
+                return true;
+            if (features.passphrase_protection && !features.passphrase_cached)
+                return true;
+            return false;
+        });
     }
-    async clearSession() {
-        // TrezorConnect doesn't expose session management, so this is a no-op.
+    clearSession() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TrezorConnect doesn't expose session management, so this is a no-op.
+        });
     }
-    async sendPin(pin) {
-        await this.transport.call("uiResponse", {
-            type: "ui-receive_pin",
-            payload: pin,
+    sendPin(pin) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.transport.call("uiResponse", {
+                type: "ui-receive_pin",
+                payload: pin,
+            });
         });
     }
-    async sendPassphrase(passphrase) {
-        await this.transport.call("uiResponse", {
-            type: "ui-receive_passphrase",
-            payload: {
-                value: passphrase,
-                save: true,
-            },
+    sendPassphrase(passphrase) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.transport.call("uiResponse", {
+                type: "ui-receive_passphrase",
+                payload: {
+                    value: passphrase,
+                    save: true,
+                },
+            });
         });
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async sendCharacter(charater) {
-        throw new Error("Trezor does not suport chiphered recovery");
+    sendCharacter(charater) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error("Trezor does not suport chiphered recovery");
+        });
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async sendWord(word) {
-        throw new Error("Trezor does not yet support recoverDevice");
+    sendWord(word) {
+        return __awaiter(this, void 0, void 0, function* () {
+            throw new Error("Trezor does not yet support recoverDevice");
+        });
     }
-    async ping(msg) {
-        // TrezorConnect doesn't expose the device's normal 'Core.Ping' message, so we
-        // have to fake it here:
-        return { msg: msg.msg };
+    ping(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // TrezorConnect doesn't expose the device's normal 'Core.Ping' message, so we
+            // have to fake it here:
+            return { msg: msg.msg };
+        });
     }
-    async wipe() {
-        const res = await this.transport.call("wipeDevice", {});
-        handleError(this.transport, res, "Could not wipe Trezor");
+    wipe() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.transport.call("wipeDevice", {});
+            (0, utils_1.handleError)(this.transport, res, "Could not wipe Trezor");
+        });
     }
-    async reset(msg) {
-        const res = await this.transport.call("resetDevice", {
-            strength: msg.entropy,
-            label: msg.label,
-            pinProtection: msg.pin,
-            passphraseProtection: msg.passphrase,
+    reset(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const res = yield this.transport.call("resetDevice", {
+                strength: msg.entropy,
+                label: msg.label,
+                pinProtection: msg.pin,
+                passphraseProtection: msg.passphrase,
+            });
+            (0, utils_1.handleError)(this.transport, res, "Could not reset Trezor");
         });
-        handleError(this.transport, res, "Could not reset Trezor");
     }
-    async cancel() {
-        await this.transport.cancel();
+    cancel() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.transport.cancel();
+        });
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async recover(msg) {
-        // https://github.com/trezor/connect/pull/320
-        throw new Error("TrezorConnect does not expose Core.RecoverDevice... yet?");
+    recover(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // https://github.com/trezor/connect/pull/320
+            throw new Error("TrezorConnect does not expose Core.RecoverDevice... yet?");
+        });
     }
-    async loadDevice(msg) {
-        // https://github.com/trezor/connect/issues/363
-        const res = await this.transport.call("loadDevice", {
-            mnemonic: msg.mnemonic,
-            pin: msg.pin,
-            passphraseProtection: msg.passphrase,
-            label: msg.label,
+    loadDevice(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // https://github.com/trezor/connect/issues/363
+            const res = yield this.transport.call("loadDevice", {
+                mnemonic: msg.mnemonic,
+                pin: msg.pin,
+                passphraseProtection: msg.passphrase,
+                label: msg.label,
+            });
+            (0, utils_1.handleError)(this.transport, res, "Could not load seed into Trezor");
         });
-        handleError(this.transport, res, "Could not load seed into Trezor");
     }
     hasOnDevicePinEntry() {
         return this.transport.hasPopup;
@@ -413,29 +499,43 @@ export class TrezorHDWallet {
     supportsBroadcast() {
         return false;
     }
-    async btcSupportsCoin(coin) {
-        return this.info.btcSupportsCoin(coin);
+    btcSupportsCoin(coin) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.info.btcSupportsCoin(coin);
+        });
     }
-    async btcSupportsScriptType(coin, scriptType) {
-        return this.info.btcSupportsScriptType(coin, scriptType);
+    btcSupportsScriptType(coin, scriptType) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.info.btcSupportsScriptType(coin, scriptType);
+        });
     }
-    async btcGetAddress(msg) {
-        return Btc.btcGetAddress(this.transport, msg);
+    btcGetAddress(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Btc.btcGetAddress(this.transport, msg);
+        });
     }
-    async btcSignTx(msg) {
-        return Btc.btcSignTx(this, this.transport, msg);
+    btcSignTx(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Btc.btcSignTx(this, this.transport, msg);
+        });
     }
-    async btcSupportsSecureTransfer() {
-        return this.info.btcSupportsSecureTransfer();
+    btcSupportsSecureTransfer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.info.btcSupportsSecureTransfer();
+        });
     }
     btcSupportsNativeShapeShift() {
         return this.info.btcSupportsNativeShapeShift();
     }
-    async btcSignMessage(msg) {
-        return Btc.btcSignMessage(this.transport, msg);
+    btcSignMessage(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Btc.btcSignMessage(this.transport, msg);
+        });
     }
-    async btcVerifyMessage(msg) {
-        return Btc.btcVerifyMessage(this.transport, msg);
+    btcVerifyMessage(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Btc.btcVerifyMessage(this.transport, msg);
+        });
     }
     btcGetAccountPaths(msg) {
         return Btc.btcGetAccountPaths(msg);
@@ -443,29 +543,43 @@ export class TrezorHDWallet {
     btcIsSameAccount(msg) {
         return this.info.btcIsSameAccount(msg);
     }
-    async ethSignTx(msg) {
-        return Eth.ethSignTx(this, this.transport, msg);
+    ethSignTx(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Eth.ethSignTx(this, this.transport, msg);
+        });
     }
-    async ethGetAddress(msg) {
-        return Eth.ethGetAddress(this.transport, msg);
+    ethGetAddress(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Eth.ethGetAddress(this.transport, msg);
+        });
     }
-    async ethSignMessage(msg) {
-        return Eth.ethSignMessage(this.transport, msg);
+    ethSignMessage(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Eth.ethSignMessage(this.transport, msg);
+        });
     }
-    async ethVerifyMessage(msg) {
-        return Eth.ethVerifyMessage(this.transport, msg);
+    ethVerifyMessage(msg) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Eth.ethVerifyMessage(this.transport, msg);
+        });
     }
-    async ethSupportsNetwork(chain_id) {
-        return this.info.ethSupportsNetwork(chain_id);
+    ethSupportsNetwork(chain_id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.info.ethSupportsNetwork(chain_id);
+        });
     }
-    async ethSupportsSecureTransfer() {
-        return this.info.ethSupportsSecureTransfer();
+    ethSupportsSecureTransfer() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.info.ethSupportsSecureTransfer();
+        });
     }
     ethSupportsNativeShapeShift() {
         return this.info.ethSupportsNativeShapeShift();
     }
-    async ethSupportsEIP1559() {
-        return await this.info.ethSupportsEIP1559();
+    ethSupportsEIP1559() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.info.ethSupportsEIP1559();
+        });
     }
     ethGetAccountPaths(msg) {
         return this.info.ethGetAccountPaths(msg);
@@ -483,10 +597,11 @@ export class TrezorHDWallet {
         return this.info.ethNextAccountPath(msg);
     }
 }
-export function info() {
+exports.TrezorHDWallet = TrezorHDWallet;
+function info() {
     return new TrezorHDWalletInfo();
 }
-export function create(transport) {
+function create(transport) {
     return new TrezorHDWallet(transport);
 }
 //# sourceMappingURL=trezor.js.map