@hackerhouse/xpub-scan 1.0.0

package/lib/input/importOperations.js

@@ -0,0 +1,406 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importOperations = void 0;
+const fs_1 = __importDefault(require("fs"));
+const chalk_1 = __importDefault(require("chalk"));
+const operation_1 = require("../models/operation");
+const settings_1 = require("../configuration/settings");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const helpers = __importStar(require("../helpers"));
+const currencies_1 = require("../configuration/currencies");
+/**
+ * Remove forbidden chars from address(es)
+ * note that comma (,) are allowed to render concatenated
+ * addresses
+ * @param  {string} address
+ *        An inputed address or an aggregated list of inputed addresses
+ * @returns string
+ *        A sanitized address or a sanitized aggregated list of addresses
+ */
+const sanitizeInputedAddress = (address) => {
+    return address.replace(/[^0-9a-zA-Z,]/gi, "");
+};
+/**
+ * Get contents from file to import
+ * @param  {string} path
+ *          Path of file to import
+ * @returns string
+ *          Imported contents
+ */
+const getFileContents = (path) => {
+    if (!fs_1.default.existsSync(path)) {
+        throw new Error("Imported file " + path + " does not exist");
+    }
+    return fs_1.default.readFileSync(path, "utf-8");
+};
+/**
+ * Import transactions from a Custom G CSV
+ * @param  {string} contents
+ *          Contents from file to import
+ * @returns Operation
+ *          Imported operations
+ */
+const importFromCustomGCSV = (contents) => {
+    const operations = [];
+    // temporary fix: offset if CSV refers to storageLimit
+    // (only columns with index > 14 have to be offsetted in this situation)
+    const offset = contents.includes("storageLimit") ? 2 : 1;
+    contents
+        .split(/\r?\n/)
+        .slice(1)
+        .forEach((line) => {
+        // split using delimiter ',' except when between double quotes
+        // as a Custom G CSV can have several addresses in the same field:
+        // ...,'<address1>,<address2>,<address3',...
+        const tokens = line.split(/,(?=(?:(?:[^"]*"){2})*[^"]*$)/);
+        if (tokens.length < 20) {
+            return;
+        }
+        // expected date format: yyyy-MM-dd HH:mm:ss
+        const date = /(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})/gi.exec(tokens[0]) || "";
+        const type = String(tokens[2]); // CREDIT || DEBIT
+        const status = String(tokens[4]); // CONFIRMED || ABORTED
+        const amount = tokens[8]; // in unit of account
+        const txid = tokens[16 + offset];
+        const sender = tokens[17 + offset];
+        const recipient = tokens[18 + offset];
+        // process only confirmed transactions
+        if (status === "CONFIRMED") {
+            if (type === "CREDIT") {
+                const op = new operation_1.Operation(date[0], amount);
+                op.setTxid(txid);
+                // recipient: one address or several concatenated addresses
+                // ! for this type of CSV, this field is required and should
+                // default to a non-empty string (here: `(no address)`) to
+                // ensure that an operation without address results in a mismatch
+                op.setAddress(sanitizeInputedAddress(recipient));
+                op.setOperationType("Received");
+                operations.push(op);
+            }
+            else if (type === "DEBIT") {
+                const op = new operation_1.Operation(date[0], amount);
+                op.setTxid(txid);
+                // sender: one address or several concatenated addresses
+                // ! for this type of CSV, this field is required and should
+                // default to a non-empty string (here: `(no address)`) to
+                // ensure that an operation without address results in a mismatch
+                op.setAddress(sanitizeInputedAddress(sender));
+                op.setOperationType("Sent");
+                operations.push(op);
+            }
+        }
+    });
+    return operations;
+};
+/**
+ * Import transactions from a Live Desktop CSV
+ * @param  {string} contents
+ *          Contents from file to import
+ * @returns Operation
+ *          Imported operations
+ */
+const importFromLiveDesktopCSV = (contents) => {
+    const operations = [];
+    contents
+        .split(/\r?\n/)
+        .slice(1)
+        .forEach((line) => {
+        const tokens = line.split(/,/);
+        if (tokens.length < 8) {
+            return;
+        }
+        // expected date format: yyyy-MM-dd HH:mm:ss
+        const date = /(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})/gi.exec(tokens[0]) || "";
+        const currency = tokens[1];
+        // skip currencies not relevant to the comparison
+        if (currency.toUpperCase() !== settings_1.configuration.currency.symbol.toUpperCase()) {
+            return;
+        }
+        const type = String(tokens[2]); // IN | OUT
+        const fees = tokens[4] !== "" ? tokens[4] : 0; // in unit of account
+        const txid = tokens[5];
+        let amount = tokens[3]; // in unit of account
+        // note: type B CSV does not refer to addresses
+        if (type === "IN") {
+            // if ETH, use fixed-point notation
+            amount =
+                settings_1.configuration.currency.symbol === currencies_1.currencies.eth.symbol
+                    ? new bignumber_js_1.default(tokens[3]).toFixed(settings_1.ETH_FIXED_PRECISION)
+                    : new bignumber_js_1.default(tokens[3]).toFixed();
+            const op = new operation_1.Operation(date[0], amount);
+            op.setTxid(txid);
+            op.setOperationType("Received");
+            operations.push(op);
+        }
+        else if (type === "OUT") {
+            // out transactions: substract fees from amount (in base unit)...
+            // and if ETH, use fixed-point notation
+            amount =
+                settings_1.configuration.currency.symbol === currencies_1.currencies.eth.symbol
+                    ? new bignumber_js_1.default(amount)
+                        .minus(new bignumber_js_1.default(fees))
+                        .toFixed(settings_1.ETH_FIXED_PRECISION)
+                    : new bignumber_js_1.default(amount).minus(new bignumber_js_1.default(fees)).toFixed();
+            // ... and convert the total back to unit of account
+            // (otherwise, there would be floating number issues)
+            const op = new operation_1.Operation(date[0], amount);
+            op.setTxid(txid);
+            op.setOperationType("Sent");
+            operations.push(op);
+        }
+    });
+    return operations;
+};
+/**
+ * Import transactions from a type A JSON
+ * @param  {string} contents
+ *          Contents from file to import
+ * @returns Operation
+ *          Imported operations
+ */
+const importFromJSONTypeA = (contents) => {
+    const operations = [];
+    let ops;
+    try {
+        ops = JSON.parse(contents).operations;
+    }
+    catch (err) {
+        throw new Error("JSON parsing error");
+    }
+    for (const operation of ops) {
+        const type = operation.operation_type;
+        const date = /(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})/gi.exec(operation.transaction.received_at) || "";
+        const txid = operation.hash;
+        const valueInBaseUnit = new bignumber_js_1.default(operation.amount); // in base unit
+        const feesInBaseUnit = new bignumber_js_1.default(operation.fees); // in base unit
+        if (type === "receive") {
+            const op = new operation_1.Operation(date[0], helpers.toAccountUnit(valueInBaseUnit));
+            op.setTxid(txid);
+            op.setOperationType("Received");
+            const addresses = [];
+            for (const output of operation.transaction.outputs) {
+                if (output.derivation !== null) {
+                    addresses.push(output.address);
+                }
+            }
+            op.setAddress(sanitizeInputedAddress(addresses.join(",")));
+            operations.push(op);
+        }
+        else if (type === "send") {
+            // out transactions: substract fees from amount (in base unit)...
+            const amountInBaseUnit = valueInBaseUnit.minus(feesInBaseUnit);
+            // ... and convert the total back to unit of account
+            // (otherwise, there would be floating number issues)
+            const op = new operation_1.Operation(date[0], helpers.toAccountUnit(amountInBaseUnit));
+            op.setTxid(txid);
+            op.setOperationType("Sent");
+            const addresses = [];
+            for (const input of operation.transaction.inputs) {
+                if (input.derivation !== null) {
+                    addresses.push(input.address);
+                }
+            }
+            op.setAddress(sanitizeInputedAddress(addresses.join(",")));
+            operations.push(op);
+        }
+    }
+    return operations;
+};
+/**
+ * Import transactions from a Live Common JSON
+ * @param  {string} contents
+ *          Contents from file to import
+ * @returns Operation
+ *          Imported operations
+ */
+const importFromLiveCommonJSON = (contents) => {
+    const operations = [];
+    let ops;
+    try {
+        ops = JSON.parse(contents).operations;
+    }
+    catch (err) {
+        throw new Error("JSON parsing error");
+    }
+    for (const operation of ops) {
+        const type = operation.type;
+        const date = /(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})/gi.exec(operation.date) || "";
+        const txid = operation.hash;
+        const valueInBaseUnit = new bignumber_js_1.default(operation.value); // in base unit
+        const feesInBaseUnit = new bignumber_js_1.default(operation.fee); // in base unit
+        const recipient = operation.recipients.join(",");
+        const sender = operation.senders.join(",");
+        if (type === "IN") {
+            const op = new operation_1.Operation(date[0], helpers.toAccountUnit(valueInBaseUnit));
+            op.setTxid(txid);
+            op.setOperationType("Received");
+            if (settings_1.configuration.currency.symbol === currencies_1.currencies.bch.symbol) {
+                // BCH: Live-common returns the cash address format
+                op.setCashAddress(sanitizeInputedAddress(recipient));
+            }
+            else {
+                op.setAddress(sanitizeInputedAddress(recipient));
+            }
+            operations.push(op);
+        }
+        else if (type === "OUT") {
+            // out transactions: substract fees from amount (in base unit)...
+            const amountInBaseUnit = valueInBaseUnit.minus(feesInBaseUnit);
+            // ... and convert the total back to unit of account
+            // (otherwise, there would be floating number issues)
+            const op = new operation_1.Operation(date[0], helpers.toAccountUnit(amountInBaseUnit));
+            op.setTxid(txid);
+            op.setOperationType("Sent");
+            if (settings_1.configuration.currency.symbol === currencies_1.currencies.bch.symbol) {
+                // BCH: Live-common returns the cash address format
+                op.setCashAddress(sanitizeInputedAddress(sender));
+            }
+            else {
+                op.setAddress(sanitizeInputedAddress(sender));
+            }
+            operations.push(op);
+        }
+    }
+    return operations;
+};
+/**
+ * Import transactions from a Custom W JSON
+ * @param  {string} contents
+ *          Contents from file to import
+ * @returns Operation
+ *          Imported operations
+ */
+const importFromCustomWJSON = (contents) => {
+    const operations = [];
+    let ops;
+    try {
+        ops = JSON.parse(contents).operations;
+    }
+    catch (err) {
+        throw new Error("JSON parsing error");
+    }
+    for (const operation of ops) {
+        const type = operation.type;
+        const amount = helpers.toAccountUnit(new bignumber_js_1.default(operation.amount));
+        const txid = operation.transaction.hash;
+        const date = /(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2})/gi.exec(operation.time) || "";
+        const token = operation.token;
+        let op = new operation_1.Operation();
+        if (type === "RECEIVE") {
+            op = new operation_1.Operation(date[0], amount);
+            op.setOperationType("Received");
+            op.setTxid(txid);
+            const addresses = [];
+            for (const output of operation.recipients) {
+                addresses.push(output);
+            }
+            op.setAddress(sanitizeInputedAddress(addresses.join(",")));
+        }
+        else if (type === "SEND") {
+            op = new operation_1.Operation(date[0], amount);
+            op.setOperationType("Sent");
+            op.setTxid(txid);
+            const addresses = [];
+            for (const input of operation.senders) {
+                addresses.push(input);
+            }
+            op.setAddress(sanitizeInputedAddress(addresses.join(",")));
+        }
+        else if (type === "NONE") {
+            op = new operation_1.Operation(date[0], new bignumber_js_1.default(0));
+            op.setOperationType("SCI (recipient)");
+            op.setTxid(txid);
+        }
+        if (typeof token !== "undefined") {
+            settings_1.configuration.augmentedImport = true;
+            const tokenAmount = new bignumber_js_1.default(token.amount).dividedBy(Math.pow(10, token.magnitude));
+            op.addToken(token.symbol, token.name, new bignumber_js_1.default(tokenAmount));
+        }
+        // TODO: enable Dapps import when this object will contain
+        // more information
+        //
+        // const dapp = operation.dapp;
+        // if (typeof dapp !== "undefined") {
+        // configuration.augmentedImport = true;
+        //   op.addDapp(dapp.contract_name);
+        // }
+        operations.push(op);
+    }
+    return operations;
+};
+/**
+ * Dispatcher: detect the type of the imported file
+ * based on its contents
+ * @param  {string} path
+ *          Path of file to import
+ * @returns Operation
+ *          Imported transactions
+ */
+const importOperations = (path) => {
+    const contents = getFileContents(path);
+    const firstLine = contents.split(/\r?\n/)[0].replace('"', "");
+    let operations = [];
+    // CSV FILES
+    if (firstLine.substring(0, 8) === "Creation") {
+        // Custom G CSV: 'Creation' is the first token
+        operations = importFromCustomGCSV(contents);
+    }
+    else if (firstLine.substring(0, 9) === "Operation") {
+        // Live Desktop CSV: 'Operation' is the first token
+        operations = importFromLiveDesktopCSV(contents);
+    }
+    // JSON FILES
+    else if (firstLine.startsWith("{") || firstLine.startsWith("[")) {
+        if (contents.includes("cursor")) {
+            // type A JSON: contains a reference to 'cursor',
+            //              an ambiguous term, but sufficient to
+            //              distinguish it from type Live Common JSON files
+            operations = importFromJSONTypeA(contents);
+        }
+        else if (contents.includes("seedIdentifier")) {
+            // Live Common JSON: contains an explicit reference to 'seedIdentifier'
+            operations = importFromLiveCommonJSON(contents);
+        }
+        else if (contents.includes("uid")) {
+            // Custom W JSON: contains an explicit reference to 'uid'
+            operations = importFromCustomWJSON(contents);
+        }
+    }
+    else {
+        throw new Error("Format not recognized.");
+    }
+    if (!settings_1.configuration.silent) {
+        console.log(chalk_1.default.grey(String(operations.length).concat(" operations have been imported")));
+    }
+    // TODO: at this point, generate a warning/error
+    // message if no operation has been imported
+    // (file parsing issue?)
+    return operations;
+};
+exports.importOperations = importOperations;

