@ledgerhq/live-common 27.0.0 → 27.0.1-next.0

package/lib/platform/logic.test.js

@@ -0,0 +1,903 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+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 (_) 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 __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+exports.__esModule = true;
+var logic_1 = require("./logic");
+var cryptoCurrencies_1 = require("../mock/fixtures/cryptoCurrencies");
+var bignumber_js_1 = __importDefault(require("bignumber.js"));
+var converters = __importStar(require("./converters"));
+var serializers = __importStar(require("./serializers"));
+var signMessage = __importStar(require("../hw/signMessage/index"));
+var currencies_1 = require("../currencies");
+describe("receiveOnAccountLogic", function () {
+    // Given
+    var mockPlatformReceiveRequested = jest.fn();
+    var mockPlatformReceiveFail = jest.fn();
+    var context = createContextContainingAccountId({
+        platformReceiveRequested: mockPlatformReceiveRequested,
+        platformReceiveFail: mockPlatformReceiveFail
+    }, "11", "12");
+    var uiNavigation = jest.fn();
+    beforeEach(function () {
+        mockPlatformReceiveRequested.mockClear();
+        mockPlatformReceiveFail.mockClear();
+        uiNavigation.mockClear();
+    });
+    describe("when nominal case", function () {
+        // Given
+        var accountId = "ethereumjs:2:ethereum:0x012:";
+        var expectedResult = "Function called";
+        beforeEach(function () { return uiNavigation.mockResolvedValueOnce(expectedResult); });
+        it("calls uiNavigation callback with an accountAddress", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var convertedAccount, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        convertedAccount = __assign(__assign({}, createPlatformAccount()), { address: "Converted address" });
+                        jest
+                            .spyOn(converters, "accountToPlatformAccount")
+                            .mockReturnValueOnce(convertedAccount);
+                        return [4 /*yield*/, (0, logic_1.receiveOnAccountLogic)(context, accountId, uiNavigation)];
+                    case 1:
+                        result = _a.sent();
+                        // Then
+                        expect(uiNavigation).toBeCalledTimes(1);
+                        expect(uiNavigation.mock.calls[0][2]).toEqual("Converted address");
+                        expect(result).toEqual(expectedResult);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it("calls the tracking for success", function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: 
+                    // When
+                    return [4 /*yield*/, (0, logic_1.receiveOnAccountLogic)(context, accountId, uiNavigation)];
+                    case 1:
+                        // When
+                        _a.sent();
+                        // Then
+                        expect(mockPlatformReceiveRequested).toBeCalledTimes(1);
+                        expect(mockPlatformReceiveFail).toBeCalledTimes(0);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe("when account cannot be found", function () {
+        // Given
+        var nonFoundAccountId = "ethereumjs:2:ethereum:0x010:";
+        it("returns an error", function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: 
+                    // When
+                    return [4 /*yield*/, expect(function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, (0, logic_1.receiveOnAccountLogic)(context, nonFoundAccountId, uiNavigation)];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); }).rejects.toThrowError("Account required")];
+                    case 1:
+                        // When
+                        _a.sent();
+                        // Then
+                        expect(uiNavigation).toBeCalledTimes(0);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it("calls the tracking for error", function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: 
+                    // When
+                    return [4 /*yield*/, expect(function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, (0, logic_1.receiveOnAccountLogic)(context, nonFoundAccountId, uiNavigation)];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); }).rejects.toThrow()];
+                    case 1:
+                        // When
+                        _a.sent();
+                        // Then
+                        expect(mockPlatformReceiveRequested).toBeCalledTimes(1);
+                        expect(mockPlatformReceiveFail).toBeCalledTimes(1);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});
+describe("completeExchangeLogic", function () {
+    // Given
+    var mockPlatformCompleteExchangeRequested = jest.fn();
+    var context = createContextContainingAccountId({
+        platformCompleteExchangeRequested: mockPlatformCompleteExchangeRequested
+    }, "11", "12");
+    var uiNavigation = jest.fn();
+    beforeAll(function () {
+        (0, currencies_1.setSupportedCurrencies)(["bitcoin", "ethereum"]);
+    });
+    afterAll(function () {
+        (0, currencies_1.setSupportedCurrencies)([]);
+    });
+    beforeEach(function () {
+        mockPlatformCompleteExchangeRequested.mockClear();
+        uiNavigation.mockClear();
+    });
+    describe("when nominal case", function () {
+        // Given
+        var expectedResult = "Function called";
+        beforeEach(function () { return uiNavigation.mockResolvedValueOnce(expectedResult); });
+        it("calls uiNavigation callback", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var fromAccount, rawPlatformTransaction, completeExchangeRequest, expectedTransaction, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        fromAccount = (0, cryptoCurrencies_1.createFixtureAccount)("17");
+                        context.accounts = __spreadArray(__spreadArray([], __read(context.accounts), false), [fromAccount], false);
+                        rawPlatformTransaction = createRawEtherumTransaction();
+                        completeExchangeRequest = {
+                            provider: "provider",
+                            fromAccountId: "ethereumjs:2:ethereum:0x017:",
+                            toAccountId: "ethereumjs:2:ethereum:0x042:",
+                            transaction: rawPlatformTransaction,
+                            binaryPayload: "binaryPayload",
+                            signature: "signature",
+                            feesStrategy: "medium",
+                            exchangeType: 8
+                        };
+                        expectedTransaction = {
+                            family: "ethereum",
+                            amount: new bignumber_js_1["default"]("1000000000"),
+                            recipient: "0x0123456",
+                            nonce: 8,
+                            data: Buffer.from("Some data...", "hex"),
+                            gasPrice: new bignumber_js_1["default"]("700000"),
+                            userGasLimit: new bignumber_js_1["default"]("1200000"),
+                            feesStrategy: "medium",
+                            estimatedGasLimit: null,
+                            feeCustomUnit: { name: "Gwei", code: "Gwei", magnitude: 9 },
+                            mode: "send",
+                            networkInfo: null,
+                            useAllAmount: false
+                        };
+                        return [4 /*yield*/, (0, logic_1.completeExchangeLogic)(context, completeExchangeRequest, uiNavigation)];
+                    case 1:
+                        result = _a.sent();
+                        // Then
+                        expect(uiNavigation).toBeCalledTimes(1);
+                        expect(uiNavigation.mock.calls[0][0]).toEqual({
+                            provider: "provider",
+                            exchange: {
+                                fromAccount: fromAccount,
+                                fromParentAccount: null,
+                                toAccount: undefined,
+                                toParentAccount: null
+                            },
+                            transaction: expectedTransaction,
+                            binaryPayload: "binaryPayload",
+                            signature: "signature",
+                            feesStrategy: "medium",
+                            exchangeType: 8
+                        });
+                        expect(result).toEqual(expectedResult);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it.each(["slow", "medium", "fast", "custom"])("calls uiNavigation with a transaction that has the %s feeStrategy", function (expectedFeeStrategy) { return __awaiter(void 0, void 0, void 0, function () {
+            var fromAccount, rawPlatformTransaction, completeExchangeRequest;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        fromAccount = (0, cryptoCurrencies_1.createFixtureAccount)("17");
+                        context.accounts = __spreadArray(__spreadArray([], __read(context.accounts), false), [fromAccount], false);
+                        rawPlatformTransaction = createRawEtherumTransaction();
+                        completeExchangeRequest = {
+                            provider: "provider",
+                            fromAccountId: "ethereumjs:2:ethereum:0x017:",
+                            toAccountId: "ethereumjs:2:ethereum:0x042:",
+                            transaction: rawPlatformTransaction,
+                            binaryPayload: "binaryPayload",
+                            signature: "signature",
+                            feesStrategy: expectedFeeStrategy,
+                            exchangeType: 8
+                        };
+                        // When
+                        return [4 /*yield*/, (0, logic_1.completeExchangeLogic)(context, completeExchangeRequest, uiNavigation)];
+                    case 1:
+                        // When
+                        _a.sent();
+                        // Then
+                        expect(uiNavigation).toBeCalledTimes(1);
+                        expect(uiNavigation.mock.calls[0][0]["transaction"].feesStrategy).toEqual(expectedFeeStrategy);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it("calls the tracking for success", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var completeExchangeRequest;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        completeExchangeRequest = {
+                            provider: "provider",
+                            fromAccountId: "ethereumjs:2:ethereum:0x012:",
+                            toAccountId: "ethereumjs:2:ethereum:0x042:",
+                            transaction: createRawEtherumTransaction(),
+                            binaryPayload: "binaryPayload",
+                            signature: "signature",
+                            feesStrategy: "feeStrategy",
+                            exchangeType: 8
+                        };
+                        // When
+                        return [4 /*yield*/, (0, logic_1.completeExchangeLogic)(context, completeExchangeRequest, uiNavigation)];
+                    case 1:
+                        // When
+                        _a.sent();
+                        // Then
+                        expect(mockPlatformCompleteExchangeRequested).toBeCalledTimes(1);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe("when Account is from a different family than the transaction", function () {
+        // Given
+        var expectedResult = "Function called";
+        beforeEach(function () { return uiNavigation.mockResolvedValueOnce(expectedResult); });
+        it("returns an error", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var fromAccount, rawPlatformTransaction, completeExchangeRequest;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        fromAccount = (0, cryptoCurrencies_1.createFixtureAccount)("17");
+                        context.accounts = __spreadArray(__spreadArray([], __read(context.accounts), false), [fromAccount], false);
+                        rawPlatformTransaction = createRawBitcoinTransaction();
+                        completeExchangeRequest = {
+                            provider: "provider",
+                            fromAccountId: "ethereumjs:2:ethereum:0x017:",
+                            toAccountId: "ethereumjs:2:ethereum:0x042:",
+                            transaction: rawPlatformTransaction,
+                            binaryPayload: "binaryPayload",
+                            signature: "signature",
+                            feesStrategy: "feeStrategy",
+                            exchangeType: 8
+                        };
+                        // When
+                        return [4 /*yield*/, expect(function () { return __awaiter(void 0, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, (0, logic_1.completeExchangeLogic)(context, completeExchangeRequest, uiNavigation)];
+                                        case 1:
+                                            _a.sent();
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); }).rejects.toThrowError("Account and transaction must be from the same family")];
+                    case 1:
+                        // When
+                        _a.sent();
+                        // Then
+                        expect(uiNavigation).toBeCalledTimes(0);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});
+describe("broadcastTransactionLogic", function () {
+    // Given
+    var mockplatformBroadcastFail = jest.fn();
+    var context = createContextContainingAccountId({
+        platformBroadcastFail: mockplatformBroadcastFail
+    }, "11", "12");
+    var uiNavigation = jest.fn();
+    beforeEach(function () {
+        mockplatformBroadcastFail.mockClear();
+        uiNavigation.mockClear();
+    });
+    describe("when nominal case", function () {
+        // Given
+        var accountId = "ethereumjs:2:ethereum:0x012:";
+        var rawSignedTransaction = createSignedOperationRaw();
+        it("calls uiNavigation callback with a signedOperation", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var expectedResult, signedOperation, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        expectedResult = "Function called";
+                        signedOperation = createSignedOperation();
+                        jest
+                            .spyOn(serializers, "deserializePlatformSignedTransaction")
+                            .mockReturnValueOnce(signedOperation);
+                        uiNavigation.mockResolvedValueOnce(expectedResult);
+                        return [4 /*yield*/, (0, logic_1.broadcastTransactionLogic)(context, accountId, rawSignedTransaction, uiNavigation)];
+                    case 1:
+                        result = _a.sent();
+                        // Then
+                        expect(uiNavigation).toBeCalledTimes(1);
+                        expect(uiNavigation.mock.calls[0][2]).toEqual(signedOperation);
+                        expect(result).toEqual(expectedResult);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it("calls the tracking for success", function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: 
+                    // When
+                    return [4 /*yield*/, (0, logic_1.broadcastTransactionLogic)(context, accountId, rawSignedTransaction, uiNavigation)];
+                    case 1:
+                        // When
+                        _a.sent();
+                        // Then
+                        expect(mockplatformBroadcastFail).toBeCalledTimes(0);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe("when account cannot be found", function () {
+        // Given
+        var nonFoundAccountId = "ethereumjs:2:ethereum:0x010:";
+        var rawSignedTransaction = createSignedOperationRaw();
+        it("returns an error", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var expectedResult, signedOperation;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        expectedResult = "Function called";
+                        signedOperation = createSignedOperation();
+                        jest
+                            .spyOn(serializers, "deserializePlatformSignedTransaction")
+                            .mockReturnValueOnce(signedOperation);
+                        uiNavigation.mockResolvedValueOnce(expectedResult);
+                        // When
+                        return [4 /*yield*/, expect(function () { return __awaiter(void 0, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, (0, logic_1.broadcastTransactionLogic)(context, nonFoundAccountId, rawSignedTransaction, uiNavigation)];
+                                        case 1:
+                                            _a.sent();
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); }).rejects.toThrowError("Account required")];
+                    case 1:
+                        // When
+                        _a.sent();
+                        // Then
+                        expect(uiNavigation).toBeCalledTimes(0);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it("calls the tracking for error", function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: 
+                    // When
+                    return [4 /*yield*/, expect(function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, (0, logic_1.broadcastTransactionLogic)(context, nonFoundAccountId, rawSignedTransaction, uiNavigation)];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); }).rejects.toThrow()];
+                    case 1:
+                        // When
+                        _a.sent();
+                        // Then
+                        expect(mockplatformBroadcastFail).toBeCalledTimes(1);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});
+describe("signMessageLogic", function () {
+    // Given
+    var mockPlatformSignMessageRequested = jest.fn();
+    var mockPlatformSignMessageFail = jest.fn();
+    var context = createContextContainingAccountId({
+        platformSignMessageRequested: mockPlatformSignMessageRequested,
+        platformSignMessageFail: mockPlatformSignMessageFail
+    }, "11", "12");
+    var uiNavigation = jest.fn();
+    beforeEach(function () {
+        mockPlatformSignMessageRequested.mockClear();
+        mockPlatformSignMessageFail.mockClear();
+        uiNavigation.mockClear();
+    });
+    describe("when nominal case", function () {
+        // Given
+        var accountId = "ethereumjs:2:ethereum:0x012:";
+        var messageToSign = "Message to sign";
+        var spyPrepareMessageToSign = jest.spyOn(signMessage, "prepareMessageToSign");
+        beforeEach(function () { return spyPrepareMessageToSign.mockClear(); });
+        it("calls uiNavigation callback with a signedOperation", function () { return __awaiter(void 0, void 0, void 0, function () {
+            var expectedResult, formattedMessage, result;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        expectedResult = "Function called";
+                        formattedMessage = createMessageData();
+                        spyPrepareMessageToSign.mockReturnValueOnce(formattedMessage);
+                        uiNavigation.mockResolvedValueOnce(expectedResult);
+                        return [4 /*yield*/, (0, logic_1.signMessageLogic)(context, accountId, messageToSign, uiNavigation)];
+                    case 1:
+                        result = _a.sent();
+                        // Then
+                        expect(uiNavigation).toBeCalledTimes(1);
+                        expect(uiNavigation.mock.calls[0][1]).toEqual(formattedMessage);
+                        expect(result).toEqual(expectedResult);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it("calls the tracking for success", function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: 
+                    // When
+                    return [4 /*yield*/, (0, logic_1.signMessageLogic)(context, accountId, messageToSign, uiNavigation)];
+                    case 1:
+                        // When
+                        _a.sent();
+                        // Then
+                        expect(mockPlatformSignMessageRequested).toBeCalledTimes(1);
+                        expect(mockPlatformSignMessageFail).toBeCalledTimes(0);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe("when account cannot be found", function () {
+        // Given
+        var nonFoundAccountId = "ethereumjs:2:ethereum:0x010:";
+        var messageToSign = "Message to sign";
+        it("returns an error", function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: 
+                    // When
+                    return [4 /*yield*/, expect(function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, (0, logic_1.signMessageLogic)(context, nonFoundAccountId, messageToSign, uiNavigation)];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); }).rejects.toThrowError("account not found")];
+                    case 1:
+                        // When
+                        _a.sent();
+                        // Then
+                        expect(uiNavigation).toBeCalledTimes(0);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it("calls the tracking for error", function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: 
+                    // When
+                    return [4 /*yield*/, expect(function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, (0, logic_1.signMessageLogic)(context, nonFoundAccountId, messageToSign, uiNavigation)];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); }).rejects.toThrow()];
+                    case 1:
+                        // When
+                        _a.sent();
+                        // Then
+                        expect(mockPlatformSignMessageRequested).toBeCalledTimes(1);
+                        expect(mockPlatformSignMessageFail).toBeCalledTimes(1);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe("when account found is not of type 'Account'", function () {
+        // Given
+        var tokenAccountId = "15";
+        var messageToSign = "Message to sign";
+        context.accounts = __spreadArray([
+            createTokenAccount(tokenAccountId)
+        ], __read(context.accounts), false);
+        it("returns an error", function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: 
+                    // When
+                    return [4 /*yield*/, expect(function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, (0, logic_1.signMessageLogic)(context, tokenAccountId, messageToSign, uiNavigation)];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); }).rejects.toThrowError("account provided should be the main one")];
+                    case 1:
+                        // When
+                        _a.sent();
+                        // Then
+                        expect(uiNavigation).toBeCalledTimes(0);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it("calls the tracking for error", function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: 
+                    // When
+                    return [4 /*yield*/, expect(function () { return __awaiter(void 0, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, (0, logic_1.signMessageLogic)(context, tokenAccountId, messageToSign, uiNavigation)];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); }).rejects.toThrow()];
+                    case 1:
+                        // When
+                        _a.sent();
+                        // Then
+                        expect(mockPlatformSignMessageRequested).toBeCalledTimes(1);
+                        expect(mockPlatformSignMessageFail).toBeCalledTimes(1);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+    describe("when inner call prepareMessageToSign raise an error", function () {
+        // Given
+        var accountId = "ethereumjs:2:ethereum:0x012:";
+        var messageToSign = "Message to sign";
+        var spyPrepareMessageToSign = jest.spyOn(signMessage, "prepareMessageToSign");
+        beforeEach(function () { return spyPrepareMessageToSign.mockClear(); });
+        it("returns an error", function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // Given
+                        spyPrepareMessageToSign.mockImplementationOnce(function () {
+                            throw new Error("Some error");
+                        });
+                        // When
+                        return [4 /*yield*/, expect(function () { return __awaiter(void 0, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, (0, logic_1.signMessageLogic)(context, accountId, messageToSign, uiNavigation)];
+                                        case 1:
+                                            _a.sent();
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); }).rejects.toThrowError("Some error")];
+                    case 1:
+                        // When
+                        _a.sent();
+                        // Then
+                        expect(uiNavigation).toBeCalledTimes(0);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+        it("calls the tracking for error", function () { return __awaiter(void 0, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // Given
+                        spyPrepareMessageToSign.mockImplementationOnce(function () {
+                            throw new Error("Some error");
+                        });
+                        // When
+                        return [4 /*yield*/, expect(function () { return __awaiter(void 0, void 0, void 0, function () {
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, (0, logic_1.signMessageLogic)(context, accountId, messageToSign, uiNavigation)];
+                                        case 1:
+                                            _a.sent();
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); }).rejects.toThrow()];
+                    case 1:
+                        // When
+                        _a.sent();
+                        // Then
+                        expect(mockPlatformSignMessageRequested).toBeCalledTimes(1);
+                        expect(mockPlatformSignMessageFail).toBeCalledTimes(1);
+                        return [2 /*return*/];
+                }
+            });
+        }); });
+    });
+});
+function createAppManifest(id) {
+    if (id === void 0) { id = "1"; }
+    return {
+        id: id,
+        private: false,
+        name: "New App Manifest",
+        url: "https://www.ledger.com",
+        homepageUrl: "https://www.ledger.com",
+        supportUrl: "https://www.ledger.com",
+        icon: null,
+        platform: "all",
+        apiVersion: "1.0.0",
+        manifestVersion: "1.0.0",
+        branch: "debug",
+        params: undefined,
+        categories: [],
+        currencies: "*",
+        content: {
+            shortDescription: {
+                en: "short description"
+            },
+            description: {
+                en: "description"
+            }
+        },
+        permissions: [],
+        domains: []
+    };
+}
+function createContextContainingAccountId(tracking) {
+    var accountIds = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        accountIds[_i - 1] = arguments[_i];
+    }
+    return {
+        manifest: createAppManifest(),
+        accounts: __spreadArray(__spreadArray([], __read(accountIds.map(function (val) { return (0, cryptoCurrencies_1.createFixtureAccount)(val); })), false), [
+            (0, cryptoCurrencies_1.createFixtureAccount)(),
+        ], false),
+        tracking: tracking
+    };
+}
+function createSignedOperation() {
+    var operation = {
+        id: "42",
+        hash: "hashed",
+        type: "IN",
+        value: new bignumber_js_1["default"](0),
+        fee: new bignumber_js_1["default"](0),
+        senders: [],
+        recipients: [],
+        blockHeight: null,
+        blockHash: null,
+        accountId: "14",
+        date: new Date(),
+        extra: {}
+    };
+    return {
+        operation: operation,
+        signature: "Signature",
+        expirationDate: null
+    };
+}
+function createSignedOperationRaw() {
+    var rawOperation = {
+        id: "12",
+        hash: "123456",
+        type: "CREATE",
+        value: "0",
+        fee: "0",
+        senders: [],
+        recipients: [],
+        blockHeight: null,
+        blockHash: null,
+        accountId: "12",
+        date: "01/01/1970",
+        extra: {}
+    };
+    return {
+        operation: rawOperation,
+        signature: "Signature",
+        expirationDate: null
+    };
+}
+function createPlatformAccount() {
+    return {
+        id: "12",
+        name: "",
+        address: "",
+        currency: "",
+        balance: new bignumber_js_1["default"](0),
+        spendableBalance: new bignumber_js_1["default"](0),
+        blockHeight: 0,
+        lastSyncDate: new Date()
+    };
+}
+function createMessageData() {
+    return {
+        currency: (0, cryptoCurrencies_1.createFixtureCryptoCurrency)("eth"),
+        path: "path",
+        derivationMode: "ethM",
+        message: "default message",
+        rawMessage: "raw default message"
+    };
+}
+function createTokenAccount(id) {
+    if (id === void 0) { id = "32"; }
+    return {
+        type: "TokenAccount",
+        id: id,
+        parentId: "whatever",
+        token: createTokenCurrency(),
+        balance: new bignumber_js_1["default"](0),
+        spendableBalance: new bignumber_js_1["default"](0),
+        creationDate: new Date(),
+        operationsCount: 0,
+        operations: [],
+        pendingOperations: [],
+        starred: false,
+        balanceHistoryCache: {
+            WEEK: { latestDate: null, balances: [] },
+            HOUR: { latestDate: null, balances: [] },
+            DAY: { latestDate: null, balances: [] }
+        },
+        swapHistory: []
+    };
+}
+function createTokenCurrency() {
+    return {
+        type: "TokenCurrency",
+        id: "3",
+        contractAddress: "",
+        parentCurrency: (0, cryptoCurrencies_1.createFixtureCryptoCurrency)("eth"),
+        tokenType: "",
+        //-- CurrencyCommon
+        name: "",
+        ticker: "",
+        units: []
+    };
+}
+function createRawEtherumTransaction() {
+    return {
+        family: "ethereum",
+        amount: "1000000000",
+        recipient: "0x0123456",
+        nonce: 8,
+        data: "Some data...",
+        gasPrice: "700000",
+        gasLimit: "1200000"
+    };
+}
+function createRawBitcoinTransaction() {
+    return {
+        family: "bitcoin",
+        amount: "1000000000",
+        recipient: "0x0123456",
+        feePerByte: "900000"
+    };
+}
+//# sourceMappingURL=logic.test.js.map