@ledgerhq/live-cli 24.10.3-nightly.3 → 24.11.0-next.0

package/lib/commands/blockchain/botTransfer.js

@@ -1,33 +1,91 @@
 "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 __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 __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable no-console */
-const rxjs_1 = require("rxjs");
-const operators_1 = require("rxjs/operators");
-const index_1 = require("@ledgerhq/live-common/currencies/index");
-const index_2 = require("@ledgerhq/live-common/bridge/index");
-const live_env_1 = require("@ledgerhq/live-env");
-const promise_1 = require("@ledgerhq/live-common/promise");
-const cache_1 = require("@ledgerhq/live-common/bridge/cache");
-const engine_1 = require("@ledgerhq/live-common/bot/engine");
-const specs_1 = __importDefault(require("@ledgerhq/live-common/generated/specs"));
-const speculos_1 = require("@ledgerhq/live-common/load/speculos");
-const index_3 = require("@ledgerhq/live-common/account/index");
-const logic_1 = require("@ledgerhq/live-countervalues/logic");
-const CONCURRENT = parseInt(process.env.CONCURRENCY || "2", 10);
-const ONLY_CURRENCIES = process.env.ONLY_CURRENCIES
+var rxjs_1 = require("rxjs");
+var operators_1 = require("rxjs/operators");
+var index_1 = require("@ledgerhq/live-common/currencies/index");
+var index_2 = require("@ledgerhq/live-common/bridge/index");
+var live_env_1 = require("@ledgerhq/live-env");
+var promise_1 = require("@ledgerhq/live-common/promise");
+var cache_1 = require("@ledgerhq/live-common/bridge/cache");
+var engine_1 = require("@ledgerhq/live-common/bot/engine");
+var specs_1 = __importDefault(require("@ledgerhq/live-common/generated/specs"));
+var speculos_1 = require("@ledgerhq/live-common/load/speculos");
+var index_3 = require("@ledgerhq/live-common/account/index");
+var logic_1 = require("@ledgerhq/live-countervalues/logic");
+var CONCURRENT = parseInt(process.env.CONCURRENCY || "2", 10);
+var ONLY_CURRENCIES = process.env.ONLY_CURRENCIES
     ? process.env.ONLY_CURRENCIES.split(",")