package/lib/models/address.d.ts

@@ -0,0 +1,40 @@
+import { DerivationMode } from "../configuration/currencies";
+import { Transaction } from "./transaction";
+import { Operation } from "./operation";
+import { Stats } from "./stats";
+import BigNumber from "bignumber.js";
+declare class Address {
+    address: string;
+    derivationMode: DerivationMode;
+    account: number;
+    index: number;
+    balance: BigNumber;
+    transactions: Array<Transaction>;
+    rawTransactions: Array<any>;
+    stats: Stats;
+    ins: Array<Operation>;
+    outs: Array<Operation>;
+    utxo: boolean;
+    constructor(itemToScan: string, derivationMode?: DerivationMode, account?: number, index?: number);
+    setTransactions(transactions: Array<Transaction>): void;
+    setRawTransactions(rawTransactions: Array<any>): void;
+    setBalance(balance: string | number): void;
+    setStats(txsCount: string | number, fundedSum: string | number, spentSum: string | number): void;
+    addFundedOperation(funded: Operation): void;
+    getFundedOperations(): Operation[];
+    addSentOperation(sent: Operation): void;
+    getSentOperations(): Operation[];
+    toString(): string;
+    asCashAddress(): string | undefined;
+    getDerivationMode(): DerivationMode;
+    getDerivation(): {
+        account: number;
+        index: number;
+    };
+    getBalance(): string;
+    getStats(): Stats;
+    getTransactions(): Transaction[];
+    getRawTransactions(): any[];
+    isUTXO(): boolean;
+}
+export { Address };

