utxofactory/utxoFactory.js

const utxoBaseNetworks = ["BTC", "LTC", "BCH", "TBTC", "TLTC", "TBCH"];

const xpubFormatBTC = /^(x|t){1}pub\w{107}$/i;
const xpubFormatLTC = /^(L|t){1}tub\w{107}$/i; ///^Ltpv\w{107}$/i;   // Ltpv or Ltub
// mainnet: Ltpv/Ltub, testnet: ttpv/ttub
// const xpubFormatLTC = (environment.testnet) ? /^Ltub\w{107}$/i : /^Ltpv\w{107}$/i;   // Ltpv or Ltub
const xpubFormatBCH = /^(x|t){1}pub\w{107}$/i;

const bitcore = require('bitcore-lib');
const litecore = require('litecore-lib');
const bch = require('bitcoincashjs');
const cashAddress = bch.Address;
const CashAddrFormat = cashAddress.CashAddrFormat;

class utxoFactory {
    constructor() {
    }

    getChildKey(xpubObj) {
        debugger;
        let responseObj = xpubObj;
        let xpub = xpubObj.xpub;
        let network = xpubObj.network.toUpperCase();
        let chain = xpubObj.chain;
        let index = xpubObj.index;
        let valid = false;

        if (utxoBaseNetworks.includes(network)) {
            switch (network) {
                case "LTC":
                case "TLTC":
                    if (xpubFormatLTC.test(xpub)) {
                        valid = true;
                    }
                    break;
                case "BCH":
                case "TBCH":
                    if (xpubFormatBCH.test(xpub)) {
                        valid = true;
                    }
                    break;
                case "BTC":
                case "TBTC":
                    if (xpubFormatBTC.test(xpub)) {
                        valid = true;
                    }
                    break;
            }
            if (valid) {
                console.log("1) xpub valid");
            }
            else {
                console.log("1) xpub invalid");
                responseObj.success = false;
                responseObj.message = "xpub not valid";
                throw { name: "xpub not valid", statusCode: 400, message: responseObj }
            }

            try {
                let childKey = this.computePubkey(network, xpub, chain, index);
                responseObj.pubkey = childKey;
                console.log("2) xpub valid");
                return responseObj;
            }
            catch (error) {
                console.log("2) xpub NOT valid");
                responseObj.success = false;
                responseObj.error = "xpub not valid";
                console.log(`${Date().toString().substring(0, 24)} factoryUTXO getChildKey Not valid xpub ${error.name}`);
                throw { name: "Not valid extended pubkey (xpub)", statusCode: 400, message: responseObj }
            }
        }
        else {
            responseObj.success = false;
            responseObj.message = "Network not UTXO";
            throw { name: "Network not UTXO", statusCode: 400, message: responseObj }
        }
    }

    computePubkey(network, xpub, chain, index) {
        switch (network) {
            case "BTC":
            case "TBTC":
                return this.computePubkeyBTC(xpub, chain, index);
            case "LTC":
            case "TLTC":
                return this.computePubkeyLTC(xpub, chain, index);
            case "BCH":
            case "TBCH":
                return this.computePubkeyBCH(xpub, chain, index);
        }
    }

    computePubkeyBTC(xpub, chain, index) {
        let HDPubKey = new bitcore.HDPublicKey(xpub);
        let thePath = "m/" + chain + "/" + index;
        let HDchild = HDPubKey.deriveChild(thePath);
        let childKey = HDchild.publicKey.toAddress().toString();
        return childKey;
    }

    computePubkeyBCH(xpub, chain, index) {
        let HDPubKey = new bitcore.HDPublicKey(xpub);
        let thePath = "m/" + chain + "/" + index;
        let HDchild = HDPubKey.deriveChild(thePath);
        let childKey = HDchild.publicKey.toAddress().toString();
        let cashAddressObj = new cashAddress(childKey);
        let childKeyBCH = cashAddressObj.toString(CashAddrFormat);
        return childKeyBCH;
    }

    computePubkeyLTC(xpub, chain, index) {
        let HDPubKey = new litecore.HDPublicKey(xpub);
        let thePath = "m/" + chain + "/" + index;
        let HDchild = HDPubKey.deriveChild(thePath);
        let childKey = HDchild.publicKey.toAddress().toString();
        return childKey;
    }
}

module.exports = utxoFactory;