-        .map(c => c.trim())
+        .map(function (c) { return c.trim(); })
         .filter(Boolean)
     : null;
 // TODO improve botTransfer by only using "allSpecs" and introduce a "transferMutation" in the specs for all spec to define how to transfer funds out (as well as UNDELEGATING funds)
 function getImplicitDeviceAction(currency, forSubAccount) {
-    for (const k in specs_1.default) {
-        const familySpec = specs_1.default[k];
-        for (const c in familySpec) {
-            const spec = familySpec[c];
+    for (var k in specs_1.default) {
+        var familySpec = specs_1.default[k];
+        for (var c in familySpec) {
+            var spec = familySpec[c];
             if (spec.currency === currency) {
                 if (forSubAccount && spec.genericDeviceActionForSubAccountTransfers) {
                     return spec.genericDeviceActionForSubAccountTransfers;
@@ -37,226 +95,341 @@ function getImplicitDeviceAction(currency, forSubAccount) {
         }
     }
 }
-const split = process.env.FUNDS_SPLIT && parseInt(process.env.FUNDS_SPLIT, 10);
+var split = process.env.FUNDS_SPLIT && parseInt(process.env.FUNDS_SPLIT, 10);
 exports.default = {
     description: "transfer funds from one seed (SEED) to another (SEED_RECIPIENT)",
     args: [],
-    job: () => {
-        const localCache = {};
-        const cache = (0, cache_1.makeBridgeCacheSystem)({
-            saveData(c, d) {
+    job: function () {
+        var localCache = {};
+        var cache = (0, cache_1.makeBridgeCacheSystem)({
+            saveData: function (c, d) {
                 localCache[c.id] = d;
                 return Promise.resolve();
             },
-            getData(c) {
+            getData: function (c) {
                 return Promise.resolve(localCache[c.id]);
             },
         });
-        async function getAllRecipients(currencies) {
-            const prevSeed = (0, live_env_1.getEnv)("SEED");
-            const { SEED_RECIPIENT } = process.env;
-            if (SEED_RECIPIENT) {
-                (0, live_env_1.setEnv)("SEED", SEED_RECIPIENT);
-            }
-            const recipientsPerCurrencyId = new Map();
-            await (0, promise_1.promiseAllBatched)(CONCURRENT, currencies, async (currency) => {
-                let device;
-                try {
-                    const r = await (0, speculos_1.createImplicitSpeculos)(`speculos:nanos:${currency.id}`);
-                    if (!r)
-                        return;
-                    device = r.device;
-                    await cache.prepareCurrency(currency);
-                    const maybeAddress = await (0, rxjs_1.firstValueFrom)((0, index_2.getCurrencyBridge)(currency)
-                        .scanAccounts({
-                        currency,
-                        deviceId: device.id,
-                        syncConfig: {
-                            paginationConfig: {},
-                        },
-                    })
-                        .pipe((0, operators_1.filter)(e => e.type === "discovered"), (0, operators_1.first)(), (0, operators_1.timeout)({
-                        each: (0, live_env_1.getEnv)("BOT_TIMEOUT_SCAN_ACCOUNTS"),
-                        with: () => (0, rxjs_1.throwError)(() => new Error("scan account timeout")),
-                    }), (0, operators_1.map)(e => e.account.freshAddress), (0, operators_1.catchError)(err => {
-                        console.error("couldn't infer address for a " + currency.id + " account", err);
-                        return (0, rxjs_1.of)(null);
-                    })));
-                    if (maybeAddress) {
-                        recipientsPerCurrencyId.set(currency.id, maybeAddress);
+        function getAllRecipients(currencies) {
+            return __awaiter(this, void 0, void 0, function () {
+                var prevSeed, SEED_RECIPIENT, recipientsPerCurrencyId;
+                var _this = this;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            prevSeed = (0, live_env_1.getEnv)("SEED");
+                            SEED_RECIPIENT = process.env.SEED_RECIPIENT;
+                            if (SEED_RECIPIENT) {
+                                (0, live_env_1.setEnv)("SEED", SEED_RECIPIENT);
+                            }
+                            recipientsPerCurrencyId = new Map();
+                            return [4 /*yield*/, (0, promise_1.promiseAllBatched)(CONCURRENT, currencies, function (currency) { return __awaiter(_this, void 0, void 0, function () {
+                                    var device, r, maybeAddress, e_1;
+                                    return __generator(this, function (_a) {
+                                        switch (_a.label) {
+                                            case 0:
+                                                _a.trys.push([0, 4, 5, 6]);
+                                                return [4 /*yield*/, (0, speculos_1.createImplicitSpeculos)("speculos:nanos:".concat(currency.id))];
+                                            case 1:
+                                                r = _a.sent();
+                                                if (!r)
+                                                    return [2 /*return*/];
+                                                device = r.device;
+                                                return [4 /*yield*/, cache.prepareCurrency(currency)];
+                                            case 2:
+                                                _a.sent();
+                                                return [4 /*yield*/, (0, rxjs_1.firstValueFrom)((0, index_2.getCurrencyBridge)(currency)
+                                                        .scanAccounts({
+                                                        currency: currency,
+                                                        deviceId: device.id,
+                                                        syncConfig: {
+                                                            paginationConfig: {},
+                                                        },
+                                                    })
+                                                        .pipe((0, operators_1.filter)(function (e) { return e.type === "discovered"; }), (0, operators_1.first)(), (0, operators_1.timeout)({
+                                                        each: (0, live_env_1.getEnv)("BOT_TIMEOUT_SCAN_ACCOUNTS"),
+                                                        with: function () { return (0, rxjs_1.throwError)(function () { return new Error("scan account timeout"); }); },
+                                                    }), (0, operators_1.map)(function (e) { return e.account.freshAddress; }), (0, operators_1.catchError)(function (err) {
+                                                        console.error("couldn't infer address for a " + currency.id + " account", err);
+                                                        return (0, rxjs_1.of)(null);
+                                                    })))];
+                                            case 3:
+                                                maybeAddress = _a.sent();
+                                                if (maybeAddress) {
+                                                    recipientsPerCurrencyId.set(currency.id, maybeAddress);
+                                                }
+                                                return [3 /*break*/, 6];
+                                            case 4:
+                                                e_1 = _a.sent();
+                                                console.error("Something went wrong on sending on " + currency.id, e_1);
+                                                return [3 /*break*/, 6];
+                                            case 5:
+                                                if (device)
+                                                    (0, speculos_1.releaseSpeculosDevice)(device.id);
+                                                return [7 /*endfinally*/];
+                                            case 6: return [2 /*return*/];
+                                        }
+                                    });
+                                }); })];
+                        case 1:
+                            _a.sent();
+                            (0, live_env_1.setEnv)("SEED", prevSeed);
+                            return [2 /*return*/, recipientsPerCurrencyId];
                     }
-                }
-                catch (e) {
-                    console.error("Something went wrong on sending on " + currency.id, e);
-                }
-                finally {
-                    if (device)
-                        (0, speculos_1.releaseSpeculosDevice)(device.id);
-                }
+                });
             });
-            (0, live_env_1.setEnv)("SEED", prevSeed);
-            return recipientsPerCurrencyId;
         }
-        async function botPortfolio(currencies) {
-            const accounts = [];
-            await (0, promise_1.promiseAllBatched)(CONCURRENT, currencies, async (currency) => {
-                let device;
-                try {
-                    const r = await (0, speculos_1.createImplicitSpeculos)(`speculos:nanos:${currency.id}`);
-                    if (!r)
-                        return;
-                    device = r.device;
-                    await (0, rxjs_1.firstValueFrom)((0, index_2.getCurrencyBridge)(currency)
-                        .scanAccounts({
-                        currency,
-                        deviceId: r.device.id,
-                        syncConfig: {
-                            paginationConfig: {},
-                        },
-                    })
-                        .pipe((0, operators_1.timeout)({
-                        each: (0, live_env_1.getEnv)("BOT_TIMEOUT_SCAN_ACCOUNTS"),
-                        with: () => (0, rxjs_1.throwError)(() => new Error("scan account timeout")),
-                    }), (0, operators_1.catchError)(e => {
-                        console.error("scan accounts failed for " + currency.id, e);
-                        return (0, rxjs_1.from)([]);
-                    }), (0, operators_1.tap)(e => {
-                        if (e.type === "discovered") {
-                            accounts.push(e.account);
-                        }
-                    })));
-                }
-                catch (e) {
-                    console.error("Something went wrong on portfolio of " + currency.id, e);
-                }
-                finally {
-                    if (device)
-                        (0, speculos_1.releaseSpeculosDevice)(device.id);
-                }
+        function botPortfolio(currencies) {
+            return __awaiter(this, void 0, void 0, function () {
+                var accounts;
+                var _this = this;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            accounts = [];
+                            return [4 /*yield*/, (0, promise_1.promiseAllBatched)(CONCURRENT, currencies, function (currency) { return __awaiter(_this, void 0, void 0, function () {
+                                    var device, r, e_2;
+                                    return __generator(this, function (_a) {
+                                        switch (_a.label) {
+                                            case 0:
+                                                _a.trys.push([0, 3, 4, 5]);
+                                                return [4 /*yield*/, (0, speculos_1.createImplicitSpeculos)("speculos:nanos:".concat(currency.id))];
+                                            case 1:
+                                                r = _a.sent();
+                                                if (!r)
+                                                    return [2 /*return*/];
+                                                device = r.device;
+                                                return [4 /*yield*/, (0, rxjs_1.firstValueFrom)((0, index_2.getCurrencyBridge)(currency)
+                                                        .scanAccounts({
+                                                        currency: currency,
+                                                        deviceId: r.device.id,
+                                                        syncConfig: {
+                                                            paginationConfig: {},
+                                                        },
+                                                    })
+                                                        .pipe((0, operators_1.timeout)({
+                                                        each: (0, live_env_1.getEnv)("BOT_TIMEOUT_SCAN_ACCOUNTS"),
+                                                        with: function () { return (0, rxjs_1.throwError)(function () { return new Error("scan account timeout"); }); },
+                                                    }), (0, operators_1.catchError)(function (e) {
+                                                        console.error("scan accounts failed for " + currency.id, e);
+                                                        return (0, rxjs_1.from)([]);
+                                                    }), (0, operators_1.tap)(function (e) {
+                                                        if (e.type === "discovered") {
+                                                            accounts.push(e.account);
+                                                        }
+                                                    })))];
+                                            case 2:
+                                                _a.sent();
+                                                return [3 /*break*/, 5];
+                                            case 3:
+                                                e_2 = _a.sent();
+                                                console.error("Something went wrong on portfolio of " + currency.id, e_2);
+                                                return [3 /*break*/, 5];
+                                            case 4:
+                                                if (device)
+                                                    (0, speculos_1.releaseSpeculosDevice)(device.id);
+                                                return [7 /*endfinally*/];
+                                            case 5: return [2 /*return*/];
+                                        }
+                                    });
+                                }); })];
+                        case 1:
+                            _a.sent();
+                            return [2 /*return*/, accounts];
+                    }
+                });
             });
-            return accounts;
         }
-        const cvUSDThreshold = 10;
-        async function sendAllFunds(accounts, recipientsPerCurrencyId) {
-            const countervalue = (0, index_1.getFiatCurrencyByTicker)("USD");
-            const countervaluesState = await (0, logic_1.loadCountervalues)(logic_1.initialState, {
-                trackingPairs: (0, logic_1.inferTrackingPairForAccounts)(accounts, countervalue),
-                autofillGaps: true,
-                refreshRate: 60000,
-                marketCapBatchingAfterRank: 20,
-            });
-            await (0, promise_1.promiseAllBatched)(CONCURRENT, accounts, async (account) => {
-                const { currency } = account;
-                const cv = (0, logic_1.calculate)(countervaluesState, {
-                    from: currency,
-                    to: countervalue,
-                    value: account.balance.toNumber(),
-                });
-                if (!cv || cv < cvUSDThreshold) {
-                    return;
-                }
-                const recipient = recipientsPerCurrencyId.get(currency.id);
-                if (!recipient) {
-                    console.log("no recipient to empty account " + account.id);
-                    return;
-                }
-                const accountBridge = (0, index_2.getAccountBridge)(account);
-                // TODO in case of cosmos & other funds that can be delegated, we need to also schedule these txs first..
-                const plannedTransactions = [];
-                // FIXME better value than this arbitrary one: calc countervalues
-                account.subAccounts?.forEach(subAccount => {
-                    const cv = (0, logic_1.calculate)(countervaluesState, {
-                        from: account.currency,
-                        to: countervalue,
-                        value: subAccount.balance.toNumber(),
-                    });
-                    if (cv && cv > cvUSDThreshold) {
-                        plannedTransactions.push(accountBridge.updateTransaction(accountBridge.createTransaction(account), {
-                            recipient,
-                            ...(split && split > 1
-                                ? {
-                                    amount: subAccount.balance.div(split).integerValue(),
-                                }
-                                : { useAllAmount: true }),
-                            subAccountId: subAccount.id,
-                        }));
+        var cvUSDThreshold = 10;
+        function sendAllFunds(accounts, recipientsPerCurrencyId) {
+            return __awaiter(this, void 0, void 0, function () {
+                var countervalue, countervaluesState;
+                var _this = this;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            countervalue = (0, index_1.getFiatCurrencyByTicker)("USD");
+                            return [4 /*yield*/, (0, logic_1.loadCountervalues)(logic_1.initialState, {
+                                    trackingPairs: (0, logic_1.inferTrackingPairForAccounts)(accounts, countervalue),
+                                    autofillGaps: true,
+                                    refreshRate: 60000,
+                                    marketCapBatchingAfterRank: 20,
+                                })];
+                        case 1:
+                            countervaluesState = _a.sent();
+                            return [4 /*yield*/, (0, promise_1.promiseAllBatched)(CONCURRENT, accounts, function (account) { return __awaiter(_this, void 0, void 0, function () {
+                                    var currency, cv, recipient, accountBridge, plannedTransactions, device, r, plannedTransactions_1, plannedTransactions_1_1, tx, deviceAction, transaction, statusCommon, status, signedOperation, optimisticOperation, _a, e_3, e_4_1, e_5;
+                                    var e_4, _b;
+                                    var _c;
+                                    return __generator(this, function (_d) {
+                                        switch (_d.label) {
+                                            case 0:
+                                                currency = account.currency;
+                                                cv = (0, logic_1.calculate)(countervaluesState, {
+                                                    from: currency,
+                                                    to: countervalue,
+                                                    value: account.balance.toNumber(),
+                                                });
+                                                if (!cv || cv < cvUSDThreshold) {
+                                                    return [2 /*return*/];
+                                                }
+                                                recipient = recipientsPerCurrencyId.get(currency.id);
+                                                if (!recipient) {
+                                                    console.log("no recipient to empty account " + account.id);
+                                                    return [2 /*return*/];
+                                                }
+                                                accountBridge = (0, index_2.getAccountBridge)(account);
+                                                plannedTransactions = [];
+                                                // FIXME better value than this arbitrary one: calc countervalues
+                                                (_c = account.subAccounts) === null || _c === void 0 ? void 0 : _c.forEach(function (subAccount) {
+                                                    var cv = (0, logic_1.calculate)(countervaluesState, {
+                                                        from: account.currency,
+                                                        to: countervalue,
+                                                        value: subAccount.balance.toNumber(),
+                                                    });
+                                                    if (cv && cv > cvUSDThreshold) {
+                                                        plannedTransactions.push(accountBridge.updateTransaction(accountBridge.createTransaction(account), __assign(__assign({ recipient: recipient }, (split && split > 1
+                                                            ? {
+                                                                amount: subAccount.balance.div(split).integerValue(),
+                                                            }
+                                                            : { useAllAmount: true })), { subAccountId: subAccount.id })));
+                                                    }
+                                                });
+                                                plannedTransactions.push(accountBridge.updateTransaction(accountBridge.createTransaction(account), __assign({ recipient: recipient }, (split && split > 1
+                                                    ? { amount: account.spendableBalance.div(split).integerValue() }
+                                                    : { useAllAmount: true }))));
+                                                _d.label = 1;
+                                            case 1:
+                                                _d.trys.push([1, 18, 19, 20]);
+                                                return [4 /*yield*/, (0, speculos_1.createImplicitSpeculos)("speculos:nanos:".concat(currency.id))];
+                                            case 2:
+                                                r = _d.sent();
+                                                if (!r) {
+                                                    console.warn("couldn't create a speculos transport for " + currency.id);
+                                                    return [2 /*return*/];
+                                                }
+                                                device = r.device;
+                                                _d.label = 3;
+                                            case 3:
+                                                _d.trys.push([3, 15, 16, 17]);
+                                                plannedTransactions_1 = __values(plannedTransactions), plannedTransactions_1_1 = plannedTransactions_1.next();
+                                                _d.label = 4;
+                                            case 4:
+                                                if (!!plannedTransactions_1_1.done) return [3 /*break*/, 14];
+                                                tx = plannedTransactions_1_1.value;
+                                                _d.label = 5;
+                                            case 5:
+                                                _d.trys.push([5, 12, , 13]);
+                                                deviceAction = getImplicitDeviceAction(account.currency, "subAccountId" in tx);
+                                                if (!deviceAction) {
+                                                    throw new Error("no spec found for currency " + account.currency.id);
+                                                }
+                                                return [4 /*yield*/, accountBridge.prepareTransaction(account, tx)];
+                                            case 6:
+                                                transaction = _d.sent();
+                                                return [4 /*yield*/, accountBridge.getTransactionStatus(account, transaction)];
+                                            case 7:
+                                                statusCommon = _d.sent();
+                                                if (Object.keys(statusCommon.errors).length !== 0) {
+                                                    return [3 /*break*/, 13];
+                                                }
+                                                status = __assign(__assign({}, statusCommon), { family: transaction.family });
+                                                return [4 /*yield*/, (0, rxjs_1.firstValueFrom)(accountBridge
+                                                        .signOperation({
+                                                        account: account,
+                                                        transaction: transaction,
+                                                        deviceId: device.id,
+                                                    })
+                                                        .pipe((0, engine_1.autoSignTransaction)({
+                                                        transport: device.transport,
+                                                        deviceAction: deviceAction,
+                                                        appCandidate: r.appCandidate,
+                                                        account: account,
+                                                        transaction: transaction,
+                                                        status: status,
+                                                        disableStrictStepValueValidation: true, // we transfer the funds without validating the field values
+                                                    }), (0, operators_1.first)(function (e) { return e.type === "signed"; }), (0, operators_1.map)(function (e) { return e.signedOperation; })))];
+                                            case 8:
+                                                signedOperation = _d.sent();
+                                                if (!(0, live_env_1.getEnv)("DISABLE_TRANSACTION_BROADCAST")) return [3 /*break*/, 9];
+                                                _a = signedOperation.operation;
+                                                return [3 /*break*/, 11];
+                                            case 9: return [4 /*yield*/, accountBridge.broadcast({
+                                                    account: account,
+                                                    signedOperation: signedOperation,
+                                                })];
+                                            case 10:
+                                                _a = _d.sent();
+                                                _d.label = 11;
+                                            case 11:
+                                                optimisticOperation = _a;
+                                                console.log((0, index_3.formatOperation)(account)(optimisticOperation));
+                                                return [3 /*break*/, 13];
+                                            case 12:
+                                                e_3 = _d.sent();
+                                                console.error("Something went wrong on trying to send from " + account.id, tx, e_3);
+                                                return [3 /*break*/, 13];
+                                            case 13:
+                                                plannedTransactions_1_1 = plannedTransactions_1.next();
+                                                return [3 /*break*/, 4];
+                                            case 14: return [3 /*break*/, 17];
+                                            case 15:
+                                                e_4_1 = _d.sent();
+                                                e_4 = { error: e_4_1 };
+                                                return [3 /*break*/, 17];
+                                            case 16:
+                                                try {
+                                                    if (plannedTransactions_1_1 && !plannedTransactions_1_1.done && (_b = plannedTransactions_1.return)) _b.call(plannedTransactions_1);
+                                                }
+                                                finally { if (e_4) throw e_4.error; }
+                                                return [7 /*endfinally*/];
+                                            case 17: return [3 /*break*/, 20];
+                                            case 18:
+                                                e_5 = _d.sent();
+                                                console.error("Something went wrong on account " + account.id, e_5);
+                                                return [3 /*break*/, 20];
+                                            case 19:
+                                                if (device)
+                                                    (0, speculos_1.releaseSpeculosDevice)(device.id);
+                                                return [7 /*endfinally*/];
+                                            case 20: return [2 /*return*/];
+                                        }
+                                    });
+                                }); })];
+                        case 2:
+                            _a.sent();
+                            return [2 /*return*/];
                     }
                 });
-                plannedTransactions.push(accountBridge.updateTransaction(accountBridge.createTransaction(account), {
-                    recipient,
-                    ...(split && split > 1
-                        ? { amount: account.spendableBalance.div(split).integerValue() }
-                        : { useAllAmount: true }),
-                }));
-                let device;
-                try {
-                    const r = await (0, speculos_1.createImplicitSpeculos)(`speculos:nanos:${currency.id}`);
-                    if (!r) {
-                        console.warn("couldn't create a speculos transport for " + currency.id);
-                        return;
-                    }
-                    device = r.device;
-                    for (const tx of plannedTransactions) {
-                        try {
-                            const deviceAction = getImplicitDeviceAction(account.currency, "subAccountId" in tx);
-                            if (!deviceAction) {
-                                throw new Error("no spec found for currency " + account.currency.id);
-                            }
-                            const transaction = await accountBridge.prepareTransaction(account, tx);
-                            const statusCommon = await accountBridge.getTransactionStatus(account, transaction);
-                            if (Object.keys(statusCommon.errors).length !== 0) {
-                                continue;
+            });
+        }
+        function main() {
+            return __awaiter(this, void 0, void 0, function () {
+                var currencies, recipientsPerCurrencyId, accounts;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            currencies = (0, index_1.listSupportedCurrencies)();
+                            if (ONLY_CURRENCIES) {
+                                currencies = currencies.filter(function (c) { return ONLY_CURRENCIES.includes(c.id); });
                             }
-                            const status = { ...statusCommon, family: transaction.family };
-                            const signedOperation = await (0, rxjs_1.firstValueFrom)(accountBridge
-                                .signOperation({
-                                account,
-                                transaction,
-                                deviceId: device.id,
-                            })
-                                .pipe((0, engine_1.autoSignTransaction)({
-                                transport: device.transport,
-                                deviceAction,
-                                appCandidate: r.appCandidate,
-                                account,
-                                transaction,
-                                status,
-                                disableStrictStepValueValidation: true, // we transfer the funds without validating the field values
-                            }), (0, operators_1.first)((e) => e.type === "signed"), (0, operators_1.map)(e => e.signedOperation)));
-                            const optimisticOperation = (0, live_env_1.getEnv)("DISABLE_TRANSACTION_BROADCAST")
-                                ? signedOperation.operation
-                                : await accountBridge.broadcast({
-                                    account,
-                                    signedOperation,
-                                });
-                            console.log((0, index_3.formatOperation)(account)(optimisticOperation));
-                        }
-                        catch (e) {
-                            console.error("Something went wrong on trying to send from " + account.id, tx, e);
-                        }
+                            currencies.sort(function () { return Math.random() - 0.5; });
+                            return [4 /*yield*/, getAllRecipients(currencies)];
+                        case 1:
+                            recipientsPerCurrencyId = _a.sent();
+                            console.log(Array.from(recipientsPerCurrencyId.keys()).length + " RECIPIENTS FETCHED");
+                            return [4 /*yield*/, botPortfolio(currencies)];
+                        case 2:
+                            accounts = _a.sent();
+                            console.log("BOT PORTFOLIO FETCHED ".concat(accounts.length, " accounts"));
+                            return [4 /*yield*/, sendAllFunds(accounts, recipientsPerCurrencyId)];
+                        case 3:
+                            _a.sent();
+                            return [2 /*return*/];
                     }
-                }
-                catch (e) {
-                    console.error("Something went wrong on account " + account.id, e);
-                }
-                finally {
-                    if (device)
-                        (0, speculos_1.releaseSpeculosDevice)(device.id);
-                }
+                });
             });
         }
-        async function main() {
-            let currencies = (0, index_1.listSupportedCurrencies)();
-            if (ONLY_CURRENCIES) {
-                currencies = currencies.filter(c => ONLY_CURRENCIES.includes(c.id));
-            }
-            currencies.sort(() => Math.random() - 0.5);
-            const recipientsPerCurrencyId = await getAllRecipients(currencies);
-            console.log(Array.from(recipientsPerCurrencyId.keys()).length + " RECIPIENTS FETCHED");
-            const accounts = await botPortfolio(currencies);
-            console.log(`BOT PORTFOLIO FETCHED ${accounts.length} accounts`);
-            await sendAllFunds(accounts, recipientsPerCurrencyId);
-        }
         return (0, rxjs_1.from)(main());
     },
 };