package/lib/models/address.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Address = void 0;
+const currencies_1 = require("../configuration/currencies");
+const stats_1 = require("./stats");
+const deriveAddresses_1 = require("../actions/deriveAddresses");
+const helpers_1 = require("../helpers");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+class Address {
+    constructor(itemToScan, derivationMode, account, index) {
+        if (derivationMode) {
+            this.address = (0, deriveAddresses_1.deriveAddress)(derivationMode, itemToScan, account, index);
+        }
+        else {
+            this.address = itemToScan;
+        }
+        this.derivationMode = derivationMode;
+        this.account = account;
+        this.index = index;
+        this.ins = [];
+        this.outs = [];
+        this.utxo = false;
+    }
+    setTransactions(transactions) {
+        this.transactions = transactions;
+    }
+    setRawTransactions(rawTransactions) {
+        this.rawTransactions = rawTransactions;
+    }
+    setBalance(balance) {
+        this.balance = new bignumber_js_1.default(balance);
+        if (!this.balance.isZero()) {
+            this.utxo = true;
+        }
+        else {
+            this.utxo = false;
+        }
+    }
+    setStats(txsCount, fundedSum, spentSum) {
+        this.stats = new stats_1.Stats();
+        this.stats.txsCount = new bignumber_js_1.default(txsCount);
+        this.stats.funded = new bignumber_js_1.default(fundedSum);
+        this.stats.spent = new bignumber_js_1.default(spentSum);
+    }
+    addFundedOperation(funded) {
+        this.ins.push(funded);
+    }
+    getFundedOperations() {
+        return this.ins;
+    }
+    addSentOperation(sent) {
+        this.outs.push(sent);
+    }
+    getSentOperations() {
+        return this.outs;
+    }
+    toString() {
+        return this.address;
+    }
+    // render as Cash Address (Bitcoin Cash)
+    asCashAddress() {
+        if (this.derivationMode === currencies_1.DerivationMode.BCH) {
+            return (0, helpers_1.toUnprefixedCashAddress)(this.address);
+        }
+        return undefined;
+    }
+    getDerivationMode() {
+        return this.derivationMode;
+    }
+    getDerivation() {
+        return {
+            account: this.account,
+            index: this.index,
+        };
+    }
+    getBalance() {
+        return this.balance.toFixed();
+    }
+    getStats() {
+        return this.stats;
+    }
+    getTransactions() {
+        return this.transactions;
+    }
+    getRawTransactions() {
+        const rawTransactions = this.rawTransactions;
+        if (typeof rawTransactions === "undefined") {
+            return []; // if no transaction, return an empty array
+        }
+        else {
+            return rawTransactions;
+        }
+    }
+    isUTXO() {
+        return this.utxo;
+    }
+}
+exports.Address = Address;

