utxo-lib 1.0.1

package/dist/src/networks.js

@@ -0,0 +1,477 @@
+"use strict";
+/*
+
+The values for the various fork coins can be found in these files:
+
+property       filename                  varname                           notes
+------------------------------------------------------------------------------------------------------------------------
+messagePrefix  src/validation.cpp        strMessageMagic                   Format `${CoinName} Signed Message`
+bech32_hrp     src/chainparams.cpp       bech32_hrp                        Only for some networks
+bip32.public   src/chainparams.cpp       base58Prefixes[EXT_PUBLIC_KEY]    Mainnets have same value, testnets have same value
+bip32.private  src/chainparams.cpp       base58Prefixes[EXT_SECRET_KEY]    Mainnets have same value, testnets have same value
+pubKeyHash     src/chainparams.cpp       base58Prefixes[PUBKEY_ADDRESS]
+scriptHash     src/chainparams.cpp       base58Prefixes[SCRIPT_ADDRESS]
+wif            src/chainparams.cpp       base58Prefixes[SECRET_KEY]        Testnets have same value
+forkId         src/script/interpreter.h  FORKID_*
+
+*/
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isBbc = exports.supportsTaproot = exports.supportsSegwit = exports.isValidNetwork = exports.isZcash = exports.isLitecoin = exports.isDogecoin = exports.isDash = exports.isBitcoinSV = exports.isBitcoinGold = exports.isECash = exports.isBitcoinCash = exports.isBitcoin = exports.getTestnet = exports.isSameCoin = exports.isTestnet = exports.isMainnet = exports.getMainnet = exports.getNetworkName = exports.getNetworkList = exports.networks = void 0;
+/**
+ * @deprecated
+ */
+const coins = {
+    /*
+     * The original Bitcoin Cash was renamed to bitcoin-abc, and bitcoin-cash-node forked from it.
+     * Later, bitcoin-abc is rebranded to ecash. Here, 'bch' corresponds to bitcoin-cash-node, and
+     * 'bcha' corresponds to ecash. Ref: https://github.com/bitcoin-cash-node/bitcoin-cash-node
+     * */
+    BCH: 'bch',
+    BCHA: 'bcha',
+    BSV: 'bsv',
+    BTC: 'btc',
+    BTG: 'btg',
+    LTC: 'ltc',
+    ZEC: 'zec',
+    DASH: 'dash',
+    DOGE: 'doge',
+    // #9286F8 PECUNIA CHANGES
+    BBC: 'bbc',
+};
+function getDefaultBip32Mainnet() {
+    return {
+        // base58 'xpub'
+        public: 0x0488b21e,
+        // base58 'xprv'
+        private: 0x0488ade4,
+    };
+}
+function getDefaultBip32Testnet() {
+    return {
+        // base58 'tpub'
+        public: 0x043587cf,
+        // base58 'tprv'
+        private: 0x04358394,
+    };
+}
+exports.networks = {
+    // https://github.com/bitcoin/bitcoin/blob/master/src/validation.cpp
+    // https://github.com/bitcoin/bitcoin/blob/master/src/chainparams.cpp
+    bitcoin: {
+        messagePrefix: '\x18Bitcoin Signed Message:\n',
+        bech32: 'bc',
+        bip32: getDefaultBip32Mainnet(),
+        pubKeyHash: 0x00,
+        scriptHash: 0x05,
+        wif: 0x80,
+        coin: coins.BTC,
+    },
+    testnet: {
+        messagePrefix: '\x18Bitcoin Signed Message:\n',
+        bech32: 'tb',
+        bip32: getDefaultBip32Testnet(),
+        pubKeyHash: 0x6f,
+        scriptHash: 0xc4,
+        wif: 0xef,
+        coin: coins.BTC,
+    },
+    // https://github.com/bitcoin-cash-node/bitcoin-cash-node/blob/master/src/validation.cpp
+    // https://github.com/bitcoin-cash-node/bitcoin-cash-node/blob/master/src/chainparams.cpp
+    // https://github.com/bitcoincashorg/bitcoincash.org/blob/master/spec/cashaddr.md
+    bitcoincash: {
+        messagePrefix: '\x18Bitcoin Signed Message:\n',
+        bip32: getDefaultBip32Mainnet(),
+        pubKeyHash: 0x00,
+        scriptHash: 0x05,
+        wif: 0x80,
+        coin: coins.BCH,
+        forkId: 0x00,
+        cashAddr: {
+            prefix: 'bitcoincash',
+            pubKeyHash: 0x00,
+            scriptHash: 0x08,
+        },
+    },
+    bitcoincashTestnet: {
+        messagePrefix: '\x18Bitcoin Signed Message:\n',
+        bip32: getDefaultBip32Testnet(),
+        pubKeyHash: 0x6f,
+        scriptHash: 0xc4,
+        wif: 0xef,
+        coin: coins.BCH,
+        cashAddr: {
+            prefix: 'bchtest',
+            pubKeyHash: 0x00,
+            scriptHash: 0x08,
+        },
+    },
+    // https://github.com/BTCGPU/BTCGPU/blob/master/src/validation.cpp
+    // https://github.com/BTCGPU/BTCGPU/blob/master/src/chainparams.cpp
+    // https://github.com/BTCGPU/BTCGPU/blob/master/src/script/interpreter.h
+    bitcoingold: {
+        messagePrefix: '\x18Bitcoin Gold Signed Message:\n',
+        bech32: 'btg',
+        bip32: getDefaultBip32Mainnet(),
+        pubKeyHash: 0x26,
+        scriptHash: 0x17,
+        wif: 0x80,
+        forkId: 79,
+        coin: coins.BTG,
+    },
+    bitcoingoldTestnet: {
+        messagePrefix: '\x18Bitcoin Gold Signed Message:\n',
+        bech32: 'tbtg',
+        bip32: getDefaultBip32Testnet(),
+        pubKeyHash: 111,
+        scriptHash: 196,
+        wif: 0xef,
+        forkId: 79,
+        coin: coins.BTG,
+    },
+    // https://github.com/bitcoin-sv/bitcoin-sv/blob/master/src/validation.cpp
+    // https://github.com/bitcoin-sv/bitcoin-sv/blob/master/src/chainparams.cpp
+    bitcoinsv: {
+        messagePrefix: '\x18Bitcoin Signed Message:\n',
+        bip32: getDefaultBip32Mainnet(),
+        pubKeyHash: 0x00,
+        scriptHash: 0x05,
+        wif: 0x80,
+        coin: coins.BSV,
+        forkId: 0x00,
+    },
+    bitcoinsvTestnet: {
+        messagePrefix: '\x18Bitcoin Signed Message:\n',
+        bip32: getDefaultBip32Testnet(),
+        pubKeyHash: 0x6f,
+        scriptHash: 0xc4,
+        wif: 0xef,
+        coin: coins.BSV,
+        forkId: 0x00,
+    },
+    // https://github.com/dashpay/dash/blob/master/src/validation.cpp
+    // https://github.com/dashpay/dash/blob/master/src/chainparams.cpp
+    dash: {
+        messagePrefix: '\x19DarkCoin Signed Message:\n',
+        bip32: getDefaultBip32Mainnet(),
+        pubKeyHash: 0x4c,
+        scriptHash: 0x10,
+        wif: 0xcc,
+        coin: coins.DASH,
+    },
+    dashTest: {
+        messagePrefix: '\x19DarkCoin Signed Message:\n',
+        bip32: getDefaultBip32Testnet(),
+        pubKeyHash: 0x8c,
+        scriptHash: 0x13,
+        wif: 0xef,
+        coin: coins.DASH,
+    },
+    // https://github.com/dogecoin/dogecoin/blob/master/src/validation.cpp
+    // https://github.com/dogecoin/dogecoin/blob/master/src/chainparams.cpp
+    // Mainnet bip32 here does not match dogecoin core, this is intended (see BG-53241)
+    dogecoin: {
+        messagePrefix: '\x19Dogecoin Signed Message:\n',
+        bip32: getDefaultBip32Mainnet(),
+        pubKeyHash: 0x1e,
+        scriptHash: 0x16,
+        wif: 0x9e,
+        coin: coins.DOGE,
+    },
+    dogecoinTest: {
+        messagePrefix: '\x19Dogecoin Signed Message:\n',
+        bip32: getDefaultBip32Testnet(),
+        pubKeyHash: 0x71,
+        scriptHash: 0xc4,
+        wif: 0xf1,
+        coin: coins.DOGE,
+    },
+    // https://github.com/Bitcoin-ABC/bitcoin-abc/blob/master/src/validation.cpp
+    // https://github.com/Bitcoin-ABC/bitcoin-abc/blob/master/src/chainparams.cpp
+    // https://github.com/Bitcoin-ABC/bitcoin-abc/blob/master/src/util/message.cpp
+    ecash: {
+        messagePrefix: '\x16eCash Signed Message:\n',
+        bip32: getDefaultBip32Mainnet(),
+        pubKeyHash: 0x00,
+        scriptHash: 0x05,
+        wif: 0x80,
+        coin: coins.BCHA,
+        forkId: 0x00,
+        cashAddr: {
+            prefix: 'ecash',
+            pubKeyHash: 0x00,
+            scriptHash: 0x08,
+        },
+    },
+    ecashTest: {
+        messagePrefix: '\x16eCash Signed Message:\n',
+        bip32: getDefaultBip32Testnet(),
+        pubKeyHash: 0x6f,
+        scriptHash: 0xc4,
+        wif: 0xef,
+        coin: coins.BCHA,
+        cashAddr: {
+            prefix: 'ecashtest',
+            pubKeyHash: 0x00,
+            scriptHash: 0x08,
+        },
+    },
+    // https://github.com/litecoin-project/litecoin/blob/master/src/validation.cpp
+    // https://github.com/litecoin-project/litecoin/blob/master/src/chainparams.cpp
+    litecoin: {
+        messagePrefix: '\x19Litecoin Signed Message:\n',
+        bech32: 'ltc',
+        bip32: getDefaultBip32Mainnet(),
+        pubKeyHash: 0x30,
+        scriptHash: 0x32,
+        wif: 0xb0,
+        coin: coins.LTC,
+    },
+    litecoinTest: {
+        messagePrefix: '\x19Litecoin Signed Message:\n',
+        bech32: 'tltc',
+        bip32: getDefaultBip32Testnet(),
+        pubKeyHash: 0x6f,
+        scriptHash: 0x3a,
+        wif: 0xef,
+        coin: coins.LTC,
+    },
+    // https://github.com/zcash/zcash/blob/master/src/validation.cpp
+    // https://github.com/zcash/zcash/blob/master/src/chainparams.cpp
+    zcash: {
+        messagePrefix: '\x18ZCash Signed Message:\n',
+        bip32: getDefaultBip32Mainnet(),
+        pubKeyHash: 0x1cb8,
+        scriptHash: 0x1cbd,
+        wif: 0x80,
+        coin: coins.ZEC,
+    },
+    zcashTest: {
+        messagePrefix: '\x18ZCash Signed Message:\n',
+        bip32: getDefaultBip32Testnet(),
+        pubKeyHash: 0x1d25,
+        scriptHash: 0x1cba,
+        wif: 0xef,
+        coin: coins.ZEC,
+    },
+    // #9286F8 PECUNIA CHANGES
+    bbc: {
+        messagePrefix: "\x19DarkCoin Signed Message:\n",
+        bip32: {
+            public: 0x0488ade3,
+            private: 0x0488b21e,
+        },
+        pubKeyHash: 0x19,
+        scriptHash: 0x66,
+        wif: 0xcd,
+        coin: coins.BBC,
+    },
+};
+/**
+ * @returns {Network[]} all known networks as array
+ */
+function getNetworkList() {
+    return Object.values(exports.networks);
+}
+exports.getNetworkList = getNetworkList;
+/**
+ * @param {Network} network
+ * @returns {NetworkName} the name of the network. Returns undefined if network is not a value
+ *                        of `networks`
+ */
+function getNetworkName(network) {
+    return Object.keys(exports.networks).find((n) => exports.networks[n] === network);
+}
+exports.getNetworkName = getNetworkName;
+/**
+ * @param {Network} network
+ * @returns {Object} the mainnet corresponding to a testnet
+ */
+function getMainnet(network) {
+    switch (network) {
+        case exports.networks.bitcoin:
+        case exports.networks.testnet:
+            return exports.networks.bitcoin;
+        case exports.networks.bitcoincash:
+        case exports.networks.bitcoincashTestnet:
+            return exports.networks.bitcoincash;
+        case exports.networks.bitcoingold:
+        case exports.networks.bitcoingoldTestnet:
+            return exports.networks.bitcoingold;
+        case exports.networks.bitcoinsv:
+        case exports.networks.bitcoinsvTestnet:
+            return exports.networks.bitcoinsv;
+        case exports.networks.dash:
+        case exports.networks.dashTest:
+            return exports.networks.dash;
+        case exports.networks.ecash:
+        case exports.networks.ecashTest:
+            return exports.networks.ecash;
+        case exports.networks.litecoin:
+        case exports.networks.litecoinTest:
+            return exports.networks.litecoin;
+        case exports.networks.zcash:
+        case exports.networks.zcashTest:
+            return exports.networks.zcash;
+        case exports.networks.dogecoin:
+        case exports.networks.dogecoinTest:
+            return exports.networks.dogecoin;
+        // #9286F8 PECUNIA CHANGES
+        case exports.networks.bbc:
+            return exports.networks.bbc;
+    }
+    throw new TypeError(`invalid network`);
+}
+exports.getMainnet = getMainnet;
+/**
+ * @param {Network} network
+ * @returns {boolean} true iff network is a mainnet
+ */
+function isMainnet(network) {
+    return getMainnet(network) === network;
+}
+exports.isMainnet = isMainnet;
+/**
+ * @param {Network} network
+ * @returns {boolean} true iff network is a testnet
+ */
+function isTestnet(network) {
+    return getMainnet(network) !== network;
+}
+exports.isTestnet = isTestnet;
+/**
+ *
+ * @param {Network} network
+ * @param {Network} otherNetwork
+ * @returns {boolean} true iff both networks are for the same coin
+ */
+function isSameCoin(network, otherNetwork) {
+    return getMainnet(network) === getMainnet(otherNetwork);
+}
+exports.isSameCoin = isSameCoin;
+const mainnets = getNetworkList().filter(isMainnet);
+const testnets = getNetworkList().filter(isTestnet);
+/**
+ * Map where keys are mainnet networks and values are testnet networks
+ * @type {Map<Network, Network[]>}
+ */
+const mainnetTestnetPairs = new Map(mainnets.map((m) => [m, testnets.filter((t) => getMainnet(t) === m)]));
+/**
+ * @param {Network} network
+ * @returns {Network|undefined} - The testnet corresponding to a mainnet.
+ *                               Returns undefined if a network has no testnet.
+ */
+function getTestnet(network) {
+    if (isTestnet(network)) {
+        return network;
+    }
+    const testnets = mainnetTestnetPairs.get(network);
+    if (testnets === undefined) {
+        throw new Error(`invalid argument`);
+    }
+    if (testnets.length === 0) {
+        return;
+    }
+    if (testnets.length === 1) {
+        return testnets[0];
+    }
+    throw new Error(`more than one testnet for ${getNetworkName(network)}`);
+}
+exports.getTestnet = getTestnet;
+/**
+ * @param {Network} network
+ * @returns {boolean} true iff network bitcoin or testnet
+ */
+function isBitcoin(network) {
+    return getMainnet(network) === exports.networks.bitcoin;
+}
+exports.isBitcoin = isBitcoin;
+/**
+ * @param {Network} network
+ * @returns {boolean} true iff network is bitcoincash or bitcoincashTestnet
+ */
+function isBitcoinCash(network) {
+    return getMainnet(network) === exports.networks.bitcoincash;
+}
+exports.isBitcoinCash = isBitcoinCash;
+/**
+ * @param {Network} network
+ * @returns {boolean} true iff network is ecash or ecashTest
+ */
+function isECash(network) {
+    return getMainnet(network) === exports.networks.ecash;
+}
+exports.isECash = isECash;
+/**
+ * @param {Network} network
+ * @returns {boolean} true iff network is bitcoingold
+ */
+function isBitcoinGold(network) {
+    return getMainnet(network) === exports.networks.bitcoingold;
+}
+exports.isBitcoinGold = isBitcoinGold;
+/**
+ * @param {Network} network
+ * @returns {boolean} true iff network is bitcoinsv or bitcoinsvTestnet
+ */
+function isBitcoinSV(network) {
+    return getMainnet(network) === exports.networks.bitcoinsv;
+}
+exports.isBitcoinSV = isBitcoinSV;
+/**
+ * @param {Network} network
+ * @returns {boolean} true iff network is dash or dashTest
+ */
+function isDash(network) {
+    return getMainnet(network) === exports.networks.dash;
+}
+exports.isDash = isDash;
+/**
+ * @param {Network} network
+ * @returns {boolean} true iff network is dogecoin or dogecoinTest
+ */
+function isDogecoin(network) {
+    return getMainnet(network) === exports.networks.dogecoin;
+}
+exports.isDogecoin = isDogecoin;
+/**
+ * @param {Network} network
+ * @returns {boolean} true iff network is litecoin or litecoinTest
+ */
+function isLitecoin(network) {
+    return getMainnet(network) === exports.networks.litecoin;
+}
+exports.isLitecoin = isLitecoin;
+/**
+ * @param {Network} network
+ * @returns {boolean} true iff network is zcash or zcashTest
+ */
+function isZcash(network) {
+    return getMainnet(network) === exports.networks.zcash;
+}
+exports.isZcash = isZcash;
+/**
+ * @param {unknown} network
+ * @returns {boolean} returns true iff network is any of the network stated in the argument
+ */
+function isValidNetwork(network) {
+    return getNetworkList().includes(network);
+}
+exports.isValidNetwork = isValidNetwork;
+function supportsSegwit(network) {
+    return [exports.networks.bitcoin, exports.networks.litecoin, exports.networks.bitcoingold].includes(getMainnet(network));
+}
+exports.supportsSegwit = supportsSegwit;
+function supportsTaproot(network) {
+    return getMainnet(network) === exports.networks.bitcoin;
+}
+exports.supportsTaproot = supportsTaproot;
+// #9286F8 PECUNIA CHANGES
+/**
+ * @param {Network} network
+ * @returns {boolean} true iff network is dash or dashTest
+ */
+function isBbc(network) {
+    return getMainnet(network) === exports.networks.bbc;
+}
+exports.isBbc = isBbc;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"networks.js","sourceRoot":"","sources":["../../src/networks.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;EAeE;;;AAEF;;GAEG;AACH,MAAM,KAAK,GAAG;IACZ;;;;SAIK;IACL,GAAG,EAAE,KAAK;IACV,IAAI,EAAE,MAAM;IACZ,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,GAAG,EAAE,KAAK;IACV,IAAI,EAAE,MAAM;IACZ,IAAI,EAAE,MAAM;IACZ,0BAA0B;IAC1B,GAAG,EAAE,KAAK;CACF,CAAC;AA8CX,SAAS,sBAAsB;IAC7B,OAAO;QACL,gBAAgB;QAChB,MAAM,EAAE,UAAU;QAClB,gBAAgB;QAChB,OAAO,EAAE,UAAU;KACpB,CAAC;AACJ,CAAC;AAED,SAAS,sBAAsB;IAC7B,OAAO;QACL,gBAAgB;QAChB,MAAM,EAAE,UAAU;QAClB,gBAAgB;QAChB,OAAO,EAAE,UAAU;KACpB,CAAC;AACJ,CAAC;AAEY,QAAA,QAAQ,GAAiC;IACpD,oEAAoE;IACpE,qEAAqE;IACrE,OAAO,EAAE;QACP,aAAa,EAAE,+BAA+B;QAC9C,MAAM,EAAE,IAAI;QACZ,KAAK,EAAE,sBAAsB,EAAE;QAC/B,UAAU,EAAE,IAAI;QAChB,UAAU,EAAE,IAAI;QAChB,GAAG,EAAE,IAAI;QACT,IAAI,EAAE,KAAK,CAAC,GAAG;KAChB;IACD,OAAO,EAAE;QACP,aAAa,EAAE,+BAA+B;QAC9C,MAAM,EAAE,IAAI;QACZ,KAAK,EAAE,sBAAsB,EAAE;QAC/B,UAAU,EAAE,IAAI;QAChB,UAAU,EAAE,IAAI;QAChB,GAAG,EAAE,IAAI;QACT,IAAI,EAAE,KAAK,CAAC,GAAG;KAChB;IAED,wFAAwF;IACxF,yFAAyF;IACzF,iFAAiF;IACjF,WAAW,EAAE;QACX,aAAa,EAAE,+BAA+B;QAC9C,KAAK,EAAE,sBAAsB,EAAE;QAC/B,UAAU,EAAE,IAAI;QAChB,UAAU,EAAE,IAAI;QAChB,GAAG,EAAE,IAAI;QACT,IAAI,EAAE,KAAK,CAAC,GAAG;QACf,MAAM,EAAE,IAAI;QACZ,QAAQ,EAAE;YACR,MAAM,EAAE,aAAa;YACrB,UAAU,EAAE,IAAI;YAChB,UAAU,EAAE,IAAI;SACjB;KACF;IACD,kBAAkB,EAAE;QAClB,aAAa,EAAE,+BAA+B;QAC9C,KAAK,EAAE,sBAAsB,EAAE;QAC/B,UAAU,EAAE,IAAI;QAChB,UAAU,EAAE,IAAI;QAChB,GAAG,EAAE,IAAI;QACT,IAAI,EAAE,KAAK,CAAC,GAAG;QACf,QAAQ,EAAE;YACR,MAAM,EAAE,SAAS;YACjB,UAAU,EAAE,IAAI;YAChB,UAAU,EAAE,IAAI;SACjB;KACF;IAED,kEAAkE;IAClE,mEAAmE;IACnE,wEAAwE;IACxE,WAAW,EAAE;QACX,aAAa,EAAE,oCAAoC;QACnD,MAAM,EAAE,KAAK;QACb,KAAK,EAAE,sBAAsB,EAAE;QAC/B,UAAU,EAAE,IAAI;QAChB,UAAU,EAAE,IAAI;QAChB,GAAG,EAAE,IAAI;QACT,MAAM,EAAE,EAAE;QACV,IAAI,EAAE,KAAK,CAAC,GAAG;KAChB;IACD,kBAAkB,EAAE;QAClB,aAAa,EAAE,oCAAoC;QACnD,MAAM,EAAE,MAAM;QACd,KAAK,EAAE,sBAAsB,EAAE;QAC/B,UAAU,EAAE,GAAG;QACf,UAAU,EAAE,GAAG;QACf,GAAG,EAAE,IAAI;QACT,MAAM,EAAE,EAAE;QACV,IAAI,EAAE,KAAK,CAAC,GAAG;KAChB;IAED,0EAA0E;IAC1E,2EAA2E;IAC3E,SAAS,EAAE;QACT,aAAa,EAAE,+BAA+B;QAC9C,KAAK,EAAE,sBAAsB,EAAE;QAC/B,UAAU,EAAE,IAAI;QAChB,UAAU,EAAE,IAAI;QAChB,GAAG,EAAE,IAAI;QACT,IAAI,EAAE,KAAK,CAAC,GAAG;QACf,MAAM,EAAE,IAAI;KACb;IACD,gBAAgB,EAAE;QAChB,aAAa,EAAE,+BAA+B;QAC9C,KAAK,EAAE,sBAAsB,EAAE;QAC/B,UAAU,EAAE,IAAI;QAChB,UAAU,EAAE,IAAI;QAChB,GAAG,EAAE,IAAI;QACT,IAAI,EAAE,KAAK,CAAC,GAAG;QACf,MAAM,EAAE,IAAI;KACb;IAED,iEAAiE;IACjE,kEAAkE;IAClE,IAAI,EAAE;QACJ,aAAa,EAAE,gCAAgC;QAC/C,KAAK,EAAE,sBAAsB,EAAE;QAC/B,UAAU,EAAE,IAAI;QAChB,UAAU,EAAE,IAAI;QAChB,GAAG,EAAE,IAAI;QACT,IAAI,EAAE,KAAK,CAAC,IAAI;KACjB;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,gCAAgC;QAC/C,KAAK,EAAE,sBAAsB,EAAE;QAC/B,UAAU,EAAE,IAAI;QAChB,UAAU,EAAE,IAAI;QAChB,GAAG,EAAE,IAAI;QACT,IAAI,EAAE,KAAK,CAAC,IAAI;KACjB;IAED,sEAAsE;IACtE,uEAAuE;IACvE,mFAAmF;IACnF,QAAQ,EAAE;QACR,aAAa,EAAE,gCAAgC;QAC/C,KAAK,EAAE,sBAAsB,EAAE;QAC/B,UAAU,EAAE,IAAI;QAChB,UAAU,EAAE,IAAI;QAChB,GAAG,EAAE,IAAI;QACT,IAAI,EAAE,KAAK,CAAC,IAAI;KACjB;IACD,YAAY,EAAE;QACZ,aAAa,EAAE,gCAAgC;QAC/C,KAAK,EAAE,sBAAsB,EAAE;QAC/B,UAAU,EAAE,IAAI;QAChB,UAAU,EAAE,IAAI;QAChB,GAAG,EAAE,IAAI;QACT,IAAI,EAAE,KAAK,CAAC,IAAI;KACjB;IAED,4EAA4E;IAC5E,6EAA6E;IAC7E,8EAA8E;IAC9E,KAAK,EAAE;QACL,aAAa,EAAE,6BAA6B;QAC5C,KAAK,EAAE,sBAAsB,EAAE;QAC/B,UAAU,EAAE,IAAI;QAChB,UAAU,EAAE,IAAI;QAChB,GAAG,EAAE,IAAI;QACT,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,MAAM,EAAE,IAAI;QACZ,QAAQ,EAAE;YACR,MAAM,EAAE,OAAO;YACf,UAAU,EAAE,IAAI;YAChB,UAAU,EAAE,IAAI;SACjB;KACF;IACD,SAAS,EAAE;QACT,aAAa,EAAE,6BAA6B;QAC5C,KAAK,EAAE,sBAAsB,EAAE;QAC/B,UAAU,EAAE,IAAI;QAChB,UAAU,EAAE,IAAI;QAChB,GAAG,EAAE,IAAI;QACT,IAAI,EAAE,KAAK,CAAC,IAAI;QAChB,QAAQ,EAAE;YACR,MAAM,EAAE,WAAW;YACnB,UAAU,EAAE,IAAI;YAChB,UAAU,EAAE,IAAI;SACjB;KACF;IAED,8EAA8E;IAC9E,+EAA+E;IAC/E,QAAQ,EAAE;QACR,aAAa,EAAE,gCAAgC;QAC/C,MAAM,EAAE,KAAK;QACb,KAAK,EAAE,sBAAsB,EAAE;QAC/B,UAAU,EAAE,IAAI;QAChB,UAAU,EAAE,IAAI;QAChB,GAAG,EAAE,IAAI;QACT,IAAI,EAAE,KAAK,CAAC,GAAG;KAChB;IACD,YAAY,EAAE;QACZ,aAAa,EAAE,gCAAgC;QAC/C,MAAM,EAAE,MAAM;QACd,KAAK,EAAE,sBAAsB,EAAE;QAC/B,UAAU,EAAE,IAAI;QAChB,UAAU,EAAE,IAAI;QAChB,GAAG,EAAE,IAAI;QACT,IAAI,EAAE,KAAK,CAAC,GAAG;KAChB;IAED,gEAAgE;IAChE,iEAAiE;IACjE,KAAK,EAAE;QACL,aAAa,EAAE,6BAA6B;QAC5C,KAAK,EAAE,sBAAsB,EAAE;QAC/B,UAAU,EAAE,MAAM;QAClB,UAAU,EAAE,MAAM;QAClB,GAAG,EAAE,IAAI;QACT,IAAI,EAAE,KAAK,CAAC,GAAG;KAChB;IACD,SAAS,EAAE;QACT,aAAa,EAAE,6BAA6B;QAC5C,KAAK,EAAE,sBAAsB,EAAE;QAC/B,UAAU,EAAE,MAAM;QAClB,UAAU,EAAE,MAAM;QAClB,GAAG,EAAE,IAAI;QACT,IAAI,EAAE,KAAK,CAAC,GAAG;KAChB;IACD,0BAA0B;IAC1B,GAAG,EAAE;QACH,aAAa,EAAE,gCAAgC;QAC/C,KAAK,EAAE;YACL,MAAM,EAAE,UAAU;YAClB,OAAO,EAAE,UAAU;SACpB;QACD,UAAU,EAAE,IAAI;QAChB,UAAU,EAAE,IAAI;QAChB,GAAG,EAAE,IAAI;QACT,IAAI,EAAE,KAAK,CAAC,GAAG;KAChB;CACF,CAAC;AAEF;;GAEG;AACH,SAAgB,cAAc;IAC5B,OAAO,MAAM,CAAC,MAAM,CAAC,gBAAQ,CAAC,CAAC;AACjC,CAAC;AAFD,wCAEC;AAED;;;;GAIG;AACH,SAAgB,cAAc,CAAC,OAAgB;IAC7C,OAAO,MAAM,CAAC,IAAI,CAAC,gBAAQ,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAE,gBAAoC,CAAC,CAAC,CAAC,KAAK,OAAO,CAEhF,CAAC;AAChB,CAAC;AAJD,wCAIC;AAED;;;GAGG;AACH,SAAgB,UAAU,CAAC,OAAgB;IACzC,QAAQ,OAAO,EAAE;QACf,KAAK,gBAAQ,CAAC,OAAO,CAAC;QACtB,KAAK,gBAAQ,CAAC,OAAO;YACnB,OAAO,gBAAQ,CAAC,OAAO,CAAC;QAE1B,KAAK,gBAAQ,CAAC,WAAW,CAAC;QAC1B,KAAK,gBAAQ,CAAC,kBAAkB;YAC9B,OAAO,gBAAQ,CAAC,WAAW,CAAC;QAE9B,KAAK,gBAAQ,CAAC,WAAW,CAAC;QAC1B,KAAK,gBAAQ,CAAC,kBAAkB;YAC9B,OAAO,gBAAQ,CAAC,WAAW,CAAC;QAE9B,KAAK,gBAAQ,CAAC,SAAS,CAAC;QACxB,KAAK,gBAAQ,CAAC,gBAAgB;YAC5B,OAAO,gBAAQ,CAAC,SAAS,CAAC;QAE5B,KAAK,gBAAQ,CAAC,IAAI,CAAC;QACnB,KAAK,gBAAQ,CAAC,QAAQ;YACpB,OAAO,gBAAQ,CAAC,IAAI,CAAC;QAEvB,KAAK,gBAAQ,CAAC,KAAK,CAAC;QACpB,KAAK,gBAAQ,CAAC,SAAS;YACrB,OAAO,gBAAQ,CAAC,KAAK,CAAC;QAExB,KAAK,gBAAQ,CAAC,QAAQ,CAAC;QACvB,KAAK,gBAAQ,CAAC,YAAY;YACxB,OAAO,gBAAQ,CAAC,QAAQ,CAAC;QAE3B,KAAK,gBAAQ,CAAC,KAAK,CAAC;QACpB,KAAK,gBAAQ,CAAC,SAAS;YACrB,OAAO,gBAAQ,CAAC,KAAK,CAAC;QAExB,KAAK,gBAAQ,CAAC,QAAQ,CAAC;QACvB,KAAK,gBAAQ,CAAC,YAAY;YACxB,OAAO,gBAAQ,CAAC,QAAQ,CAAC;QAC3B,0BAA0B;QAC1B,KAAK,gBAAQ,CAAC,GAAG;YACf,OAAO,gBAAQ,CAAC,GAAG,CAAC;KACvB;IACD,MAAM,IAAI,SAAS,CAAC,iBAAiB,CAAC,CAAC;AACzC,CAAC;AA1CD,gCA0CC;AAED;;;GAGG;AACH,SAAgB,SAAS,CAAC,OAAgB;IACxC,OAAO,UAAU,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC;AACzC,CAAC;AAFD,8BAEC;AAED;;;GAGG;AACH,SAAgB,SAAS,CAAC,OAAgB;IACxC,OAAO,UAAU,CAAC,OAAO,CAAC,KAAK,OAAO,CAAC;AACzC,CAAC;AAFD,8BAEC;AAED;;;;;GAKG;AACH,SAAgB,UAAU,CAAC,OAAgB,EAAE,YAAqB;IAChE,OAAO,UAAU,CAAC,OAAO,CAAC,KAAK,UAAU,CAAC,YAAY,CAAC,CAAC;AAC1D,CAAC;AAFD,gCAEC;AAED,MAAM,QAAQ,GAAG,cAAc,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;AACpD,MAAM,QAAQ,GAAG,cAAc,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;AAEpD;;;GAGG;AACH,MAAM,mBAAmB,GAAG,IAAI,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,UAAU,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAE3G;;;;GAIG;AACH,SAAgB,UAAU,CAAC,OAAgB;IACzC,IAAI,SAAS,CAAC,OAAO,CAAC,EAAE;QACtB,OAAO,OAAO,CAAC;KAChB;IACD,MAAM,QAAQ,GAAG,mBAAmB,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAClD,IAAI,QAAQ,KAAK,SAAS,EAAE;QAC1B,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;KACrC;IACD,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE;QACzB,OAAO;KACR;IACD,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE;QACzB,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC;KACpB;IACD,MAAM,IAAI,KAAK,CAAC,6BAA6B,cAAc,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;AAC1E,CAAC;AAfD,gCAeC;AAED;;;GAGG;AACH,SAAgB,SAAS,CAAC,OAAgB;IACxC,OAAO,UAAU,CAAC,OAAO,CAAC,KAAK,gBAAQ,CAAC,OAAO,CAAC;AAClD,CAAC;AAFD,8BAEC;AAED;;;GAGG;AACH,SAAgB,aAAa,CAAC,OAAgB;IAC5C,OAAO,UAAU,CAAC,OAAO,CAAC,KAAK,gBAAQ,CAAC,WAAW,CAAC;AACtD,CAAC;AAFD,sCAEC;AAED;;;GAGG;AACH,SAAgB,OAAO,CAAC,OAAgB;IACtC,OAAO,UAAU,CAAC,OAAO,CAAC,KAAK,gBAAQ,CAAC,KAAK,CAAC;AAChD,CAAC;AAFD,0BAEC;AAED;;;GAGG;AACH,SAAgB,aAAa,CAAC,OAAgB;IAC5C,OAAO,UAAU,CAAC,OAAO,CAAC,KAAK,gBAAQ,CAAC,WAAW,CAAC;AACtD,CAAC;AAFD,sCAEC;AAED;;;GAGG;AACH,SAAgB,WAAW,CAAC,OAAgB;IAC1C,OAAO,UAAU,CAAC,OAAO,CAAC,KAAK,gBAAQ,CAAC,SAAS,CAAC;AACpD,CAAC;AAFD,kCAEC;AAED;;;GAGG;AACH,SAAgB,MAAM,CAAC,OAAgB;IACrC,OAAO,UAAU,CAAC,OAAO,CAAC,KAAK,gBAAQ,CAAC,IAAI,CAAC;AAC/C,CAAC;AAFD,wBAEC;AAED;;;GAGG;AACH,SAAgB,UAAU,CAAC,OAAgB;IACzC,OAAO,UAAU,CAAC,OAAO,CAAC,KAAK,gBAAQ,CAAC,QAAQ,CAAC;AACnD,CAAC;AAFD,gCAEC;AAED;;;GAGG;AACH,SAAgB,UAAU,CAAC,OAAgB;IACzC,OAAO,UAAU,CAAC,OAAO,CAAC,KAAK,gBAAQ,CAAC,QAAQ,CAAC;AACnD,CAAC;AAFD,gCAEC;AAED;;;GAGG;AACH,SAAgB,OAAO,CAAC,OAAgB;IACtC,OAAO,UAAU,CAAC,OAAO,CAAC,KAAK,gBAAQ,CAAC,KAAK,CAAC;AAChD,CAAC;AAFD,0BAEC;AAED;;;GAGG;AACH,SAAgB,cAAc,CAAC,OAAgB;IAC7C,OAAO,cAAc,EAAE,CAAC,QAAQ,CAAC,OAAkB,CAAC,CAAC;AACvD,CAAC;AAFD,wCAEC;AAED,SAAgB,cAAc,CAAC,OAAgB;IAC7C,OAAQ,CAAC,gBAAQ,CAAC,OAAO,EAAE,gBAAQ,CAAC,QAAQ,EAAE,gBAAQ,CAAC,WAAW,CAAe,CAAC,QAAQ,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC,CAAC;AAClH,CAAC;AAFD,wCAEC;AAED,SAAgB,eAAe,CAAC,OAAgB;IAC9C,OAAO,UAAU,CAAC,OAAO,CAAC,KAAK,gBAAQ,CAAC,OAAO,CAAC;AAClD,CAAC;AAFD,0CAEC;AAED,0BAA0B;AAC1B;;;GAGG;AACH,SAAgB,KAAK,CAAC,OAAgB;IACpC,OAAO,UAAU,CAAC,OAAO,CAAC,KAAK,gBAAQ,CAAC,GAAG,CAAC;AAC9C,CAAC;AAFD,sBAEC","sourcesContent":["/*\n\nThe values for the various fork coins can be found in these files:\n\nproperty       filename                  varname                           notes\n------------------------------------------------------------------------------------------------------------------------\nmessagePrefix  src/validation.cpp        strMessageMagic                   Format `${CoinName} Signed Message`\nbech32_hrp     src/chainparams.cpp       bech32_hrp                        Only for some networks\nbip32.public   src/chainparams.cpp       base58Prefixes[EXT_PUBLIC_KEY]    Mainnets have same value, testnets have same value\nbip32.private  src/chainparams.cpp       base58Prefixes[EXT_SECRET_KEY]    Mainnets have same value, testnets have same value\npubKeyHash     src/chainparams.cpp       base58Prefixes[PUBKEY_ADDRESS]\nscriptHash     src/chainparams.cpp       base58Prefixes[SCRIPT_ADDRESS]\nwif            src/chainparams.cpp       base58Prefixes[SECRET_KEY]        Testnets have same value\nforkId         src/script/interpreter.h  FORKID_*\n\n*/\n\n/**\n * @deprecated\n */\nconst coins = {\n  /*\n   * The original Bitcoin Cash was renamed to bitcoin-abc, and bitcoin-cash-node forked from it.\n   * Later, bitcoin-abc is rebranded to ecash. Here, 'bch' corresponds to bitcoin-cash-node, and\n   * 'bcha' corresponds to ecash. Ref: https://github.com/bitcoin-cash-node/bitcoin-cash-node\n   * */\n  BCH: 'bch',\n  BCHA: 'bcha',\n  BSV: 'bsv',\n  BTC: 'btc',\n  BTG: 'btg',\n  LTC: 'ltc',\n  ZEC: 'zec',\n  DASH: 'dash',\n  DOGE: 'doge',\n  // #9286F8 PECUNIA CHANGES\n  BBC: 'bbc',\n} as const;\n\nexport type NetworkName =\n  | 'bitcoin'\n  | 'testnet'\n  | 'bitcoincash'\n  | 'bitcoincashTestnet'\n  | 'ecash'\n  | 'ecashTest'\n  | 'bitcoingold'\n  | 'bitcoingoldTestnet'\n  | 'bitcoinsv'\n  | 'bitcoinsvTestnet'\n  | 'dash'\n  | 'dashTest'\n  | 'dogecoin'\n  | 'dogecoinTest'\n  | 'litecoin'\n  | 'litecoinTest'\n  | 'zcash'\n  | 'zcashTest'\n  // #9286F8 PECUNIA CHANGES\n  | 'bbc';\n\nexport type Network = {\n  messagePrefix: string;\n  pubKeyHash: number;\n  scriptHash: number;\n  wif: number;\n  bip32: {\n    public: number;\n    private: number;\n  };\n  cashAddr?: {\n    prefix: string;\n    pubKeyHash: number;\n    scriptHash: number;\n  };\n  bech32?: string;\n  forkId?: number;\n  /**\n   * @deprecated\n   */\n  coin: string;\n};\n\nfunction getDefaultBip32Mainnet() {\n  return {\n    // base58 'xpub'\n    public: 0x0488b21e,\n    // base58 'xprv'\n    private: 0x0488ade4,\n  };\n}\n\nfunction getDefaultBip32Testnet() {\n  return {\n    // base58 'tpub'\n    public: 0x043587cf,\n    // base58 'tprv'\n    private: 0x04358394,\n  };\n}\n\nexport const networks: Record<NetworkName, Network> = {\n  // https://github.com/bitcoin/bitcoin/blob/master/src/validation.cpp\n  // https://github.com/bitcoin/bitcoin/blob/master/src/chainparams.cpp\n  bitcoin: {\n    messagePrefix: '\\x18Bitcoin Signed Message:\\n',\n    bech32: 'bc',\n    bip32: getDefaultBip32Mainnet(),\n    pubKeyHash: 0x00,\n    scriptHash: 0x05,\n    wif: 0x80,\n    coin: coins.BTC,\n  },\n  testnet: {\n    messagePrefix: '\\x18Bitcoin Signed Message:\\n',\n    bech32: 'tb',\n    bip32: getDefaultBip32Testnet(),\n    pubKeyHash: 0x6f,\n    scriptHash: 0xc4,\n    wif: 0xef,\n    coin: coins.BTC,\n  },\n\n  // https://github.com/bitcoin-cash-node/bitcoin-cash-node/blob/master/src/validation.cpp\n  // https://github.com/bitcoin-cash-node/bitcoin-cash-node/blob/master/src/chainparams.cpp\n  // https://github.com/bitcoincashorg/bitcoincash.org/blob/master/spec/cashaddr.md\n  bitcoincash: {\n    messagePrefix: '\\x18Bitcoin Signed Message:\\n',\n    bip32: getDefaultBip32Mainnet(),\n    pubKeyHash: 0x00,\n    scriptHash: 0x05,\n    wif: 0x80,\n    coin: coins.BCH,\n    forkId: 0x00,\n    cashAddr: {\n      prefix: 'bitcoincash',\n      pubKeyHash: 0x00,\n      scriptHash: 0x08,\n    },\n  },\n  bitcoincashTestnet: {\n    messagePrefix: '\\x18Bitcoin Signed Message:\\n',\n    bip32: getDefaultBip32Testnet(),\n    pubKeyHash: 0x6f,\n    scriptHash: 0xc4,\n    wif: 0xef,\n    coin: coins.BCH,\n    cashAddr: {\n      prefix: 'bchtest',\n      pubKeyHash: 0x00,\n      scriptHash: 0x08,\n    },\n  },\n\n  // https://github.com/BTCGPU/BTCGPU/blob/master/src/validation.cpp\n  // https://github.com/BTCGPU/BTCGPU/blob/master/src/chainparams.cpp\n  // https://github.com/BTCGPU/BTCGPU/blob/master/src/script/interpreter.h\n  bitcoingold: {\n    messagePrefix: '\\x18Bitcoin Gold Signed Message:\\n',\n    bech32: 'btg',\n    bip32: getDefaultBip32Mainnet(),\n    pubKeyHash: 0x26,\n    scriptHash: 0x17,\n    wif: 0x80,\n    forkId: 79,\n    coin: coins.BTG,\n  },\n  bitcoingoldTestnet: {\n    messagePrefix: '\\x18Bitcoin Gold Signed Message:\\n',\n    bech32: 'tbtg',\n    bip32: getDefaultBip32Testnet(),\n    pubKeyHash: 111,\n    scriptHash: 196,\n    wif: 0xef,\n    forkId: 79,\n    coin: coins.BTG,\n  },\n\n  // https://github.com/bitcoin-sv/bitcoin-sv/blob/master/src/validation.cpp\n  // https://github.com/bitcoin-sv/bitcoin-sv/blob/master/src/chainparams.cpp\n  bitcoinsv: {\n    messagePrefix: '\\x18Bitcoin Signed Message:\\n',\n    bip32: getDefaultBip32Mainnet(),\n    pubKeyHash: 0x00,\n    scriptHash: 0x05,\n    wif: 0x80,\n    coin: coins.BSV,\n    forkId: 0x00,\n  },\n  bitcoinsvTestnet: {\n    messagePrefix: '\\x18Bitcoin Signed Message:\\n',\n    bip32: getDefaultBip32Testnet(),\n    pubKeyHash: 0x6f,\n    scriptHash: 0xc4,\n    wif: 0xef,\n    coin: coins.BSV,\n    forkId: 0x00,\n  },\n\n  // https://github.com/dashpay/dash/blob/master/src/validation.cpp\n  // https://github.com/dashpay/dash/blob/master/src/chainparams.cpp\n  dash: {\n    messagePrefix: '\\x19DarkCoin Signed Message:\\n',\n    bip32: getDefaultBip32Mainnet(),\n    pubKeyHash: 0x4c,\n    scriptHash: 0x10,\n    wif: 0xcc,\n    coin: coins.DASH,\n  },\n  dashTest: {\n    messagePrefix: '\\x19DarkCoin Signed Message:\\n',\n    bip32: getDefaultBip32Testnet(),\n    pubKeyHash: 0x8c,\n    scriptHash: 0x13,\n    wif: 0xef,\n    coin: coins.DASH,\n  },\n\n  // https://github.com/dogecoin/dogecoin/blob/master/src/validation.cpp\n  // https://github.com/dogecoin/dogecoin/blob/master/src/chainparams.cpp\n  // Mainnet bip32 here does not match dogecoin core, this is intended (see BG-53241)\n  dogecoin: {\n    messagePrefix: '\\x19Dogecoin Signed Message:\\n',\n    bip32: getDefaultBip32Mainnet(),\n    pubKeyHash: 0x1e,\n    scriptHash: 0x16,\n    wif: 0x9e,\n    coin: coins.DOGE,\n  },\n  dogecoinTest: {\n    messagePrefix: '\\x19Dogecoin Signed Message:\\n',\n    bip32: getDefaultBip32Testnet(),\n    pubKeyHash: 0x71,\n    scriptHash: 0xc4,\n    wif: 0xf1,\n    coin: coins.DOGE,\n  },\n\n  // https://github.com/Bitcoin-ABC/bitcoin-abc/blob/master/src/validation.cpp\n  // https://github.com/Bitcoin-ABC/bitcoin-abc/blob/master/src/chainparams.cpp\n  // https://github.com/Bitcoin-ABC/bitcoin-abc/blob/master/src/util/message.cpp\n  ecash: {\n    messagePrefix: '\\x16eCash Signed Message:\\n',\n    bip32: getDefaultBip32Mainnet(),\n    pubKeyHash: 0x00,\n    scriptHash: 0x05,\n    wif: 0x80,\n    coin: coins.BCHA,\n    forkId: 0x00,\n    cashAddr: {\n      prefix: 'ecash',\n      pubKeyHash: 0x00,\n      scriptHash: 0x08,\n    },\n  },\n  ecashTest: {\n    messagePrefix: '\\x16eCash Signed Message:\\n',\n    bip32: getDefaultBip32Testnet(),\n    pubKeyHash: 0x6f,\n    scriptHash: 0xc4,\n    wif: 0xef,\n    coin: coins.BCHA,\n    cashAddr: {\n      prefix: 'ecashtest',\n      pubKeyHash: 0x00,\n      scriptHash: 0x08,\n    },\n  },\n\n  // https://github.com/litecoin-project/litecoin/blob/master/src/validation.cpp\n  // https://github.com/litecoin-project/litecoin/blob/master/src/chainparams.cpp\n  litecoin: {\n    messagePrefix: '\\x19Litecoin Signed Message:\\n',\n    bech32: 'ltc',\n    bip32: getDefaultBip32Mainnet(),\n    pubKeyHash: 0x30,\n    scriptHash: 0x32,\n    wif: 0xb0,\n    coin: coins.LTC,\n  },\n  litecoinTest: {\n    messagePrefix: '\\x19Litecoin Signed Message:\\n',\n    bech32: 'tltc',\n    bip32: getDefaultBip32Testnet(),\n    pubKeyHash: 0x6f,\n    scriptHash: 0x3a,\n    wif: 0xef,\n    coin: coins.LTC,\n  },\n\n  // https://github.com/zcash/zcash/blob/master/src/validation.cpp\n  // https://github.com/zcash/zcash/blob/master/src/chainparams.cpp\n  zcash: {\n    messagePrefix: '\\x18ZCash Signed Message:\\n',\n    bip32: getDefaultBip32Mainnet(),\n    pubKeyHash: 0x1cb8,\n    scriptHash: 0x1cbd,\n    wif: 0x80,\n    coin: coins.ZEC,\n  },\n  zcashTest: {\n    messagePrefix: '\\x18ZCash Signed Message:\\n',\n    bip32: getDefaultBip32Testnet(),\n    pubKeyHash: 0x1d25,\n    scriptHash: 0x1cba,\n    wif: 0xef,\n    coin: coins.ZEC,\n  },\n  // #9286F8 PECUNIA CHANGES\n  bbc: {\n    messagePrefix: \"\\x19DarkCoin Signed Message:\\n\",\n    bip32: {\n      public: 0x0488ade3,\n      private: 0x0488b21e,\n    },\n    pubKeyHash: 0x19,\n    scriptHash: 0x66,\n    wif: 0xcd,\n    coin: coins.BBC,\n  },\n};\n\n/**\n * @returns {Network[]} all known networks as array\n */\nexport function getNetworkList(): Network[] {\n  return Object.values(networks);\n}\n\n/**\n * @param {Network} network\n * @returns {NetworkName} the name of the network. Returns undefined if network is not a value\n *                        of `networks`\n */\nexport function getNetworkName(network: Network): NetworkName | undefined {\n  return Object.keys(networks).find((n) => (networks as Record<string, Network>)[n] === network) as\n    | NetworkName\n    | undefined;\n}\n\n/**\n * @param {Network} network\n * @returns {Object} the mainnet corresponding to a testnet\n */\nexport function getMainnet(network: Network): Network {\n  switch (network) {\n    case networks.bitcoin:\n    case networks.testnet:\n      return networks.bitcoin;\n\n    case networks.bitcoincash:\n    case networks.bitcoincashTestnet:\n      return networks.bitcoincash;\n\n    case networks.bitcoingold:\n    case networks.bitcoingoldTestnet:\n      return networks.bitcoingold;\n\n    case networks.bitcoinsv:\n    case networks.bitcoinsvTestnet:\n      return networks.bitcoinsv;\n\n    case networks.dash:\n    case networks.dashTest:\n      return networks.dash;\n\n    case networks.ecash:\n    case networks.ecashTest:\n      return networks.ecash;\n\n    case networks.litecoin:\n    case networks.litecoinTest:\n      return networks.litecoin;\n\n    case networks.zcash:\n    case networks.zcashTest:\n      return networks.zcash;\n\n    case networks.dogecoin:\n    case networks.dogecoinTest:\n      return networks.dogecoin;\n    // #9286F8 PECUNIA CHANGES\n    case networks.bbc:\n      return networks.bbc;\n  }\n  throw new TypeError(`invalid network`);\n}\n\n/**\n * @param {Network} network\n * @returns {boolean} true iff network is a mainnet\n */\nexport function isMainnet(network: Network): boolean {\n  return getMainnet(network) === network;\n}\n\n/**\n * @param {Network} network\n * @returns {boolean} true iff network is a testnet\n */\nexport function isTestnet(network: Network): boolean {\n  return getMainnet(network) !== network;\n}\n\n/**\n *\n * @param {Network} network\n * @param {Network} otherNetwork\n * @returns {boolean} true iff both networks are for the same coin\n */\nexport function isSameCoin(network: Network, otherNetwork: Network): boolean {\n  return getMainnet(network) === getMainnet(otherNetwork);\n}\n\nconst mainnets = getNetworkList().filter(isMainnet);\nconst testnets = getNetworkList().filter(isTestnet);\n\n/**\n * Map where keys are mainnet networks and values are testnet networks\n * @type {Map<Network, Network[]>}\n */\nconst mainnetTestnetPairs = new Map(mainnets.map((m) => [m, testnets.filter((t) => getMainnet(t) === m)]));\n\n/**\n * @param {Network} network\n * @returns {Network|undefined} - The testnet corresponding to a mainnet.\n *                               Returns undefined if a network has no testnet.\n */\nexport function getTestnet(network: Network): Network | undefined {\n  if (isTestnet(network)) {\n    return network;\n  }\n  const testnets = mainnetTestnetPairs.get(network);\n  if (testnets === undefined) {\n    throw new Error(`invalid argument`);\n  }\n  if (testnets.length === 0) {\n    return;\n  }\n  if (testnets.length === 1) {\n    return testnets[0];\n  }\n  throw new Error(`more than one testnet for ${getNetworkName(network)}`);\n}\n\n/**\n * @param {Network} network\n * @returns {boolean} true iff network bitcoin or testnet\n */\nexport function isBitcoin(network: Network): boolean {\n  return getMainnet(network) === networks.bitcoin;\n}\n\n/**\n * @param {Network} network\n * @returns {boolean} true iff network is bitcoincash or bitcoincashTestnet\n */\nexport function isBitcoinCash(network: Network): boolean {\n  return getMainnet(network) === networks.bitcoincash;\n}\n\n/**\n * @param {Network} network\n * @returns {boolean} true iff network is ecash or ecashTest\n */\nexport function isECash(network: Network): boolean {\n  return getMainnet(network) === networks.ecash;\n}\n\n/**\n * @param {Network} network\n * @returns {boolean} true iff network is bitcoingold\n */\nexport function isBitcoinGold(network: Network): boolean {\n  return getMainnet(network) === networks.bitcoingold;\n}\n\n/**\n * @param {Network} network\n * @returns {boolean} true iff network is bitcoinsv or bitcoinsvTestnet\n */\nexport function isBitcoinSV(network: Network): boolean {\n  return getMainnet(network) === networks.bitcoinsv;\n}\n\n/**\n * @param {Network} network\n * @returns {boolean} true iff network is dash or dashTest\n */\nexport function isDash(network: Network): boolean {\n  return getMainnet(network) === networks.dash;\n}\n\n/**\n * @param {Network} network\n * @returns {boolean} true iff network is dogecoin or dogecoinTest\n */\nexport function isDogecoin(network: Network): boolean {\n  return getMainnet(network) === networks.dogecoin;\n}\n\n/**\n * @param {Network} network\n * @returns {boolean} true iff network is litecoin or litecoinTest\n */\nexport function isLitecoin(network: Network): boolean {\n  return getMainnet(network) === networks.litecoin;\n}\n\n/**\n * @param {Network} network\n * @returns {boolean} true iff network is zcash or zcashTest\n */\nexport function isZcash(network: Network): boolean {\n  return getMainnet(network) === networks.zcash;\n}\n\n/**\n * @param {unknown} network\n * @returns {boolean} returns true iff network is any of the network stated in the argument\n */\nexport function isValidNetwork(network: unknown): network is Network {\n  return getNetworkList().includes(network as Network);\n}\n\nexport function supportsSegwit(network: Network): boolean {\n  return ([networks.bitcoin, networks.litecoin, networks.bitcoingold] as Network[]).includes(getMainnet(network));\n}\n\nexport function supportsTaproot(network: Network): boolean {\n  return getMainnet(network) === networks.bitcoin;\n}\n\n// #9286F8 PECUNIA CHANGES\n/**\n * @param {Network} network\n * @returns {boolean} true iff network is dash or dashTest\n */\nexport function isBbc(network: Network): boolean {\n  return getMainnet(network) === networks.bbc;\n}\n"]}

