@hackerhouse/xpub-scan 1.0.0

package/lib/comparison/compareOperations.js

@@ -0,0 +1,500 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkImportedOperations = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const settings_1 = require("../configuration/settings");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+/**
+ * Sort by amount and, then, if needed, by address
+ * @param  {Operation} A
+ *          The first operation to compare
+ * @param  {Operation} B
+ *          The second operation to compare
+ * @returns number
+ *          -1 if A > B
+ *           1 if A < B
+ *           0 if A == B
+ */
+const compareOps = (A, B) => {
+    // date
+    if (A.date > B.date) {
+        return -1;
+    }
+    if (A.date < B.date) {
+        return 1;
+    }
+    // amount
+    if (A.amount > B.amount) {
+        return -1;
+    }
+    if (A.amount < B.amount) {
+        return 1;
+    }
+    // address
+    if (A.address > B.address) {
+        return -1;
+    }
+    if (A.address < B.address) {
+        return 1;
+    }
+    return 0;
+};
+/**
+ * Check whether imported and actual operation are matching or not
+ * @param  {Operation} importedOperation
+ *          An imported operation
+ * @param  {Operation} actualOperation
+ *          An actual operation
+ * @returns boolean
+ *          `true` if operations are matching
+ *          `false` if operations are not matching
+ */
+const areMatching = (importedOperation, actualOperation) => {
+    // ┏━━━━━━━━━━━━━━━━━━━━━┓
+    // ┃ 1 | CHECK ADDRESSES ┃
+    // ┗━━━━━━━━━━━━━━━━━━━━━┛
+    var _a, _b, _c;
+    // 1. Check addresses (general case)
+    // only check if imported address is set (not always the case: Live Desktpop CSVs)
+    // besides, imported address can be a superset of actual address as the
+    // imported operation can have several addresses; therefore, `includes` has to
+    // be used
+    let mismatchingAddresses = false;
+    const importedAddress = (_a = importedOperation.getAddress()) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+    const actualAddress = actualOperation.getAddress().toLowerCase();
+    if (importedAddress &&
+        !importedAddress.includes(actualAddress) &&
+        !actualAddress.includes(importedAddress)) {
+        mismatchingAddresses = true;
+    }
+    // 1b. Check addresses (Bitcoin Cash)
+    const importedCashAddress = (_b = importedOperation.getCashAddress()) === null || _b === void 0 ? void 0 : _b.toLowerCase();
+    const actualCashAddress = (_c = actualOperation.getCashAddress()) === null || _c === void 0 ? void 0 : _c.toLowerCase();
+    if (importedCashAddress &&
+        actualCashAddress &&
+        !importedCashAddress.includes(actualCashAddress) &&
+        !actualCashAddress.includes(importedCashAddress)) {
+        mismatchingAddresses = true;
+    }
+    if (mismatchingAddresses) {
+        return "Mismatch: addresses";
+    }
+    // ┏━━━━━━━━━━━━━━━━━━━┓
+    // ┃ 2 | CHECK AMOUNTS ┃
+    // ┗━━━━━━━━━━━━━━━━━━━┛
+    // Note: absolute values are compared because one of the amounts can be negative (i.e., swap)
+    if (!importedOperation.amount
+        .absoluteValue()
+        .isEqualTo(actualOperation.amount.absoluteValue())) {
+        return "Mismatch: amounts";
+    }
+    // ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+    // ┃ 3 | CHECK TOKENS (OPTIONAL) ┃
+    // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+    // 3. (if applicable: augmented mode) check tokens
+    const importedToken = importedOperation.token;
+    const actualToken = actualOperation.token;
+    if (typeof importedToken !== "undefined" &&
+        typeof actualToken !== "undefined") {
+        if (!importedToken.amount.isEqualTo(actualToken.amount)) {
+            return "Mismatch: token amounts";
+        }
+        if (importedToken.symbol.toLocaleLowerCase() !==
+            actualToken.symbol.toLocaleLowerCase()) {
+            return "Mismatch: token tickers";
+        }
+    }
+    // ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+    // ┃ 4 | CHECK DAPPS (OPTIONAL) ┃
+    // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+    // 4. (if applicable: augmented mode) check dapp
+    const importedDapp = importedOperation.dapp;
+    const actualDapp = actualOperation.token; // currently, as far as the external provider is concerned, token == Dapp
+    if (typeof importedDapp !== "undefined" &&
+        typeof actualDapp !== "undefined") {
+        if (importedDapp.contract_name.toLocaleLowerCase() !==
+            actualDapp.name.toLocaleLowerCase()) {
+            return "Mismatch: Dapp";
+        }
+    }
+    return "Match";
+};
+/**
+ * Make addresses displayable
+ * @param  {string} address
+ *          An address to display
+ * @returns string
+ *          empty string if no address
+ *          partial address + ellipsis if long address
+ *          the address itself otherwise
+ */
+const renderAddress = (address) => {
+    const maxLength = 35;
+    if (!address) {
+        return "".padEnd(maxLength + 4, " ");
+    }
+    if (address.length < maxLength) {
+        return address.padEnd(maxLength + 4, " ");
+    }
+    return address
+        .substring(0, maxLength - 3)
+        .concat("...")
+        .padEnd(maxLength + 4, " ");
+};
+/**
+ * Display the comparison between two operations or, if an operation
+ * is missing, display one operation with the indication that one operation
+ * is missing
+ * @param  {ComparisonStatus} status
+ *          Status of the comparison (Match, Mismatch, etc.)
+ * @param  {Operation} A
+ *          An operation
+ * @param  {Operation} B?
+ *          An optional operation
+ * @returns void
+ */
+const showOperations = (status, A, B) => {
+    var _a, _b;
+    if (settings_1.configuration.silent) {
+        return;
+    }
+    const halfColorPadding = 84;
+    const fullColorPadding = 85;
+    let imported = "";
+    let actual = "";
+    switch (status) {
+        case "Match":
+        /* fallthrough */
+        case (_a = status.match(/^Mismatch.*/)) === null || _a === void 0 ? void 0 : _a.input:
+            /* fallthrough */
+            imported = A.date
+                .padEnd(24, " ")
+                .concat(renderAddress(A.address))
+                .concat(String(A.amount));
+            if (B) {
+                actual = B.date
+                    .padEnd(24, " ")
+                    .concat(renderAddress(B.address))
+                    .concat(String(B.amount));
+            }
+            break;
+        case "Extra Operation":
+            actual = "(missing operation)";
+            imported = A.date
+                .padEnd(24, " ")
+                .concat(renderAddress(A.address))
+                .concat(String(A.amount));
+            break;
+        case "Missing Operation":
+            imported = "(missing operation)";
+            actual = A.date
+                .padEnd(24, " ")
+                .concat(renderAddress(A.address))
+                .concat(String(A.amount));
+            break;
+        case "Missing (aggregated)":
+            imported = "(aggregated operation)";
+            actual = A.date
+                .padEnd(24, " ")
+                .concat(renderAddress(A.address))
+                .concat(String(A.amount));
+            break;
+    }
+    if (A.operationType === "Failed to send" ||
+        (B === null || B === void 0 ? void 0 : B.operationType) === "Failed to send") {
+        actual = chalk_1.default.blueBright(actual.concat("\t[failed]"));
+    }
+    if (A.operationType.includes("token") || (B === null || B === void 0 ? void 0 : B.operationType.includes("token"))) {
+        actual = chalk_1.default.white(actual.concat("\t[token]"));
+    }
+    if (A.operationType.includes("dapp") || (B === null || B === void 0 ? void 0 : B.operationType.includes("dapp"))) {
+        actual = chalk_1.default.white(actual.concat("\t[dapp]"));
+    }
+    if (A.operationType.includes("SCI") || (B === null || B === void 0 ? void 0 : B.operationType.includes("SCI"))) {
+        actual = chalk_1.default.white(actual.concat("\t[sci]"));
+    }
+    if (A.operationType.includes("Swapped") ||
+        (B === null || B === void 0 ? void 0 : B.operationType.includes("Swapped"))) {
+        actual = chalk_1.default.white(actual.concat("\t[swap]"));
+    }
+    switch (status) {
+        case "Match":
+            console.log(chalk_1.default.greenBright(imported.padEnd(halfColorPadding, " ")), actual);
+            break;
+        case "Match (aggregated)":
+        /* fallthrough */
+        case "Missing (aggregated)":
+            console.log(chalk_1.default.green(imported.padEnd(halfColorPadding, " ")), actual);
+            break;
+        case (_b = status.match(/^Mismatch.*/)) === null || _b === void 0 ? void 0 : _b.input:
+        /* fallthrough */
+        case "Missing Operation":
+        /* fallthrough */
+        case "Extra Operation":
+            console.log(chalk_1.default.redBright(imported.padEnd(fullColorPadding, " ").concat(actual)));
+            break;
+    }
+};
+/**
+ * Check whether operations are aggregated or not
+ * @param  {Operation} importedOp
+ *          An imported operation
+ * @param  {Array<Operation>} actualOps
+ *          List of actual operations
+ * @returns boolean
+ *          `true` if operations are aggregated
+ *          `false` if operations are not aggregated
+ */
+const areAggregated = (importedOp, actualOps) => {
+    if (typeof importedOp === "undefined") {
+        return false;
+    }
+    const actual = actualOps.filter((op) => op.txid === importedOp.txid);
+    if (actual.length < 2) {
+        return false;
+    }
+    let actualAmountTotal = new bignumber_js_1.default(0);
+    for (const actualOp of actualOps) {
+        actualAmountTotal = actualAmountTotal.plus(actualOp.amount);
+    }
+    const importedAmount = new bignumber_js_1.default(importedOp.amount);
+    return actualAmountTotal.isEqualTo(importedAmount);
+};
+/**
+ * Compare the imported operations with the actual ones
+ * @param importedOperations operations from the product
+ * @param actualOperations operations from the provider (source of truth)
+ * @param actualAddresses actual addresses
+ * @param partialComparison (optional) partial comparison
+ * @returns list of comparisons
+ */
+const checkImportedOperations = (importedOperations, actualOperations, actualAddresses, partialComparison) => {
+    if (!settings_1.configuration.silent) {
+        console.log(chalk_1.default.bold.whiteBright("\nComparison between imported and actual operations\n"));
+        console.log(chalk_1.default.grey("imported operations" + "\t".repeat(8) + "     actual operations"));
+    }
+    const allComparingCriteria = [];
+    const comparisons = [];
+    const blockHeightUpperLimit = settings_1.configuration.blockHeightUpperLimit;
+    // filter imported operations if scan is limited (range scan)
+    if (partialComparison) {
+        const rangeAddresses = actualAddresses.map((address) => address.toString());
+        importedOperations = importedOperations.filter((op) => op.address.split(",").find((a) => rangeAddresses.includes(a)));
+    }
+    // create a list of comparing criterion containing all elements that can be used
+    // to compare transactions. That is: date, txid, and/or block number
+    importedOperations.concat(actualOperations).forEach((op) => {
+        if (!allComparingCriteria.some((t) => t.hash === op.txid)) {
+            // (ignore duplicates)
+            allComparingCriteria.push({
+                date: op.date,
+                hash: op.txid,
+                block: op.block,
+            });
+        }
+    });
+    // sort by reverse chronological order
+    allComparingCriteria.sort((a, b) => (a.date > b.date ? -1 : 1));
+    for (const comparingCriterion of allComparingCriteria) {
+        let importedOps;
+        let actualOps;
+        if (importedOperations.some((op) => typeof op.txid !== "undefined")) {
+            // case 1. tx id is set
+            importedOps = importedOperations.filter((op) => op.txid === comparingCriterion.hash);
+            actualOps = actualOperations.filter((op) => op.txid === comparingCriterion.hash);
+        }
+        else {
+            // case 2. tx id is NOT set: compare by block number instead
+            importedOps = importedOperations.filter((op) => op.block === comparingCriterion.block);
+            actualOps = actualOperations.filter((op) => op.block === comparingCriterion.block);
+        }
+        // the imported operations can have multiple concatenated addresses
+        // that have to be reduced to only one:
+        // the one corresponding to that of an actual operation from the same
+        // block and with the same amount
+        for (const imported of importedOps) {
+            // do not continue if no address (see: Live Desktop CSVs): not relevant
+            if (!imported.address) {
+                break;
+            }
+            // the actual operation address must already be present in the
+            // imported operations' addresses and the amount must match
+            const actual = actualOperations.filter((op) => imported.address.includes(op.address) &&
+                op.amount === imported.amount);
+            if (Object.keys(actual).length === 1) {
+                imported.setAddress(actual[0].address);
+            }
+        }
+        // sort I (common case):
+        // compare by date, amount, address
+        importedOps.sort(compareOps);
+        actualOps.sort(compareOps);
+        // sort II (edge case):
+        // sort operations with same txid, same date, and same amount
+        // that cannot be sorted by address
+        for (const criterion of allComparingCriteria) {
+            const imported = importedOps.filter((op) => op.txid === criterion.hash);
+            // if only one imported operation have this txid, skip...
+            if (imported.length < 2 || typeof criterion.hash === "undefined") {
+                continue;
+            }
+            // ... otherwise, sort the imported operations
+            for (const importedOp of imported) {
+                for (let i = 0; i < actualOps.length; ++i) {
+                    // if an actual operation is having the same txid,
+                    // but the operation types or addresses differ...
+                    if (
+                    // [ an actual operation has the same txid,
+                    (actualOps[i].txid === importedOp.txid &&
+                        // and:
+                        // 1. the operation type is the same {use of
+                        //    `startsWith` as the actual operation types are
+                        //    a superset of imported operation types:
+                        //       - Send (to self, to sibling);
+                        //       - Received ((non-sibling to change))},
+                        !actualOps[i]
+                            .getOperationType()
+                            .startsWith(importedOp.getOperationType())) ||
+                        // and
+                        // 2. the imported operation does include the actual
+                        //    address (`includes`: imported addresses can be aggregated) ]
+                        (importedOp.address &&
+                            !importedOp.address.includes(actualOps[i].address))) {
+                        // ... then swap it with first actual operation
+                        [actualOps[0], actualOps[i]] = [actualOps[i], actualOps[0]];
+                        break;
+                    }
+                }
+            }
+        }
+        const aggregatedTxids = [];
+        // Math.max(...) used here because the imported and actual arrays do not
+        // necessarily have the same size (i.e. missing operations)
+        for (let i = 0; i < Math.max(importedOps.length, actualOps.length); ++i) {
+            const importedOp = importedOps[i];
+            const actualOp = actualOps[i];
+            // aggregated operations
+            // (fixes https://github.com/LedgerHQ/xpub-scan/issues/23)
+            if (typeof actualOp !== "undefined" &&
+                (aggregatedTxids.includes(actualOp.txid) ||
+                    areAggregated(importedOp, actualOps))) {
+                // ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+                // ┃ CASE 1 | AGGREGATED OPERATIONS ┃
+                // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+                aggregatedTxids.push(actualOp.txid);
+                if (typeof importedOp !== "undefined") {
+                    // ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+                    // ┃ CASE 1A | MATCHING AGGREGATED OPERATIONS ┃
+                    // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+                    showOperations("Match (aggregated)", importedOp, actualOp);
+                    comparisons.push({
+                        imported: importedOp,
+                        actual: actualOp,
+                        status: "Match (aggregated)",
+                    });
+                }
+                else {
+                    // ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+                    // ┃ CASE 1B | MISSING AGGREGATED OPERATIONS ┃
+                    // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+                    showOperations("Missing (aggregated)", actualOp);
+                    comparisons.push({
+                        imported: importedOp,
+                        actual: actualOp,
+                        status: "Missing (aggregated)",
+                    });
+                }
+                continue;
+            }
+            // actual operation with no corresponding imported operation
+            if (typeof importedOp === "undefined") {
+                // if the block height upper limit is reached, skip the comparison...
+                if (blockHeightUpperLimit > 0 &&
+                    actualOp.getBlockNumber() > blockHeightUpperLimit) {
+                    // ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+                    // ┃ CASE 2 | SKIPPED OPERATIONS (BLOCK HEIGHT UPPER LIMIT MODE) ┃
+                    // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+                    comparisons.push({
+                        imported: undefined,
+                        actual: actualOp,
+                        status: "Skipped",
+                    });
+                    continue;
+                }
+                // ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+                // ┃ CASE 3 | MISSING OPERATION ┃
+                // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+                // ...else, this is a missing operation
+                showOperations("Missing Operation", actualOp);
+                comparisons.push({
+                    imported: undefined,
+                    actual: actualOp,
+                    status: "Missing Operation",
+                });
+                continue;
+            }
+            // imported operation with no corresponding actual operation
+            if (typeof actualOp === "undefined") {
+                // ┏━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+                // ┃ CASE 4 | EXTRA OPERATION ┃
+                // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+                showOperations("Extra Operation", importedOp);
+                comparisons.push({
+                    imported: importedOp,
+                    actual: undefined,
+                    status: "Extra Operation",
+                });
+                continue;
+            }
+            const comparisonResult = areMatching(importedOp, actualOp);
+            if (comparisonResult !== "Match") {
+                // ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+                // ┃ CASE 5 | MISMATCHING OPERATIONS ┃
+                // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+                showOperations(comparisonResult, importedOp, actualOp);
+                comparisons.push({
+                    imported: importedOp,
+                    actual: actualOp,
+                    status: comparisonResult,
+                });
+            }
+            else {
+                // ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
+                // ┃ CASE 6 | MATCHING OPERATIONS ┃
+                // ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
+                showOperations("Match", importedOp, actualOp);
+                comparisons.push({
+                    imported: importedOp,
+                    actual: actualOp,
+                    status: "Match",
+                });
+            }
+        }
+    }
+    // Sort the comparisons
+    // 1. Split the comparisons in two segments:
+    //   first segment (can be empty): skipped comparisons
+    //   second segment: unskipped comparisons
+    const skippedComparisons = [];
+    for (let i = comparisons.length - 1; i >= 0; i--) {
+        const comparison = comparisons[i];
+        if (comparison.status === "Skipped") {
+            skippedComparisons.push(comparison);
+            comparisons.splice(i, 1);
+        }
+    }
+    // 2. Sort the skipped comparisons by date
+    skippedComparisons.sort((a, b) => {
+        return a.actual.date > b.actual.date ? -1 : 1;
+    });
+    // 3. Merge the two segments into one.
+    // The comparisons are then sorted this way:
+    //   first: all skipped comparisons, sorted by date
+    //   second: all unskipped comparisons, sorted following the
+    //           imported operations ordering
+    return skippedComparisons.concat(comparisons);
+};
+exports.checkImportedOperations = checkImportedOperations;

