@hackerhouse/xpub-scan 1.0.0

package/lib/helpers.js

@@ -0,0 +1,255 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toAccountUnit = exports.toBaseUnit = exports.toUnprefixedCashAddress = exports.setNetwork = exports.retry = exports.getNetworkLabel = exports.getJSON = exports.init = void 0;
+const axios_1 = __importDefault(require("axios"));
+const chalk_1 = __importDefault(require("chalk"));
+const bchaddrjs_1 = __importDefault(require("bchaddrjs"));
+const settings_1 = require("./configuration/settings");
+const currencies_1 = require("./configuration/currencies");
+const bip32_1 = __importDefault(require("bip32"));
+const ecc = __importStar(require("tiny-secp256k1"));
+const bip32 = (0, bip32_1.default)(ecc);
+function getJSON(url, APIKey, { retries, retryDelayMS } = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const job = () => __awaiter(this, void 0, void 0, function* () {
+            const headers = Object.assign({}, (APIKey ? { "X-API-Key": APIKey } : {}));
+            const res = yield axios_1.default.get(url, { headers });
+            if (res.status !== 200) {
+                console.log(chalk_1.default.red("GET request error"));
+                throw new Error("GET REQUEST ERROR: "
+                    .concat(url)
+                    .concat(", Status Code: ")
+                    .concat(String(res.status)));
+            }
+            return res.data;
+        });
+        return retry(job, { retries, retryDelayMS });
+    });
+}
+exports.getJSON = getJSON;
+function retry(job, { retries = 5, retryDelayMS = 0 } = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let err = null;
+        for (let i = 0; i < retries; i++) {
+            try {
+                return yield job();
+            }
+            catch (e) {
+                err = e;
+                // wait before retrying if it's not the last try
+                if (retryDelayMS && i < retries - 1) {
+                    yield new Promise((r) => setTimeout(r, retryDelayMS));
+                }
+            }
+        }
+        if (err)
+            throw err;
+        throw new Error(`No result after ${retries} retries`);
+    });
+}
+exports.retry = retry;
+function setNetwork(xpub, currency, testnet) {
+    settings_1.configuration.testnet = testnet || false;
+    if (typeof currency === "undefined" ||
+        currency === "BTC" ||
+        currency === "LTC" ||
+        currency === "DOGE") {
+        const prefix = xpub.substring(0, 4).toLocaleLowerCase();
+        if (prefix === "xpub") {
+            // Bitcoin mainnet
+            settings_1.configuration.currency = currencies_1.currencies.btc;
+            settings_1.configuration.currency.network = currencies_1.currencies.btc.network_mainnet;
+        }
+        else if (prefix === "tpub") {
+            // Bitcoin testnet
+            settings_1.configuration.currency = currencies_1.currencies.btc;
+            settings_1.configuration.currency.network = currencies_1.currencies.btc.network_testnet;
+            settings_1.configuration.testnet = true;
+        }
+        else if (prefix === "ltub") {
+            // Litecoin
+            settings_1.configuration.currency = currencies_1.currencies.ltc;
+            // TODO: LTC testnet
+            settings_1.configuration.currency.network = currencies_1.currencies.ltc.network_mainnet;
+        }
+        else if (prefix === "dgub") {
+            // Dogecoin
+            settings_1.configuration.currency = currencies_1.currencies.doge;
+            settings_1.configuration.currency.network = currencies_1.currencies.doge.network_mainnet;
+        }
+        else {
+            throw new Error("INVALID XPUB: " + xpub + " has not a valid prefix");
+        }
+    }
+    else {
+        // Bitcoin Cash
+        if (currency === "BCH") {
+            settings_1.configuration.currency = currencies_1.currencies.bch;
+            // TODO: BCH testnet
+            settings_1.configuration.currency.network = currencies_1.currencies.bch.network_mainnet;
+            return;
+        }
+        // Ethereum
+        else if (currency === "ETH") {
+            settings_1.configuration.currency = currencies_1.currencies.eth;
+            return;
+        }
+        throw new Error("INVALID CURRENCY: '" + currency + "' is not supported");
+    }
+}
+exports.setNetwork = setNetwork;
+/**
+ * Configure the external provider URL (i.e., default v. Crypto APIs provider)
+ * @param  {string} currency?
+ *          Symbol of the currency (e.g. 'BCH')
+ * @returns void
+ */
+const setExternalProviderURL = () => {
+    // custom provider (i.e., API key is set)
+    if (process.env.XPUB_SCAN_CUSTOM_API_KEY_V2) {
+        settings_1.configuration.externalProviderURL = settings_1.CRYPTOAPIS_URL.replace("{network}", getNetworkLabel());
+        settings_1.configuration.providerType = "Crypto APIs";
+        return;
+    }
+    // default provider
+    const currency = settings_1.configuration.currency;
+    if (currency.symbol === currencies_1.currencies.btc.symbol ||
+        currency.symbol === currencies_1.currencies.ltc.symbol ||
+        currency.symbol === currencies_1.currencies.doge.symbol) {
+        settings_1.configuration.externalProviderURL = settings_1.DEFAULT_API_URLS.general;
+        return;
+    }
+    if (currency.symbol === currencies_1.currencies.bch.symbol) {
+        settings_1.configuration.externalProviderURL = settings_1.DEFAULT_API_URLS.bch;
+        return;
+    }
+    if (currency.symbol === currencies_1.currencies.eth.symbol) {
+        settings_1.configuration.externalProviderURL = settings_1.DEFAULT_API_URLS.eth;
+    }
+};
+function checkXpub(xpub) {
+    try {
+        bip32.fromBase58(xpub, settings_1.configuration.currency.network);
+    }
+    catch (e) {
+        throw new Error("INVALID XPUB: " + xpub + " is not a valid xpub -- " + e);
+    }
+}
+function init(xpub, silent, quiet, currency, testnet, derivationMode) {
+    if (typeof silent !== "undefined") {
+        settings_1.configuration.silent = silent;
+    }
+    if (typeof quiet !== "undefined") {
+        settings_1.configuration.quiet = quiet;
+    }
+    setNetwork(xpub, currency, testnet);
+    setExternalProviderURL();
+    if (settings_1.configuration.currency.utxo_based) {
+        checkXpub(xpub);
+    }
+    settings_1.configuration.specificDerivationMode = derivationMode;
+    if (settings_1.configuration.silent) {
+        return;
+    }
+    console.log(chalk_1.default.grey("(Data fetched from the "
+        .concat(chalk_1.default.bold(settings_1.configuration.providerType))
+        .concat(" provider)")));
+}
+exports.init = init;
+// remove prefixes (`bitcoincash:`) from Bitcoin Cash addresses
+function toUnprefixedCashAddress(address) {
+    if (settings_1.configuration.currency.symbol !== currencies_1.currencies.bch.symbol) {
+        return undefined;
+    }
+    if (!bchaddrjs_1.default.isCashAddress(address)) {
+        address = bchaddrjs_1.default.toCashAddress(address);
+    }
+    return address.replace("bitcoincash:", "");
+}
+exports.toUnprefixedCashAddress = toUnprefixedCashAddress;
+/**
+ * Convert from unit of account to base unit (e.g. bitcoins to satoshis)
+ * @param amount the amount (in unit of account) to convert
+ * @returns the converted amount, in base unit
+ */
+function toBaseUnit(amount) {
+    if (amount.isZero()) {
+        return amount.toFixed(0);
+    }
+    const convertedAmount = amount.times(settings_1.configuration.currency.precision);
+    return convertedAmount.toFixed(0);
+}
+exports.toBaseUnit = toBaseUnit;
+/**
+ * Convert from base unit to unit of account (e.g. satoshis to bitcoins)
+ * @param amount the amount (in base unit) to convert
+ * @param decimalPlaces (optional) decimal precision
+ * @returns the converted amount, in unit of account
+ */
+function toAccountUnit(amount, decimalPlaces) {
+    if (amount.isZero()) {
+        return amount.toFixed();
+    }
+    let convertedValue;
+    if (settings_1.configuration.currency.symbol === currencies_1.currencies.eth.symbol) {
+        return (amount.toNumber() / settings_1.configuration.currency.precision).toFixed(settings_1.ETH_FIXED_PRECISION);
+    }
+    else {
+        convertedValue = amount.dividedBy(settings_1.configuration.currency.precision);
+        if (typeof decimalPlaces !== "undefined" && decimalPlaces) {
+            return convertedValue.toFixed(decimalPlaces);
+        }
+    }
+    return convertedValue.toFixed();
+}
+exports.toAccountUnit = toAccountUnit;
+function getNetworkLabel() {
+    if (settings_1.configuration.testnet) {
+        if (settings_1.configuration.currency.symbol === currencies_1.currencies.eth.symbol &&
+            typeof settings_1.configuration.APIKey !== "undefined") {
+            return "ropsten";
+        }
+        else {
+            return "testnet";
+        }
+    }
+    else {
+        return "mainnet";
+    }
+}
+exports.getNetworkLabel = getNetworkLabel;

