@atomiqlabs/sdk 7.0.12 → 8.0.8

package/dist/bitcoin/coinselect2/utils.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utils = exports.DUST_THRESHOLDS = void 0;
+const Logger_1 = require("../../utils/Logger");
+const logger = (0, Logger_1.getLogger)("CoinSelect: ");
+// baseline estimates, used to improve performance
+const TX_EMPTY_SIZE = 4 + 1 + 1 + 4;
+const TX_INPUT_BASE = 32 + 4 + 1 + 4;
+const WITNESS_OVERHEAD = 2 / 4;
+const P2WPKH_WITNESS = (1 + 1 + 72 + 1 + 33) / 4;
+const P2TR_WITNESS = (1 + 1 + 65) / 4;
+const TX_INPUT_PUBKEYHASH = 107;
+const TX_INPUT_P2SH_P2WPKH = 23 + P2WPKH_WITNESS + 1;
+const TX_INPUT_P2WPKH = 0 + P2WPKH_WITNESS;
+const TX_INPUT_P2WSH = 0 + (1 + 1 + 64) / 4;
+const TX_INPUT_P2TR = 0 + P2TR_WITNESS;
+const TX_OUTPUT_BASE = 8 + 1;
+const TX_OUTPUT_PUBKEYHASH = 25;
+const TX_OUTPUT_P2SH_P2WPKH = 23;
+const TX_OUTPUT_P2WPKH = 22;
+const TX_OUTPUT_P2WSH = 34;
+const TX_OUTPUT_P2TR = 34;
+const INPUT_BYTES = {
+    "p2sh-p2wpkh": TX_INPUT_P2SH_P2WPKH,
+    "p2wpkh": TX_INPUT_P2WPKH,
+    "p2tr": TX_INPUT_P2TR,
+    "p2pkh": TX_INPUT_PUBKEYHASH,
+    "p2wsh": TX_INPUT_P2WSH
+};
+function inputBytes(input) {
+    if (input.script == null && input.type == null)
+        throw new Error("Needs either script or type defined!");
+    return TX_INPUT_BASE + (input.script ? input.script.length : INPUT_BYTES[input.type]);
+}
+const OUTPUT_BYTES = {
+    "p2sh-p2wpkh": TX_OUTPUT_P2SH_P2WPKH,
+    "p2wpkh": TX_OUTPUT_P2WPKH,
+    "p2tr": TX_OUTPUT_P2TR,
+    "p2pkh": TX_OUTPUT_PUBKEYHASH,
+    "p2wsh": TX_OUTPUT_P2WSH
+};
+function outputBytes(output) {
+    if (output.script == null && output.type == null)
+        throw new Error("Needs either script or type defined!");
+    return TX_OUTPUT_BASE + (output.script ? output.script.length : OUTPUT_BYTES[output.type]);
+}
+exports.DUST_THRESHOLDS = {
+    "p2sh-p2wpkh": 540,
+    "p2wpkh": 294,
+    "p2tr": 330,
+    "p2pkh": 546,
+    "p2wsh": 330
+};
+function dustThreshold(output) {
+    return exports.DUST_THRESHOLDS[output.type];
+}
+function transactionBytes(inputs, outputs, changeType) {
+    let size = TX_EMPTY_SIZE;
+    let isSegwit = false;
+    if (changeType != null && changeType !== "p2pkh") {
+        size += WITNESS_OVERHEAD;
+        isSegwit = true;
+    }
+    for (let input of inputs) {
+        if (!isSegwit && (input.type !== "p2pkh")) {
+            isSegwit = true;
+            size += WITNESS_OVERHEAD;
+        }
+        size += inputBytes(input);
+    }
+    for (let output of outputs) {
+        size += outputBytes(output);
+    }
+    return Math.ceil(size);
+}
+function uintOrNaN(v) {
+    if (typeof v !== 'number')
+        return NaN;
+    if (!isFinite(v))
+        return NaN;
+    if (Math.floor(v) !== v)
+        return NaN;
+    if (v < 0)
+        return NaN;
+    return v;
+}
+function sumForgiving(range) {
+    return range.reduce((a, x) => a + (isFinite(x.value) ? x.value : 0), 0);
+}
+function sumOrNaN(range) {
+    return range.reduce((a, x) => a + uintOrNaN(x.value), 0);
+}
+function finalize(inputs, outputs, feeRate, changeType, cpfpAddFee = 0) {
+    const bytesAccum = transactionBytes(inputs, outputs, changeType);
+    logger.debug("finalize(): Transaction bytes: ", bytesAccum);
+    const feeAfterExtraOutput = (feeRate * (bytesAccum + outputBytes({ type: changeType }))) + cpfpAddFee;
+    logger.debug("finalize(): TX fee after adding change output: ", feeAfterExtraOutput);
+    const remainderAfterExtraOutput = Math.floor(sumOrNaN(inputs) - (sumOrNaN(outputs) + feeAfterExtraOutput));
+    logger.debug("finalize(): Leaves change (changeType=" + changeType + ") value: ", remainderAfterExtraOutput);
+    // is it worth a change output?
+    if (remainderAfterExtraOutput >= dustThreshold({ type: changeType })) {
+        outputs = outputs.concat({ value: remainderAfterExtraOutput, type: changeType });
+    }
+    const fee = sumOrNaN(inputs) - sumOrNaN(outputs);
+    logger.debug("finalize(): Re-calculated total fee: ", fee);
+    if (!isFinite(fee))
+        return { fee: (feeRate * bytesAccum) + cpfpAddFee };
+    return {
+        inputs: inputs,
+        outputs: outputs,
+        fee: fee
+    };
+}
+exports.utils = {
+    dustThreshold: dustThreshold,
+    finalize: finalize,
+    inputBytes: inputBytes,
+    outputBytes: outputBytes,
+    sumOrNaN: sumOrNaN,
+    sumForgiving: sumForgiving,
+    transactionBytes: transactionBytes,
+    uintOrNaN: uintOrNaN
+};

