@bsv/wallet-toolbox-client 1.7.15 → 1.7.17

package/out/src/services/providers/WhatsOnChain.js

@@ -0,0 +1,679 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WhatsOnChain = exports.WhatsOnChainNoServices = void 0;
+exports.convertWocToBlockHeaderHex = convertWocToBlockHeaderHex;
+exports.getWhatsOnChainBlockHeaderByHash = getWhatsOnChainBlockHeaderByHash;
+const sdk_1 = require("@bsv/sdk");
+const tscProofToMerklePath_1 = require("../../utility/tscProofToMerklePath");
+const SdkWhatsOnChain_1 = __importDefault(require("./SdkWhatsOnChain"));
+const WERR_errors_1 = require("../../sdk/WERR_errors");
+const WalletError_1 = require("../../sdk/WalletError");
+const utilityHelpers_1 = require("../../utility/utilityHelpers");
+const utilityHelpers_noBuffer_1 = require("../../utility/utilityHelpers.noBuffer");
+const Services_1 = require("../Services");
+class WhatsOnChainNoServices extends SdkWhatsOnChain_1.default {
+    constructor(chain = 'main', config = {}) {
+        super(chain, config);
+    }
+    /**
+     * POST
+     * https://api.whatsonchain.com/v1/bsv/main/txs/status
+     * Content-Type: application/json
+     * data: "{\"txids\":[\"6815f8014db74eab8b7f75925c68929597f1d97efa970109d990824c25e5e62b\"]}"
+     *
+     * result for a mined txid:
+     *     [{
+     *        "txid":"294cd1ebd5689fdee03509f92c32184c0f52f037d4046af250229b97e0c8f1aa",
+     *        "blockhash":"000000000000000004b5ce6670f2ff27354a1e87d0a01bf61f3307f4ccd358b5",
+     *        "blockheight":612251,
+     *        "blocktime":1575841517,
+     *        "confirmations":278272
+     *      }]
+     *
+     * result for a valid recent txid:
+     *     [{"txid":"6815f8014db74eab8b7f75925c68929597f1d97efa970109d990824c25e5e62b"}]
+     *
+     * result for an unknown txid:
+     *     [{"txid":"6815f8014db74eab8b7f75925c68929597f1d97efa970109d990824c25e5e62c","error":"unknown"}]
+     */
+    async getStatusForTxids(txids) {
+        const r = {
+            name: 'WoC',
+            status: 'error',
+            error: undefined,
+            results: []
+        };
+        const requestOptions = {
+            method: 'POST',
+            headers: this.getHttpHeaders(),
+            data: { txids }
+        };
+        const url = `${this.URL}/txs/status`;
+        try {
+            const response = await this.httpClient.request(url, requestOptions);
+            if (!response.data || !response.ok || response.status !== 200)
+                throw new WERR_errors_1.WERR_INVALID_OPERATION(`Unable to get status for txids at this timei.`);
+            const data = response.data;
+            for (const txid of txids) {
+                const d = data.find(d => d.txid === txid);
+                if (!d || d.error === 'unknown')
+                    r.results.push({ txid, status: 'unknown', depth: undefined });
+                else if (d.error !== undefined) {
+                    console.log(`WhatsOnChain getStatusForTxids unexpected error ${d.error} ${txid}`);
+                    r.results.push({ txid, status: 'unknown', depth: undefined });
+                }
+                else if (d.confirmations === undefined)
+                    r.results.push({ txid, status: 'known', depth: 0 });
+                else
+                    r.results.push({ txid, status: 'mined', depth: d.confirmations });
+            }
+            r.status = 'success';
+        }
+        catch (eu) {
+            const e = WalletError_1.WalletError.fromUnknown(eu);
+            r.error = e;
+        }
+        return r;
+    }
+    /**
+     * 2025-02-16 throwing internal server error 500.
+     * @param txid
+     * @returns
+     */
+    async getTxPropagation(txid) {
+        const requestOptions = {
+            method: 'GET',
+            headers: this.getHttpHeaders()
+        };
+        const response = await this.httpClient.request(`${this.URL}/tx/hash/${txid}/propagation`, requestOptions);
+        // response.statusText is often, but not always 'OK' on success...
+        if (!response.data || !response.ok || response.status !== 200)
+            throw new WERR_errors_1.WERR_INVALID_PARAMETER('txid', `valid transaction. '${txid}' response ${response.statusText}`);
+        return 0;
+    }
+    /**
+     * May return undefined for unmined transactions that are in the mempool.
+     * @param txid
+     * @returns raw transaction as hex string or undefined if txid not found in mined block.
+     */
+    async getRawTx(txid) {
+        const headers = this.getHttpHeaders();
+        headers['Cache-Control'] = 'no-cache';
+        const requestOptions = {
+            method: 'GET',
+            headers
+        };
+        const url = `${this.URL}/tx/${txid}/hex`;
+        for (let retry = 0; retry < 2; retry++) {
+            const response = await this.httpClient.request(url, requestOptions);
+            if (response.statusText === 'Too Many Requests' && retry < 2) {
+                await (0, utilityHelpers_1.wait)(2000);
+                continue;
+            }
+            if (response.status === 404 && response.statusText === 'Not Found')
+                return undefined;
+            // response.statusText is often, but not always 'OK' on success...
+            if (!response.data || !response.ok || response.status !== 200)
+                throw new WERR_errors_1.WERR_INVALID_PARAMETER('txid', `valid transaction. '${txid}' response ${response.statusText}`);
+            return response.data;
+        }
+        throw new WERR_errors_1.WERR_INTERNAL();
+    }
+    async getRawTxResult(txid) {
+        const r = { name: 'WoC', txid: (0, utilityHelpers_noBuffer_1.asString)(txid) };
+        try {
+            const rawTxHex = await this.getRawTx(txid);
+            if (rawTxHex)
+                r.rawTx = (0, utilityHelpers_noBuffer_1.asArray)(rawTxHex);
+        }
+        catch (err) {
+            r.error = WalletError_1.WalletError.fromUnknown(err);
+        }
+        return r;
+    }
+    /**
+     * WhatsOnChain does not natively support a postBeef end-point aware of multiple txids of interest in the Beef.
+     *
+     * Send rawTx in `txids` order from beef.
+     *
+     * @param beef
+     * @param txids
+     * @returns
+     */
+    async postBeef(beef, txids) {
+        const r = {
+            name: 'WoC',
+            status: 'success',
+            txidResults: [],
+            notes: []
+        };
+        let delay = false;
+        const nn = () => ({ name: 'WoCpostBeef', when: new Date().toISOString() });
+        const nne = () => ({ ...nn(), beef: beef.toHex(), txids: txids.join(',') });
+        for (const txid of txids) {
+            const rawTx = sdk_1.Utils.toHex(beef.findTxid(txid).rawTx);
+            if (delay) {
+                // For multiple txids, give WoC time to propagate each one.
+                await (0, utilityHelpers_1.wait)(3000);
+            }
+            delay = true;
+            const tr = await this.postRawTx(rawTx);
+            if (txid !== tr.txid) {
+                tr.notes.push({ ...nne(), what: 'postRawTxTxidChanged', txid, trTxid: tr.txid });
+            }
+            r.txidResults.push(tr);
+            if (r.status === 'success' && tr.status !== 'success')
+                r.status = 'error';
+        }
+        if (r.status === 'success') {
+            r.notes.push({ ...nn(), what: 'postBeefSuccess' });
+        }
+        else {
+            r.notes.push({ ...nne(), what: 'postBeefError' });
+        }
+        return r;
+    }
+    /**
+     * @param rawTx raw transaction to broadcast as hex string
+     * @returns txid returned by transaction processor of transaction broadcast
+     */
+    async postRawTx(rawTx) {
+        let txid = sdk_1.Utils.toHex((0, utilityHelpers_1.doubleSha256BE)(sdk_1.Utils.toArray(rawTx, 'hex')));
+        const r = {
+            txid,
+            status: 'success',
+            notes: []
+        };
+        const headers = this.getHttpHeaders();
+        headers['Content-Type'] = 'application/json';
+        headers['Accept'] = 'text/plain';
+        const requestOptions = {
+            method: 'POST',
+            headers,
+            data: { txhex: rawTx }
+        };
+        const url = `${this.URL}/tx/raw`;
+        const nn = () => ({ name: 'WoCpostRawTx', when: new Date().toISOString() });
+        const nne = () => ({ ...nn(), rawTx, txid, url });
+        const retryLimit = 5;
+        for (let retry = 0; retry < retryLimit; retry++) {
+            try {
+                const response = await this.httpClient.request(url, requestOptions);
+                if (response.statusText === 'Too Many Requests' && retry < 2) {
+                    r.notes.push({ ...nn(), what: 'postRawTxRateLimit' });
+                    await (0, utilityHelpers_1.wait)(2000);
+                    continue;
+                }
+                if (response.ok) {
+                    const txid = response.data;
+                    r.notes.push({ ...nn(), what: 'postRawTxSuccess' });
+                }
+                else if (response.data === 'unexpected response code 500: Transaction already in the mempool') {
+                    r.notes.push({ ...nne(), what: 'postRawTxSuccessAlreadyInMempool' });
+                }
+                else {
+                    r.status = 'error';
+                    if (response.data === 'unexpected response code 500: 258: txn-mempool-conflict') {
+                        r.doubleSpend = true; // this is a possible double spend attempt
+                        r.competingTxs = undefined; // not provided with any data for this.
+                        r.notes.push({ ...nne(), what: 'postRawTxErrorMempoolConflict' });
+                    }
+                    else if (response.data === 'unexpected response code 500: Missing inputs') {
+                        r.doubleSpend = true; // this is a possible double spend attempt
+                        r.competingTxs = undefined; // not provided with any data for this.
+                        r.notes.push({ ...nne(), what: 'postRawTxErrorMissingInputs' });
+                    }
+                    else {
+                        const n = {
+                            ...nne(),
+                            what: 'postRawTxError'
+                        };
+                        if (typeof response.data === 'string') {
+                            n.data = response.data.slice(0, 128);
+                            r.data = response.data;
+                        }
+                        else {
+                            r.data = '';
+                        }
+                        if (typeof response.statusText === 'string') {
+                            n.statusText = response.statusText.slice(0, 128);
+                            r.data += `,${response.statusText}`;
+                        }
+                        if (typeof response.status === 'string') {
+                            n.status = response.status.slice(0, 128);
+                            r.data += `,${response.status}`;
+                        }
+                        if (typeof response.status === 'number') {
+                            n.status = response.status;
+                            r.data += `,${response.status}`;
+                        }
+                        r.notes.push(n);
+                    }
+                }
+            }
+            catch (eu) {
+                r.status = 'error';
+                const e = WalletError_1.WalletError.fromUnknown(eu);
+                r.notes.push({
+                    ...nne(),
+                    what: 'postRawTxCatch',
+                    code: e.code,
+                    description: e.description
+                });
+                r.serviceError = true;
+                r.data = `${e.code} ${e.description}`;
+            }
+            return r;
+        }
+        r.status = 'error';
+        r.serviceError = true;
+        r.notes.push({
+            ...nne(),
+            what: 'postRawTxRetryLimit',
+            retryLimit
+        });
+        return r;
+    }
+    async updateBsvExchangeRate(rate, updateMsecs) {
+        if (rate) {
+            // Check if the rate we know is stale enough to update.
+            updateMsecs || (updateMsecs = 1000 * 60 * 15);
+            if (new Date(Date.now() - updateMsecs) < rate.timestamp)
+                return rate;
+        }
+        const requestOptions = {
+            method: 'GET',
+            headers: this.getHttpHeaders()
+        };
+        for (let retry = 0; retry < 2; retry++) {
+            const response = await this.httpClient.request(`${this.URL}/exchangerate`, requestOptions);
+            if (response.statusText === 'Too Many Requests' && retry < 2) {
+                await (0, utilityHelpers_1.wait)(2000);
+                continue;
+            }
+            // response.statusText is often, but not always 'OK' on success...
+            if (!response.data || !response.ok || response.status !== 200)
+                throw new WERR_errors_1.WERR_INVALID_OPERATION(`WoC exchangerate response ${response.statusText}`);
+            const wocrate = response.data;
+            if (wocrate.currency !== 'USD')
+                wocrate.rate = NaN;
+            const newRate = {
+                timestamp: new Date(),
+                base: 'USD',
+                rate: wocrate.rate
+            };
+            return newRate;
+        }
+        throw new WERR_errors_1.WERR_INTERNAL();
+    }
+    async getUtxoStatus(output, outputFormat, outpoint) {
+        const r = {
+            name: 'WoC',
+            status: 'error',
+            error: new WERR_errors_1.WERR_INTERNAL(),
+            details: []
+        };
+        for (let retry = 0;; retry++) {
+            let url = '';
+            try {
+                const scriptHash = (0, Services_1.validateScriptHash)(output, outputFormat);
+                const requestOptions = {
+                    method: 'GET',
+                    headers: this.getHttpHeaders()
+                };
+                const response = await this.httpClient.request(`${this.URL}/script/${scriptHash}/unspent/all`, requestOptions);
+                if (response.statusText === 'Too Many Requests' && retry < 2) {
+                    await (0, utilityHelpers_1.wait)(2000);
+                    continue;
+                }
+                // response.statusText is often, but not always 'OK' on success...
+                if (!response.data || !response.ok || response.status !== 200)
+                    throw new WERR_errors_1.WERR_INVALID_OPERATION(`WoC getUtxoStatus response ${response.statusText}`);
+                const data = response.data;
+                if (data.script !== scriptHash || !Array.isArray(data.result)) {
+                    throw new WERR_errors_1.WERR_INTERNAL('data. is not an array');
+                }
+                if (data.result.length === 0) {
+                    r.status = 'success';
+                    r.error = undefined;
+                    r.isUtxo = false;
+                }
+                else {
+                    r.status = 'success';
+                    r.error = undefined;
+                    for (const s of data.result) {
+                        r.details.push({
+                            txid: s.tx_hash,
+                            satoshis: s.value,
+                            height: s.height,
+                            index: s.tx_pos
+                        });
+                    }
+                    if (outpoint) {
+                        const { txid, vout } = sdk_1.Validation.parseWalletOutpoint(outpoint);
+                        r.isUtxo = r.details.find(d => d.txid === txid && d.index === vout) !== undefined;
+                    }
+                    else
+                        r.isUtxo = r.details.length > 0;
+                }
+                return r;
+            }
+            catch (eu) {
+                const e = WalletError_1.WalletError.fromUnknown(eu);
+                if (e.code !== 'ECONNRESET' || retry > 2) {
+                    r.error = new WERR_errors_1.WERR_INTERNAL(`service failure: ${url}, error: ${JSON.stringify(WalletError_1.WalletError.fromUnknown(eu))}`);
+                    return r;
+                }
+            }
+        }
+    }
+    async getScriptHashConfirmedHistory(hash) {
+        const r = {
+            name: 'WoC',
+            status: 'error',
+            error: undefined,
+            history: []
+        };
+        // reverse hash from LE to BE for Woc
+        hash = sdk_1.Utils.toHex(sdk_1.Utils.toArray(hash, 'hex').reverse());
+        const url = `${this.URL}/script/${hash}/confirmed/history`;
+        for (let retry = 0;; retry++) {
+            try {
+                const requestOptions = {
+                    method: 'GET',
+                    headers: this.getHttpHeaders()
+                };
+                const response = await this.httpClient.request(url, requestOptions);
+                if (response.statusText === 'Too Many Requests' && retry < 2) {
+                    await (0, utilityHelpers_1.wait)(2000);
+                    continue;
+                }
+                if (!response.ok && response.status === 404) {
+                    // There is no history for this script hash...
+                    r.status = 'success';
+                    return r;
+                }
+                // response.statusText is often, but not always 'OK' on success...
+                if (!response.data || !response.ok || response.status !== 200) {
+                    r.error = new WERR_errors_1.WERR_BAD_REQUEST(`WoC getScriptHashConfirmedHistory response ${response.ok} ${response.status} ${response.statusText}`);
+                    return r;
+                }
+                if (response.data.error) {
+                    r.error = new WERR_errors_1.WERR_BAD_REQUEST(`WoC getScriptHashConfirmedHistory error ${response.data.error}`);
+                    return r;
+                }
+                r.history = response.data.result.map(d => ({ txid: d.tx_hash, height: d.height }));
+                r.status = 'success';
+                return r;
+            }
+            catch (eu) {
+                const e = WalletError_1.WalletError.fromUnknown(eu);
+                if (e.code !== 'ECONNRESET' || retry > 2) {
+                    r.error = new WERR_errors_1.WERR_INTERNAL(`WoC getScriptHashConfirmedHistory service failure: ${url}, error: ${JSON.stringify(WalletError_1.WalletError.fromUnknown(eu))}`);
+                    return r;
+                }
+            }
+        }
+        return r;
+    }
+    async getScriptHashUnconfirmedHistory(hash) {
+        const r = {
+            name: 'WoC',
+            status: 'error',
+            error: undefined,
+            history: []
+        };
+        // reverse hash from LE to BE for Woc
+        hash = sdk_1.Utils.toHex(sdk_1.Utils.toArray(hash, 'hex').reverse());
+        const url = `${this.URL}/script/${hash}/unconfirmed/history`;
+        for (let retry = 0;; retry++) {
+            try {
+                const requestOptions = {
+                    method: 'GET',
+                    headers: this.getHttpHeaders()
+                };
+                const response = await this.httpClient.request(url, requestOptions);
+                if (response.statusText === 'Too Many Requests' && retry < 2) {
+                    await (0, utilityHelpers_1.wait)(2000);
+                    continue;
+                }
+                if (!response.ok && response.status === 404) {
+                    // There is no history for this script hash...
+                    r.status = 'success';
+                    return r;
+                }
+                // response.statusText is often, but not always 'OK' on success...
+                if (!response.data || !response.ok || response.status !== 200) {
+                    r.error = new WERR_errors_1.WERR_BAD_REQUEST(`WoC getScriptHashUnconfirmedHistory response ${response.ok} ${response.status} ${response.statusText}`);
+                    return r;
+                }
+                if (response.data.error) {
+                    r.error = new WERR_errors_1.WERR_BAD_REQUEST(`WoC getScriptHashUnconfirmedHistory error ${response.data.error}`);
+                    return r;
+                }
+                r.history = response.data.result.map(d => ({ txid: d.tx_hash, height: d.height }));
+                r.status = 'success';
+                return r;
+            }
+            catch (eu) {
+                const e = WalletError_1.WalletError.fromUnknown(eu);
+                if (e.code !== 'ECONNRESET' || retry > 2) {
+                    r.error = new WERR_errors_1.WERR_INTERNAL(`WoC getScriptHashUnconfirmedHistory service failure: ${url}, error: ${JSON.stringify(WalletError_1.WalletError.fromUnknown(eu))}`);
+                    return r;
+                }
+            }
+        }
+        return r;
+    }
+    async getScriptHashHistory(hash) {
+        const r1 = await this.getScriptHashConfirmedHistory(hash);
+        if (r1.error || r1.status !== 'success')
+            return r1;
+        const r2 = await this.getScriptHashUnconfirmedHistory(hash);
+        if (r2.error || r2.status !== 'success')
+            return r2;
+        r1.history = r1.history.concat(r2.history);
+        return r1;
+    }
+    /**
+      {
+        "hash": "000000000000000004a288072ebb35e37233f419918f9783d499979cb6ac33eb",
+        "confirmations": 328433,
+        "size": 14421,
+        "height": 575045,
+        "version": 536928256,
+        "versionHex": "2000e000",
+        "merkleroot": "4ebcba09addd720991d03473f39dce4b9a72cc164e505cd446687a54df9b1585",
+        "time": 1553416668,
+        "mediantime": 1553414858,
+        "nonce": 87914848,
+        "bits": "180997ee",
+        "difficulty": 114608607557.4425,
+        "chainwork": "000000000000000000000000000000000000000000ddf5d385546872bab7dc01",
+        "previousblockhash": "00000000000000000988156c7075dc9147a5b62922f1310862e8b9000d46dd9b",
+        "nextblockhash": "00000000000000000112b36a37c10235fa0c991f680bc5482ba9692e0ae697db",
+        "nTx": 0,
+        "num_tx": 5
+      }
+     */
+    async getBlockHeaderByHash(hash) {
+        const headers = this.getHttpHeaders();
+        const requestOptions = {
+            method: 'GET',
+            headers
+        };
+        const url = `${this.URL}/block/${hash}/header`;
+        for (let retry = 0; retry < 2; retry++) {
+            const response = await this.httpClient.request(url, requestOptions);
+            if (response.statusText === 'Too Many Requests' && retry < 2) {
+                await (0, utilityHelpers_1.wait)(2000);
+                continue;
+            }
+            if (response.status === 404 && response.statusText === 'Not Found')
+                return undefined;
+            // response.statusText is often, but not always 'OK' on success...
+            if (!response.data || !response.ok || response.status !== 200)
+                throw new WERR_errors_1.WERR_INVALID_PARAMETER('hash', `valid block hash. '${hash}' response ${response.statusText}`);
+            const header = convertWocToBlockHeaderHex(response.data);
+            return header;
+        }
+        throw new WERR_errors_1.WERR_INTERNAL();
+    }
+    async getChainInfo() {
+        const headers = this.getHttpHeaders();
+        const requestOptions = {
+            method: 'GET',
+            headers
+        };
+        const url = `${this.URL}/chain/info`;
+        for (let retry = 0; retry < 2; retry++) {
+            const response = await this.httpClient.request(url, requestOptions);
+            if (response.statusText === 'Too Many Requests' && retry < 2) {
+                await (0, utilityHelpers_1.wait)(2000);
+                continue;
+            }
+            // response.statusText is often, but not always 'OK' on success...
+            if (!response.data || !response.ok || response.status !== 200)
+                throw new WERR_errors_1.WERR_INVALID_PARAMETER('hash', `valid block hash. '${url}' response ${response.statusText}`);
+            return response.data;
+        }
+        throw new WERR_errors_1.WERR_INTERNAL();
+    }
+}
+exports.WhatsOnChainNoServices = WhatsOnChainNoServices;
+/**
+ *
+ */
+class WhatsOnChain extends WhatsOnChainNoServices {
+    constructor(chain = 'main', config = {}, services) {
+        super(chain, config);
+        this.services = services || new Services_1.Services(chain);
+    }
+    /**
+     * @param txid
+     * @returns
+     */
+    async getMerklePath(txid, services) {
+        const r = { name: 'WoCTsc', notes: [] };
+        const headers = this.getHttpHeaders();
+        const requestOptions = {
+            method: 'GET',
+            headers
+        };
+        for (let retry = 0; retry < 2; retry++) {
+            try {
+                const response = await this.httpClient.request(`${this.URL}/tx/${txid}/proof/tsc`, requestOptions);
+                if (response.statusText === 'Too Many Requests' && retry < 2) {
+                    r.notes.push({
+                        what: 'getMerklePathRetry',
+                        name: r.name,
+                        status: response.status,
+                        statusText: response.statusText
+                    });
+                    await (0, utilityHelpers_1.wait)(2000);
+                    continue;
+                }
+                if (response.status === 404 && response.statusText === 'Not Found') {
+                    r.notes.push({
+                        what: 'getMerklePathNotFound',
+                        name: r.name,
+                        status: response.status,
+                        statusText: response.statusText
+                    });
+                    return r;
+                }
+                // response.statusText is often, but not always 'OK' on success...
+                if (!response.ok || response.status !== 200) {
+                    r.notes.push({
+                        what: 'getMerklePathBadStatus',
+                        name: r.name,
+                        status: response.status,
+                        statusText: response.statusText
+                    });
+                    throw new WERR_errors_1.WERR_INVALID_PARAMETER('txid', `valid transaction. '${txid}' response ${response.statusText}`);
+                }
+                if (!response.data) {
+                    // Unmined, proof not yet available.
+                    r.notes.push({
+                        what: 'getMerklePathNoData',
+                        name: r.name,
+                        status: response.status,
+                        statusText: response.statusText
+                    });
+                    return r;
+                }
+                if (!Array.isArray(response.data))
+                    response.data = [response.data];
+                if (response.data.length != 1)
+                    return r;
+                const p = response.data[0];
+                const header = await services.hashToHeader(p.target);
+                if (header) {
+                    const proof = {
+                        index: p.index,
+                        nodes: p.nodes,
+                        height: header.height
+                    };
+                    r.merklePath = (0, tscProofToMerklePath_1.convertProofToMerklePath)(txid, proof);
+                    r.header = header;
+                    r.notes.push({
+                        what: 'getMerklePathSuccess',
+                        name: r.name,
+                        status: response.status,
+                        statusText: response.statusText
+                    });
+                }
+                else {
+                    r.notes.push({
+                        what: 'getMerklePathNoHeader',
+                        target: p.target,
+                        name: r.name,
+                        status: response.status,
+                        statusText: response.statusText
+                    });
+                    throw new WERR_errors_1.WERR_INVALID_PARAMETER('blockhash', 'a valid on-chain block hash');
+                }
+            }
+            catch (eu) {
+                const e = WalletError_1.WalletError.fromUnknown(eu);
+                r.notes.push({
+                    what: 'getMerklePathError',
+                    name: r.name,
+                    code: e.code,
+                    description: e.description
+                });
+                r.error = e;
+            }
+            return r;
+        }
+        r.notes.push({ what: 'getMerklePathInternal', name: r.name });
+        throw new WERR_errors_1.WERR_INTERNAL();
+    }
+}
+exports.WhatsOnChain = WhatsOnChain;
+function convertWocToBlockHeaderHex(woc) {
+    const bits = typeof woc.bits === 'string' ? parseInt(woc.bits, 16) : woc.bits;
+    if (!woc.previousblockhash) {
+        woc.previousblockhash = '0000000000000000000000000000000000000000000000000000000000000000'; // genesis
+    }
+    return {
+        version: woc.version,
+        previousHash: woc.previousblockhash,
+        merkleRoot: woc.merkleroot,
+        time: woc.time,
+        bits,
+        nonce: woc.nonce,
+        hash: woc.hash,
+        height: woc.height
+    };
+}
+async function getWhatsOnChainBlockHeaderByHash(hash, chain = 'main', apiKey) {
+    const config = apiKey ? { apiKey } : {};
+    const woc = new WhatsOnChain(chain, config);
+    const header = await woc.getBlockHeaderByHash(hash);
+    return header;
+}
+//# sourceMappingURL=WhatsOnChain.js.map