@atomicfinance/utils 3.5.3 → 3.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atomicfinance/utils",
-  "version": "3.5.3",
+  "version": "3.6.0",
   "description": "",
   "module": "dist/index.js",
   "main": "dist/index.js",
@@ -23,9 +23,9 @@
     "node": ">=14"
   },
   "dependencies": {
-    "@atomicfinance/crypto": "^3.5.3",
-    "@atomicfinance/errors": "^3.5.3",
-    "@atomicfinance/types": "^3.5.3",
+    "@atomicfinance/crypto": "^3.6.0",
+    "@atomicfinance/errors": "^3.6.0",
+    "@atomicfinance/types": "^3.6.0",
     "@babel/runtime": "^7.12.1",
     "bignumber.js": "^9.0.0",
     "bip174": "^2.0.1",

package/lib/bitcoin.js

@@ -1,243 +0,0 @@
-"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.validateAddress = exports.getPubKeyHash = exports.AddressTypes = exports.witnessStackToScriptWitness = exports.normalizeTransactionObject = exports.decodeRawTransaction = exports.selectCoins = exports.getAddressNetwork = exports.compressPubKey = exports.calculateFee = void 0;
-const crypto_1 = require("@atomicfinance/crypto");
-const errors_1 = require("@atomicfinance/errors");
-const types_1 = require("@atomicfinance/types");
-const bignumber_js_1 = __importDefault(require("bignumber.js"));
-const varuint = __importStar(require("bip174/src/lib/converter/varint"));
-const bitcoin_networks_1 = require("bitcoin-networks");
-const bitcoin = __importStar(require("bitcoinjs-lib"));
-const classify = __importStar(require("bitcoinjs-lib/src/classify"));
-const coinselect_1 = __importDefault(require("coinselect"));
-const accumulative_1 = __importDefault(require("coinselect/accumulative"));
-const lodash_1 = require("lodash");
-const _1 = require("./");
-const AddressTypes = ['legacy', 'p2sh-segwit', 'bech32'];
-exports.AddressTypes = AddressTypes;
-function calculateFee(numInputs, numOutputs, feePerByte) {
-    return (numInputs * 148 + numOutputs * 34 + 10) * feePerByte;
-}
-exports.calculateFee = calculateFee;
-/**
- * Get compressed pubKey from pubKey.
- * @param {!string} pubKey - 65 byte string with prefix, x, y.
- * @return {string} Returns the compressed pubKey of uncompressed pubKey.
- */
-function compressPubKey(pubKey) {
-    const x = pubKey.substring(2, 66);
-    const y = pubKey.substring(66, 130);
-    const even = parseInt(y.substring(62, 64), 16) % 2 === 0;
-    const prefix = even ? '02' : '03';
-    return prefix + x;
-}
-exports.compressPubKey = compressPubKey;
-/**
- * Get a network object from an address
- * @param {string} address The bitcoin address
- * @return {Network}
- */
-function getAddressNetwork(address) {
-    // TODO: can this be simplified using just bitcoinjs-lib??
-    let networkKey;
-    // bech32
-    networkKey = (0, lodash_1.findKey)(bitcoin_networks_1.BitcoinNetworks, (network) => address.startsWith(network.bech32));
-    // base58
-    if (!networkKey) {
-        const prefix = crypto_1.base58.decode(address).toString('hex').substring(0, 2);
-        networkKey = (0, lodash_1.findKey)(bitcoin_networks_1.BitcoinNetworks, (network) => {
-            const pubKeyHashPrefix = (0, crypto_1.padHexStart)(network.pubKeyHash.toString(16), 1);
-            const scriptHashPrefix = (0, crypto_1.padHexStart)(network.scriptHash.toString(16), 1);
-            return [pubKeyHashPrefix, scriptHashPrefix].includes(prefix);
-        });
-    }
-    return bitcoin_networks_1.BitcoinNetworks[networkKey];
-}
-exports.getAddressNetwork = getAddressNetwork;
-function selectCoins(utxos, targets, feePerByte, fixedInputs = []) {
-    let selectUtxos = utxos;
-    // Default coinselect won't accumulate some inputs
-    // TODO: does coinselect need to be modified to ABSOLUTELY not skip an input?
-    const coinselectStrat = fixedInputs.length
-        ? accumulative_1.default
-        : coinselect_1.default;
-    if (fixedInputs.length) {
-        selectUtxos = [
-            // Order fixed inputs to the start of the list so they are used
-            ...fixedInputs,
-            ...utxos.filter((utxo) => !fixedInputs.find((input) => input.vout === utxo.vout && input.txid === utxo.txid)),
-        ];
-    }
-    const { inputs, outputs, fee } = coinselectStrat(selectUtxos, targets, Math.ceil(feePerByte));
-    let change;
-    if (inputs && outputs) {
-        change = outputs.find((output) => output.id !== 'main');
-    }
-    return { inputs, outputs, fee, change };
-}
-exports.selectCoins = selectCoins;
-const OUTPUT_TYPES_MAP = {
-    [classify.types.P2WPKH]: 'witness_v0_keyhash',
-    [classify.types.P2WSH]: 'witness_v0_scripthash',
-};
-function decodeRawTransaction(hex, network) {
-    const bjsTx = bitcoin.Transaction.fromHex(hex);
-    const vin = bjsTx.ins.map((input) => {
-        return {
-            txid: Buffer.from(input.hash).reverse().toString('hex'),
-            vout: input.index,
-            scriptSig: {
-                asm: bitcoin.script.toASM(input.script),
-                hex: input.script.toString('hex'),
-            },
-            txinwitness: input.witness.map((w) => w.toString('hex')),
-            sequence: input.sequence,
-        };
-    });
-    const vout = bjsTx.outs.map((output, n) => {
-        const type = classify.output(output.script);
-        const vout = {
-            value: output.value / 1e8,
-            n,
-            scriptPubKey: {
-                asm: bitcoin.script.toASM(output.script),
-                hex: output.script.toString('hex'),
-                reqSigs: 1,
-                type: OUTPUT_TYPES_MAP[type] || type,
-                addresses: [],
-            },
-        };
-        try {
-            const address = bitcoin.address.fromOutputScript(output.script, network);
-            vout.scriptPubKey.addresses.push(address);
-        }
-        catch (e) {
-            /** If output script is not parasable, we just skip it */
-        }
-        return vout;
-    });
-    return {
-        txid: bjsTx.getHash(false).reverse().toString('hex'),
-        hash: bjsTx.getHash(true).reverse().toString('hex'),
-        version: bjsTx.version,
-        locktime: bjsTx.locktime,
-        size: bjsTx.byteLength(),
-        vsize: bjsTx.virtualSize(),
-        weight: bjsTx.weight(),
-        vin,
-        vout,
-        hex,
-    };
-}
-exports.decodeRawTransaction = decodeRawTransaction;
-function normalizeTransactionObject(tx, fee, block) {
-    const value = tx.vout.reduce((p, n) => p.plus(new bignumber_js_1.default(n.value).times(1e8)), new bignumber_js_1.default(0));
-    const result = {
-        hash: tx.txid,
-        value: value.toNumber(),
-        _raw: tx,
-        confirmations: 0,
-        status: tx.confirmations > 0 ? types_1.TxStatus.Success : types_1.TxStatus.Pending,
-    };
-    if (fee) {
-        const feePrice = Math.round(fee / tx.vsize);
-        Object.assign(result, {
-            fee,
-            feePrice,
-        });
-    }
-    if (block) {
-        Object.assign(result, {
-            blockHash: block.hash,
-            blockNumber: block.number,
-            confirmations: tx.confirmations,
-        });
-    }
-    return result;
-}
-exports.normalizeTransactionObject = normalizeTransactionObject;
-// TODO: This is copy pasta because it's not exported from bitcoinjs-lib
-// https://github.com/bitcoinjs/bitcoinjs-lib/blob/master/test/integration/csv.spec.ts#L477
-function witnessStackToScriptWitness(witness) {
-    let buffer = Buffer.allocUnsafe(0);
-    function writeSlice(slice) {
-        buffer = Buffer.concat([buffer, Buffer.from(slice)]);
-    }
-    function writeVarInt(i) {
-        const currentLen = buffer.length;
-        const varintLen = varuint.encodingLength(i);
-        buffer = Buffer.concat([buffer, Buffer.allocUnsafe(varintLen)]);
-        varuint.encode(i, buffer, currentLen);
-    }
-    function writeVarSlice(slice) {
-        writeVarInt(slice.length);
-        writeSlice(slice);
-    }
-    function writeVector(vector) {
-        writeVarInt(vector.length);
-        vector.forEach(writeVarSlice);
-    }
-    writeVector(witness);
-    return buffer;
-}
-exports.witnessStackToScriptWitness = witnessStackToScriptWitness;
-function getPubKeyHash(address, network) {
-    const outputScript = bitcoin.address.toOutputScript(address, network);
-    const type = classify.output(outputScript);
-    if (![classify.types.P2PKH, classify.types.P2WPKH].includes(type)) {
-        throw new Error(`Bitcoin swap doesn't support the address ${address} type of ${type}. Not possible to derive public key hash.`);
-    }
-    try {
-        const bech32 = bitcoin.address.fromBech32(address);
-        return bech32.data;
-    }
-    catch (e) {
-        const base58 = bitcoin.address.fromBase58Check(address);
-        return base58.hash;
-    }
-}
-exports.getPubKeyHash = getPubKeyHash;
-function validateAddress(_address, network) {
-    const address = (0, _1.addressToString)(_address);
-    if (typeof address !== 'string') {
-        throw new errors_1.InvalidAddressError(`Invalid address: ${address}`);
-    }
-    let pubKeyHash;
-    try {
-        pubKeyHash = getPubKeyHash(address, network);
-    }
-    catch (e) {
-        throw new errors_1.InvalidAddressError(`Invalid Address. Failed to parse: ${address}`);
-    }
-    if (!pubKeyHash) {
-        throw new errors_1.InvalidAddressError(`Invalid Address: ${address}`);
-    }
-}
-exports.validateAddress = validateAddress;
-//# sourceMappingURL=bitcoin.js.map

package/lib/index.js

@@ -1,84 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateExpiration = exports.validateSecretAndHash = exports.validateSecretHash = exports.validateSecret = exports.validateValue = exports.caseInsensitiveEqual = exports.asyncSetImmediate = exports.addressToString = exports.sleep = void 0;
-require("setimmediate");
-const crypto_1 = require("@atomicfinance/crypto");
-const errors_1 = require("@atomicfinance/errors");
-const types_1 = require("@atomicfinance/types");
-function addressToString(address) {
-    if (typeof address === 'string')
-        return address;
-    else
-        return address.address;
-}
-exports.addressToString = addressToString;
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-exports.sleep = sleep;
-function asyncSetImmediate() {
-    return new Promise((resolve) => setImmediate(resolve));
-}
-exports.asyncSetImmediate = asyncSetImmediate;
-function caseInsensitiveEqual(left, right) {
-    left = left && left.toLowerCase();
-    right = right && right.toLowerCase();
-    return left === right;
-}
-exports.caseInsensitiveEqual = caseInsensitiveEqual;
-function validateValue(value) {
-    if (!types_1.BigNumber.isBigNumber(value)) {
-        throw new Error(`Invalid value: ${value}`);
-    }
-    if (value.lte(0)) {
-        throw new Error(`Invalid value: ${value}`);
-    }
-}
-exports.validateValue = validateValue;
-function validateSecretHash(secretHash) {
-    if (typeof secretHash !== 'string') {
-        throw new errors_1.InvalidSecretError(`Invalid secret hash type`);
-    }
-    if (Buffer.from(secretHash, 'hex').toString('hex') !== secretHash) {
-        throw new errors_1.InvalidSecretError(`Invalid secret hash. Not Hex.`);
-    }
-    if (Buffer.byteLength(secretHash, 'hex') !== 32) {
-        throw new errors_1.InvalidSecretError(`Invalid secret hash: ${secretHash}`);
-    }
-    if ((0, crypto_1.sha256)('0000000000000000000000000000000000000000000000000000000000000000') === secretHash) {
-        throw new errors_1.InvalidSecretError(`Invalid secret hash: ${secretHash}. Secret 0 detected.`);
-    }
-}
-exports.validateSecretHash = validateSecretHash;
-function validateSecret(secret) {
-    if (typeof secret !== 'string') {
-        throw new errors_1.InvalidSecretError(`Invalid secret type`);
-    }
-    if (Buffer.from(secret, 'hex').toString('hex') !== secret) {
-        throw new errors_1.InvalidSecretError(`Invalid secret. Not Hex.`);
-    }
-    const secretBuff = Buffer.from(secret, 'hex');
-    if (secretBuff.length !== 32) {
-        throw new errors_1.InvalidSecretError(`Invalid secret size`);
-    }
-}
-exports.validateSecret = validateSecret;
-function validateSecretAndHash(secret, secretHash) {
-    validateSecret(secret);
-    validateSecretHash(secretHash);
-    const computedSecretHash = Buffer.from((0, crypto_1.sha256)(secret), 'hex');
-    if (!computedSecretHash.equals(Buffer.from(secretHash, 'hex'))) {
-        throw new errors_1.InvalidSecretError(`Invalid secret: Does not match expected secret hash: ${secretHash}`);
-    }
-}
-exports.validateSecretAndHash = validateSecretAndHash;
-function validateExpiration(expiration) {
-    if (isNaN(expiration)) {
-        throw new errors_1.InvalidExpirationError(`Invalid expiration. NaN: ${expiration}`);
-    }
-    if (expiration < 500000000 || expiration > 5000000000000) {
-        throw new errors_1.InvalidExpirationError(`Invalid expiration. Out of bounds: ${expiration}`);
-    }
-}
-exports.validateExpiration = validateExpiration;
-//# sourceMappingURL=index.js.map