package/dist/bitcoin/mempool/MempoolApi.d.ts

@@ -0,0 +1,350 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Buffer } from "buffer";
+/**
+ * Bitcoin transaction confirmation status
+ * @category Bitcoin
+ */
+export type BitcoinTransactionStatus = {
+    confirmed: boolean;
+    block_height: number;
+    block_hash: string;
+    block_time: number;
+};
+/**
+ * Bitcoin transaction output
+ * @category Bitcoin
+ */
+export type TxVout = {
+    scriptpubkey: string;
+    scriptpubkey_asm: string;
+    scriptpubkey_type: string;
+    scriptpubkey_address: string;
+    value: number;
+};
+/**
+ * Bitcoin transaction input
+ * @category Bitcoin
+ */
+export type TxVin = {
+    txid: string;
+    vout: number;
+    prevout: TxVout;
+    scriptsig: string;
+    scriptsig_asm: string;
+    witness: string[];
+    is_coinbase: boolean;
+    sequence: number;
+    inner_witnessscript_asm: string;
+};
+/**
+ * Full Bitcoin transaction data
+ * @category Bitcoin
+ */
+export type BitcoinTransaction = {
+    txid: string;
+    version: number;
+    locktime: number;
+    vin: TxVin[];
+    vout: TxVout[];
+    size: number;
+    weight: number;
+    fee: number;
+    status: BitcoinTransactionStatus;
+};
+/**
+ * Bitcoin block data
+ * @category Bitcoin
+ */
+export type BlockData = {
+    bits: number;
+    difficulty: number;
+    extras: any;
+    height: number;
+    id: string;
+    mediantime: number;
+    merkle_root: string;
+    nonce: number;
+    previousblockhash: string;
+    size: number;
+    timestamp: number;
+    tx_count: number;
+    version: number;
+    weight: number;
+};
+/**
+ * Bitcoin block header data
+ * @category Bitcoin
+ */
+export type BitcoinBlockHeader = {
+    id: string;
+    height: number;
+    version: number;
+    timestamp: number;
+    tx_count: number;
+    size: number;
+    weight: number;
+    merkle_root: string;
+    previousblockhash: string;
+    mediantime: number;
+    nonce: number;
+    bits: number;
+    difficulty: number;
+};
+export type LNNodeInfo = {
+    public_key: string;
+    alias: string;
+    first_seen: number;
+    updated_at: number;
+    color: string;
+    sockets: string;
+    as_number: number;
+    city_id: number;
+    country_id: number;
+    subdivision_id: number;
+    longtitude: number;
+    latitude: number;
+    iso_code: string;
+    as_organization: string;
+    city: {
+        [lang: string]: string;
+    };
+    country: {
+        [lang: string]: string;
+    };
+    subdivision: {
+        [lang: string]: string;
+    };
+    active_channel_count: number;
+    capacity: string;
+    opened_channel_count: number;
+    closed_channel_count: number;
+};
+export type AddressInfo = {
+    address: string;
+    chain_stats: {
+        funded_txo_count: number;
+        funded_txo_sum: number;
+        spent_txo_count: number;
+        spent_txo_sum: number;
+        tx_count: number;
+    };
+    mempool_stats: {
+        funded_txo_count: number;
+        funded_txo_sum: number;
+        spent_txo_count: number;
+        spent_txo_sum: number;
+        tx_count: number;
+    };
+};
+export type TransactionCPFPData = {
+    ancestors: {
+        txid: string;
+        fee: number;
+        weight: number;
+    }[];
+    descendants: {
+        txid: string;
+        fee: number;
+        weight: number;
+    }[];
+    effectiveFeePerVsize: number;
+    sigops: number;
+    adjustedVsize: number;
+};
+export type BitcoinFees = {
+    fastestFee: number;
+    halfHourFee: number;
+    hourFee: number;
+    economyFee: number;
+    minimumFee: number;
+};
+export type BitcoinPendingBlock = {
+    blockSize: number;
+    blockVSize: number;
+    nTx: number;
+    totalFees: number;
+    medianFee: number;
+    feeRange: number[];
+};
+export type BlockStatus = {
+    in_best_chain: boolean;
+    height: number;
+    next_best: string;
+};
+export type TransactionProof = {
+    block_height: number;
+    merkle: string[];
+    pos: number;
+};
+export type TransactionOutspend = {
+    spent: boolean;
+    txid: string;
+    vin: number;
+    status: BitcoinTransactionStatus;
+};
+/**
+ * Mempool.space REST API client for Bitcoin blockchain data
+ * @category Bitcoin
+ */
+export declare class MempoolApi {
+    backends: {
+        url: string;
+        operational: boolean | null;
+    }[];
+    timeout: number;
+    /**
+     * Returns api url that should be operational
+     *
+     * @private
+     */
+    private getOperationalApi;
+    /**
+     * Returns api urls that are maybe operational, in case none is considered operational returns all of the price
+     *  apis such that they can be tested again whether they are operational
+     *
+     * @private
+     */
+    private getMaybeOperationalApis;
+    /**
+     * Sends a GET or POST request to the mempool api, handling the non-200 responses as errors & throwing
+     *
+     * @param url
+     * @param path
+     * @param responseType
+     * @param type
+     * @param body
+     */
+    private _request;
+    /**
+     * Sends request in parallel to multiple maybe operational api urls
+     *
+     * @param path
+     * @param responseType
+     * @param type
+     * @param body
+     * @private
+     */
+    private requestFromMaybeOperationalUrls;
+    /**
+     * Sends a request to mempool API, first tries to use the operational API (if any) and if that fails it falls back
+     *  to using maybe operational price APIs
+     *
+     * @param path
+     * @param responseType
+     * @param type
+     * @param body
+     * @private
+     */
+    private request;
+    constructor(url?: string | string[], timeout?: number);
+    /**
+     * Returns information about a specific lightning network node as identified by the public key (in hex encoding)
+     *
+     * @param pubkey
+     */
+    getLNNodeInfo(pubkey: string): Promise<LNNodeInfo | null>;
+    /**
+     * Returns on-chain transaction as identified by its txId
+     *
+     * @param txId
+     */
+    getTransaction(txId: string): Promise<BitcoinTransaction | null>;
+    /**
+     * Returns raw binary encoded bitcoin transaction, also strips the witness data from the transaction
+     *
+     * @param txId
+     */
+    getRawTransaction(txId: string): Promise<Buffer | null>;
+    /**
+     * Returns confirmed & unconfirmed balance of the specific bitcoin address
+     *
+     * @param address
+     */
+    getAddressBalances(address: string): Promise<{
+        confirmedBalance: bigint;
+        unconfirmedBalance: bigint;
+    }>;
+    /**
+     * Returns CPFP (children pays for parent) data for a given transaction
+     *
+     * @param txId
+     */
+    getCPFPData(txId: string): Promise<TransactionCPFPData>;
+    /**
+     * Returns UTXOs (unspent transaction outputs) for a given address
+     *
+     * @param address
+     */
+    getAddressUTXOs(address: string): Promise<{
+        txid: string;
+        vout: number;
+        status: {
+            confirmed: boolean;
+            block_height: number;
+            block_hash: string;
+            block_time: number;
+        };
+        value: bigint;
+    }[]>;
+    /**
+     * Returns current on-chain bitcoin fees
+     */
+    getFees(): Promise<BitcoinFees>;
+    /**
+     * Returns all transactions for a given address
+     *
+     * @param address
+     */
+    getAddressTransactions(address: string): Promise<BitcoinTransaction[]>;
+    /**
+     * Returns expected pending (mempool) blocks
+     */
+    getPendingBlocks(): Promise<BitcoinPendingBlock[]>;
+    /**
+     * Returns the blockheight of the current bitcoin blockchain's tip
+     */
+    getTipBlockHeight(): Promise<number>;
+    /**
+     * Returns the bitcoin blockheader as identified by its blockhash
+     *
+     * @param blockhash
+     */
+    getBlockHeader(blockhash: string): Promise<BitcoinBlockHeader>;
+    /**
+     * Returns the block status
+     *
+     * @param blockhash
+     */
+    getBlockStatus(blockhash: string): Promise<BlockStatus>;
+    /**
+     * Returns the transaction's proof (merkle proof)
+     *
+     * @param txId
+     */
+    getTransactionProof(txId: string): Promise<TransactionProof>;
+    /**
+     * Returns the transaction's proof (merkle proof)
+     *
+     * @param txId
+     */
+    getOutspends(txId: string): Promise<TransactionOutspend[]>;
+    /**
+     * Returns blockhash of a block at a specific blockheight
+     *
+     * @param height
+     */
+    getBlockHash(height: number): Promise<string>;
+    /**
+     * Returns past 15 blockheaders before (and including) the specified height
+     *
+     * @param endHeight
+     */
+    getPast15BlockHeaders(endHeight: number): Promise<BlockData[]>;
+    /**
+     * Sends raw hex encoded bitcoin transaction
+     *
+     * @param transactionHex
+     */
+    sendTransaction(transactionHex: string): Promise<string>;
+}