package/lib/comparison/diffs.d.ts

@@ -0,0 +1,18 @@
+import { Comparison } from "../models/comparison";
+/**
+ * Show differences between imported and actual data
+ * @param  {number} actualBalance
+ *          Actual balance
+ * @param  {number} importedBalance?
+ *          Optional imported balance
+ * @param  {Array<Comparison>} comparisons?
+ *          Optional list of comparisons
+ * @param  {boolean} diff?
+ *          Optional diff boolean
+ * @returns number
+ *          An exist code:
+ *              - zero if no diff
+ *              - non-zero otherwise
+ */
+declare const showDiff: (actualBalance: number, importedBalance?: string, comparisons?: Array<Comparison>, diff?: boolean) => number;
+export { showDiff };

package/lib/comparison/diffs.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showDiff = void 0;
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const chalk_1 = __importDefault(require("chalk"));
+const helpers_1 = require("../helpers");
+/**
+ * Show differences between imported and actual data
+ * @param  {number} actualBalance
+ *          Actual balance
+ * @param  {number} importedBalance?
+ *          Optional imported balance
+ * @param  {Array<Comparison>} comparisons?
+ *          Optional list of comparisons
+ * @param  {boolean} diff?
+ *          Optional diff boolean
+ * @returns number
+ *          An exist code:
+ *              - zero if no diff
+ *              - non-zero otherwise
+ */
+const showDiff = (actualBalance, importedBalance, comparisons, diff) => {
+    let exitCode = 0;
+    // check operations
+    if (comparisons && diff) {
+        const operationsMismatches = comparisons.filter((comparison) => !comparison.status.startsWith("Match"));
+        const mismatches = [];
+        for (const o of operationsMismatches) {
+            mismatches.push({
+                imported: typeof o.imported !== "undefined"
+                    ? Object.assign(Object.assign({}, o.imported), { amount: o.imported.amount.toFixed() }) : undefined,
+                actual: typeof o.actual !== "undefined"
+                    ? Object.assign(Object.assign({}, o.actual), { cashAddress: (0, helpers_1.toUnprefixedCashAddress)(o.actual.address), amount: o.actual.amount.toFixed() }) : undefined,
+                status: o.status,
+            });
+        }
+        if (mismatches.length > 0) {
+            console.log(chalk_1.default.redBright("Diff [ KO ]: operations mismatches"));
+            console.dir(JSON.parse(JSON.stringify(mismatches)));
+            exitCode += 1;
+        }
+        else {
+            console.log(chalk_1.default.greenBright("Diff [ OK ]: operations match"));
+        }
+    }
+    // check balance
+    if (importedBalance) {
+        const imported = new bignumber_js_1.default(importedBalance).toFixed(0);
+        const actual = (0, helpers_1.toBaseUnit)(new bignumber_js_1.default(actualBalance));
+        if (imported !== actual) {
+            console.log(chalk_1.default.redBright("Diff [ KO ]: balances mismatch"));
+            console.log("| imported balance: ", imported);
+            console.log("| actual balance:   ", actual);
+            exitCode += 2;
+        }
+        else {
+            console.log(chalk_1.default.greenBright("Diff [ OK ]: balances match: ".concat(actual)));
+        }
+    }
+    // exit codes:
+    //  0: OK
+    //  1: operation(s) mismatch(es)
+    //  2: balance mismatch
+    //  3: operation(s) _and_ balance mismatches
+    return exitCode;
+};
+exports.showDiff = showDiff;