package/lib/models/comparison.d.ts

@@ -0,0 +1,8 @@
+import { Operation } from "./operation";
+type ComparisonStatus = "Match" | "Match (aggregated)" | "Missing (aggregated)" | "Mismatch: addresses" | "Mismatch: amounts" | "Mismatch: token amounts" | "Mismatch: token tickers" | "Mismatch: Dapp" | "Missing Operation" | "Extra Operation" | "Skipped";
+declare class Comparison {
+    imported: Operation | undefined;
+    actual: Operation | undefined;
+    status: ComparisonStatus;
+}
+export { Comparison, ComparisonStatus };

package/lib/models/comparison.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Comparison = void 0;
+class Comparison {
+}
+exports.Comparison = Comparison;

package/lib/models/currency.d.ts

@@ -0,0 +1,11 @@
+import * as bjs from "bitcoinjs-lib";
+import { DerivationMode } from "../configuration/currencies";
+declare class Currency {
+    name: string;
+    symbol: string;
+    network?: bjs.networks.Network;
+    derivationModes?: Array<DerivationMode>;
+    precision: number;
+    utxo_based: boolean;
+}
+export { Currency };

package/lib/models/currency.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Currency = void 0;
+class Currency {
+}
+exports.Currency = Currency;

package/lib/models/operation.d.ts

