@ledgerhq/live-common 22.0.3 → 22.2.0-next.0

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

@@ -10,6 +10,29 @@ var __assign = (this && this.__assign) || function () {
     };
     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) {
@@ -46,75 +69,28 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
         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 __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 __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 exports.__esModule = true;
+exports.NEW_ACCOUNT_ERROR_MESSAGE = void 0;
 /* eslint-disable no-param-reassign */
-var invariant_1 = __importDefault(require("invariant"));
+var errors_1 = require("@ledgerhq/errors");
 var bignumber_js_1 = require("bignumber.js");
-var rxjs_1 = require("rxjs");
+var invariant_1 = __importDefault(require("invariant"));
 var ripple_bs58check_1 = __importDefault(require("ripple-bs58check"));
-var errors_1 = require("@ledgerhq/errors");
-var derivation_1 = require("../../../derivation");
-var currencies_1 = require("../../../currencies");
-var operation_1 = require("../../../operation");
+var rxjs_1 = require("rxjs");
 var account_1 = require("../../../account");
-var account_2 = require("../../../account");
-var getAddress_1 = __importDefault(require("../../../hw/getAddress"));
-var deviceAccess_1 = require("../../../hw/deviceAccess");
-var Ripple_1 = require("../../../api/Ripple");
-var signTransaction_1 = __importDefault(require("../../../hw/signTransaction"));
+var Ripple_1 = __importStar(require("../../../api/Ripple"));
 var jsHelpers_1 = require("../../../bridge/jsHelpers");
-var Ripple_2 = require("../../../api/Ripple");
-// true if the error should be forwarded and is not a "not found" case
-var checkAccountNotFound = function (e) {
-    return (!e.data || (e.message !== "actNotFound" && e.data.error !== "actNotFound"));
-};
+var currencies_1 = require("../../../currencies");
+var signTransaction_1 = __importDefault(require("../../../hw/signTransaction"));
+var deviceAccess_1 = require("../../../hw/deviceAccess");
+var operation_1 = require("../../../operation");
+var js_synchronization_1 = require("../js-synchronization");
+exports.NEW_ACCOUNT_ERROR_MESSAGE = "actNotFound";
+var LEDGER_OFFSET = 20;
 var receive = (0, jsHelpers_1.makeAccountBridgeReceive)();
-var getSequenceNumber = function (account) { return __awaiter(void 0, void 0, void 0, function () {
-    var lastOp, info;
-    return __generator(this, function (_a) {
-        switch (_a.label) {
-            case 0:
-                lastOp = account.operations.find(function (op) { return op.type === "OUT"; });
-                if (lastOp && lastOp.transactionSequenceNumber) {
-                    return [2 /*return*/, (lastOp.transactionSequenceNumber + account.pendingOperations.length + 1)];
-                }
-                return [4 /*yield*/, (0, Ripple_2.getAccountInfo)(account.freshAddress)];
-            case 1:
-                info = _a.sent();
-                return [2 /*return*/, info.sequence + account.pendingOperations.length];
-        }
-    });
-}); };
 var uint32maxPlus1 = new bignumber_js_1.BigNumber(2).pow(32);
 var validateTag = function (tag) {
     return (!tag.isNaN() &&
@@ -123,6 +99,17 @@ var validateTag = function (tag) {
         tag.isPositive() &&
         tag.lt(uint32maxPlus1));
 };
+var getNextValidSequence = function (account) { return __awaiter(void 0, void 0, void 0, function () {
+    var accInfo;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, (0, Ripple_1.getAccountInfo)(account.freshAddress, true)];
+            case 1:
+                accInfo = _a.sent();
+                return [2 /*return*/, accInfo.account_data.Sequence];
+        }
+    });
+}); };
 var signOperation = function (_a) {
     var account = _a.account, transaction = _a.transaction, deviceId = _a.deviceId;
     return (0, deviceAccess_1.withDevice)(deviceId)(function (transport) {
@@ -133,49 +120,45 @@ var signOperation = function (_a) {
                 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 tag, nextSequenceNumber, payment, signature, hash, operation, e_1;
                     var _a;
                     return __generator(this, function (_b) {
                         switch (_b.label) {
                             case 0:
-                                amount = (0, Ripple_1.formatAPICurrencyXRP)(transaction.amount);
+                                _b.trys.push([0, 4, , 5]);
                                 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
+                                return [4 /*yield*/, getNextValidSequence(account)];
+                            case 1:
+                                nextSequenceNumber = _b.sent();
+                                _a = {
+                                    TransactionType: "Payment",
+                                    Account: account.freshAddress,
+                                    Amount: transaction.amount.toString(),
+                                    Destination: transaction.recipient,
+                                    DestinationTag: tag,
+                                    Fee: fee.toString(),
+                                    Flags: 2147483648,
+                                    Sequence: nextSequenceNumber
                                 };
+                                return [4 /*yield*/, (0, Ripple_1["default"])()];
+                            case 2:
+                                payment = (_a.LastLedgerSequence = (_b.sent()) + LEDGER_OFFSET,
+                                    _a);
                                 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))];
+                                return [4 /*yield*/, (0, signTransaction_1["default"])(account.currency, transport, account.freshAddressPath, payment)];
                             case 3:
                                 signature = _b.sent();
                                 o.next({
                                     type: "device-signature-granted"
                                 });
                                 hash = "";
-                                _a = {
+                                operation = {
                                     id: "".concat(account.id, "-").concat(hash, "-OUT"),
                                     hash: hash,
                                     accountId: account.id,
@@ -186,18 +169,10 @@ var signOperation = function (_a) {
                                     blockHeight: null,
                                     senders: [account.freshAddress],
                                     recipients: [transaction.recipient],
-                                    date: new Date()
+                                    date: new Date(),
+                                    transactionSequenceNumber: nextSequenceNumber,
+                                    extra: {}
                                 };
-                                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;
-                                }
                                 o.next({
                                     type: "signed",
                                     signedOperation: {
@@ -206,14 +181,14 @@ var signOperation = function (_a) {
                                         expirationDate: null
                                     }
                                 });
-                                return [3 /*break*/, 6];
-                            case 5:
+                                return [3 /*break*/, 5];
+                            case 4:
                                 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 6: return [2 /*return*/];
+                            case 5: return [2 /*return*/];
                         }
                     });
                 });
@@ -228,7 +203,7 @@ var broadcast = function (_a) {
         var submittedPayment, hash;
         return __generator(this, function (_c) {
             switch (_c.label) {
-                case 0: return [4 /*yield*/, (0, Ripple_2.submit)(signature)];
+                case 0: return [4 /*yield*/, (0, Ripple_1.submit)(signature)];
                 case 1:
                     submittedPayment = _c.sent();
                     if (submittedPayment.engine_result !== "tesSUCCESS" &&
@@ -250,61 +225,20 @@ function isRecipientValid(recipient) {
         return false;
     }
 }
-var txToOperation = function (account) {
-    return function (_a) {
-        var id = _a.id, sequence = _a.sequence, _b = _a.outcome, fee = _b.fee, deliveredAmount = _b.deliveredAmount, ledgerVersion = _b.ledgerVersion, timestamp = _b.timestamp, _c = _a.specification, source = _c.source, destination = _c.destination;
-        var type = source.address === account.freshAddress ? "OUT" : "IN";
-        var value = deliveredAmount
-            ? (0, Ripple_1.parseAPICurrencyObject)(deliveredAmount)
-            : new bignumber_js_1.BigNumber(0);
-        var feeValue = (0, Ripple_1.parseAPIValue)(fee);
-        if (type === "OUT") {
-            if (!Number.isNaN(feeValue)) {
-                value = value.plus(feeValue);
-            }
-        }
-        var op = {
-            id: "".concat(account.id, "-").concat(id, "-").concat(type),
-            hash: id,
-            accountId: account.id,
-            type: type,
-            value: value,
-            fee: feeValue,
-            blockHash: null,
-            blockHeight: ledgerVersion,
-            senders: [source.address],
-            recipients: [destination.address],
-            date: new Date(timestamp),
-            transactionSequenceNumber: sequence,
-            extra: {}
-        };
-        if (destination.tag) {
-            op.extra.tag = destination.tag;
-        }
-        return op;
-    };
-};
-var recipientIsNew = function (endpointConfig, recipient) { return __awaiter(void 0, void 0, void 0, function () {
-    var e_2;
+var recipientIsNew = function (recipient) { return __awaiter(void 0, void 0, void 0, function () {
+    var info;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
                 if (!isRecipientValid(recipient))
                     return [2 /*return*/, false];
-                _a.label = 1;
+                return [4 /*yield*/, (0, Ripple_1.getAccountInfo)(recipient)];
             case 1:
-                _a.trys.push([1, 3, , 4]);
-                return [4 /*yield*/, (0, Ripple_2.getAccountInfo)(recipient, endpointConfig)];
-            case 2:
-                _a.sent();
-                return [2 /*return*/, false];
-            case 3:
-                e_2 = _a.sent();
-                if (checkAccountNotFound(e_2)) {
-                    throw e_2;
+                info = _a.sent();
+                if (info.error === exports.NEW_ACCOUNT_ERROR_MESSAGE) {
+                    return [2 /*return*/, true];
                 }
-                return [2 /*return*/, true];
-            case 4: return [2 /*return*/];
+                return [2 /*return*/, false];
         }
     });
 }); };
@@ -318,319 +252,16 @@ var remapError = function (error) {
     return error;
 };
 var cacheRecipientsNew = {};
-var cachedRecipientIsNew = function (endpointConfig, recipient) {
+var cachedRecipientIsNew = function (recipient) {
     if (recipient in cacheRecipientsNew)
         return cacheRecipientsNew[recipient];
-    cacheRecipientsNew[recipient] = recipientIsNew(endpointConfig, recipient);
+    cacheRecipientsNew[recipient] = recipientIsNew(recipient);
     return cacheRecipientsNew[recipient];
 };
 var currencyBridge = {
     preload: function () { return Promise.resolve({}); },
     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,
-                                                    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];
-                                    }
-                                    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,
-                                        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*/];
-                            }
-                        });
-                    });
-                }
-                main();
-                return unsubscribe;
-            });
-        });
-    }
-};
-var sync = function (_a) {
-    var endpointConfig = _a.endpointConfig, freshAddress = _a.freshAddress, blockHeight = _a.blockHeight, operations = _a.operations;
-    return new rxjs_1.Observable(function (o) {
-        var finished = false;
-        var currentOpsLength = operations ? operations.length : 0;
-        var unsubscribe = function () {
-            finished = true;
-        };
-        function main() {
-            return __awaiter(this, void 0, void 0, function () {
-                var serverInfo, ledgers, minLedgerVersion, maxLedgerVersion_1, info, e_6, balance_1, transactions_1, e_7;
-                return __generator(this, function (_a) {
-                    switch (_a.label) {
-                        case 0:
-                            _a.trys.push([0, 7, , 8]);
-                            if (finished)
-                                return [2 /*return*/];
-                            return [4 /*yield*/, (0, Ripple_2.getServerInfo)(endpointConfig)];
-                        case 1:
-                            serverInfo = _a.sent();
-                            if (finished)
-                                return [2 /*return*/];
-                            ledgers = serverInfo.completeLedgers.split("-");
-                            minLedgerVersion = Number(ledgers[0]);
-                            maxLedgerVersion_1 = Number(ledgers[1]);
-                            info = void 0;
-                            _a.label = 2;
-                        case 2:
-                            _a.trys.push([2, 4, , 5]);
-                            return [4 /*yield*/, (0, Ripple_2.getAccountInfo)(freshAddress)];
-                        case 3:
-                            info = _a.sent();
-                            return [3 /*break*/, 5];
-                        case 4:
-                            e_6 = _a.sent();
-                            if (checkAccountNotFound(e_6)) {
-                                throw e_6;
-                            }
-                            return [3 /*break*/, 5];
-                        case 5:
-                            if (finished)
-                                return [2 /*return*/];
-                            if (!info) {
-                                // account does not exist, we have nothing to sync but to update the last sync date
-                                o.next(function (a) { return (__assign(__assign({}, a), { lastSyncDate: new Date() })); });
-                                o.complete();
-                                return [2 /*return*/];
-                            }
-                            balance_1 = (0, Ripple_1.parseAPIValue)(info.xrpBalance);
-                            (0, invariant_1["default"])(!balance_1.isNaN() && balance_1.isFinite(), "Ripple: invalid balance=".concat(balance_1.toString(), " for address ").concat(freshAddress));
-                            return [4 /*yield*/, (0, Ripple_2.getTransactions)(freshAddress, {
-                                    minLedgerVersion: Math.max(currentOpsLength === 0 ? 0 : blockHeight, // if there is no ops, it might be after a clear and we prefer to pull from the oldest possible history
-                                    minLedgerVersion),
-                                    maxLedgerVersion: maxLedgerVersion_1,
-                                    types: ["payment"]
-                                })];
-                        case 6:
-                            transactions_1 = _a.sent();
-                            if (finished)
-                                return [2 /*return*/];
-                            o.next(function (a) {
-                                var newOps = transactions_1.map(txToOperation(a));
-                                var operations = (0, jsHelpers_1.mergeOps)(a.operations, newOps);
-                                var _a = __read(operations, 1), last = _a[0];
-                                var pendingOperations = a.pendingOperations.filter(function (oo) {
-                                    return !operations.some(function (op) { return oo.hash === op.hash; }) &&
-                                        last &&
-                                        last.transactionSequenceNumber &&
-                                        oo.transactionSequenceNumber &&
-                                        oo.transactionSequenceNumber > last.transactionSequenceNumber;
-                                });
-                                return __assign(__assign({}, a), { balance: balance_1, spendableBalance: balance_1, 
-                                    // TODO use reserve
-                                    operations: operations, pendingOperations: pendingOperations, blockHeight: maxLedgerVersion_1, lastSyncDate: new Date() });
-                            });
-                            o.complete();
-                            return [3 /*break*/, 8];
-                        case 7:
-                            e_7 = _a.sent();
-                            o.error(remapError(e_7));
-                            return [3 /*break*/, 8];
-                        case 8: return [2 /*return*/];
-                    }
-                });
-            });
-        }
-        main();
-        return unsubscribe;
-    });
+    scanAccounts: js_synchronization_1.scanAccounts
 };
 var createTransaction = function () { return ({
     family: "ripple",
@@ -643,7 +274,7 @@ var createTransaction = function () { return ({
 }); };
 var updateTransaction = function (t, patch) { return (__assign(__assign({}, t), patch)); };
 var prepareTransaction = function (a, t) { return __awaiter(void 0, void 0, void 0, function () {
-    var networkInfo, info, serverFee, e_8, fee;
+    var networkInfo, info, serverFee, e_2, fee;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
@@ -652,10 +283,10 @@ var prepareTransaction = function (a, t) { return __awaiter(void 0, void 0, void
                 _a.label = 1;
             case 1:
                 _a.trys.push([1, 3, , 4]);
-                return [4 /*yield*/, (0, Ripple_2.getServerInfo)(a.endpointConfig)];
+                return [4 /*yield*/, (0, Ripple_1.getServerInfo)(a.endpointConfig)];
             case 2:
                 info = _a.sent();
-                serverFee = (0, Ripple_1.parseAPIValue)(info.validatedLedger.baseFeeXRP);
+                serverFee = (0, Ripple_1.parseAPIValue)(info.info.validated_ledger.base_fee_xrp.toString());
                 networkInfo = {
                     family: "ripple",
                     serverFee: serverFee,
@@ -663,8 +294,8 @@ var prepareTransaction = function (a, t) { return __awaiter(void 0, void 0, void
                 };
                 return [3 /*break*/, 4];
             case 3:
-                e_8 = _a.sent();
-                throw remapError(e_8);
+                e_2 = _a.sent();
+                throw remapError(e_2);
             case 4:
                 fee = t.fee || networkInfo.serverFee;
                 if (t.networkInfo !== networkInfo || t.fee !== fee) {
@@ -675,16 +306,16 @@ var prepareTransaction = function (a, t) { return __awaiter(void 0, void 0, void
     });
 }); };
 var getTransactionStatus = function (a, t) { return __awaiter(void 0, void 0, void 0, function () {
-    var errors, warnings, r, reserveBaseXRP, estimatedFees, totalSpent, amount, _a, f;
+    var errors, warnings, r, reserveBaseXRP, estimatedFees, totalSpent, amount, _a;
     return __generator(this, function (_b) {
         switch (_b.label) {
             case 0:
                 errors = {};
                 warnings = {};
-                return [4 /*yield*/, (0, Ripple_2.getServerInfo)(a.endpointConfig)];
+                return [4 /*yield*/, (0, Ripple_1.getServerInfo)(a.endpointConfig)];
             case 1:
                 r = _b.sent();
-                reserveBaseXRP = (0, Ripple_1.parseAPIValue)(r.validatedLedger.reserveBaseXRP);
+                reserveBaseXRP = (0, Ripple_1.parseAPIValue)(r.info.validated_ledger.reserve_base_xrp.toString());
                 estimatedFees = new bignumber_js_1.BigNumber(t.fee || 0);
                 totalSpent = new bignumber_js_1.BigNumber(t.amount).plus(estimatedFees);
                 amount = new bignumber_js_1.BigNumber(t.amount);
@@ -711,16 +342,19 @@ var getTransactionStatus = function (a, t) { return __awaiter(void 0, void 0, vo
             case 4:
                 _a = t.recipient;
                 if (!_a) return [3 /*break*/, 6];
-                return [4 /*yield*/, cachedRecipientIsNew(a.endpointConfig, t.recipient)];
+                return [4 /*yield*/, cachedRecipientIsNew(t.recipient)];
             case 5:
                 _a = (_b.sent());
                 _b.label = 6;
             case 6:
                 if (_a &&
                     t.amount.lt(reserveBaseXRP)) {
-                    f = (0, Ripple_1.formatAPICurrencyXRP)(reserveBaseXRP);
                     errors.amount = new errors_1.NotEnoughBalanceBecauseDestinationNotCreated("", {
-                        minimalAmount: "".concat(f.currency, " ").concat(new bignumber_js_1.BigNumber(f.value).toFixed())
+                        minimalAmount: (0, currencies_1.formatCurrencyUnit)(a.currency.units[0], reserveBaseXRP, {
+                            disableRounding: true,
+                            useGrouping: false,
+                            showCode: true
+                        })
                     });
                 }
                 _b.label = 7;
@@ -762,10 +396,10 @@ var estimateMaxSpendable = function (_a) {
             switch (_b.label) {
                 case 0:
                     mainAccount = (0, account_1.getMainAccount)(account, parentAccount);
-                    return [4 /*yield*/, (0, Ripple_2.getServerInfo)(mainAccount.endpointConfig)];
+                    return [4 /*yield*/, (0, Ripple_1.getServerInfo)(mainAccount.endpointConfig)];
                 case 1:
                     r = _b.sent();
-                    reserveBaseXRP = (0, Ripple_1.parseAPIValue)(r.validatedLedger.reserveBaseXRP);
+                    reserveBaseXRP = (0, Ripple_1.parseAPIValue)(r.info.validated_ledger.reserve_base_xrp.toString());
                     return [4 /*yield*/, prepareTransaction(mainAccount, __assign(__assign(__assign({}, createTransaction()), transaction), { recipient: (transaction === null || transaction === void 0 ? void 0 : transaction.recipient) || "rHsMGQEkVNJmpGWs8XUBoTBiAAbwxZN5v3", 
                             // public testing seed abandonx11,about
                             amount: new bignumber_js_1.BigNumber(0) }))];
@@ -785,7 +419,7 @@ var accountBridge = {
     prepareTransaction: prepareTransaction,
     getTransactionStatus: getTransactionStatus,
     estimateMaxSpendable: estimateMaxSpendable,
-    sync: sync,
+    sync: js_synchronization_1.sync,
     receive: receive,
     signOperation: signOperation,
     broadcast: broadcast