@ledgerhq/live-common 21.36.3 → 21.36.4

package/lib/families/ripple/bridge/js.js

@@ -89,7 +89,7 @@ var operation_1 = require("../../../operation");
 var account_1 = require("../../../account");
 var account_2 = require("../../../account");
 var getAddress_1 = __importDefault(require("../../../hw/getAddress"));
-var deviceAccess_1 = require("../../../hw/deviceAccess");
+var hw_1 = require("../../../hw");
 var Ripple_1 = require("../../../api/Ripple");
 var signTransaction_1 = __importDefault(require("../../../hw/signTransaction"));
 var jsHelpers_1 = require("../../../bridge/jsHelpers");
@@ -125,101 +125,109 @@ var validateTag = function (tag) {
 };
 var signOperation = function (_a) {
     var account = _a.account, transaction = _a.transaction, deviceId = _a.deviceId;
-    return (0, deviceAccess_1.withDevice)(deviceId)(function (transport) {
-        return new rxjs_1.Observable(function (o) {
-            delete cacheRecipientsNew[transaction.recipient];
-            var fee = transaction.fee;
-            if (!fee)
-                throw new errors_1.FeeNotLoaded();
-            function main() {
-                return __awaiter(this, void 0, void 0, function () {
-                    var amount, tag, payment, instruction, prepared, signature, hash, operation, e_1;
-                    var _a;
-                    return __generator(this, function (_b) {
-                        switch (_b.label) {
-                            case 0:
-                                amount = (0, Ripple_1.formatAPICurrencyXRP)(transaction.amount);
-                                tag = transaction.tag ? transaction.tag : undefined;
-                                payment = {
-                                    source: {
-                                        address: account.freshAddress,
-                                        amount: amount
-                                    },
-                                    destination: {
-                                        address: transaction.recipient,
-                                        minAmount: amount,
-                                        tag: tag
-                                    }
-                                };
-                                instruction = {
-                                    fee: (0, Ripple_1.formatAPICurrencyXRP)(fee).value,
-                                    maxLedgerVersionOffset: 12
-                                };
-                                if (tag)
-                                    (0, invariant_1["default"])(validateTag(new bignumber_js_1.BigNumber(tag)), "tag is set but is not in a valid format, should be between [0 - ".concat(uint32maxPlus1
-                                        .minus(1)
-                                        .toString(), "]"));
-                                return [4 /*yield*/, (0, Ripple_2.preparePayment)(account.freshAddress, payment, instruction)];
-                            case 1:
-                                prepared = _b.sent();
-                                _b.label = 2;
-                            case 2:
-                                _b.trys.push([2, 5, , 6]);
-                                o.next({
-                                    type: "device-signature-requested"
-                                });
-                                return [4 /*yield*/, (0, signTransaction_1["default"])(account.currency, transport, account.freshAddressPath, JSON.parse(prepared.txJSON))];
-                            case 3:
-                                signature = _b.sent();
-                                o.next({
-                                    type: "device-signature-granted"
-                                });
-                                hash = "";
-                                _a = {
-                                    id: "".concat(account.id, "-").concat(hash, "-OUT"),
-                                    hash: hash,
-                                    accountId: account.id,
-                                    type: "OUT",
-                                    value: transaction.amount,
-                                    fee: fee,
-                                    blockHash: null,
-                                    blockHeight: null,
-                                    senders: [account.freshAddress],
-                                    recipients: [transaction.recipient],
-                                    date: new Date()
-                                };
-                                return [4 /*yield*/, getSequenceNumber(account)];
-                            case 4:
-                                operation = (
-                                // we probably can't get it so it's a predictive value
-                                _a.transactionSequenceNumber = _b.sent(),
-                                    _a.extra = {},
-                                    _a);
-                                if (transaction.tag) {
-                                    operation.extra.tag = transaction.tag;
+    return new rxjs_1.Observable(function (o) {
+        delete cacheRecipientsNew[transaction.recipient];
+        var fee = transaction.fee;
+        if (!fee)
+            throw new errors_1.FeeNotLoaded();
+        function main() {
+            return __awaiter(this, void 0, void 0, function () {
+                var amount, tag, payment, instruction, prepared, signature, transport, hash, operation, e_1;
+                var _a;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
+                        case 0:
+                            _b.trys.push([0, 8, , 9]);
+                            amount = (0, Ripple_1.formatAPICurrencyXRP)(transaction.amount);
+                            tag = transaction.tag ? transaction.tag : undefined;
+                            payment = {
+                                source: {
+                                    address: account.freshAddress,
+                                    amount: amount
+                                },
+                                destination: {
+                                    address: transaction.recipient,
+                                    minAmount: amount,
+                                    tag: tag
                                 }
-                                o.next({
-                                    type: "signed",
-                                    signedOperation: {
-                                        operation: operation,
-                                        signature: signature,
-                                        expirationDate: null
-                                    }
-                                });
-                                return [3 /*break*/, 6];
-                            case 5:
-                                e_1 = _b.sent();
-                                if (e_1 && e_1.name === "RippledError" && e_1.data.resultMessage) {
-                                    throw new Error(e_1.data.resultMessage);
+                            };
+                            instruction = {
+                                fee: (0, Ripple_1.formatAPICurrencyXRP)(fee).value,
+                                maxLedgerVersionOffset: 12
+                            };
+                            if (tag)
+                                (0, invariant_1["default"])(validateTag(new bignumber_js_1.BigNumber(tag)), "tag is set but is not in a valid format, should be between [0 - ".concat(uint32maxPlus1
+                                    .minus(1)
+                                    .toString(), "]"));
+                            return [4 /*yield*/, (0, Ripple_2.preparePayment)(account.freshAddress, payment, instruction)];
+                        case 1:
+                            prepared = _b.sent();
+                            signature = void 0;
+                            return [4 /*yield*/, (0, hw_1.open)(deviceId)];
+                        case 2:
+                            transport = _b.sent();
+                            _b.label = 3;
+                        case 3:
+                            _b.trys.push([3, , 5, 6]);
+                            o.next({
+                                type: "device-signature-requested"
+                            });
+                            return [4 /*yield*/, (0, signTransaction_1["default"])(account.currency, transport, account.freshAddressPath, JSON.parse(prepared.txJSON))];
+                        case 4:
+                            signature = _b.sent();
+                            o.next({
+                                type: "device-signature-granted"
+                            });
+                            return [3 /*break*/, 6];
+                        case 5:
+                            (0, hw_1.close)(transport, deviceId);
+                            return [7 /*endfinally*/];
+                        case 6:
+                            hash = "";
+                            _a = {
+                                id: "".concat(account.id, "-").concat(hash, "-OUT"),
+                                hash: hash,
+                                accountId: account.id,
+                                type: "OUT",
+                                value: transaction.amount,
+                                fee: fee,
+                                blockHash: null,
+                                blockHeight: null,
+                                senders: [account.freshAddress],
+                                recipients: [transaction.recipient],
+                                date: new Date()
+                            };
+                            return [4 /*yield*/, getSequenceNumber(account)];
+                        case 7:
+                            operation = (
+                            // we probably can't get it so it's a predictive value
+                            _a.transactionSequenceNumber = _b.sent(),
+                                _a.extra = {},
+                                _a);
+                            if (transaction.tag) {
+                                operation.extra.tag = transaction.tag;
+                            }
+                            o.next({
+                                type: "signed",
+                                signedOperation: {
+                                    operation: operation,
+                                    signature: signature,
+                                    expirationDate: null
                                 }
-                                throw e_1;
-                            case 6: return [2 /*return*/];
-                        }
-                    });
+                            });
+                            return [3 /*break*/, 9];
+                        case 8:
+                            e_1 = _b.sent();
+                            if (e_1 && e_1.name === "RippledError" && e_1.data.resultMessage) {
+                                throw new Error(e_1.data.resultMessage);
+                            }
+                            throw e_1;
+                        case 9: return [2 /*return*/];
+                    }
                 });
-            }
-            main().then(function () { return o.complete(); }, function (e) { return o.error(e); });
-        });
+            });
+        }
+        main().then(function () { return o.complete(); }, function (e) { return o.error(e); });
     });
 };
 var broadcast = function (_a) {
@@ -329,216 +337,222 @@ var currencyBridge = {
     hydrate: function () { },
     scanAccounts: function (_a) {
         var currency = _a.currency, deviceId = _a.deviceId;
-        return (0, deviceAccess_1.withDevice)(deviceId)(function (transport) {
-            return new rxjs_1.Observable(function (o) {
-                var finished = false;
-                var unsubscribe = function () {
-                    finished = true;
-                };
-                function main() {
-                    return __awaiter(this, void 0, void 0, function () {
-                        var serverInfo, ledgers, minLedgerVersion, maxLedgerVersion, derivationModes, derivationModes_1, derivationModes_1_1, derivationMode, derivationScheme, stopAt, index, freshAddressPath, address, accountId, info, e_3, freshAddress, balance, transactions, account, e_4_1, e_5;
-                        var e_4, _a;
-                        return __generator(this, function (_b) {
-                            switch (_b.label) {
-                                case 0:
-                                    _b.trys.push([0, 17, , 18]);
-                                    return [4 /*yield*/, (0, Ripple_2.getServerInfo)()];
-                                case 1:
-                                    serverInfo = _b.sent();
-                                    ledgers = serverInfo.completeLedgers.split("-");
-                                    minLedgerVersion = Number(ledgers[0]);
-                                    maxLedgerVersion = Number(ledgers[1]);
-                                    derivationModes = (0, derivation_1.getDerivationModesForCurrency)(currency);
-                                    _b.label = 2;
-                                case 2:
-                                    _b.trys.push([2, 14, 15, 16]);
-                                    derivationModes_1 = __values(derivationModes), derivationModes_1_1 = derivationModes_1.next();
-                                    _b.label = 3;
-                                case 3:
-                                    if (!!derivationModes_1_1.done) return [3 /*break*/, 13];
-                                    derivationMode = derivationModes_1_1.value;
-                                    derivationScheme = (0, derivation_1.getDerivationScheme)({
-                                        derivationMode: derivationMode,
-                                        currency: currency
-                                    });
-                                    stopAt = (0, derivation_1.isIterableDerivationMode)(derivationMode)
-                                        ? 255
-                                        : 1;
-                                    index = 0;
-                                    _b.label = 4;
-                                case 4:
-                                    if (!(index < stopAt)) return [3 /*break*/, 12];
-                                    if (!(0, derivation_1.derivationModeSupportsIndex)(derivationMode, index))
-                                        return [3 /*break*/, 11];
-                                    freshAddressPath = (0, derivation_1.runDerivationScheme)(derivationScheme, currency, {
-                                        account: index
-                                    });
-                                    return [4 /*yield*/, (0, getAddress_1["default"])(transport, {
-                                            currency: currency,
-                                            path: freshAddressPath,
-                                            derivationMode: derivationMode
-                                        })];
-                                case 5:
-                                    address = (_b.sent()).address;
-                                    if (finished)
-                                        return [2 /*return*/];
-                                    accountId = "ripplejs:2:".concat(currency.id, ":").concat(address, ":").concat(derivationMode);
-                                    info = void 0;
-                                    _b.label = 6;
-                                case 6:
-                                    _b.trys.push([6, 8, , 9]);
-                                    return [4 /*yield*/, (0, Ripple_2.getAccountInfo)(address)];
-                                case 7:
-                                    info = _b.sent();
-                                    return [3 /*break*/, 9];
-                                case 8:
-                                    e_3 = _b.sent();
-                                    if (checkAccountNotFound(e_3)) {
-                                        throw e_3;
-                                    }
-                                    return [3 /*break*/, 9];
-                                case 9:
-                                    freshAddress = address;
-                                    if (!info) {
-                                        // account does not exist in Ripple server
-                                        // we are generating a new account locally
-                                        if (derivationMode === "") {
-                                            o.next({
-                                                type: "discovered",
-                                                account: {
-                                                    type: "Account",
-                                                    id: accountId,
-                                                    seedIdentifier: freshAddress,
-                                                    derivationMode: derivationMode,
-                                                    name: (0, account_2.getNewAccountPlaceholderName)({
-                                                        currency: currency,
-                                                        index: index,
-                                                        derivationMode: derivationMode
-                                                    }),
-                                                    starred: false,
-                                                    used: false,
-                                                    freshAddress: freshAddress,
-                                                    freshAddressPath: freshAddressPath,
-                                                    freshAddresses: [
-                                                        {
-                                                            address: freshAddress,
-                                                            derivationPath: freshAddressPath
-                                                        },
-                                                    ],
-                                                    balance: new bignumber_js_1.BigNumber(0),
-                                                    spendableBalance: new bignumber_js_1.BigNumber(0),
-                                                    blockHeight: maxLedgerVersion,
-                                                    index: index,
+        return new rxjs_1.Observable(function (o) {
+            var finished = false;
+            var unsubscribe = function () {
+                finished = true;
+            };
+            function main() {
+                return __awaiter(this, void 0, void 0, function () {
+                    var transport, serverInfo, ledgers, minLedgerVersion, maxLedgerVersion, derivationModes, derivationModes_1, derivationModes_1_1, derivationMode, derivationScheme, stopAt, index, freshAddressPath, address, accountId, info, e_3, freshAddress, balance, transactions, account, e_4_1, e_5;
+                    var e_4, _a;
+                    return __generator(this, function (_b) {
+                        switch (_b.label) {
+                            case 0:
+                                _b.trys.push([0, 18, 19, 22]);
+                                return [4 /*yield*/, (0, hw_1.open)(deviceId)];
+                            case 1:
+                                transport = _b.sent();
+                                return [4 /*yield*/, (0, Ripple_2.getServerInfo)()];
+                            case 2:
+                                serverInfo = _b.sent();
+                                ledgers = serverInfo.completeLedgers.split("-");
+                                minLedgerVersion = Number(ledgers[0]);
+                                maxLedgerVersion = Number(ledgers[1]);
+                                derivationModes = (0, derivation_1.getDerivationModesForCurrency)(currency);
+                                _b.label = 3;
+                            case 3:
+                                _b.trys.push([3, 15, 16, 17]);
+                                derivationModes_1 = __values(derivationModes), derivationModes_1_1 = derivationModes_1.next();
+                                _b.label = 4;
+                            case 4:
+                                if (!!derivationModes_1_1.done) return [3 /*break*/, 14];
+                                derivationMode = derivationModes_1_1.value;
+                                derivationScheme = (0, derivation_1.getDerivationScheme)({
+                                    derivationMode: derivationMode,
+                                    currency: currency
+                                });
+                                stopAt = (0, derivation_1.isIterableDerivationMode)(derivationMode) ? 255 : 1;
+                                index = 0;
+                                _b.label = 5;
+                            case 5:
+                                if (!(index < stopAt)) return [3 /*break*/, 13];
+                                if (!(0, derivation_1.derivationModeSupportsIndex)(derivationMode, index))
+                                    return [3 /*break*/, 12];
+                                freshAddressPath = (0, derivation_1.runDerivationScheme)(derivationScheme, currency, {
+                                    account: index
+                                });
+                                return [4 /*yield*/, (0, getAddress_1["default"])(transport, {
+                                        currency: currency,
+                                        path: freshAddressPath,
+                                        derivationMode: derivationMode
+                                    })];
+                            case 6:
+                                address = (_b.sent()).address;
+                                if (finished)
+                                    return [2 /*return*/];
+                                accountId = "ripplejs:2:".concat(currency.id, ":").concat(address, ":").concat(derivationMode);
+                                info = void 0;
+                                _b.label = 7;
+                            case 7:
+                                _b.trys.push([7, 9, , 10]);
+                                return [4 /*yield*/, (0, Ripple_2.getAccountInfo)(address)];
+                            case 8:
+                                info = _b.sent();
+                                return [3 /*break*/, 10];
+                            case 9:
+                                e_3 = _b.sent();
+                                if (checkAccountNotFound(e_3)) {
+                                    throw e_3;
+                                }
+                                return [3 /*break*/, 10];
+                            case 10:
+                                freshAddress = address;
+                                if (!info) {
+                                    // account does not exist in Ripple server
+                                    // we are generating a new account locally
+                                    if (derivationMode === "") {
+                                        o.next({
+                                            type: "discovered",
+                                            account: {
+                                                type: "Account",
+                                                id: accountId,
+                                                seedIdentifier: freshAddress,
+                                                derivationMode: derivationMode,
+                                                name: (0, account_2.getNewAccountPlaceholderName)({
                                                     currency: currency,
-                                                    operationsCount: 0,
-                                                    operations: [],
-                                                    pendingOperations: [],
-                                                    unit: currency.units[0],
-                                                    // @ts-expect-error archived does not exists on type Account
-                                                    archived: false,
-                                                    lastSyncDate: new Date(),
-                                                    creationDate: new Date(),
-                                                    swapHistory: [],
-                                                    balanceHistoryCache: account_2.emptyHistoryCache
-                                                }
-                                            });
-                                        }
-                                        return [3 /*break*/, 12];
+                                                    index: index,
+                                                    derivationMode: derivationMode
+                                                }),
+                                                starred: false,
+                                                used: false,
+                                                freshAddress: freshAddress,
+                                                freshAddressPath: freshAddressPath,
+                                                freshAddresses: [
+                                                    {
+                                                        address: freshAddress,
+                                                        derivationPath: freshAddressPath
+                                                    },
+                                                ],
+                                                balance: new bignumber_js_1.BigNumber(0),
+                                                spendableBalance: new bignumber_js_1.BigNumber(0),
+                                                blockHeight: maxLedgerVersion,
+                                                index: index,
+                                                currency: currency,
+                                                operationsCount: 0,
+                                                operations: [],
+                                                pendingOperations: [],
+                                                unit: currency.units[0],
+                                                // @ts-expect-error archived does not exists on type Account
+                                                archived: false,
+                                                lastSyncDate: new Date(),
+                                                creationDate: new Date(),
+                                                swapHistory: [],
+                                                balanceHistoryCache: account_2.emptyHistoryCache
+                                            }
+                                        });
                                     }
-                                    if (finished)
-                                        return [2 /*return*/];
-                                    balance = (0, Ripple_1.parseAPIValue)(info.xrpBalance);
-                                    (0, invariant_1["default"])(!balance.isNaN() && balance.isFinite(), "Ripple: invalid balance=".concat(balance.toString(), " for address ").concat(address));
-                                    return [4 /*yield*/, (0, Ripple_2.getTransactions)(address, {
-                                            minLedgerVersion: minLedgerVersion,
-                                            maxLedgerVersion: maxLedgerVersion,
-                                            types: ["payment"]
-                                        })];
-                                case 10:
-                                    transactions = _b.sent();
-                                    if (finished)
-                                        return [2 /*return*/];
-                                    account = {
-                                        type: "Account",
-                                        id: accountId,
-                                        seedIdentifier: freshAddress,
-                                        derivationMode: derivationMode,
-                                        name: (0, account_2.getAccountPlaceholderName)({
-                                            currency: currency,
-                                            index: index,
-                                            derivationMode: derivationMode
-                                        }),
-                                        starred: false,
-                                        used: true,
-                                        freshAddress: freshAddress,
-                                        freshAddressPath: freshAddressPath,
-                                        freshAddresses: [
-                                            {
-                                                address: freshAddress,
-                                                derivationPath: freshAddressPath
-                                            },
-                                        ],
-                                        balance: balance,
-                                        spendableBalance: balance,
-                                        // TODO calc with base reserve
-                                        blockHeight: maxLedgerVersion,
-                                        index: index,
+                                    return [3 /*break*/, 13];
+                                }
+                                if (finished)
+                                    return [2 /*return*/];
+                                balance = (0, Ripple_1.parseAPIValue)(info.xrpBalance);
+                                (0, invariant_1["default"])(!balance.isNaN() && balance.isFinite(), "Ripple: invalid balance=".concat(balance.toString(), " for address ").concat(address));
+                                return [4 /*yield*/, (0, Ripple_2.getTransactions)(address, {
+                                        minLedgerVersion: minLedgerVersion,
+                                        maxLedgerVersion: maxLedgerVersion,
+                                        types: ["payment"]
+                                    })];
+                            case 11:
+                                transactions = _b.sent();
+                                if (finished)
+                                    return [2 /*return*/];
+                                account = {
+                                    type: "Account",
+                                    id: accountId,
+                                    seedIdentifier: freshAddress,
+                                    derivationMode: derivationMode,
+                                    name: (0, account_2.getAccountPlaceholderName)({
                                         currency: currency,
-                                        operationsCount: 0,
-                                        operations: [],
-                                        pendingOperations: [],
-                                        unit: currency.units[0],
-                                        lastSyncDate: new Date(),
-                                        creationDate: new Date(),
-                                        swapHistory: [],
-                                        balanceHistoryCache: account_2.emptyHistoryCache
-                                    };
-                                    account.operations = transactions
-                                        .map(txToOperation(account))
-                                        .filter(Boolean);
-                                    account.operationsCount = account.operations.length;
-                                    if (account.operations.length > 0) {
-                                        account.creationDate =
-                                            account.operations[account.operations.length - 1].date;
-                                    }
-                                    o.next({
-                                        type: "discovered",
-                                        account: account
-                                    });
-                                    _b.label = 11;
-                                case 11:
-                                    index++;
-                                    return [3 /*break*/, 4];
-                                case 12:
-                                    derivationModes_1_1 = derivationModes_1.next();
-                                    return [3 /*break*/, 3];
-                                case 13: return [3 /*break*/, 16];
-                                case 14:
-                                    e_4_1 = _b.sent();
-                                    e_4 = { error: e_4_1 };
-                                    return [3 /*break*/, 16];
-                                case 15:
-                                    try {
-                                        if (derivationModes_1_1 && !derivationModes_1_1.done && (_a = derivationModes_1["return"])) _a.call(derivationModes_1);
-                                    }
-                                    finally { if (e_4) throw e_4.error; }
-                                    return [7 /*endfinally*/];
-                                case 16:
-                                    o.complete();
-                                    return [3 /*break*/, 18];
-                                case 17:
-                                    e_5 = _b.sent();
-                                    o.error(e_5);
-                                    return [3 /*break*/, 18];
-                                case 18: return [2 /*return*/];
-                            }
-                        });
+                                        index: index,
+                                        derivationMode: derivationMode
+                                    }),
+                                    starred: false,
+                                    used: true,
+                                    freshAddress: freshAddress,
+                                    freshAddressPath: freshAddressPath,
+                                    freshAddresses: [
+                                        {
+                                            address: freshAddress,
+                                            derivationPath: freshAddressPath
+                                        },
+                                    ],
+                                    balance: balance,
+                                    spendableBalance: balance,
+                                    // TODO calc with base reserve
+                                    blockHeight: maxLedgerVersion,
+                                    index: index,
+                                    currency: currency,
+                                    operationsCount: 0,
+                                    operations: [],
+                                    pendingOperations: [],
+                                    unit: currency.units[0],
+                                    lastSyncDate: new Date(),
+                                    creationDate: new Date(),
+                                    swapHistory: [],
+                                    balanceHistoryCache: account_2.emptyHistoryCache
+                                };
+                                account.operations = transactions
+                                    .map(txToOperation(account))
+                                    .filter(Boolean);
+                                account.operationsCount = account.operations.length;
+                                if (account.operations.length > 0) {
+                                    account.creationDate =
+                                        account.operations[account.operations.length - 1].date;
+                                }
+                                o.next({
+                                    type: "discovered",
+                                    account: account
+                                });
+                                _b.label = 12;
+                            case 12:
+                                index++;
+                                return [3 /*break*/, 5];
+                            case 13:
+                                derivationModes_1_1 = derivationModes_1.next();
+                                return [3 /*break*/, 4];
+                            case 14: return [3 /*break*/, 17];
+                            case 15:
+                                e_4_1 = _b.sent();
+                                e_4 = { error: e_4_1 };
+                                return [3 /*break*/, 17];
+                            case 16:
+                                try {
+                                    if (derivationModes_1_1 && !derivationModes_1_1.done && (_a = derivationModes_1["return"])) _a.call(derivationModes_1);
+                                }
+                                finally { if (e_4) throw e_4.error; }
+                                return [7 /*endfinally*/];
+                            case 17:
+                                o.complete();
+                                return [3 /*break*/, 22];
+                            case 18:
+                                e_5 = _b.sent();
+                                o.error(e_5);
+                                return [3 /*break*/, 22];
+                            case 19:
+                                if (!transport) return [3 /*break*/, 21];
+                                return [4 /*yield*/, (0, hw_1.close)(transport, deviceId)];
+                            case 20:
+                                _b.sent();
+                                _b.label = 21;
+                            case 21: return [7 /*endfinally*/];
+                            case 22: return [2 /*return*/];
+                        }
                     });
-                }
-                main();
-                return unsubscribe;
-            });
+                });
+            }
+            main();
+            return unsubscribe;
         });
     }
 };