package/dist/src/noble_ecc.d.ts

@@ -0,0 +1,28 @@
+import { ECPairAPI, ECPairInterface } from 'ecpair';
+import { BIP32API, BIP32Interface } from 'bip32';
+import { MuSig } from '@brandonblack/musig';
+declare const ecc: {
+    isPoint: (p: Uint8Array) => boolean;
+    isPrivate: (d: Uint8Array) => boolean;
+    isXOnlyPoint: (p: Uint8Array) => boolean;
+    xOnlyPointAddTweak: (p: Uint8Array, tweak: Uint8Array) => {
+        parity: 0 | 1;
+        xOnlyPubkey: Uint8Array;
+    } | null;
+    pointFromScalar: (sk: Uint8Array, compressed?: boolean | undefined) => Uint8Array | null;
+    pointCompress: (p: Uint8Array, compressed?: boolean | undefined) => Uint8Array;
+    pointMultiply: (a: Uint8Array, tweak: Uint8Array, compressed?: boolean | undefined) => Uint8Array | null;
+    pointAdd: (a: Uint8Array, b: Uint8Array, compressed?: boolean | undefined) => Uint8Array | null;
+    pointAddScalar: (p: Uint8Array, tweak: Uint8Array, compressed?: boolean | undefined) => Uint8Array | null;
+    privateAdd: (d: Uint8Array, tweak: Uint8Array) => Uint8Array | null;
+    privateNegate: (d: Uint8Array) => Uint8Array;
+    sign: (h: Uint8Array, d: Uint8Array, e?: Uint8Array | undefined) => Uint8Array;
+    signSchnorr: (h: Uint8Array, d: Uint8Array, e?: Uint8Array) => Uint8Array;
+    verify: (h: Uint8Array, Q: Uint8Array, signature: Uint8Array, strict?: boolean | undefined) => boolean;
+    verifySchnorr: (h: Uint8Array, Q: Uint8Array, signature: Uint8Array) => boolean;
+};
+declare const ECPair: ECPairAPI;
+declare const bip32: BIP32API;
+declare const musig: MuSig;
+export { ecc, ECPair, ECPairAPI, ECPairInterface, bip32, BIP32API, BIP32Interface, musig, MuSig };
+//# sourceMappingURL=noble_ecc.d.ts.map