package/lib/input/args.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Returns the valid args entered by the user
+ * @returns any
+ *          The validated args
+ */
+export declare const getArgs: () => any;

package/lib/input/args.js

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArgs = void 0;
+const yargs_1 = __importDefault(require("yargs"));
+const check_1 = require("./check");
+/**
+ * Returns the valid args entered by the user
+ * @returns any
+ *          The validated args
+ */
+const getArgs = () => {
+    const args = yargs_1.default
+        // primary options
+        .option("currency", {
+        description: "currency",
+        demand: false,
+        type: "string",
+    })
+        .option("testnet", {
+        description: "testnet",
+        demand: false,
+        type: "boolean",
+        default: false,
+    })
+        .option("account", {
+        alias: "a",
+        description: "Account number",
+        demand: false,
+        type: "number",
+    })
+        .option("index", {
+        alias: "i",
+        description: "Index number",
+        demand: false,
+        type: "number",
+    })
+        .option("from-index", {
+        description: "ScanLimits: FROM index X",
+        demand: false,
+        type: "number",
+    })
+        .option("to-index", {
+        description: "ScanLimits: TO index Y",
+        demand: false,
+        type: "number",
+    })
+        .option("pre-derivation-size", {
+        description: "ScanLimits: number of pre-derived addresses per account",
+        demand: false,
+        type: "number",
+    })
+        .option("address", {
+        description: "Address",
+        demand: false,
+        type: "string",
+    })
+        .option("derivation-mode", {
+        description: "Select specific derivation mode (legacy, SegWit, etc.)",
+        demand: false,
+        type: "string",
+    })
+        // stdout options
+        .option("silent", {
+        description: "Do not display anything (except for the filepath of the saved reports)",
+        demand: false,
+        type: "boolean",
+        default: false,
+    })
+        .option("quiet", {
+        description: "Do not display analysis progress",
+        demand: false,
+        type: "boolean",
+        default: false,
+    })
+        .option("diff", {
+        description: "Show diffs",
+        demand: false,
+        type: "boolean",
+    })
+        .option("addresses", {
+        description: "Import addresses (file) for comparison",
+        demand: false,
+        type: "string",
+    })
+        .option("balance", {
+        description: "Import balance for comparison (has to be in base unit) for comparison",
+        demand: false,
+        type: "string",
+    })
+        .option("balance-only", {
+        description: "Do not fetch operations, only balance of the account (utxo-list for btc)",
+        demand: false,
+        type: "boolean",
+        default: false,
+    })
+        .option("utxos", {
+        description: "Import UTXOs (file) for comparison",
+        demand: false,
+        type: "string",
+    })
+        .option("operations", {
+        description: "Import operations history (file) for comparison",
+        demand: false,
+        type: "string",
+    })
+        // save
+        .option("save", {
+        description: "Save analysis",
+        demand: false,
+        type: "string",
+    })
+        .option("custom-provider", {
+        description: "Require the use of the custom provider",
+        demand: false,
+        type: "boolean",
+        default: false,
+    })
+        .option("block-height-limit", {
+        description: "Block height limit",
+        demand: false,
+        type: "number",
+    }).argv;
+    (0, check_1.checkArgs)(args, process.argv);
+    return args;
+};
+exports.getArgs = getArgs;

