@ledgerhq/live-cli 22.4.7-nightly.1 → 22.4.8-hotfix.0

package/lib/commands/appsCheckAllAppVersions.js

@@ -14,7 +14,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     function verb(n) { return function (v) { return step([n, v]); }; }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+        while (_) try {
             if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
             if (y = 0, t) op = [op[0] & 2, t.value];
             switch (op[0]) {

package/lib/commands/botTransfer.js

@@ -25,7 +25,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     function verb(n) { return function (v) { return step([n, v]); }; }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+        while (_) try {
             if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
             if (y = 0, t) op = [op[0] & 2, t.value];
             switch (op[0]) {

package/lib/commands/confirmOp.js

@@ -14,7 +14,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     function verb(n) { return function (v) { return step([n, v]); }; }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+        while (_) try {
             if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
             if (y = 0, t) op = [op[0] & 2, t.value];
             switch (op[0]) {

package/lib/commands/countervalues.d.ts

@@ -1,5 +1,5 @@
 import "lodash.product";
-type Opts = Partial<{
+declare type Opts = Partial<{
     currency: string[];
     countervalue: string[];
     fiats: boolean;

package/lib/commands/countervalues.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"countervalues.d.ts","sourceRoot":"","sources":["../../src/commands/countervalues.ts"],"names":[],"mappings":"AAAA,OAAO,gBAAgB,CAAC;AAqFxB,KAAK,IAAI,GAAG,OAAO,CAAC;IAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,mBAAmB,EAAE,OAAO,CAAC;IAC7B,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAkEW,IAAI;;AAjElB,wBAiIE"}
+{"version":3,"file":"countervalues.d.ts","sourceRoot":"","sources":["../../src/commands/countervalues.ts"],"names":[],"mappings":"AAAA,OAAO,gBAAgB,CAAC;AAqFxB,aAAK,IAAI,GAAG,OAAO,CAAC;IAClB,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,mBAAmB,EAAE,OAAO,CAAC;IAC7B,MAAM,EAAE,OAAO,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAkEW,IAAI;;AAjElB,wBAiIE"}

package/lib/commands/countervalues.js

@@ -14,7 +14,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     function verb(n) { return function (v) { return step([n, v]); }; }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+        while (_) try {
             if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
             if (y = 0, t) op = [op[0] & 2, t.value];
             switch (op[0]) {

package/lib/commands/devDeviceAppsScenario.d.ts

@@ -1,5 +1,5 @@
 import { Observable } from "rxjs";
-type Scenario = number[];
+declare type Scenario = number[];
 declare const scenarios: Record<string, Scenario>;
 declare const _default: {
     description: string;

package/lib/commands/devDeviceAppsScenario.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"devDeviceAppsScenario.d.ts","sourceRoot":"","sources":["../../src/commands/devDeviceAppsScenario.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,UAAU,EAAE,MAAM,MAAM,CAAC;AAevD,KAAK,QAAQ,GAAG,MAAM,EAAE,CAAC;AAMzB,QAAA,MAAM,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CA0BvC,CAAC;;;;;;;;;;;;;;;;gBAmCU,MAAM;kBACJ,MAAM,gBAAgB;;;AAhBpC,wBAiDE"}
+{"version":3,"file":"devDeviceAppsScenario.d.ts","sourceRoot":"","sources":["../../src/commands/devDeviceAppsScenario.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,UAAU,EAAE,MAAM,MAAM,CAAC;AAevD,aAAK,QAAQ,GAAG,MAAM,EAAE,CAAC;AAMzB,QAAA,MAAM,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CA0BvC,CAAC;;;;;;;;;;;;;;;;gBAmCU,MAAM;kBACJ,MAAM,gBAAgB;;;AAhBpC,wBAiDE"}

package/lib/commands/firmwareUpdate.js

@@ -14,7 +14,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     function verb(n) { return function (v) { return step([n, v]); }; }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+        while (_) try {
             if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
             if (y = 0, t) op = [op[0] & 2, t.value];
             switch (op[0]) {

package/lib/commands/ftsFetchImage.d.ts

@@ -1,5 +1,5 @@
 import type { ScanCommonOpts } from "../scan";
-type ftsFetchImageJobOpts = ScanCommonOpts & {
+declare type ftsFetchImageJobOpts = ScanCommonOpts & {
     fileOutput: string;
 };
 declare const _default: {

package/lib/commands/ftsFetchImage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ftsFetchImage.d.ts","sourceRoot":"","sources":["../../src/commands/ftsFetchImage.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAI9C,KAAK,oBAAoB,GAAG,cAAc,GAAG;IAC3C,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;;;;;;;;;;;;;;;gBA2CY,oBAAoB,KAAG,GAAG;;AAXxC,wBAYE"}
+{"version":3,"file":"ftsFetchImage.d.ts","sourceRoot":"","sources":["../../src/commands/ftsFetchImage.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAI9C,aAAK,oBAAoB,GAAG,cAAc,GAAG;IAC3C,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;;;;;;;;;;;;;;;gBAwCY,oBAAoB,KAAG,GAAG;;AAXxC,wBAYE"}

package/lib/commands/ftsFetchImage.js

@@ -14,7 +14,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     function verb(n) { return function (v) { return step([n, v]); }; }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+        while (_) try {
             if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
             if (y = 0, t) op = [op[0] & 2, t.value];
             switch (op[0]) {
@@ -54,13 +54,8 @@ var exec = function (opts) { return __awaiter(void 0, void 0, void 0, function (
                         return (0, ftsFetchImage_1["default"])({ deviceId: deviceId }).subscribe(function (event) {
                             if (event.type === "imageFetched") {
                                 var hexImage = event.hexImage;
-                                if (!fileOutput) {
-                                    console.log(hexImage);
-                                }
-                                else {
-                                    fs_1["default"].writeFileSync(fileOutput, hexImage);
-                                    console.log("".concat(fileOutput, " written"));
-                                }
+                                fs_1["default"].writeFileSync(fileOutput, hexImage);
+                                console.log("".concat(fileOutput, " written"));
                             }
                             else {
                                 console.log(event);

package/lib/commands/ftsFetchImage.js.map

@@ -1 +1 @@
-{"version":3,"file":"ftsFetchImage.js","sourceRoot":"","sources":["../../src/commands/ftsFetchImage.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+BAA+B;AAC/B,6BAA4B;AAC5B,0CAAoB;AAEpB,gCAAoC;AACpC,yFAAmE;AAMnE,IAAM,IAAI,GAAG,UAAO,IAA0B;;;;;gBACpC,KAAsC,IAAI,OAArB,EAAb,QAAQ,mBAAG,EAAE,KAAA,EAAE,UAAU,GAAK,IAAI,WAAT,CAAU;gBAEnD,qBAAM,IAAI,OAAO,CAAO,UAAC,CAAC;wBACxB,OAAA,IAAA,0BAAa,EAAC,EAAE,QAAQ,UAAA,EAAE,CAAC,CAAC,SAAS,CACnC,UAAC,KAAK;4BACJ,IAAI,KAAK,CAAC,IAAI,KAAK,cAAc,EAAE;gCACzB,IAAA,QAAQ,GAAK,KAAK,SAAV,CAAW;gCAC3B,IAAI,CAAC,UAAU,EAAE;oCACf,OAAO,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAA;iCACtB;qCAAM;oCACL,eAAE,CAAC,aAAa,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;oCACvC,OAAO,CAAC,GAAG,CAAC,UAAG,UAAU,aAAU,CAAC,CAAC;iCACtC;6BACF;iCAAM;gCACL,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;6BACpB;wBACH,CAAC,EACD,UAAC,CAAC;4BACA,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;4BACjB,CAAC,EAAE,CAAC;wBACN,CAAC,EACD;4BACE,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;4BAC9B,CAAC,EAAE,CAAC;wBACN,CAAC,CACF;oBAtBD,CAsBC,CACF,EAAA;;gBAxBD,SAwBC,CAAC;;;;KACH,CAAC;AAEF,qBAAe;IACb,WAAW,EAAE,2EAA2E;IACxF,IAAI,EAAE;QACJ,gBAAS;QACT;YACE,IAAI,EAAE,YAAY;YAClB,KAAK,EAAE,GAAG;YACV,IAAI,EAAE,MAAM;YACZ,IAAI,EAAE,4DAA4D;SACnE;KACF;IACD,GAAG,EAAE,UAAC,IAA0B,IAAU,OAAA,IAAA,WAAI,EAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAhB,CAAgB;CAC3D,CAAC"}
+{"version":3,"file":"ftsFetchImage.js","sourceRoot":"","sources":["../../src/commands/ftsFetchImage.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+BAA+B;AAC/B,6BAA4B;AAC5B,0CAAoB;AAEpB,gCAAoC;AACpC,yFAAmE;AAMnE,IAAM,IAAI,GAAG,UAAO,IAA0B;;;;;gBACpC,KAAsC,IAAI,OAArB,EAAb,QAAQ,mBAAG,EAAE,KAAA,EAAE,UAAU,GAAK,IAAI,WAAT,CAAU;gBAEnD,qBAAM,IAAI,OAAO,CAAO,UAAC,CAAC;wBACxB,OAAA,IAAA,0BAAa,EAAC,EAAE,QAAQ,UAAA,EAAE,CAAC,CAAC,SAAS,CACnC,UAAC,KAAK;4BACJ,IAAI,KAAK,CAAC,IAAI,KAAK,cAAc,EAAE;gCACzB,IAAA,QAAQ,GAAK,KAAK,SAAV,CAAW;gCAE3B,eAAE,CAAC,aAAa,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC;gCACvC,OAAO,CAAC,GAAG,CAAC,UAAG,UAAU,aAAU,CAAC,CAAC;6BACtC;iCAAM;gCACL,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;6BACpB;wBACH,CAAC,EACD,UAAC,CAAC;4BACA,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;4BACjB,CAAC,EAAE,CAAC;wBACN,CAAC,EACD;4BACE,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;4BAC9B,CAAC,EAAE,CAAC;wBACN,CAAC,CACF;oBAnBD,CAmBC,CACF,EAAA;;gBArBD,SAqBC,CAAC;;;;KACH,CAAC;AAEF,qBAAe;IACb,WAAW,EAAE,2EAA2E;IACxF,IAAI,EAAE;QACJ,gBAAS;QACT;YACE,IAAI,EAAE,YAAY;YAClB,KAAK,EAAE,GAAG;YACV,IAAI,EAAE,MAAM;YACZ,IAAI,EAAE,4DAA4D;SACnE;KACF;IACD,GAAG,EAAE,UAAC,IAA0B,IAAU,OAAA,IAAA,WAAI,EAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAhB,CAAgB;CAC3D,CAAC"}

package/lib/commands/ftsLoadImage.d.ts

@@ -1,5 +1,5 @@
 import type { ScanCommonOpts } from "../scan";
-type ftsLoadImageJobOpts = ScanCommonOpts & {
+declare type ftsLoadImageJobOpts = ScanCommonOpts & {
     fileInput: string;
 };
 declare const _default: {

package/lib/commands/ftsLoadImage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ftsLoadImage.d.ts","sourceRoot":"","sources":["../../src/commands/ftsLoadImage.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAI9C,KAAK,mBAAmB,GAAG,cAAc,GAAG;IAC1C,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;;;;;;;;;;;;;;;gBAkCY,mBAAmB,KAAG,GAAG;;AAXvC,wBAYE"}
+{"version":3,"file":"ftsLoadImage.d.ts","sourceRoot":"","sources":["../../src/commands/ftsLoadImage.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAI9C,aAAK,mBAAmB,GAAG,cAAc,GAAG;IAC1C,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;;;;;;;;;;;;;;;gBAkCY,mBAAmB,KAAG,GAAG;;AAXvC,wBAYE"}

package/lib/commands/ftsLoadImage.js

@@ -14,7 +14,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     function verb(n) { return function (v) { return step([n, v]); }; }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+        while (_) try {
             if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
             if (y = 0, t) op = [op[0] & 2, t.value];
             switch (op[0]) {
@@ -50,13 +50,13 @@ var exec = function (opts) { return __awaiter(void 0, void 0, void 0, function (
             case 0:
                 fileInput = opts.fileInput, _a = opts.device, deviceId = _a === void 0 ? "" : _a;
                 hexImage = fs_1["default"].readFileSync(fileInput, "utf-8");
-                return [4 /*yield*/, new Promise(function (resolve) {
+                return [4 /*yield*/, new Promise(function (p) {
                         return (0, ftsLoadImage_1["default"])({ deviceId: deviceId, hexImage: hexImage }).subscribe(function (x) { return console.log(x); }, function (e) {
                             console.error(e);
-                            resolve();
+                            p();
                         }, function () {
                             console.log("Image loaded.");
-                            resolve();
+                            p();
                         });
                     })];
             case 1:
@@ -73,7 +73,7 @@ exports["default"] = {
             name: "fileInput",
             alias: "i",
             type: String,
-            desc: "Text file containing the hex data of the image to load on FTS"
+            desc: "Text file containing the base64 data of the image to load on FTS"
         }
     ],
     job: function (opts) { return (0, rxjs_1.from)(exec(opts)); }

package/lib/commands/ftsLoadImage.js.map

@@ -1 +1 @@
-{"version":3,"file":"ftsLoadImage.js","sourceRoot":"","sources":["../../src/commands/ftsLoadImage.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,6BAA4B;AAC5B,0CAAoB;AAEpB,uFAAiE;AACjE,gCAAoC;AAOpC,IAAM,IAAI,GAAG,UAAO,IAAyB;;;;;gBACnC,SAAS,GAA4B,IAAI,UAAhC,EAAE,KAA0B,IAAI,OAAT,EAAb,QAAQ,mBAAG,EAAE,KAAA,CAAU;gBAE5C,QAAQ,GAAG,eAAE,CAAC,YAAY,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;gBAErD,qBAAM,IAAI,OAAO,CAAO,UAAC,OAAO;wBAC5B,OAAA,IAAA,yBAAY,EAAC,EAAE,QAAQ,UAAA,EAAE,QAAQ,UAAA,EAAE,CAAC,CAAC,SAAS,CAC5C,UAAC,CAAC,IAAK,OAAA,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAd,CAAc,EACrB,UAAC,CAAC;4BACA,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;4BACjB,OAAO,EAAE,CAAC;wBACZ,CAAC,EACD;4BACE,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;4BAC7B,OAAO,EAAE,CAAC;wBACZ,CAAC,CACF;oBAVD,CAUC,CACF,EAAA;;gBAZH,SAYG,CAAC;;;;KACL,CAAC;AAEF,qBAAe;IACb,WAAW,EAAE,0EAA0E;IACvF,IAAI,EAAE;QACJ,gBAAS;QACT;YACE,IAAI,EAAE,WAAW;YACjB,KAAK,EAAE,GAAG;YACV,IAAI,EAAE,MAAM;YACZ,IAAI,EAAE,+DAA+D;SACtE;KACF;IACD,GAAG,EAAE,UAAC,IAAyB,IAAU,OAAA,IAAA,WAAI,EAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAhB,CAAgB;CAC1D,CAAC"}
+{"version":3,"file":"ftsLoadImage.js","sourceRoot":"","sources":["../../src/commands/ftsLoadImage.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,6BAA4B;AAC5B,0CAAoB;AAEpB,uFAAiE;AACjE,gCAAoC;AAOpC,IAAM,IAAI,GAAG,UAAO,IAAyB;;;;;gBACnC,SAAS,GAA4B,IAAI,UAAhC,EAAE,KAA0B,IAAI,OAAT,EAAb,QAAQ,mBAAG,EAAE,KAAA,CAAU;gBAE5C,QAAQ,GAAG,eAAE,CAAC,YAAY,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;gBAErD,qBAAM,IAAI,OAAO,CAAO,UAAC,CAAC;wBACtB,OAAA,IAAA,yBAAY,EAAC,EAAE,QAAQ,UAAA,EAAE,QAAQ,UAAA,EAAE,CAAC,CAAC,SAAS,CAC5C,UAAC,CAAC,IAAK,OAAA,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAd,CAAc,EACrB,UAAC,CAAC;4BACA,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;4BACjB,CAAC,EAAE,CAAC;wBACN,CAAC,EACD;4BACE,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;4BAC7B,CAAC,EAAE,CAAC;wBACN,CAAC,CACF;oBAVD,CAUC,CACF,EAAA;;gBAZH,SAYG,CAAC;;;;KACL,CAAC;AAEF,qBAAe;IACb,WAAW,EAAE,0EAA0E;IACvF,IAAI,EAAE;QACJ,gBAAS;QACT;YACE,IAAI,EAAE,WAAW;YACjB,KAAK,EAAE,GAAG;YACV,IAAI,EAAE,MAAM;YACZ,IAAI,EAAE,kEAAkE;SACzE;KACF;IACD,GAAG,EAAE,UAAC,IAAyB,IAAU,OAAA,IAAA,WAAI,EAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAhB,CAAgB;CAC1D,CAAC"}

package/lib/commands/i18n.d.ts

@@ -1,5 +1,5 @@
 import type { ScanCommonOpts } from "../scan";
-type i18nJobOps = ScanCommonOpts & {
+declare type i18nJobOps = ScanCommonOpts & {
     deviceId: string;
     install: string;
     uninstall: string;

package/lib/commands/i18n.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../../src/commands/i18n.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAM9C,KAAK,UAAU,GAAG,cAAc,GAAG;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;;;;;;;;;;;;;;;gBAuDY,UAAU,KAAG,GAAG;;AAjB9B,wBAkBE"}
+{"version":3,"file":"i18n.d.ts","sourceRoot":"","sources":["../../src/commands/i18n.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAM9C,aAAK,UAAU,GAAG,cAAc,GAAG;IACjC,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;IACrB,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;;;;;;;;;;;;;;;gBAuDY,UAAU,KAAG,GAAG;;AAjB9B,wBAkBE"}

package/lib/commands/i18n.js

@@ -14,7 +14,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     function verb(n) { return function (v) { return step([n, v]); }; }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+        while (_) try {
             if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
             if (y = 0, t) op = [op[0] & 2, t.value];
             switch (op[0]) {

package/lib/commands/proxy.js

@@ -14,7 +14,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     function verb(n) { return function (v) { return step([n, v]); }; }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+        while (_) try {
             if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
             if (y = 0, t) op = [op[0] & 2, t.value];
             switch (op[0]) {

package/lib/commands/speculosList.js

@@ -14,7 +14,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     function verb(n) { return function (v) { return step([n, v]); }; }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+        while (_) try {
             if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
             if (y = 0, t) op = [op[0] & 2, t.value];
             switch (op[0]) {

package/lib/commands/swap.d.ts

@@ -1,5 +1,5 @@
 import type { ScanCommonOpts } from "../scan";
-type SwapJobOpts = ScanCommonOpts & {
+declare type SwapJobOpts = ScanCommonOpts & {
     amount: string;
     useAllAmount: boolean;
     useFloat: boolean;

package/lib/commands/swap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swap.d.ts","sourceRoot":"","sources":["../../src/commands/swap.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAgB9C,KAAK,WAAW,GAAG,cAAc,GAAG;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,OAAO,CAAC;IACtB,QAAQ,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,GAAG,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAqTY,WAAW;;AA1CzB,wBA2CE"}
+{"version":3,"file":"swap.d.ts","sourceRoot":"","sources":["../../src/commands/swap.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAgB9C,aAAK,WAAW,GAAG,cAAc,GAAG;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,OAAO,CAAC;IACtB,QAAQ,EAAE,OAAO,CAAC;IAClB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,GAAG,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAqTY,WAAW;;AA1CzB,wBA2CE"}

package/lib/commands/swap.js

@@ -14,7 +14,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     function verb(n) { return function (v) { return step([n, v]); }; }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+        while (_) try {
             if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
             if (y = 0, t) op = [op[0] & 2, t.value];
             switch (op[0]) {

package/lib/commands/sync.js

@@ -25,7 +25,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     function verb(n) { return function (v) { return step([n, v]); }; }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+        while (_) try {
             if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
             if (y = 0, t) op = [op[0] & 2, t.value];
             switch (op[0]) {

package/lib/commands/testGetTrustedInputFromTxHash.js

@@ -14,7 +14,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     function verb(n) { return function (v) { return step([n, v]); }; }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+        while (_) try {
             if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
             if (y = 0, t) op = [op[0] & 2, t.value];
             switch (op[0]) {

package/lib/commands/walletconnect.d.ts

@@ -1,5 +1,5 @@
 import type { ScanCommonOpts } from "../scan";
-type Opts = ScanCommonOpts & Partial<{
+declare type Opts = ScanCommonOpts & Partial<{
     walletConnectURI: string;
     walletConnectSession: string;
     verbose: boolean;

package/lib/commands/walletconnect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"walletconnect.d.ts","sourceRoot":"","sources":["../../src/commands/walletconnect.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAiB9C,KAAK,IAAI,GAAG,cAAc,GACxB,OAAO,CAAC;IACN,gBAAgB,EAAE,MAAM,CAAC;IACzB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA2KS,IAAI;;AA1BlB,wBAwCE"}
+{"version":3,"file":"walletconnect.d.ts","sourceRoot":"","sources":["../../src/commands/walletconnect.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAiB9C,aAAK,IAAI,GAAG,cAAc,GACxB,OAAO,CAAC;IACN,gBAAgB,EAAE,MAAM,CAAC;IACzB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBA2KS,IAAI;;AA1BlB,wBAwCE"}

package/lib/commands/walletconnect.js

@@ -15,7 +15,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     function verb(n) { return function (v) { return step([n, v]); }; }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+        while (_) try {
             if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
             if (y = 0, t) op = [op[0] & 2, t.value];
             switch (op[0]) {

package/lib/commands-index.d.ts

@@ -580,35 +580,6 @@ declare const _default: {
             listOSUs: boolean;
         }>) => import("rxjs").Observable<unknown>;
     };
-    ftsFetchAndRestoreDemo: {
-        description: string;
-        args: ({
-            name: string;
-            alias: string;
-            type: StringConstructor;
-            descOpt: string;
-            desc: string;
-        } | {
-            name: string;
-            alias: string;
-            type: StringConstructor;
-            desc: string;
-        })[];
-        job: (opts: Partial<{
-            device: string;
-            id: string[];
-            xpub: string[];
-            file: string;
-            appjsonFile: string;
-            currency: string;
-            scheme: string;
-            index: number;
-            length: number;
-            paginateOperations: number;
-        }> & {
-            fileInput: string;
-        }) => any;
-    };
     ftsFetchImage: {
         description: string;
         args: ({
@@ -638,28 +609,6 @@ declare const _default: {
             fileOutput: string;
         }) => any;
     };
-    ftsFetchImageHash: {
-        description: string;
-        args: {
-            name: string;
-            alias: string;
-            type: StringConstructor;
-            descOpt: string;
-            desc: string;
-        }[];
-        job: (arg: Partial<{
-            device: string;
-            id: string[];
-            xpub: string[];
-            file: string;
-            appjsonFile: string;
-            currency: string;
-            scheme: string;
-            index: number;
-            length: number;
-            paginateOperations: number;
-        }>) => any;
-    };
     ftsLoadImage: {
         description: string;
         args: ({

package/lib/commands-index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"commands-index.d.ts","sourceRoot":"","sources":["../src/commands-index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyDA,wBAyDE"}
+{"version":3,"file":"commands-index.d.ts","sourceRoot":"","sources":["../src/commands-index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuDA,wBAuDE"}

package/lib/commands-index.js

@@ -27,9 +27,7 @@ var estimateMaxSpendable_1 = __importDefault(require("./commands/estimateMaxSpen
 var exportAccounts_1 = __importDefault(require("./commands/exportAccounts"));
 var firmwareRepair_1 = __importDefault(require("./commands/firmwareRepair"));
 var firmwareUpdate_1 = __importDefault(require("./commands/firmwareUpdate"));
-var ftsFetchAndRestoreDemo_1 = __importDefault(require("./commands/ftsFetchAndRestoreDemo"));
 var ftsFetchImage_1 = __importDefault(require("./commands/ftsFetchImage"));
-var ftsFetchImageHash_1 = __importDefault(require("./commands/ftsFetchImageHash"));
 var ftsLoadImage_1 = __importDefault(require("./commands/ftsLoadImage"));
 var generateTestScanAccounts_1 = __importDefault(require("./commands/generateTestScanAccounts"));
 var generateTestTransaction_1 = __importDefault(require("./commands/generateTestTransaction"));
@@ -84,9 +82,7 @@ exports["default"] = {
     exportAccounts: exportAccounts_1["default"],
     firmwareRepair: firmwareRepair_1["default"],
     firmwareUpdate: firmwareUpdate_1["default"],
-    ftsFetchAndRestoreDemo: ftsFetchAndRestoreDemo_1["default"],
     ftsFetchImage: ftsFetchImage_1["default"],
-    ftsFetchImageHash: ftsFetchImageHash_1["default"],
     ftsLoadImage: ftsLoadImage_1["default"],
     generateTestScanAccounts: generateTestScanAccounts_1["default"],
     generateTestTransaction: generateTestTransaction_1["default"],

package/lib/commands-index.js.map

@@ -1 +1 @@
-{"version":3,"file":"commands-index.js","sourceRoot":"","sources":["../src/commands-index.ts"],"names":[],"mappings":";;;;;AAAA,uDAAiC;AACjC,+EAAyD;AACzD,+FAAyE;AACzE,6EAAuD;AACvD,mFAA6D;AAC7D,6EAAuD;AACvD,uDAAiC;AACjC,yEAAmD;AACnD,uEAAiD;AACjD,mEAA6C;AAC7C,2EAAqD;AACrD,mEAA6C;AAC7C,2EAAqD;AACrD,qEAA+C;AAC/C,2FAAqE;AACrE,iFAA2D;AAC3D,qEAA+C;AAC/C,2EAAqD;AACrD,+EAAyD;AACzD,yDAAmC;AACnC,yFAAmE;AACnE,6EAAuD;AACvD,6EAAuD;AACvD,6EAAuD;AACvD,6FAAuE;AACvE,2EAAqD;AACrD,mFAA6D;AAC7D,yEAAmD;AACnD,iGAA2E;AAC3E,+FAAyE;AACzE,yEAAmD;AACnD,qEAA+C;AAC/C,yFAAmE;AACnE,yFAAmE;AACnE,yDAAmC;AACnC,iEAA2C;AAC3C,uFAAiE;AACjE,+EAAyD;AACzD,mEAA6C;AAC7C,2DAAqC;AACrC,+DAAyC;AACzC,yDAAmC;AACnC,iEAA2C;AAC3C,6EAAuD;AACvD,+EAAyD;AACzD,yDAAmC;AACnC,uEAAiD;AACjD,yEAAmD;AACnD,yDAAmC;AACnC,yDAAmC;AACnC,2FAAqE;AACrE,2FAAqE;AACrE,2GAAqF;AACrF,yDAAmC;AACnC,+DAAyC;AACzC,2EAAqD;AAErD,qBAAe;IACb,GAAG,kBAAA;IACH,eAAe,8BAAA;IACf,uBAAuB,sCAAA;IACvB,cAAc,6BAAA;IACd,iBAAiB,gCAAA;IACjB,cAAc,6BAAA;IACd,GAAG,kBAAA;IACH,YAAY,2BAAA;IACZ,WAAW,0BAAA;IACX,SAAS,wBAAA;IACT,aAAa,4BAAA;IACb,SAAS,wBAAA;IACT,aAAa,4BAAA;IACb,UAAU,yBAAA;IACV,qBAAqB,oCAAA;IACrB,gBAAgB,+BAAA;IAChB,UAAU,yBAAA;IACV,aAAa,4BAAA;IACb,eAAe,8BAAA;IACf,IAAI,mBAAA;IACJ,oBAAoB,mCAAA;IACpB,cAAc,6BAAA;IACd,cAAc,6BAAA;IACd,cAAc,6BAAA;IACd,sBAAsB,qCAAA;IACtB,aAAa,4BAAA;IACb,iBAAiB,gCAAA;IACjB,YAAY,2BAAA;IACZ,wBAAwB,uCAAA;IACxB,uBAAuB,sCAAA;IACvB,YAAY,2BAAA;IACZ,UAAU,yBAAA;IACV,oBAAoB,mCAAA;IACpB,oBAAoB,mCAAA;IACpB,IAAI,mBAAA;IACJ,QAAQ,uBAAA;IACR,mBAAmB,kCAAA;IACnB,eAAe,8BAAA;IACf,SAAS,wBAAA;IACT,KAAK,oBAAA;IACL,OAAO,sBAAA;IACP,IAAI,mBAAA;IACJ,QAAQ,uBAAA;IACR,cAAc,6BAAA;IACd,eAAe,8BAAA;IACf,IAAI,mBAAA;IACJ,WAAW,0BAAA;IACX,YAAY,2BAAA;IACZ,IAAI,mBAAA;IACJ,IAAI,mBAAA;IACJ,qBAAqB,oCAAA;IACrB,qBAAqB,oCAAA;IACrB,6BAA6B,4CAAA;IAC7B,IAAI,mBAAA;IACJ,OAAO,sBAAA;IACP,aAAa,4BAAA;CACd,CAAC"}
+{"version":3,"file":"commands-index.js","sourceRoot":"","sources":["../src/commands-index.ts"],"names":[],"mappings":";;;;;AAAA,uDAAiC;AACjC,+EAAyD;AACzD,+FAAyE;AACzE,6EAAuD;AACvD,mFAA6D;AAC7D,6EAAuD;AACvD,uDAAiC;AACjC,yEAAmD;AACnD,uEAAiD;AACjD,mEAA6C;AAC7C,2EAAqD;AACrD,mEAA6C;AAC7C,2EAAqD;AACrD,qEAA+C;AAC/C,2FAAqE;AACrE,iFAA2D;AAC3D,qEAA+C;AAC/C,2EAAqD;AACrD,+EAAyD;AACzD,yDAAmC;AACnC,yFAAmE;AACnE,6EAAuD;AACvD,6EAAuD;AACvD,6EAAuD;AACvD,2EAAqD;AACrD,yEAAmD;AACnD,iGAA2E;AAC3E,+FAAyE;AACzE,yEAAmD;AACnD,qEAA+C;AAC/C,yFAAmE;AACnE,yFAAmE;AACnE,yDAAmC;AACnC,iEAA2C;AAC3C,uFAAiE;AACjE,+EAAyD;AACzD,mEAA6C;AAC7C,2DAAqC;AACrC,+DAAyC;AACzC,yDAAmC;AACnC,iEAA2C;AAC3C,6EAAuD;AACvD,+EAAyD;AACzD,yDAAmC;AACnC,uEAAiD;AACjD,yEAAmD;AACnD,yDAAmC;AACnC,yDAAmC;AACnC,2FAAqE;AACrE,2FAAqE;AACrE,2GAAqF;AACrF,yDAAmC;AACnC,+DAAyC;AACzC,2EAAqD;AAErD,qBAAe;IACb,GAAG,kBAAA;IACH,eAAe,8BAAA;IACf,uBAAuB,sCAAA;IACvB,cAAc,6BAAA;IACd,iBAAiB,gCAAA;IACjB,cAAc,6BAAA;IACd,GAAG,kBAAA;IACH,YAAY,2BAAA;IACZ,WAAW,0BAAA;IACX,SAAS,wBAAA;IACT,aAAa,4BAAA;IACb,SAAS,wBAAA;IACT,aAAa,4BAAA;IACb,UAAU,yBAAA;IACV,qBAAqB,oCAAA;IACrB,gBAAgB,+BAAA;IAChB,UAAU,yBAAA;IACV,aAAa,4BAAA;IACb,eAAe,8BAAA;IACf,IAAI,mBAAA;IACJ,oBAAoB,mCAAA;IACpB,cAAc,6BAAA;IACd,cAAc,6BAAA;IACd,cAAc,6BAAA;IACd,aAAa,4BAAA;IACb,YAAY,2BAAA;IACZ,wBAAwB,uCAAA;IACxB,uBAAuB,sCAAA;IACvB,YAAY,2BAAA;IACZ,UAAU,yBAAA;IACV,oBAAoB,mCAAA;IACpB,oBAAoB,mCAAA;IACpB,IAAI,mBAAA;IACJ,QAAQ,uBAAA;IACR,mBAAmB,kCAAA;IACnB,eAAe,8BAAA;IACf,SAAS,wBAAA;IACT,KAAK,oBAAA;IACL,OAAO,sBAAA;IACP,IAAI,mBAAA;IACJ,QAAQ,uBAAA;IACR,cAAc,6BAAA;IACd,eAAe,8BAAA;IACf,IAAI,mBAAA;IACJ,WAAW,0BAAA;IACX,YAAY,2BAAA;IACZ,IAAI,mBAAA;IACJ,IAAI,mBAAA;IACJ,qBAAqB,oCAAA;IACrB,qBAAqB,oCAAA;IACrB,6BAA6B,4CAAA;IAC7B,IAAI,mBAAA;IACJ,OAAO,sBAAA;IACP,aAAa,4BAAA;CACd,CAAC"}

package/lib/live-common-setup.js

@@ -40,7 +40,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     function verb(n) { return function (v) { return step([n, v]); }; }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+        while (_) try {
             if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
             if (y = 0, t) op = [op[0] & 2, t.value];
             switch (op[0]) {

package/lib/scan.d.ts

@@ -14,7 +14,7 @@ export declare const currencyOpt: {
     type: StringConstructor;
     desc: string;
 };
-export type ScanCommonOpts = Partial<{
+export declare type ScanCommonOpts = Partial<{
     device: string;
     id: string[];
     xpub: string[];

package/lib/scan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../src/scan.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAuC,MAAM,MAAM,CAAC;AAUvE,OAAO,KAAK,EACV,OAAO,EAER,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EACV,cAAc,EACf,MAAM,8BAA8B,CAAC;AA8BtC,eAAO,MAAM,SAAS;;;;;;CAMrB,CAAC;AACF,eAAO,MAAM,WAAW;;;;;CAKvB,CAAC;AAYF,MAAM,MAAM,cAAc,GAAG,OAAO,CAAC;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC,CAAC;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAkD1B,CAAC;AACF,eAAO,MAAM,eAAe,YAAa,MAAM,KAAG,MAQjD,CAAC;AAYF,eAAO,MAAM,aAAa;YAEd,MAAM;cACJ,MAAM;UACV,MAAM;UACN,MAAM,EAAE;QACV,MAAM,EAAE;sGA2Bf,CAAC;AAiBF,wBAAgB,IAAI,CAAC,GAAG,EAAE,cAAc,GAAG,UAAU,CAAC,OAAO,CAAC,CAkN7D"}
+{"version":3,"file":"scan.d.ts","sourceRoot":"","sources":["../src/scan.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAuC,MAAM,MAAM,CAAC;AAUvE,OAAO,KAAK,EACV,OAAO,EAER,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EACV,cAAc,EACf,MAAM,8BAA8B,CAAC;AA8BtC,eAAO,MAAM,SAAS;;;;;;CAMrB,CAAC;AACF,eAAO,MAAM,WAAW;;;;;CAKvB,CAAC;AAYF,oBAAY,cAAc,GAAG,OAAO,CAAC;IACnC,MAAM,EAAE,MAAM,CAAC;IACf,EAAE,EAAE,MAAM,EAAE,CAAC;IACb,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC,CAAC;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAkD1B,CAAC;AACF,eAAO,MAAM,eAAe,YAAa,MAAM,KAAG,MAQjD,CAAC;AAYF,eAAO,MAAM,aAAa;YAEd,MAAM;cACJ,MAAM;UACV,MAAM;UACN,MAAM,EAAE;QACV,MAAM,EAAE;sGA2Bf,CAAC;AAiBF,wBAAgB,IAAI,CAAC,GAAG,EAAE,cAAc,GAAG,UAAU,CAAC,OAAO,CAAC,CAkN7D"}

package/lib/signedOperation.d.ts

@@ -1,6 +1,6 @@
 import type { Observable } from "rxjs";
 import type { SignedOperation, Account } from "@ledgerhq/types-live";
-export type InferSignedOperationsOpts = Partial<{
+export declare type InferSignedOperationsOpts = Partial<{
     "signed-operation": string;
 }>;
 export declare const inferSignedOperationsOpts: {

package/lib/signedOperation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signedOperation.d.ts","sourceRoot":"","sources":["../src/signedOperation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAGvC,OAAO,KAAK,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAGrE,MAAM,MAAM,yBAAyB,GAAG,OAAO,CAAC;IAC9C,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC,CAAC;AACH,eAAO,MAAM,yBAAyB;;;;;GAOrC,CAAC;AACF,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,OAAO,EACpB,IAAI,EAAE,yBAAyB,GAC9B,UAAU,CAAC,eAAe,CAAC,CAe7B"}
+{"version":3,"file":"signedOperation.d.ts","sourceRoot":"","sources":["../src/signedOperation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,MAAM,CAAC;AAGvC,OAAO,KAAK,EAAE,eAAe,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AAGrE,oBAAY,yBAAyB,GAAG,OAAO,CAAC;IAC9C,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC,CAAC;AACH,eAAO,MAAM,yBAAyB;;;;;GAOrC,CAAC;AACF,wBAAgB,qBAAqB,CACnC,WAAW,EAAE,OAAO,EACpB,IAAI,EAAE,yBAAyB,GAC9B,UAAU,CAAC,eAAe,CAAC,CAe7B"}

package/lib/transaction.d.ts

@@ -1,7 +1,7 @@
 import "lodash.product";
 import type { Transaction } from "@ledgerhq/live-common/generated/types";
 import type { Account, TransactionStatusCommon } from "@ledgerhq/types-live";
-export type InferTransactionsOpts = Partial<{
+export declare type InferTransactionsOpts = Partial<{
     "self-transaction": boolean;
     "use-all-amount": boolean;
     recipient: string[];

package/lib/transaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../src/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,gBAAgB,CAAC;AAOxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uCAAuC,CAAC;AACzE,OAAO,KAAK,EACV,OAAO,EAGP,uBAAuB,EACxB,MAAM,sBAAsB,CAAC;AA4B9B,MAAM,MAAM,qBAAqB,GAAG,OAAO,CAAC;IAC1C,kBAAkB,EAAE,OAAO,CAAC;IAC5B,gBAAgB,EAAE,OAAO,CAAC;IAC1B,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC,CAAC;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;IA+CjC,CAAC;AACF,wBAAsB,iBAAiB,CACrC,WAAW,EAAE,OAAO,EACpB,IAAI,EAAE,qBAAqB,GAC1B,OAAO,CAAC,CAAC,WAAW,EAAE,uBAAuB,CAAC,EAAE,CAAC,CA8EnD"}
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../src/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,gBAAgB,CAAC;AAOxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uCAAuC,CAAC;AACzE,OAAO,KAAK,EACV,OAAO,EAGP,uBAAuB,EACxB,MAAM,sBAAsB,CAAC;AA4B9B,oBAAY,qBAAqB,GAAG,OAAO,CAAC;IAC1C,kBAAkB,EAAE,OAAO,CAAC;IAC5B,gBAAgB,EAAE,OAAO,CAAC;IAC1B,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC,CAAC;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;IA+CjC,CAAC;AACF,wBAAsB,iBAAiB,CACrC,WAAW,EAAE,OAAO,EACpB,IAAI,EAAE,qBAAqB,GAC1B,OAAO,CAAC,CAAC,WAAW,EAAE,uBAAuB,CAAC,EAAE,CAAC,CA8EnD"}

package/lib/transaction.js

@@ -14,7 +14,7 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     function verb(n) { return function (v) { return step([n, v]); }; }
     function step(op) {
         if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+        while (_) try {
             if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
             if (y = 0, t) op = [op[0] & 2, t.value];
             switch (op[0]) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ledgerhq/live-cli",
-  "version": "22.4.7-nightly.1",
+  "version": "22.4.8-hotfix.0",
   "description": "ledger-live CLI version",
   "repository": {
     "type": "git",
@@ -17,10 +17,10 @@
     "lib"
   ],
   "peerDependencies": {
-    "@ledgerhq/hw-transport-node-ble": "^6.27.8-nightly.0"
+    "@ledgerhq/hw-transport-node-ble": "^6.27.7"
   },
   "optionalDependencies": {
-    "@ledgerhq/hw-transport-node-ble": "^6.27.8-nightly.0"
+    "@ledgerhq/hw-transport-node-ble": "^6.27.7"
   },
   "dependencies": {
     "@walletconnect/client": "^1.7.1",
@@ -43,14 +43,14 @@
     "winston": "^3.5.1",
     "ws": "^8.6.0",
     "@ledgerhq/cryptoassets": "^6.37.0",
-    "@ledgerhq/errors": "^6.12.1-nightly.0",
-    "@ledgerhq/hw-app-btc": "^9.0.1-nightly.0",
-    "@ledgerhq/hw-transport": "^6.27.8-nightly.0",
-    "@ledgerhq/hw-transport-http": "^6.27.8-nightly.0",
-    "@ledgerhq/hw-transport-mocker": "^6.27.8-nightly.0",
-    "@ledgerhq/hw-transport-node-hid": "^6.27.8-nightly.0",
-    "@ledgerhq/hw-transport-node-speculos": "^6.27.8-nightly.0",
-    "@ledgerhq/live-common": "^27.8.0-nightly.1",
+    "@ledgerhq/errors": "^6.12.0",
+    "@ledgerhq/hw-app-btc": "^9.0.0",
+    "@ledgerhq/hw-transport": "^6.27.7",
+    "@ledgerhq/hw-transport-http": "^6.27.7",
+    "@ledgerhq/hw-transport-mocker": "^6.27.7",
+    "@ledgerhq/hw-transport-node-hid": "^6.27.7",
+    "@ledgerhq/hw-transport-node-speculos": "^6.27.7",
+    "@ledgerhq/live-common": "^27.7.2-hotfix.0",
     "@ledgerhq/logs": "^6.10.1"
   },
   "devDependencies": {
@@ -61,7 +61,7 @@
     "ts-node": "^10.4.0",
     "typescript": "^4.8.3",
     "@ledgerhq/types-cryptoassets": "^6.23.3",
-    "@ledgerhq/types-live": "^6.27.0-nightly.0"
+    "@ledgerhq/types-live": "^6.26.0"
   },
   "scripts": {
     "prebuild": "zx ./scripts/gen.mjs",

package/lib/commands/ftsFetchAndRestoreDemo.d.ts

@@ -1,28 +0,0 @@
-import type { ScanCommonOpts } from "../scan";
-/**
- * This is an implmentation demo of what we will have during a firmware update
- * where an image will be backed up _only_ if the hash we have is the cached
- * version we have is different from the one on the device. This would speed up
- * the flow if the user hasn't changed the image since the last time we backed it.
- */
-type ftsFetchAndRestoreJobOpts = ScanCommonOpts & {
-    fileInput: string;
-};
-declare const _default: {
-    description: string;
-    args: ({
-        name: string;
-        alias: string;
-        type: StringConstructor;
-        descOpt: string;
-        desc: string;
-    } | {
-        name: string;
-        alias: string;
-        type: StringConstructor;
-        desc: string;
-    })[];
-    job: (opts: ftsFetchAndRestoreJobOpts) => any;
-};
-export default _default;
-//# sourceMappingURL=ftsFetchAndRestoreDemo.d.ts.map

package/lib/commands/ftsFetchAndRestoreDemo.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ftsFetchAndRestoreDemo.d.ts","sourceRoot":"","sources":["../../src/commands/ftsFetchAndRestoreDemo.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAO9C;;;;;GAKG;AAEF,KAAK,yBAAyB,GAAG,cAAc,GAAG;IAChD,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;;;;;;;;;;;;;;;gBAoDY,yBAAyB,KAAG,GAAG;;AAX7C,wBAYE"}

package/lib/commands/ftsFetchAndRestoreDemo.js

@@ -1,140 +0,0 @@
-"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 __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-exports.__esModule = true;
-/* eslint-disable no-console */
-var rxjs_1 = require("rxjs");
-var fs_1 = __importDefault(require("fs"));
-var scan_1 = require("../scan");
-var ftsFetchImageHash_1 = __importDefault(require("@ledgerhq/live-common/hw/ftsFetchImageHash"));
-var ftsLoadImage_1 = __importStar(require("@ledgerhq/live-common/hw/ftsLoadImage"));
-var deviceAccess_1 = require("@ledgerhq/live-common/hw/deviceAccess");
-var crypto_1 = __importDefault(require("crypto"));
-var exec = function (opts) { return __awaiter(void 0, void 0, void 0, function () {
-    var fileInput, _a, deviceId, hexImageWithoutHeader, hexImage;
-    return __generator(this, function (_b) {
-        switch (_b.label) {
-            case 0:
-                fileInput = opts.fileInput, _a = opts.device, deviceId = _a === void 0 ? "" : _a;
-                hexImageWithoutHeader = fs_1["default"].readFileSync(fileInput, "utf-8");
-                return [4 /*yield*/, (0, ftsLoadImage_1.generateFtsImageFormat)(hexImageWithoutHeader, true)];
-            case 1:
-                hexImage = _b.sent();
-                return [4 /*yield*/, new Promise(function (resolve) { return __awaiter(void 0, void 0, void 0, function () {
-                        var hash, currentHash, result;
-                        return __generator(this, function (_a) {
-                            switch (_a.label) {
-                                case 0:
-                                    hash = crypto_1["default"].createHash('sha256').update(hexImage).digest('hex');
-                                    console.log("Computing hash for input file");
-                                    console.log(hash);
-                                    console.log("Extracting hash from device");
-                                    return [4 /*yield*/, (0, deviceAccess_1.withDevice)(deviceId)(function (t) { return (0, rxjs_1.from)((0, ftsFetchImageHash_1["default"])(t)); }).toPromise()];
-                                case 1:
-                                    currentHash = _a.sent();
-                                    if (currentHash === hash) {
-                                        console.log("Hashes match, skip backup step because we can use the one we have");
-                                    }
-                                    else {
-                                        console.log("Hashes don't match, fetch image before updating");
-                                    }
-                                    console.log("Delete the current image (simulate the wipe from fw update)");
-                                    return [4 /*yield*/, (0, deviceAccess_1.withDevice)(deviceId)(function (t) { return (0, rxjs_1.from)(t.exchange(Buffer.from("e063000000", "hex"))); }).toPromise()];
-                                case 2:
-                                    result = _a.sent();
-                                    console.log("Restoring the image we backedup");
-                                    return [4 /*yield*/, new Promise(function (resolve) {
-                                            return (0, ftsLoadImage_1["default"])({ deviceId: deviceId, hexImage: hexImageWithoutHeader }).subscribe(function (x) { return console.log(x); }, function (e) {
-                                                console.error(e);
-                                                resolve();
-                                            }, function () {
-                                                console.log("Image loaded.");
-                                                resolve();
-                                            });
-                                        })];
-                                case 3:
-                                    _a.sent();
-                                    return [2 /*return*/];
-                            }
-                        });
-                    }); })];
-            case 2:
-                _b.sent();
-                return [2 /*return*/];
-        }
-    });
-}); };
-exports["default"] = {
-    description: "Conditionally backup, delete, and restore a custom image on FTS",
-    args: [
-        scan_1.deviceOpt,
-        {
-            name: "fileInput",
-            alias: "i",
-            type: String,
-            desc: "Text file containing the hex data of the image to load on FTS"
-        },
-    ],
-    job: function (opts) { return (0, rxjs_1.from)(exec(opts)); }
-};
-//# sourceMappingURL=ftsFetchAndRestoreDemo.js.map

package/lib/commands/ftsFetchAndRestoreDemo.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ftsFetchAndRestoreDemo.js","sourceRoot":"","sources":["../../src/commands/ftsFetchAndRestoreDemo.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+BAA+B;AAC/B,6BAA4B;AAC5B,0CAAoB;AAEpB,gCAAoC;AACpC,iGAA2E;AAC3E,oFAA6F;AAC7F,sEAAmE;AACnE,kDAA4B;AAc3B,IAAM,IAAI,GAAG,UAAO,IAA+B;;;;;gBACzC,SAAS,GAA4B,IAAI,UAAhC,EAAE,KAA0B,IAAI,OAAT,EAAb,QAAQ,mBAAG,EAAE,KAAA,CAAU;gBAC5C,qBAAqB,GAAG,eAAE,CAAC,YAAY,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;gBACjD,qBAAM,IAAA,qCAAsB,EAAC,qBAAqB,EAAE,IAAI,CAAC,EAAA;;gBAApE,QAAQ,GAAG,SAAyD;gBAE1E,qBAAM,IAAI,OAAO,CAAO,UAAO,OAAO;;;;;oCAChC,IAAI,GAAG,mBAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAA;oCACtE,OAAO,CAAC,GAAG,CAAC,+BAA+B,CAAC,CAAA;oCAC5C,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;oCACjB,OAAO,CAAC,GAAG,CAAC,6BAA6B,CAAC,CAAA;oCAEtB,qBAAM,IAAA,yBAAU,EAAC,QAAQ,CAAC,CAAC,UAAA,CAAC,IAAE,OAAA,IAAA,WAAI,EAAC,IAAA,8BAAiB,EAAC,CAAC,CAAC,CAAC,EAA1B,CAA0B,CAAC,CAAC,SAAS,EAAE,EAAA;;oCAAnF,WAAW,GAAG,SAAqE;oCACzF,IAAI,WAAW,KAAK,IAAI,EAAE;wCACxB,OAAO,CAAC,GAAG,CAAC,mEAAmE,CAAC,CAAA;qCACjF;yCAAM;wCACL,OAAO,CAAC,GAAG,CAAC,iDAAiD,CAAC,CAAA;qCAC/D;oCAED,OAAO,CAAC,GAAG,CAAC,6DAA6D,CAAC,CAAA;oCAC3D,qBAAM,IAAA,yBAAU,EAAC,QAAQ,CAAC,CAAC,UAAA,CAAC,IAAE,OAAA,IAAA,WAAI,EAAC,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,IAAI,CAAC,YAAY,EAAE,KAAK,CAAC,CAAC,CAAC,EAAlD,CAAkD,CAAC,CAAC,SAAS,EAAE,EAAA;;oCAAtG,MAAM,GAAG,SAA6F;oCAE5G,OAAO,CAAC,GAAG,CAAC,iCAAiC,CAAC,CAAA;oCAC9C,qBAAM,IAAI,OAAO,CAAO,UAAC,OAAO;4CAC9B,OAAA,IAAA,yBAAY,EAAC,EAAE,QAAQ,UAAA,EAAE,QAAQ,EAAE,qBAAqB,EAAE,CAAC,CAAC,SAAS,CACnE,UAAC,CAAC,IAAK,OAAA,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAd,CAAc,EACrB,UAAC,CAAC;gDACA,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;gDACjB,OAAO,EAAE,CAAC;4CACZ,CAAC,EACD;gDACE,OAAO,CAAC,GAAG,CAAC,eAAe,CAAC,CAAC;gDAC7B,OAAO,EAAE,CAAC;4CACZ,CAAC,CACF;wCAVD,CAUC,CACF,EAAA;;oCAZD,SAYC,CAAC;;;;yBACF,CAAC,EAAA;;gBA9BF,SA8BE,CAAA;;;;KACH,CAAC;AAEF,qBAAe;IACb,WAAW,EAAE,iEAAiE;IAC9E,IAAI,EAAE;QACJ,gBAAS;QACT;YACE,IAAI,EAAE,WAAW;YACjB,KAAK,EAAE,GAAG;YACV,IAAI,EAAE,MAAM;YACZ,IAAI,EAAE,+DAA+D;SACtE;KACF;IACD,GAAG,EAAE,UAAC,IAA+B,IAAU,OAAA,IAAA,WAAI,EAAC,IAAI,CAAC,IAAI,CAAC,CAAC,EAAhB,CAAgB;CAChE,CAAC"}

package/lib/commands/ftsFetchImageHash.d.ts

@@ -1,14 +0,0 @@
-import type { ScanCommonOpts } from "../scan";
-declare const _default: {
-    description: string;
-    args: {
-        name: string;
-        alias: string;
-        type: StringConstructor;
-        descOpt: string;
-        desc: string;
-    }[];
-    job: (arg: ScanCommonOpts) => any;
-};
-export default _default;
-//# sourceMappingURL=ftsFetchImageHash.d.ts.map

package/lib/commands/ftsFetchImageHash.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ftsFetchImageHash.d.ts","sourceRoot":"","sources":["../../src/commands/ftsFetchImageHash.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;;;;;;;;;;eAUjC,cAAc,KAAG,GAAG;;AALjC,wBAUE"}

package/lib/commands/ftsFetchImageHash.js

@@ -1,20 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-exports.__esModule = true;
-/* eslint-disable no-console */
-var rxjs_1 = require("rxjs");
-var scan_1 = require("../scan");
-var ftsFetchImageHash_1 = __importDefault(require("@ledgerhq/live-common/hw/ftsFetchImageHash"));
-var deviceAccess_1 = require("@ledgerhq/live-common/hw/deviceAccess");
-exports["default"] = {
-    description: "Fetch the hash of the custom image",
-    args: [
-        scan_1.deviceOpt,
-    ],
-    job: function (arg) { return (0, deviceAccess_1.withDevice)(arg.device || "")(function (t) {
-        return (0, rxjs_1.from)((0, ftsFetchImageHash_1["default"])(t));
-    }); }
-};
-//# sourceMappingURL=ftsFetchImageHash.js.map

package/lib/commands/ftsFetchImageHash.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"ftsFetchImageHash.js","sourceRoot":"","sources":["../../src/commands/ftsFetchImageHash.ts"],"names":[],"mappings":";;;;;AAAA,+BAA+B;AAC/B,6BAA4B;AAG5B,gCAAoC;AACpC,iGAA2E;AAC3E,sEAAmE;AAEnE,qBAAe;IACb,WAAW,EAAE,oCAAoC;IACjD,IAAI,EAAE;QACJ,gBAAS;KACV;IACD,GAAG,EAAE,UAAC,GAAmB,IAAU,OAAA,IAAA,yBAAU,EAAC,GAAG,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,UAAC,CAAC;QAChE,OAAA,IAAA,WAAI,EACF,IAAA,8BAAiB,EAAC,CAAC,CAAC,CACrB;IAFD,CAEC,CACF,EAJkC,CAIlC;CACF,CAAC"}