package/dist/src/noble_ecc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noble_ecc.d.ts","sourceRoot":"","sources":["../../src/noble_ecc.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAiB,eAAe,EAAE,MAAM,QAAQ,CAAC;AAEnE,OAAO,EAAE,QAAQ,EAAgB,cAAc,EAAE,MAAM,OAAO,CAAC;AAI/D,OAAO,EAAE,KAAK,EAAgB,MAAM,qBAAqB,CAAC;AAqC1D,QAAA,MAAM,GAAG;iBACM,UAAU,KAAG,OAAO;mBAClB,UAAU,KAAG,OAAO;sBACjB,UAAU,KAAG,OAAO;4BAEd,UAAU,SAAS,UAAU,KAAG;QAAE,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC;QAAC,WAAW,EAAE,UAAU,CAAA;KAAE,GAAG,IAAI;0BAOnF,UAAU,uCAAyB,UAAU,GAAG,IAAI;uBAGvD,UAAU,uCAAyB,UAAU;uBAI7C,UAAU,SAAS,UAAU,uCAAyB,UAAU,GAAG,IAAI;kBAG5E,UAAU,KAAK,UAAU,uCAAyB,UAAU,GAAG,IAAI;wBAO7D,UAAU,SAAS,UAAU,uCAAyB,UAAU,GAAG,IAAI;oBAG3E,UAAU,SAAS,UAAU,KAAG,UAAU,GAAG,IAAI;uBAS9C,UAAU,KAAG,UAAU;cAEhC,UAAU,KAAK,UAAU,iCAAmB,UAAU;qBAI/C,UAAU,KAAK,UAAU,MAAK,UAAU,KAA4B,UAAU;gBAInF,UAAU,KAAK,UAAU,aAAa,UAAU,mCAAqB,OAAO;uBAIrE,UAAU,KAAK,UAAU,aAAa,UAAU,KAAG,OAAO;CAG9E,CAAC;AAkEF,QAAA,MAAM,MAAM,EAAE,SAA8B,CAAC;AAC7C,QAAA,MAAM,KAAK,EAAE,QAA4B,CAAC;AAC1C,QAAA,MAAM,KAAK,EAAE,KAA4B,CAAC;AAE1C,OAAO,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,eAAe,EAAE,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC"}