@atomiqlabs/sdk 7.0.12 → 8.0.8

package/dist/bitcoin/mempool/MempoolApi.js

@@ -0,0 +1,311 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MempoolApi = void 0;
+const buffer_1 = require("buffer");
+const Utils_1 = require("../../utils/Utils");
+const RequestError_1 = require("../../errors/RequestError");
+const HttpUtils_1 = require("../../http/HttpUtils");
+const RetryUtils_1 = require("../../utils/RetryUtils");
+/**
+ * Mempool.space REST API client for Bitcoin blockchain data
+ * @category Bitcoin
+ */
+class MempoolApi {
+    /**
+     * Returns api url that should be operational
+     *
+     * @private
+     */
+    getOperationalApi() {
+        return this.backends.find(e => e.operational === true);
+    }
+    /**
+     * 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
+     */
+    getMaybeOperationalApis() {
+        let operational = this.backends.filter(e => e.operational === true || e.operational === null);
+        if (operational.length === 0) {
+            this.backends.forEach(e => e.operational = null);
+            operational = this.backends;
+        }
+        return operational;
+    }
+    /**
+     * 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
+     */
+    async _request(url, path, responseType, type = "GET", body) {
+        const response = await (0, HttpUtils_1.fetchWithTimeout)(url + path, {
+            method: type,
+            timeout: this.timeout,
+            body: typeof (body) === "string" ? body : JSON.stringify(body)
+        });
+        if (response.status !== 200) {
+            let resp;
+            try {
+                resp = await response.text();
+            }
+            catch (e) {
+                throw new RequestError_1.RequestError(response.statusText, response.status);
+            }
+            throw RequestError_1.RequestError.parse(resp, response.status);
+        }
+        if (responseType === "str")
+            return await response.text();
+        return await response.json();
+    }
+    /**
+     * Sends request in parallel to multiple maybe operational api urls
+     *
+     * @param path
+     * @param responseType
+     * @param type
+     * @param body
+     * @private
+     */
+    async requestFromMaybeOperationalUrls(path, responseType, type = "GET", body) {
+        try {
+            return await (0, Utils_1.promiseAny)(this.getMaybeOperationalApis().map(obj => (async () => {
+                try {
+                    const result = await this._request(obj.url, path, responseType, type, body);
+                    obj.operational = true;
+                    return result;
+                }
+                catch (e) {
+                    //Only mark as non operational on 5xx server errors!
+                    if (e instanceof RequestError_1.RequestError && Math.floor(e.httpCode / 100) !== 5) {
+                        obj.operational = true;
+                        throw e;
+                    }
+                    else {
+                        obj.operational = false;
+                        throw e;
+                    }
+                }
+            })()));
+        }
+        catch (_e) {
+            const e = _e;
+            throw e.find(err => err instanceof RequestError_1.RequestError && Math.floor(err.httpCode / 100) !== 5) || e[0];
+        }
+    }
+    /**
+     * 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
+     */
+    async request(path, responseType, type = "GET", body) {
+        return (0, RetryUtils_1.tryWithRetries)(() => {
+            const operationalPriceApi = this.getOperationalApi();
+            if (operationalPriceApi != null) {
+                return this._request(operationalPriceApi.url, path, responseType, type, body).catch(err => {
+                    //Only retry on 5xx server errors!
+                    if (err instanceof RequestError_1.RequestError && Math.floor(err.httpCode / 100) !== 5)
+                        throw err;
+                    operationalPriceApi.operational = false;
+                    return this.requestFromMaybeOperationalUrls(path, responseType, type, body);
+                });
+            }
+            return this.requestFromMaybeOperationalUrls(path, responseType, type, body);
+        }, undefined, (err) => err instanceof RequestError_1.RequestError && Math.floor(err.httpCode / 100) !== 5);
+    }
+    constructor(url, timeout) {
+        url = url ?? "https://mempool.space/testnet/api/";
+        if (Array.isArray(url)) {
+            this.backends = url.map(val => {
+                return { url: val, operational: null };
+            });
+        }
+        else {
+            this.backends = [
+                { url: url, operational: null }
+            ];
+        }
+        this.timeout = timeout ?? 15 * 1000;
+    }
+    /**
+     * Returns information about a specific lightning network node as identified by the public key (in hex encoding)
+     *
+     * @param pubkey
+     */
+    getLNNodeInfo(pubkey) {
+        //500, 200
+        return this.request("v1/lightning/nodes/" + pubkey, "obj").catch((e) => {
+            if (e.message === "This node does not exist, or our node is not seeing it yet")
+                return null;
+            throw e;
+        });
+    }
+    /**
+     * Returns on-chain transaction as identified by its txId
+     *
+     * @param txId
+     */
+    getTransaction(txId) {
+        //404 ("Transaction not found"), 200
+        return this.request("tx/" + txId, "obj").catch((e) => {
+            if (e.message === "Transaction not found")
+                return null;
+            throw e;
+        });
+    }
+    /**
+     * Returns raw binary encoded bitcoin transaction, also strips the witness data from the transaction
+     *
+     * @param txId
+     */
+    async getRawTransaction(txId) {
+        //404 ("Transaction not found"), 200
+        const rawTransaction = await this.request("tx/" + txId + "/hex", "str").catch((e) => {
+            if (e.message === "Transaction not found")
+                return null;
+            throw e;
+        });
+        return rawTransaction == null ? null : buffer_1.Buffer.from(rawTransaction, "hex");
+    }
+    /**
+     * Returns confirmed & unconfirmed balance of the specific bitcoin address
+     *
+     * @param address
+     */
+    async getAddressBalances(address) {
+        //400 ("Invalid Bitcoin address"), 200
+        const jsonBody = await this.request("address/" + address, "obj");
+        const confirmedInput = BigInt(jsonBody.chain_stats.funded_txo_sum);
+        const confirmedOutput = BigInt(jsonBody.chain_stats.spent_txo_sum);
+        const unconfirmedInput = BigInt(jsonBody.mempool_stats.funded_txo_sum);
+        const unconfirmedOutput = BigInt(jsonBody.mempool_stats.spent_txo_sum);
+        return {
+            confirmedBalance: confirmedInput - confirmedOutput,
+            unconfirmedBalance: unconfirmedInput - unconfirmedOutput
+        };
+    }
+    /**
+     * Returns CPFP (children pays for parent) data for a given transaction
+     *
+     * @param txId
+     */
+    getCPFPData(txId) {
+        //200
+        return this.request("v1/cpfp/" + txId, "obj");
+    }
+    /**
+     * Returns UTXOs (unspent transaction outputs) for a given address
+     *
+     * @param address
+     */
+    async getAddressUTXOs(address) {
+        //400 ("Invalid Bitcoin address"), 200
+        let jsonBody = await this.request("address/" + address + "/utxo", "obj");
+        jsonBody.forEach(e => e.value = BigInt(e.value));
+        return jsonBody;
+    }
+    /**
+     * Returns current on-chain bitcoin fees
+     */
+    getFees() {
+        //200
+        return this.request("v1/fees/recommended", "obj");
+    }
+    /**
+     * Returns all transactions for a given address
+     *
+     * @param address
+     */
+    getAddressTransactions(address) {
+        //400 ("Invalid Bitcoin address"), 200
+        return this.request("address/" + address + "/txs", "obj");
+    }
+    /**
+     * Returns expected pending (mempool) blocks
+     */
+    getPendingBlocks() {
+        //200
+        return this.request("v1/fees/mempool-blocks", "obj");
+    }
+    /**
+     * Returns the blockheight of the current bitcoin blockchain's tip
+     */
+    async getTipBlockHeight() {
+        //200
+        const response = await this.request("blocks/tip/height", "str");
+        return parseInt(response);
+    }
+    /**
+     * Returns the bitcoin blockheader as identified by its blockhash
+     *
+     * @param blockhash
+     */
+    getBlockHeader(blockhash) {
+        //404 ("Block not found"), 200
+        return this.request("block/" + blockhash, "obj");
+    }
+    /**
+     * Returns the block status
+     *
+     * @param blockhash
+     */
+    getBlockStatus(blockhash) {
+        //200
+        return this.request("block/" + blockhash + "/status", "obj");
+    }
+    /**
+     * Returns the transaction's proof (merkle proof)
+     *
+     * @param txId
+     */
+    getTransactionProof(txId) {
+        //404 ("Transaction not found or is unconfirmed"), 200
+        return this.request("tx/" + txId + "/merkle-proof", "obj");
+    }
+    /**
+     * Returns the transaction's proof (merkle proof)
+     *
+     * @param txId
+     */
+    getOutspends(txId) {
+        //404 ("Transaction not found"), 200
+        return this.request("tx/" + txId + "/outspends", "obj");
+    }
+    /**
+     * Returns blockhash of a block at a specific blockheight
+     *
+     * @param height
+     */
+    getBlockHash(height) {
+        //404 ("Block not found"), 200
+        return this.request("block-height/" + height, "str");
+    }
+    /**
+     * Returns past 15 blockheaders before (and including) the specified height
+     *
+     * @param endHeight
+     */
+    getPast15BlockHeaders(endHeight) {
+        //200
+        return this.request("v1/blocks/" + endHeight, "obj");
+    }
+    /**
+     * Sends raw hex encoded bitcoin transaction
+     *
+     * @param transactionHex
+     */
+    sendTransaction(transactionHex) {
+        //400??, 200
+        return this.request("tx", "str", "POST", transactionHex);
+    }
+}
+exports.MempoolApi = MempoolApi;

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