package/lib/input/check.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Ensure that args are valid
+ * @param  {any} args
+ * @returns void
+ */
+export declare const checkArgs: (args: any, argv: Array<string>) => void;

package/lib/input/check.js

@@ -0,0 +1,217 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkArgs = void 0;
+const fs_1 = __importDefault(require("fs"));
+const chalk_1 = __importDefault(require("chalk"));
+const currencies_1 = require("../configuration/currencies");
+const settings_1 = require("../configuration/settings");
+/**
+ * Ensure that args are valid
+ * @param  {any} args
+ * @returns void
+ */
+const checkArgs = (args, argv) => {
+    // (important) Command line mode: enable output
+    settings_1.configuration.commandLineMode = true;
+    args.itemToScan = args._[0];
+    if (Number(args.itemToScan)) {
+        args.itemToScan = argv[2];
+    }
+    const itemToScan = args.itemToScan;
+    const testnet = args.testnet;
+    const address = args.address;
+    const balance = args.balance;
+    const save = args.save;
+    const currency = args.currency;
+    const derivationMode = args.derivationMode;
+    const account = args.account;
+    const index = args.index;
+    const fromIndex = args.fromIndex;
+    const toIndex = args.toIndex;
+    const preDerivationSize = args.preDerivationSize;
+    const blockHeightLimit = args.blockHeightLimit;
+    // xpub: set, non-empty
+    if (typeof itemToScan === "undefined" || itemToScan === "") {
+        throw new Error("Xpub or address is required");
+    }
+    // address: non-empty
+    if (typeof address !== "undefined" && address === "") {
+        throw new Error("Address should not be empty");
+    }
+    // imported balance: integer (i.e., base unit)
+    if (typeof balance !== "undefined") {
+        if (balance % 1 !== 0) {
+            throw new Error("Balance is not an integer: " + balance);
+        }
+    }
+    if (args.balanceOnly && args.operations) {
+        throw new Error("You cannot pass an operation file in --balance-only mode");
+    }
+    // currency: exists
+    if (typeof currency !== "undefined") {
+        args.currency = args.currency.toUpperCase();
+        const currencyProperties = Object.entries(currencies_1.currencies).filter((c) => c[1].symbol.toUpperCase() === args.currency.toUpperCase());
+        if (currencyProperties.length === 0) {
+            throw new Error("Currency '" + currency + "' has not been implemented yet");
+        }
+    }
+    // derivation mode: compatible with (implicitly) selected currency
+    if (typeof derivationMode !== "undefined") {
+        let availableDerivationModes = [];
+        if (typeof currency !== "undefined") {
+            // if currency is defined, explicitly use its derivation modes
+            const configuredCurrency = Object.entries(currencies_1.currencies)
+                .filter((c) => c[1].symbol.toUpperCase() === args.currency.toUpperCase())
+                .map((c) => {
+                return c[1];
+            })[0];
+            // implementation note: this complex way of performing this verification
+            // is due to the fact that derivationModes is optional...
+            for (const c of Object.entries(configuredCurrency)) {
+                if (c[0] === "derivationModes") {
+                    availableDerivationModes = c[1];
+                }
+            }
+        }
+        else {
+            // if currency is not defined, implicitly use BTC's derivation modes
+            availableDerivationModes = currencies_1.currencies.btc.derivationModes;
+        }
+        if (availableDerivationModes.filter((d) => d.toLocaleLowerCase().startsWith(derivationMode.toLocaleLowerCase())).length === 0) {
+            throw new Error("Selected derivation mode " +
+                derivationMode +
+                " is not compatible with selected currency");
+        }
+    }
+    // warnings: not implemented yet
+    if (typeof args.addresses !== "undefined") {
+        console.log(chalk_1.default.bgYellowBright.black(" Warning: `--addresses` option has not been implemented yet. Skipped. "));
+    }
+    if (typeof args.utxos !== "undefined") {
+        console.log(chalk_1.default.bgYellowBright.black(" Warning: `--utxos` option has not been implemented yet. Skipped. "));
+    }
+    // imported files: non-empty, exist
+    const importedFiles = [args.addresses, args.utxos, args.operations];
+    for (const importedFile of importedFiles) {
+        if (typeof importedFile !== "undefined") {
+            if (importedFile === "" || !fs_1.default.existsSync(importedFile)) {
+                throw new Error("Imported file " + importedFile + " does not exist");
+            }
+        }
+    }
+    if (blockHeightLimit) {
+        if (!args.operations) {
+            throw new Error("The block height limit can only be used in comparison mode");
+        }
+        if (blockHeightLimit < 0) {
+            throw new Error("The block height limit cannot be negative");
+        }
+        settings_1.configuration.blockHeightUpperLimit = blockHeightLimit;
+    }
+    // save dirpath: exists, is a directory, writable
+    if (typeof save !== "undefined" && save.toLocaleLowerCase() !== "stdout") {
+        try {
+            if (!fs_1.default.statSync(save).isDirectory()) {
+                throw new Error("Save path " + save + " is not a directory");
+            }
+        }
+        catch (_a) {
+            throw new Error("Save path " + save + " does not exist");
+        }
+        fs_1.default.access(save, fs_1.default.constants.W_OK, function (err) {
+            if (err) {
+                throw new Error("Save directory " + save + " is not writable");
+            }
+        });
+    }
+    // account/index/scanLimits options
+    if (typeof account !== "undefined") {
+        // -a {positive number}
+        if (account < 0) {
+            throw new Error("Account number is required to be positive (including zero)");
+        }
+        // -a X -i Y or -a X --from-index Y [--to-index Z]
+        if (typeof index === "undefined" && typeof fromIndex === "undefined") {
+            throw new Error("Index or scanLimits is required when account number option (`-a`) is enabled");
+        }
+        // -a X -i {positive number}
+        if (typeof index !== "undefined" && index < 0) {
+            throw new Error("Index number is required to be positive (including zero)");
+        }
+        if (typeof fromIndex !== "undefined") {
+            // -a X --from-index {postive number} [--to-index {postive number}]
+            if (fromIndex < 0) {
+                throw new Error("`--from-index` option is required to be positive (including zero)");
+            }
+            if (typeof toIndex !== "undefined") {
+                if (toIndex < 0) {
+                    throw new Error("`--to-index` option is required to be positive");
+                }
+                // -a X --from-index Y --to-index Z | Y <= Z
+                if (fromIndex > toIndex) {
+                    throw new Error("`--from-index` has to be less or equal to `--to-index`");
+                }
+            }
+        }
+    }
+    else {
+        // -a X -i Y
+        if (typeof index !== "undefined") {
+            throw new Error("Account number is required when index number option (`-i`) is enabled");
+        }
+        // -a X --from-index Y --to-index Z
+        if (typeof fromIndex !== "undefined") {
+            throw new Error("Account number is required when scanLimits index option (`--from-index`) is enabled");
+        }
+    }
+    if (typeof preDerivationSize !== "undefined") {
+        if (preDerivationSize < 0) {
+            throw new Error("`--pre-derivation-size` option is required to be positive");
+        }
+    }
+    else if (typeof account !== "undefined") {
+        args.preDerivationSize = 2000; // magic number
+    }
+    // if needed, create scanLimits
+    if (typeof account !== "undefined") {
+        if (typeof index !== "undefined") {
+            args.scanLimits = {
+                account,
+                indexFrom: index,
+                indexTo: index,
+                preDerivationSize: args.preDerivationSize,
+            };
+        }
+        else if (typeof fromIndex !== "undefined") {
+            args.scanLimits = {
+                account,
+                indexFrom: fromIndex,
+                indexTo: toIndex,
+                preDerivationSize: args.preDerivationSize,
+            };
+        }
+    }
+    // testnet
+    if (typeof testnet !== "undefined" && testnet) {
+        // temporary guard clause:
+        // only Bitcoin and Ethereum testnet are supported at the moment
+        if (
+        // case 1. non-tpub
+        (typeof args.xpub !== "undefined" &&
+            args.xpub.substring(0, 4).toLocaleLowerCase() !== "tpub") ||
+            // case 2. non-ETH
+            (typeof currency !== "undefined" && currency.toUpperCase() !== "ETH") ||
+            // case 3. ETH via default provider
+            (currency.toUpperCase() === "ETH" &&
+                typeof process.env.XPUB_SCAN_CUSTOM_API_KEY_V2 === "undefined")) {
+            throw new Error("The analysis of this currency cannot be performed on testnet");
+        }
+    }
+    if (args.customProvider && !process.env.XPUB_SCAN_CUSTOM_API_KEY_V2) {
+        throw new Error("Custom provider v2 API key (XPUB_SCAN_CUSTOM_API_KEY_V2) is missing");
+    }
+};
+exports.checkArgs = checkArgs;

package/lib/input/importOperations.d.ts

@@ -0,0 +1,11 @@
+import { Operation } from "../models/operation";
+/**
+ * Dispatcher: detect the type of the imported file
+ * based on its contents
+ * @param  {string} path
+ *          Path of file to import
+ * @returns Operation
+ *          Imported transactions
+ */
+declare const importOperations: (path: string) => Array<Operation>;
+export { importOperations };