@bsv/wallet-toolbox 2.12.0 → 2.13.2

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

@@ -4,9 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WhatsOnChain = exports.WhatsOnChainNoServices = void 0;
+exports.validateWocChainInfo = validateWocChainInfo;
 exports.convertWocToBlockHeaderHex = convertWocToBlockHeaderHex;
 exports.getWhatsOnChainBlockHeaderByHash = getWhatsOnChainBlockHeaderByHash;
 const sdk_1 = require("@bsv/sdk");
+const utils_1 = require("@bsv/sdk/primitives/utils");
 const tscProofToMerklePath_1 = require("../../utility/tscProofToMerklePath");
 const SdkWhatsOnChain_1 = __importDefault(require("./SdkWhatsOnChain"));
 const WERR_errors_1 = require("../../sdk/WERR_errors");
@@ -15,17 +17,106 @@ const utilityHelpers_1 = require("../../utility/utilityHelpers");
 const utilityHelpers_noBuffer_1 = require("../../utility/utilityHelpers.noBuffer");
 const Services_1 = require("../Services");
 const whatsOnChainHelpers_1 = require("./whatsOnChainHelpers");
+const blockHeaderUtilities_1 = require("../chaintracker/chaintracks/util/blockHeaderUtilities");
+const validateMerklePathResult_1 = require("../validateMerklePathResult");
+const validateStatusForTxidsResult_1 = require("../validateStatusForTxidsResult");
+const validateRawTxResult_1 = require("../validateRawTxResult");
+const validateUtxoStatusResult_1 = require("../validateUtxoStatusResult");
+const validateScriptHashHistoryResult_1 = require("../validateScriptHashHistoryResult");
+const validatePostBeefResult_1 = require("../validatePostBeefResult");
+const HEX_32_BYTES = /^[0-9a-fA-F]{64}$/;
+const UINT32_MAX = 0xffffffff;
+const MAX_BLOCK_HEIGHT = 0x7fffffff;
+function requirePlainDataRecord(value, name) {
+    if (value == null || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`${name} must be a plain data object.`);
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        throw new Error(`${name} must be a plain data object.`);
+    }
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    if (Object.getOwnPropertySymbols(value).length !== 0 ||
+        Object.keys(descriptors).length > 64 ||
+        Object.values(descriptors).some(d => d.get != null || d.set != null)) {
+        throw new Error(`${name} must contain only bounded data properties.`);
+    }
+}
+function requireDenseWocArray(value, name) {
+    if (!Array.isArray(value) || value.length > validateUtxoStatusResult_1.MAX_UTXO_STATUS_DETAILS) {
+        throw new Error(`${name} must be a bounded dense array.`);
+    }
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    if (Object.getOwnPropertySymbols(value).length !== 0 ||
+        Object.values(descriptors).some(descriptor => descriptor.get != null || descriptor.set != null)) {
+        throw new Error(`${name} must be a bounded dense array.`);
+    }
+    const expectedKeys = new Set(['length', ...Array.from({ length: value.length }, (_, index) => String(index))]);
+    if (Object.keys(descriptors).some(key => !expectedKeys.has(key)) ||
+        Object.keys(descriptors).length !== expectedKeys.size) {
+        throw new Error(`${name} must be a bounded dense array.`);
+    }
+    return value;
+}
+function requireInteger(value, name, maximum) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > maximum) {
+        throw new Error(`${name} must be an integer between 0 and ${maximum}.`);
+    }
+    return value;
+}
+function requireFiniteNumber(value, name, maximum = Number.MAX_VALUE) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0 || value > maximum) {
+        throw new Error(`${name} must be a finite non-negative number.`);
+    }
+    return value;
+}
+function requireHex32(value, name) {
+    if (typeof value !== 'string' || !HEX_32_BYTES.test(value))
+        throw new Error(`${name} must be 32 hex bytes.`);
+    return value.toLowerCase();
+}
+function requireHeaderBits(value) {
+    if (typeof value === 'string') {
+        if (!/^[0-9a-fA-F]{1,8}$/.test(value))
+            throw new Error('WhatsOnChain header bits are invalid.');
+        return Number.parseInt(value, 16);
+    }
+    return requireInteger(value, 'WhatsOnChain header bits', UINT32_MAX);
+}
+function validateWocChainInfo(value, expectedChain) {
+    requirePlainDataRecord(value, 'WhatsOnChain chain info');
+    if (value.chain !== expectedChain) {
+        throw new Error(`WhatsOnChain returned chain ${String(value.chain)} for configured chain ${expectedChain}.`);
+    }
+    if (typeof value.pruned !== 'boolean')
+        throw new Error('WhatsOnChain chain info pruned must be boolean.');
+    return {
+        chain: value.chain,
+        blocks: requireInteger(value.blocks, 'WhatsOnChain chain info blocks', MAX_BLOCK_HEIGHT),
+        headers: requireInteger(value.headers, 'WhatsOnChain chain info headers', MAX_BLOCK_HEIGHT),
+        bestblockhash: requireHex32(value.bestblockhash, 'WhatsOnChain chain info bestblockhash'),
+        difficulty: requireFiniteNumber(value.difficulty, 'WhatsOnChain chain info difficulty'),
+        mediantime: requireInteger(value.mediantime, 'WhatsOnChain chain info mediantime', UINT32_MAX),
+        verificationprogress: requireFiniteNumber(value.verificationprogress, 'WhatsOnChain chain info verificationprogress', 2),
+        pruned: value.pruned,
+        chainwork: requireHex32(value.chainwork, 'WhatsOnChain chain info chainwork')
+    };
+}
 class WhatsOnChainNoServices extends SdkWhatsOnChain_1.default {
     requestGate;
     constructor(chain = 'main', config = {}) {
         if (chain === 'mock')
             throw new Error("WhatsOnChain does not support 'mock' chain. Use MockServices directly.");
         super(chain, config);
-        this.requestGate = config.requestGate;
+        const requestGate = Object.getOwnPropertyDescriptor(config, 'requestGate')?.value;
+        if (requestGate !== undefined && typeof requestGate !== 'function') {
+            throw new Error('WhatsOnChain request gate must be a function or absent.');
+        }
+        this.requestGate = requestGate;
     }
     async requestWithAnonymousAuthFallback(url, requestOptions) {
         await this.requestGate?.();
-        const response = await this.httpClient.request(url, requestOptions);
+        const response = await this.request(url, requestOptions);
         if ((response.status !== 401 && response.status !== 403) || this.apiKey.trim() === '') {
             return response;
         }
@@ -35,7 +126,7 @@ class WhatsOnChainNoServices extends SdkWhatsOnChain_1.default {
             await this.requestGate();
         else
             await (0, utilityHelpers_1.wait)(350);
-        return await this.httpClient.request(url, {
+        return await this.request(url, {
             method: 'GET',
             headers: { Accept: 'application/json' }
         });
@@ -62,6 +153,7 @@ class WhatsOnChainNoServices extends SdkWhatsOnChain_1.default {
      *     [{"txid":"6815f8014db74eab8b7f75925c68929597f1d97efa970109d990824c25e5e62c","error":"unknown"}]
      */
     async getStatusForTxids(txids) {
+        const normalizedTxids = txids.map((txid, index) => (0, validateMerklePathResult_1.normalizeTxid)(txid, `txids[${index}]`));
         const r = {
             name: 'WoC',
             status: 'error',
@@ -71,21 +163,20 @@ class WhatsOnChainNoServices extends SdkWhatsOnChain_1.default {
         const requestOptions = {
             method: 'POST',
             headers: this.getHttpHeaders(),
-            data: { txids }
+            data: { txids: normalizedTxids }
         };
         const url = `${this.URL}/txs/status`;
         try {
-            const response = await this.httpClient.request(url, requestOptions);
+            const response = await this.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) {
+            for (const txid of normalizedTxids) {
                 const d = data.find(d => d.txid === txid);
                 if (d == null || 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)
@@ -94,10 +185,13 @@ class WhatsOnChainNoServices extends SdkWhatsOnChain_1.default {
                     r.results.push({ txid, status: 'mined', depth: d.confirmations });
             }
             r.status = 'success';
+            return (0, validateStatusForTxidsResult_1.validateStatusForTxidsResult)(r, normalizedTxids, r.name);
         }
         catch (error_) {
             const e = WalletError_1.WalletError.fromUnknown(error_);
+            r.status = 'error';
             r.error = e;
+            r.results = [];
         }
         return r;
     }
@@ -111,7 +205,7 @@ class WhatsOnChainNoServices extends SdkWhatsOnChain_1.default {
             method: 'GET',
             headers: this.getHttpHeaders()
         };
-        const response = await this.httpClient.request(`${this.URL}/tx/hash/${txid}/propagation`, requestOptions);
+        const response = await this.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}`);
@@ -124,15 +218,16 @@ class WhatsOnChainNoServices extends SdkWhatsOnChain_1.default {
      * @returns raw transaction as hex string or undefined if txid not found in mined block.
      */
     async getRawTx(txid) {
+        const normalizedTxid = (0, validateMerklePathResult_1.normalizeTxid)(txid);
         const headers = this.getHttpHeaders();
         headers['Cache-Control'] = 'no-cache';
         const requestOptions = {
             method: 'GET',
             headers
         };
-        const url = `${this.URL}/tx/${txid}/hex`;
+        const url = `${this.URL}/tx/${normalizedTxid}/hex`;
         for (let retry = 0; retry < 2; retry++) {
-            const response = await this.httpClient.request(url, requestOptions);
+            const response = await this.request(url, requestOptions);
             if (response.statusText === 'Too Many Requests' && retry < 2) {
                 await (0, utilityHelpers_1.wait)(2000);
                 continue;
@@ -143,21 +238,28 @@ class WhatsOnChainNoServices extends SdkWhatsOnChain_1.default {
             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;
+            if (response.data.length === 0 ||
+                response.data.length > validateRawTxResult_1.MAX_RAW_TRANSACTION_BYTES * 2 ||
+                response.data.length % 2 !== 0 ||
+                !/^[0-9a-fA-F]+$/.test(response.data)) {
+                throw new WERR_errors_1.WERR_INVALID_OPERATION('WhatsOnChain returned malformed or excessive raw transaction data.');
+            }
+            return response.data.toLowerCase();
         }
         throw new WERR_errors_1.WERR_INTERNAL();
     }
     async getRawTxResult(txid) {
-        const r = { name: 'WoC', txid: (0, utilityHelpers_noBuffer_1.asString)(txid) };
+        const normalizedTxid = (0, validateMerklePathResult_1.normalizeTxid)(txid);
+        const r = { name: 'WoC', txid: normalizedTxid };
         try {
-            const rawTxHex = await this.getRawTx(txid);
+            const rawTxHex = await this.getRawTx(normalizedTxid);
             if (rawTxHex)
                 r.rawTx = (0, utilityHelpers_noBuffer_1.asArray)(rawTxHex);
         }
         catch (err) {
             r.error = WalletError_1.WalletError.fromUnknown(err);
         }
-        return r;
+        return (0, validateRawTxResult_1.validateRawTxResult)(r, normalizedTxid, 'WoC');
     }
     /**
      * WhatsOnChain does not natively support a postBeef end-point aware of multiple txids of interest in the Beef.
@@ -169,6 +271,9 @@ class WhatsOnChainNoServices extends SdkWhatsOnChain_1.default {
      * @returns
      */
     async postBeef(beef, txids) {
+        const request = (0, validatePostBeefResult_1.snapshotPostBeefRequest)(beef, txids);
+        beef = sdk_1.Beef.fromBinaryStrict(request.beefBytes);
+        txids = request.txids;
         const r = {
             name: 'WoC',
             status: 'success',
@@ -179,7 +284,7 @@ class WhatsOnChainNoServices extends SdkWhatsOnChain_1.default {
         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);
+            const rawTx = (0, utils_1.toHex)(beef.findTxid(txid).rawTx);
             if (delay) {
                 // For multiple txids, give WoC time to propagate each one.
                 await (0, utilityHelpers_1.wait)(3000);
@@ -199,14 +304,15 @@ class WhatsOnChainNoServices extends SdkWhatsOnChain_1.default {
         else {
             r.notes.push({ ...nne(), what: 'postBeefError' });
         }
-        return r;
+        return (0, validatePostBeefResult_1.validatePostBeefResultOrServiceError)(r, txids, 'WoC');
     }
     /**
      * @param rawTx raw transaction to broadcast as hex string
      * @returns txid returned by transaction processor of transaction broadcast
      */
     async postRawTx(rawTx) {
-        const txid = sdk_1.Utils.toHex((0, utilityHelpers_1.doubleSha256BE)(sdk_1.Utils.toArray(rawTx, 'hex')));
+        rawTx = (0, validatePostBeefResult_1.normalizePostRawHex)(rawTx, validateRawTxResult_1.MAX_RAW_TRANSACTION_BYTES);
+        const txid = (0, utils_1.toHex)((0, utilityHelpers_1.doubleSha256BE)((0, utils_1.toArray)(rawTx, 'hex')));
         const r = {
             txid,
             status: 'success',
@@ -226,7 +332,7 @@ class WhatsOnChainNoServices extends SdkWhatsOnChain_1.default {
         const retryLimit = 5;
         for (let retry = 0; retry < retryLimit; retry++) {
             try {
-                const response = await this.httpClient.request(url, requestOptions);
+                const response = await this.request(url, requestOptions);
                 if (response.statusText === 'Too Many Requests' && retry < 2) {
                     r.notes.push({ ...nn(), what: 'postRawTxRateLimit' });
                     await (0, utilityHelpers_1.wait)(2000);
@@ -254,7 +360,7 @@ class WhatsOnChainNoServices extends SdkWhatsOnChain_1.default {
                 r.serviceError = true;
                 r.data = `${e.code} ${e.description}`;
             }
-            return r;
+            return (0, validatePostBeefResult_1.validatePostTxResultOrServiceError)(r, txid, 'WoC');
         }
         r.status = 'error';
         r.serviceError = true;
@@ -263,7 +369,7 @@ class WhatsOnChainNoServices extends SdkWhatsOnChain_1.default {
             what: 'postRawTxRetryLimit',
             retryLimit
         });
-        return r;
+        return (0, validatePostBeefResult_1.validatePostTxResultOrServiceError)(r, txid, 'WoC');
     }
     async updateBsvExchangeRate(rate, updateMsecs) {
         if (rate != null) {
@@ -277,7 +383,7 @@ class WhatsOnChainNoServices extends SdkWhatsOnChain_1.default {
             headers: this.getHttpHeaders()
         };
         for (let retry = 0; retry < 2; retry++) {
-            const response = await this.httpClient.request(`${this.URL}/exchangerate`, requestOptions);
+            const response = await this.request(`${this.URL}/exchangerate`, requestOptions);
             if (response.statusText === 'Too Many Requests' && retry < 2) {
                 await (0, utilityHelpers_1.wait)(2000);
                 continue;
@@ -305,7 +411,7 @@ class WhatsOnChainNoServices extends SdkWhatsOnChain_1.default {
         const requestOptions = { method: 'GET', headers: this.getHttpHeaders() };
         for (let retry = 0; retry <= 2; retry++) {
             try {
-                const response = await this.httpClient.request(url, requestOptions);
+                const response = await this.request(url, requestOptions);
                 if (response.statusText === 'Too Many Requests' && retry < 2) {
                     await (0, utilityHelpers_1.wait)(2000);
                     continue;
@@ -326,14 +432,27 @@ class WhatsOnChainNoServices extends SdkWhatsOnChain_1.default {
             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');
+        requirePlainDataRecord(data, 'WhatsOnChain UTXO status');
+        if (data.script !== scriptHash)
+            throw new WERR_errors_1.WERR_INTERNAL('WhatsOnChain UTXO status script hash mismatch');
+        const details = requireDenseWocArray(data.result, 'WhatsOnChain UTXO status result').map((candidate, index) => {
+            requirePlainDataRecord(candidate, `WhatsOnChain UTXO status result[${index}]`);
+            return {
+                txid: requireHex32(candidate.tx_hash, `WhatsOnChain UTXO status result[${index}].tx_hash`),
+                satoshis: requireInteger(candidate.value, `WhatsOnChain UTXO status result[${index}].value`, Number.MAX_SAFE_INTEGER),
+                height: requireInteger(candidate.height, `WhatsOnChain UTXO status result[${index}].height`, MAX_BLOCK_HEIGHT),
+                index: requireInteger(candidate.tx_pos, `WhatsOnChain UTXO status result[${index}].tx_pos`, UINT32_MAX)
+            };
+        });
+        const normalizedOutpoint = (0, validateUtxoStatusResult_1.normalizeWalletOutpoint)(outpoint);
         r.status = 'success';
         r.error = undefined;
-        if (data.result.length === 0)
-            r.isUtxo = false;
-        else
-            (0, whatsOnChainHelpers_1.populateUtxoDetails)(r, data.result, outpoint);
+        r.details = details;
+        r.isUtxo =
+            normalizedOutpoint == null
+                ? details.length > 0
+                : details.some(detail => `${detail.txid}.${detail.index}` === normalizedOutpoint);
+        Object.assign(r, (0, validateUtxoStatusResult_1.validateUtxoStatusResult)(r, normalizedOutpoint, 'WoC'));
     }
     async getScriptHashConfirmedHistory(hash) {
         const r = {
@@ -342,32 +461,37 @@ class WhatsOnChainNoServices extends SdkWhatsOnChain_1.default {
             error: undefined,
             history: []
         };
-        // reverse hash from LE to BE for Woc
-        hash = sdk_1.Utils.toHex(sdk_1.Utils.toArray(hash, 'hex').reverse());
+        // Convert the exact little-endian wallet hash to the big-endian WoC route.
+        hash = (0, Services_1.validateScriptHash)(hash, 'hashLE');
         const url = `${this.URL}/script/${hash}/confirmed/history`;
         const methodName = 'getScriptHashConfirmedHistory';
         for (let retry = 0; retry <= 2; retry++) {
             try {
                 const requestOptions = { method: 'GET', headers: this.getHttpHeaders() };
-                const response = await this.httpClient.request(url, requestOptions);
+                const response = await this.request(url, requestOptions);
+                requirePlainDataRecord(response, 'WhatsOnChain script-history response');
+                if (response.data != null)
+                    requirePlainDataRecord(response.data, 'WhatsOnChain script-history data');
                 const action = (0, whatsOnChainHelpers_1.handleScriptHashHistoryResponse)(r, response, methodName, retry);
                 if (action === 'continue') {
                     await (0, utilityHelpers_1.wait)(2000);
                     continue;
                 }
                 if (action === 'return')
-                    return r;
-                r.history = response.data.result.map((d) => ({
-                    txid: d.tx_hash,
-                    height: d.height
-                }));
+                    return (0, validateScriptHashHistoryResult_1.validateScriptHashHistoryResult)(r, 'WoC');
+                r.history = requireDenseWocArray(response.data.result, 'WhatsOnChain confirmed script history').map((candidate, index) => {
+                    requirePlainDataRecord(candidate, `WhatsOnChain confirmed script history[${index}]`);
+                    const txid = requireHex32(candidate.tx_hash, `WhatsOnChain confirmed script history[${index}].tx_hash`);
+                    const height = requireInteger(candidate.height, `WhatsOnChain confirmed script history[${index}].height`, MAX_BLOCK_HEIGHT);
+                    return { txid, height };
+                });
                 r.status = 'success';
-                return r;
+                return (0, validateScriptHashHistoryResult_1.validateScriptHashHistoryResult)(r, 'WoC');
             }
             catch (error_) {
                 const shouldRetry = (0, whatsOnChainHelpers_1.handleScriptHashHistoryCatch)(r, error_, url, methodName, retry, 2);
                 if (!shouldRetry)
-                    return r;
+                    return (0, validateScriptHashHistoryResult_1.validateScriptHashHistoryResult)(r, 'WoC');
             }
         }
         return r;
@@ -379,33 +503,40 @@ class WhatsOnChainNoServices extends SdkWhatsOnChain_1.default {
             error: undefined,
             history: []
         };
-        // reverse hash from LE to BE for Woc
-        hash = sdk_1.Utils.toHex(sdk_1.Utils.toArray(hash, 'hex').reverse());
+        // Convert the exact little-endian wallet hash to the big-endian WoC route.
+        hash = (0, Services_1.validateScriptHash)(hash, 'hashLE');
         const url = `${this.URL}/script/${hash}/unconfirmed/history`;
         const methodName = 'getScriptHashUnconfirmedHistory';
         for (let retry = 0;; retry++) {
             try {
                 const requestOptions = { method: 'GET', headers: this.getHttpHeaders() };
-                const response = await this.httpClient.request(url, requestOptions);
+                const response = await this.request(url, requestOptions);
+                requirePlainDataRecord(response, 'WhatsOnChain script-history response');
+                if (response.data != null)
+                    requirePlainDataRecord(response.data, 'WhatsOnChain script-history data');
                 const action = (0, whatsOnChainHelpers_1.handleScriptHashHistoryResponse)(r, response, methodName, retry);
                 if (action === 'continue') {
                     await (0, utilityHelpers_1.wait)(2000);
                     continue;
                 }
                 if (action === 'return')
-                    return r;
-                r.history = response.data.result.map((d) => ({
-                    txid: d.tx_hash,
-                    height: d.height
-                }));
+                    return (0, validateScriptHashHistoryResult_1.validateScriptHashHistoryResult)(r, 'WoC');
+                r.history = requireDenseWocArray(response.data.result, 'WhatsOnChain unconfirmed script history').map((candidate, index) => {
+                    requirePlainDataRecord(candidate, `WhatsOnChain unconfirmed script history[${index}]`);
+                    const txid = requireHex32(candidate.tx_hash, `WhatsOnChain unconfirmed script history[${index}].tx_hash`);
+                    if (candidate.height !== undefined) {
+                        requireInteger(candidate.height, `WhatsOnChain unconfirmed script history[${index}].height`, MAX_BLOCK_HEIGHT);
+                    }
+                    return candidate.height === undefined ? { txid } : { txid, height: candidate.height };
+                });
                 r.status = 'success';
-                return r;
+                return (0, validateScriptHashHistoryResult_1.validateScriptHashHistoryResult)(r, 'WoC');
             }
             catch (error_) {
                 // Note: original used retry > 2 (not >= 2) for the unconfirmed variant
                 const shouldRetry = (0, whatsOnChainHelpers_1.handleScriptHashHistoryCatch)(r, error_, url, methodName, retry, 3);
                 if (!shouldRetry)
-                    return r;
+                    return (0, validateScriptHashHistoryResult_1.validateScriptHashHistoryResult)(r, 'WoC');
             }
         }
     }
@@ -416,8 +547,7 @@ class WhatsOnChainNoServices extends SdkWhatsOnChain_1.default {
         const r2 = await this.getScriptHashUnconfirmedHistory(hash);
         if (r2.error || r2.status !== 'success')
             return r2;
-        r1.history = r1.history.concat(r2.history);
-        return r1;
+        return (0, validateScriptHashHistoryResult_1.validateScriptHashHistoryResult)({ name: 'WoC', status: 'success', history: r1.history.concat(r2.history) }, 'WoC');
     }
     /**
       {
@@ -441,12 +571,13 @@ class WhatsOnChainNoServices extends SdkWhatsOnChain_1.default {
       }
      */
     async getBlockHeaderByHash(hash) {
+        const requestedHash = requireHex32(hash, 'hash');
         const headers = this.getHttpHeaders();
         const requestOptions = {
             method: 'GET',
             headers
         };
-        const url = `${this.URL}/block/${hash}/header`;
+        const url = `${this.URL}/block/${requestedHash}/header`;
         for (let retry = 0; retry < 2; retry++) {
             const response = await this.requestWithAnonymousAuthFallback(url, requestOptions);
             if (response.statusText === 'Too Many Requests' && retry < 2) {
@@ -460,6 +591,9 @@ class WhatsOnChainNoServices extends SdkWhatsOnChain_1.default {
                 throw new WERR_errors_1.WERR_INVALID_PARAMETER('hash', `valid block hash. '${hash}' response ${response.statusText}`);
             }
             const header = convertWocToBlockHeaderHex(response.data);
+            if (header.hash !== requestedHash) {
+                throw new WERR_errors_1.WERR_INVALID_PARAMETER('hash', `matching block hash. Expected '${requestedHash}', got '${header.hash}'.`);
+            }
             return header;
         }
         throw new WERR_errors_1.WERR_INTERNAL();
@@ -481,7 +615,8 @@ class WhatsOnChainNoServices extends SdkWhatsOnChain_1.default {
             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;
+            const expectedChain = this.network === 'ttn' ? 'test' : this.network;
+            return validateWocChainInfo(response.data, expectedChain);
         }
         throw new WERR_errors_1.WERR_INTERNAL();
     }
@@ -507,7 +642,7 @@ class WhatsOnChain extends WhatsOnChainNoServices {
         const url = `${this.URL}/tx/${txid}/proof/tsc`;
         for (let retry = 0; retry < 2; retry++) {
             try {
-                const response = await this.httpClient.request(url, requestOptions);
+                const response = await this.request(url, requestOptions);
                 const classification = (0, whatsOnChainHelpers_1.classifyMerklePathResponse)(response.status, response.statusText, retry);
                 if (classification === 'retry') {
                     r.notes.push((0, whatsOnChainHelpers_1.makeMerklePathNote)('getMerklePathRetry', name, { status: response.status, statusText: response.statusText }));
@@ -548,10 +683,19 @@ class WhatsOnChain extends WhatsOnChainNoServices {
         if (response.data.length !== 1)
             return;
         const p = response.data[0];
-        const header = await services.hashToHeader(p.target);
+        const target = (0, validateMerklePathResult_1.normalizeTxid)(p.target, 'TSC proof target');
+        const header = await services.hashToHeader(target);
         if (header) {
-            r.merklePath = (0, tscProofToMerklePath_1.convertProofToMerklePath)(txid, { index: p.index, nodes: p.nodes, height: header.height });
-            r.header = header;
+            if ((0, validateMerklePathResult_1.normalizeTxid)(header.hash, 'TSC proof header hash') !== target) {
+                throw new WERR_errors_1.WERR_INVALID_PARAMETER('blockhash', 'the requested canonical block header');
+            }
+            const candidate = {
+                merklePath: (0, tscProofToMerklePath_1.convertProofToMerklePath)(txid, { index: p.index, nodes: p.nodes, height: header.height }),
+                header
+            };
+            const validated = (0, validateMerklePathResult_1.validateMerklePathResult)(txid, candidate);
+            r.merklePath = validated.merklePath;
+            r.header = validated.header;
             r.notes.push((0, whatsOnChainHelpers_1.makeMerklePathNote)('getMerklePathSuccess', name, { status: response.status, statusText: response.statusText }));
         }
         else {
@@ -566,20 +710,28 @@ class WhatsOnChain extends WhatsOnChainNoServices {
 }
 exports.WhatsOnChain = WhatsOnChain;
 function convertWocToBlockHeaderHex(woc) {
-    const bits = typeof woc.bits === 'string' ? Number.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
+    requirePlainDataRecord(woc, 'WhatsOnChain header');
+    const height = requireInteger(woc.height, 'WhatsOnChain header height', MAX_BLOCK_HEIGHT);
+    const previousHash = woc.previousblockhash == null || woc.previousblockhash === ''
+        ? height === 0
+            ? '0'.repeat(64)
+            : (() => {
+                throw new Error('WhatsOnChain header previousblockhash is missing for a non-genesis header.');
+            })()
+        : requireHex32(woc.previousblockhash, 'WhatsOnChain header previousblockhash');
+    const header = {
+        version: requireInteger(woc.version, 'WhatsOnChain header version', UINT32_MAX),
+        previousHash,
+        merkleRoot: requireHex32(woc.merkleroot, 'WhatsOnChain header merkleroot'),
+        time: requireInteger(woc.time, 'WhatsOnChain header time', UINT32_MAX),
+        bits: requireHeaderBits(woc.bits),
+        nonce: requireInteger(woc.nonce, 'WhatsOnChain header nonce', UINT32_MAX),
+        hash: requireHex32(woc.hash, 'WhatsOnChain header hash'),
+        height
     };
+    (0, blockHeaderUtilities_1.validateHeaderFormat)(header);
+    (0, blockHeaderUtilities_1.validateHeaderProofOfWork)(header);
+    return header;
 }
 async function getWhatsOnChainBlockHeaderByHash(hash, chain = 'main', apiKey) {
     const config = apiKey ? { apiKey } : {};