@@ -0,0 +1,44 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { BtcBlock } from "@atomiqlabs/base";
+import { Buffer } from "buffer";
+export type MempoolBitcoinBlockType = {
+    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 declare class MempoolBitcoinBlock implements BtcBlock {
+    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;
+    constructor(obj: MempoolBitcoinBlockType);
+    getHeight(): number;
+    getHash(): string;
+    getMerkleRoot(): string;
+    getNbits(): number;
+    getNonce(): number;
+    getPrevBlockhash(): string;
+    getTimestamp(): number;
+    getVersion(): number;
+    getChainWork(): Buffer;
+}

package/dist/bitcoin/mempool/MempoolBitcoinBlock.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MempoolBitcoinBlock = void 0;
+class MempoolBitcoinBlock {
+    constructor(obj) {
+        this.id = obj.id;
+        this.height = obj.height;
+        this.version = obj.version;
+        this.timestamp = obj.timestamp;
+        this.tx_count = obj.tx_count;
+        this.size = obj.size;
+        this.weight = obj.weight;
+        this.merkle_root = obj.merkle_root;
+        this.previousblockhash = obj.previousblockhash;
+        this.mediantime = obj.mediantime;
+        this.nonce = obj.nonce;
+        this.bits = obj.bits;
+        this.difficulty = obj.difficulty;
+    }
+    getHeight() {
+        return this.height;
+    }
+    getHash() {
+        return this.id;
+    }
+    getMerkleRoot() {
+        return this.merkle_root;
+    }
+    getNbits() {
+        return this.bits;
+    }
+    getNonce() {
+        return this.nonce;
+    }
+    getPrevBlockhash() {
+        return this.previousblockhash;
+    }
+    getTimestamp() {
+        return this.timestamp;
+    }
+    getVersion() {
+        return this.version;
+    }
+    getChainWork() {
+        throw new Error("Unsupported");
+    }
+}
+exports.MempoolBitcoinBlock = MempoolBitcoinBlock;

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

@@ -0,0 +1,119 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { BtcBlockWithTxs, BtcSyncInfo, BtcTx } from "@atomiqlabs/base";
+import { MempoolBitcoinBlock } from "./MempoolBitcoinBlock";
+import { MempoolApi } from "./MempoolApi";
+import { Buffer } from "buffer";
+import { BitcoinRpcWithAddressIndex, BtcTxWithBlockheight } from "../BitcoinRpcWithAddressIndex";
+import { LightningNetworkApi, LNNodeLiquidity } from "../LightningNetworkApi";
+/**
+ * Bitcoin RPC implementation via Mempool.space API
+ * @category Bitcoin
+ */
+export declare class MempoolBitcoinRpc implements BitcoinRpcWithAddressIndex<MempoolBitcoinBlock>, LightningNetworkApi {
+    api: MempoolApi;
+    constructor(urlOrMempoolApi: MempoolApi | string | string[]);
+    /**
+     * Returns a txo hash for a specific transaction vout
+     *
+     * @param vout
+     * @private
+     */
+    private static getTxoHash;
+    /**
+     * Returns delay in milliseconds till an unconfirmed transaction is expected to confirm, returns -1
+     *  if the transaction won't confirm any time soon
+     *
+     * @param feeRate
+     * @private
+     */
+    private getTimeTillConfirmation;
+    /**
+     * Returns an estimate after which time the tx will confirm with the required amount of confirmations,
+     *  confirmationDelay of -1 means the transaction won't confirm in the near future
+     *
+     * @param tx
+     * @param requiredConfirmations
+     * @private
+     *
+     * @returns estimated confirmation delay, -1 if the transaction won't confirm in the near future, null if the
+     *  transaction was replaced or was confirmed in the meantime
+     */
+    getConfirmationDelay(tx: {
+        txid: string;
+        confirmations?: number;
+    }, requiredConfirmations: number): Promise<number | null>;
+    /**
+     * Converts mempool API's transaction to BtcTx object while fetching the raw tx separately
+     * @param tx Transaction to convert
+     * @private
+     */
+    private toBtcTx;
+    /**
+     * Converts mempool API's transaction to BtcTx object, doesn't populate raw and hex fields
+     * @param tx Transaction to convert
+     * @private
+     */
+    private toBtcTxWithoutRawData;
+    getTipHeight(): Promise<number>;
+    getBlockHeader(blockhash: string): Promise<MempoolBitcoinBlock>;
+    getMerkleProof(txId: string, blockhash: string): Promise<{
+        reversedTxId: Buffer;
+        pos: number;
+        merkle: Buffer[];
+        blockheight: number;
+    }>;
+    getTransaction(txId: string): Promise<BtcTxWithBlockheight | null>;
+    isInMainChain(blockhash: string): Promise<boolean>;
+    getBlockhash(height: number): Promise<string>;
+    getBlockWithTransactions(blockhash: string): Promise<BtcBlockWithTxs>;
+    getSyncInfo(): Promise<BtcSyncInfo>;
+    getPast15Blocks(height: number): Promise<MempoolBitcoinBlock[]>;
+    checkAddressTxos(address: string, txoHash: Buffer): Promise<{
+        tx: Omit<BtcTxWithBlockheight, "hex" | "raw">;
+        vout: number;
+    } | null>;
+    /**
+     * Waits till the address receives a transaction containing a specific txoHash
+     *
+     * @param address
+     * @param txoHash
+     * @param requiredConfirmations
+     * @param stateUpdateCbk
+     * @param abortSignal
+     * @param intervalSeconds
+     */
+    waitForAddressTxo(address: string, txoHash: Buffer, requiredConfirmations: number, stateUpdateCbk: (btcTx?: Omit<BtcTxWithBlockheight, "hex" | "raw">, vout?: number, txEtaMS?: number) => void, abortSignal?: AbortSignal, intervalSeconds?: number): Promise<{
+        tx: Omit<BtcTxWithBlockheight, "hex" | "raw">;
+        vout: number;
+    }>;
+    waitForTransaction(txId: string, requiredConfirmations: number, stateUpdateCbk: (btcTx?: BtcTxWithBlockheight, txEtaMS?: number) => void, abortSignal?: AbortSignal, intervalSeconds?: number): Promise<BtcTxWithBlockheight>;
+    getLNNodeLiquidity(pubkey: string): Promise<LNNodeLiquidity | null>;
+    sendRawTransaction(rawTx: string): Promise<string>;
+    sendRawPackage(rawTx: string[]): Promise<string[]>;
+    isSpent(utxo: string, confirmed?: boolean): Promise<boolean>;
+    parseTransaction(rawTx: string): Promise<BtcTx>;
+    getEffectiveFeeRate(btcTx: BtcTx): Promise<{
+        vsize: number;
+        fee: number;
+        feeRate: number;
+    }>;
+    getFeeRate(): Promise<number>;
+    getAddressBalances(address: string): Promise<{
+        confirmedBalance: bigint;
+        unconfirmedBalance: bigint;
+    }>;
+    getAddressUTXOs(address: string): Promise<{
+        txid: string;
+        vout: number;
+        confirmed: boolean;
+        block_height: number;
+        block_hash: string;
+        block_time: number;
+        value: bigint;
+    }[]>;
+    getCPFPData(txId: string): Promise<{
+        effectiveFeePerVsize: number;
+        adjustedVsize: number;
+    }>;
+}