@@ -0,0 +1,33 @@
+import BigNumber from "bignumber.js";
+type OperationType = "Received" | "Received (non-sibling to change)" | "Received (token)" | "Sent" | "Sent (token)" | "Sent to self" | "Sent to sibling" | "Failed to send" | "SCI (caller)" | "SCI (recipient)" | "Swapped";
+declare class Operation {
+    operationType: OperationType;
+    txid: string;
+    date: string;
+    block: number;
+    address: string;
+    cashAddress?: string;
+    amount: BigNumber;
+    token: {
+        name: string;
+        symbol: string;
+        amount: BigNumber;
+    };
+    dapp: {
+        contract_name: string;
+    };
+    constructor(date?: string, amount?: BigNumber | string);
+    setTxid(txid: string): void;
+    getTxid(): string;
+    setBlockNumber(blockNumber: number): void;
+    getBlockNumber(): number;
+    setAddress(address?: string): void;
+    setCashAddress(cashAddress: string | undefined): void;
+    getAddress(): string;
+    getCashAddress(): string | undefined;
+    setOperationType(operationType: OperationType): void;
+    getOperationType(): OperationType;
+    addToken(symbol: string, name: string, amount: BigNumber): void;
+    addDapp(contract_name: string): void;
+}
+export { Operation, OperationType };