package/lib/configuration/currencies.d.ts

@@ -0,0 +1,55 @@
+export declare enum DerivationMode {
+    LEGACY = "Legacy",
+    NATIVE = "Native SegWit",
+    SEGWIT = "SegWit",
+    TAPROOT = "Taproot",
+    BCH = "Bitcoin Cash",
+    ETHEREUM = "Ethereum",
+    DOGECOIN = "Dogecoin",
+    UNKNOWN = "Unknown"
+}
+export declare const currencies: {
+    btc: {
+        name: string;
+        symbol: string;
+        network_mainnet: any;
+        network_testnet: any;
+        derivationModes: DerivationMode[];
+        precision: number;
+        utxo_based: boolean;
+    };
+    bch: {
+        name: string;
+        symbol: string;
+        network_mainnet: any;
+        network_testnet: any;
+        derivationModes: DerivationMode[];
+        precision: number;
+        utxo_based: boolean;
+    };
+    ltc: {
+        name: string;
+        symbol: string;
+        network_mainnet: any;
+        network_testnet: any;
+        derivationModes: DerivationMode[];
+        precision: number;
+        utxo_based: boolean;
+    };
+    eth: {
+        name: string;
+        symbol: string;
+        precision: number;
+        utxo_based: boolean;
+        derivationModes: DerivationMode[];
+    };
+    doge: {
+        name: string;
+        symbol: string;
+        network_mainnet: any;
+        network_testnet: any;
+        precision: number;
+        utxo_based: boolean;
+        derivationModes: DerivationMode[];
+    };
+};