@bopen-io/wallet-toolbox 2.1.21-parity-fix.2 → 2.6.2-brc153.2

package/out/src/services/Services.js

@@ -9,6 +9,7 @@ const createDefaultWalletServicesOptions_1 = require("./createDefaultWalletServi
 const WhatsOnChain_1 = require("./providers/WhatsOnChain");
 const exchangeRates_1 = require("./providers/exchangeRates");
 const ARC_1 = require("./providers/ARC");
+const Arcade_1 = require("./providers/Arcade");
 const Bitails_1 = require("./providers/Bitails");
 const getBeefForTxid_1 = require("./providers/getBeefForTxid");
 const WERR_errors_1 = require("../sdk/WERR_errors");
@@ -17,82 +18,136 @@ const WalletError_1 = require("../sdk/WalletError");
 const utilityHelpers_1 = require("../utility/utilityHelpers");
 const utilityHelpers_noBuffer_1 = require("../utility/utilityHelpers.noBuffer");
 class Services {
+    static getStatusForTxidsBatchLimit = 20;
     static createDefaultOptions(chain) {
         return (0, createDefaultWalletServicesOptions_1.createDefaultWalletServicesOptions)(chain);
     }
+    options;
+    whatsonchain;
+    arcTaal;
+    arcGorillaPool;
+    /** Primary Arcade (bsv-blockchain/arcade) broadcaster, when `options.arcadeUrl` is set. */
+    arcade;
+    bitails;
+    getMerklePathServices;
+    getRawTxServices;
+    postBeefServices;
+    getUtxoStatusServices;
+    getStatusForTxidsServices;
+    getScriptHashHistoryServices;
+    updateFiatExchangeRateServices;
+    chain;
+    telemetry;
     constructor(optionsOrChain) {
-        this.postBeefMode = 'UntilSuccess';
-        /**
-         * Soft timeout used for each provider call in `UntilSuccess` mode.
-         * This bounds request latency when a provider hangs before failover.
-         */
-        this.postBeefUntilSuccessSoftTimeoutMs = 5000;
-        /**
-         * Additional soft-timeout budget (ms) per KiB of serialized Beef payload.
-         * Helps avoid false timeout failover on legitimately large submissions.
-         */
-        this.postBeefUntilSuccessSoftTimeoutPerKbMs = 50;
-        /**
-         * Upper bound for adaptive soft-timeout in `UntilSuccess` mode.
-         */
-        this.postBeefUntilSuccessSoftTimeoutMaxMs = 30000;
         this.chain = typeof optionsOrChain === 'string' ? optionsOrChain : optionsOrChain.chain;
         if (this.chain === 'mock') {
-            throw new WERR_errors_1.WERR_INVALID_PARAMETER('chain', `'main', 'test', or 'teratest'. Use MockServices for 'mock' chain.`);
+            throw new WERR_errors_1.WERR_INVALID_PARAMETER('chain', "'main', 'test', 'stn', 'ttn', or 'tstn'. Use MockServices for 'mock' chain.");
         }
         this.options = typeof optionsOrChain === 'string' ? Services.createDefaultOptions(this.chain) : optionsOrChain;
+        this.telemetry = new sdk_1.Telemetry(this.options.telemetry);
         this.whatsonchain = new WhatsOnChain_1.WhatsOnChain(this.chain, { apiKey: this.options.whatsOnChainApiKey }, this);
         this.arcTaal = new ARC_1.ARC(this.options.arcUrl, this.options.arcConfig, 'arcTaal');
-        if (this.options.arcGorillaPoolUrl) {
+        const { hasBitails, hasWhatsOnChain } = this.configureOptionalProviders();
+        this.initializeReadServices(hasBitails, hasWhatsOnChain);
+        this.initializePostBeefServices(hasBitails, hasWhatsOnChain);
+        this.initializeFiatRateServices();
+    }
+    configureOptionalProviders() {
+        if (this.options.arcGorillaPoolUrl != null && this.options.arcGorillaPoolUrl !== '') {
             this.arcGorillaPool = new ARC_1.ARC(this.options.arcGorillaPoolUrl, this.options.arcGorillaPoolConfig, 'arcGorillaPool');
         }
+        if (this.options.arcadeUrl != null && this.options.arcadeUrl !== '') {
+            this.arcade = new Arcade_1.Arcade(this.options.arcadeUrl, this.options.arcadeConfig, 'arcade');
+        }
         const hasBitails = this.chain === 'main' || this.chain === 'test';
+        // The public WhatsOnChain API documents mainnet and testnet only.
+        // Teranode-family networks use Arcade/ChainTracks and explicit operator
+        // endpoints instead of being silently aliased to testnet.
+        const hasWhatsOnChain = this.chain === 'main' || this.chain === 'test';
         if (hasBitails) {
             this.bitails = new Bitails_1.Bitails(this.chain, { apiKey: this.options.bitailsApiKey });
         }
-        //prettier-ignore
-        this.getMerklePathServices = new ServiceCollection_1.ServiceCollection('getMerklePath')
-            .add({ name: 'WhatsOnChain', service: this.whatsonchain.getMerklePath.bind(this.whatsonchain) });
-        if (hasBitails && this.bitails) {
+        return { hasBitails, hasWhatsOnChain };
+    }
+    initializeReadServices(hasBitails, hasWhatsOnChain) {
+        this.getMerklePathServices = new ServiceCollection_1.ServiceCollection('getMerklePath');
+        // Arcade is first when configured: it can return proofs for transactions
+        // it broadcast and otherwise allows the collection to fall through.
+        if (this.arcade != null) {
+            // prettier-ignore
+            this.getMerklePathServices.add({ name: 'Arcade', service: this.arcade.getMerklePath.bind(this.arcade) });
+        }
+        if (hasWhatsOnChain) {
+            // prettier-ignore
+            this.getMerklePathServices
+                .add({ name: 'WhatsOnChain', service: this.whatsonchain.getMerklePath.bind(this.whatsonchain) });
+        }
+        if (hasBitails && this.bitails != null) {
             this.getMerklePathServices.add({ name: 'Bitails', service: this.bitails.getMerklePath.bind(this.bitails) });
         }
-        //prettier-ignore
-        this.getRawTxServices = new ServiceCollection_1.ServiceCollection('getRawTx')
-            .add({ name: 'WhatsOnChain', service: this.whatsonchain.getRawTxResult.bind(this.whatsonchain) });
+        this.getRawTxServices = new ServiceCollection_1.ServiceCollection('getRawTx');
+        if (hasWhatsOnChain) {
+            // prettier-ignore
+            this.getRawTxServices
+                .add({ name: 'WhatsOnChain', service: this.whatsonchain.getRawTxResult.bind(this.whatsonchain) });
+        }
+        this.getUtxoStatusServices = new ServiceCollection_1.ServiceCollection('getUtxoStatus');
+        if (hasWhatsOnChain) {
+            // prettier-ignore
+            this.getUtxoStatusServices
+                .add({ name: 'WhatsOnChain', service: this.whatsonchain.getUtxoStatus.bind(this.whatsonchain) });
+        }
+        this.getStatusForTxidsServices = new ServiceCollection_1.ServiceCollection('getStatusForTxids');
+        if (hasWhatsOnChain) {
+            // prettier-ignore
+            this.getStatusForTxidsServices
+                .add({ name: 'WhatsOnChain', service: this.whatsonchain.getStatusForTxids.bind(this.whatsonchain) });
+        }
+        this.getScriptHashHistoryServices = new ServiceCollection_1.ServiceCollection('getScriptHashHistory');
+        if (hasWhatsOnChain) {
+            // prettier-ignore
+            this.getScriptHashHistoryServices
+                .add({ name: 'WhatsOnChain', service: this.whatsonchain.getScriptHashHistory.bind(this.whatsonchain) });
+        }
+    }
+    initializePostBeefServices(hasBitails, hasWhatsOnChain) {
         this.postBeefServices = new ServiceCollection_1.ServiceCollection('postBeef');
-        if (this.arcGorillaPool) {
-            //prettier-ignore
+        // Arcade remains the primary broadcaster. ARC and explorer providers
+        // retain their existing fallback order under the default UntilSuccess mode.
+        if (this.arcade != null) {
+            // prettier-ignore
+            this.postBeefServices.add({ name: 'ArcadeBeef', service: this.arcade.postBeef.bind(this.arcade) });
+        }
+        if (this.arcGorillaPool != null) {
+            // prettier-ignore
             this.postBeefServices.add({ name: 'GorillaPoolArcBeef', service: this.arcGorillaPool.postBeef.bind(this.arcGorillaPool) });
         }
-        //prettier-ignore
+        // prettier-ignore
         this.postBeefServices
             .add({ name: 'TaalArcBeef', service: this.arcTaal.postBeef.bind(this.arcTaal) });
-        if (hasBitails && this.bitails) {
+        if (hasBitails && this.bitails != null) {
             this.postBeefServices.add({ name: 'Bitails', service: this.bitails.postBeef.bind(this.bitails) });
         }
-        //prettier-ignore
-        this.postBeefServices
-            .add({ name: 'WhatsOnChain', service: this.whatsonchain.postBeef.bind(this.whatsonchain) });
-        //prettier-ignore
-        this.getUtxoStatusServices = new ServiceCollection_1.ServiceCollection('getUtxoStatus')
-            .add({ name: 'WhatsOnChain', service: this.whatsonchain.getUtxoStatus.bind(this.whatsonchain) });
-        //prettier-ignore
-        this.getStatusForTxidsServices = new ServiceCollection_1.ServiceCollection('getStatusForTxids')
-            .add({ name: 'WhatsOnChain', service: this.whatsonchain.getStatusForTxids.bind(this.whatsonchain) });
-        //prettier-ignore
-        this.getScriptHashHistoryServices = new ServiceCollection_1.ServiceCollection('getScriptHashHistory')
-            .add({ name: 'WhatsOnChain', service: this.whatsonchain.getScriptHashHistory.bind(this.whatsonchain) });
-        //prettier-ignore
+        if (hasWhatsOnChain) {
+            // prettier-ignore
+            this.postBeefServices
+                .add({ name: 'WhatsOnChain', service: this.whatsonchain.postBeef.bind(this.whatsonchain) });
+        }
+    }
+    initializeFiatRateServices() {
+        // prettier-ignore
         this.updateFiatExchangeRateServices = new ServiceCollection_1.ServiceCollection('updateFiatExchangeRate');
-        if (this.options.exchangeratesapiKey)
-            // If the api key for paid service is set, only use that sesrvice.
+        // A configured paid exchange-rate service is exclusive; otherwise use
+        // Chaintracks as the zero-configuration default.
+        if (this.options.exchangeratesapiKey != null && this.options.exchangeratesapiKey !== '') {
             this.updateFiatExchangeRateServices.add({ name: 'exchangeratesapi', service: exchangeRates_1.updateExchangeratesapi });
-        else
-            // Otherwise use the chaintracks service
+        }
+        else {
             this.updateFiatExchangeRateServices.add({
                 name: 'ChaintracksFiatRates',
                 service: exchangeRates_1.updateChaintracksFiatExchangeRates
             });
+        }
     }
     getServicesCallHistory(reset) {
         return {
@@ -107,24 +162,26 @@ class Services {
         };
     }
     async getChainTracker() {
-        if (!this.options.chaintracks)
-            throw new WERR_errors_1.WERR_INVALID_PARAMETER('options.chaintracks', `valid to enable 'getChainTracker' service.`);
-        return new ChaintracksChainTracker_1.ChaintracksChainTracker(this.chain, this.options.chaintracks);
+        if (this.options.chaintracks == null) {
+            throw new WERR_errors_1.WERR_INVALID_PARAMETER('options.chaintracks', "valid to enable 'getChainTracker' service.");
+        }
+        return new ChaintracksChainTracker_1.ChaintracksChainTracker(this.chain, this.options.chaintracks, {
+            telemetry: this.options.telemetry
+        });
     }
     async getBsvExchangeRate() {
         this.options.bsvExchangeRate = await this.whatsonchain.updateBsvExchangeRate(this.options.bsvExchangeRate, this.options.bsvUpdateMsecs);
         return this.options.bsvExchangeRate.rate;
     }
     async getFiatExchangeRate(currency, base) {
-        var _a, _b;
-        base || (base = 'USD');
+        base ||= 'USD';
         if (currency === base)
             return 1;
         const required = base === 'USD' ? [currency] : [currency, base];
         await this.updateFiatExchangeRates(required, this.options.fiatUpdateMsecs);
         const rates = this.options.fiatExchangeRates;
-        const c = (_a = rates.rates) === null || _a === void 0 ? void 0 : _a[currency];
-        const b = (_b = rates.rates) === null || _b === void 0 ? void 0 : _b[base];
+        const c = rates.rates?.[currency];
+        const b = rates.rates?.[base];
         if (typeof c !== 'number') {
             throw new WERR_errors_1.WERR_INVALID_PARAMETER('currency', `valid fiat currency '${currency}' with an exchange rate.`);
         }
@@ -134,12 +191,11 @@ class Services {
         return c / b;
     }
     async getFiatExchangeRates(targetCurrencies) {
-        var _a;
         await this.updateFiatExchangeRates(targetCurrencies, this.options.fiatUpdateMsecs);
         const stored = this.options.fiatExchangeRates;
         const rates = {};
         for (const c of targetCurrencies) {
-            const v = (_a = stored.rates) === null || _a === void 0 ? void 0 : _a[c];
+            const v = stored.rates?.[c];
             if (typeof v === 'number') {
                 rates[c] = v;
             }
@@ -165,7 +221,7 @@ class Services {
     }
     async getStatusForTxids(txids, useNext) {
         const services = this.getStatusForTxidsServices;
-        if (useNext)
+        if (useNext === true)
             services.next();
         let r0 = {
             name: '<noservices>',
@@ -182,15 +238,13 @@ class Services {
                     r0 = r;
                     break;
                 }
-                else {
-                    if (r.error)
-                        services.addServiceCallError(stc, r.error);
-                    else
-                        services.addServiceCallFailure(stc);
-                }
+                if (r.error != null)
+                    services.addServiceCallError(stc, r.error);
+                else
+                    services.addServiceCallFailure(stc);
             }
-            catch (eu) {
-                const e = WalletError_1.WalletError.fromUnknown(eu);
+            catch (error_) {
+                const e = WalletError_1.WalletError.fromUnknown(error_);
                 services.addServiceCallError(stc, e);
             }
             services.next();
@@ -206,7 +260,7 @@ class Services {
             if (r.status !== 'success') {
                 return r;
             }
-            if (!error && r.error)
+            if (error == null && r.error != null)
                 error = r.error;
             results.push(...r.results);
         }
@@ -226,16 +280,16 @@ class Services {
         return hash;
     }
     async isUtxo(output) {
-        if (!output.lockingScript) {
+        if (output.lockingScript == null) {
             throw new WERR_errors_1.WERR_INVALID_PARAMETER('output.lockingScript', 'validated by storage provider validateOutputScript.');
         }
         const hash = this.hashOutputScript(sdk_1.Utils.toHex(output.lockingScript));
-        const or = await this.getUtxoStatus(hash, undefined, `${output.txid}.${output.vout}`);
+        const or = await this.getUtxoStatus(hash, undefined, `${output.txid ?? ''}.${output.vout}`);
         return or.isUtxo === true;
     }
     async getUtxoStatus(output, outputFormat, outpoint, useNext, logger) {
         const services = this.getUtxoStatusServices;
-        if (useNext)
+        if (useNext === true)
             services.next();
         let r0 = {
             name: '<noservices>',
@@ -243,41 +297,41 @@ class Services {
             error: new WERR_errors_1.WERR_INTERNAL('No services available.'),
             details: []
         };
-        logger === null || logger === void 0 ? void 0 : logger.group(`services getUtxoStatus`);
+        logger?.group('services getUtxoStatus');
         for (let retry = 0; retry < 2; retry++) {
-            for (let tries = 0; tries < services.count; tries++) {
-                const stc = services.serviceToCall;
-                try {
-                    const r = await stc.service(output, outputFormat, outpoint);
-                    logger === null || logger === void 0 ? void 0 : logger.log(`${stc.providerName} status ${r.status}`);
-                    if (r.status === 'success') {
-                        services.addServiceCallSuccess(stc);
-                        r0 = r;
-                        break;
-                    }
-                    else {
-                        if (r.error)
-                            services.addServiceCallError(stc, r.error);
-                        else
-                            services.addServiceCallFailure(stc);
-                    }
-                }
-                catch (eu) {
-                    const e = WalletError_1.WalletError.fromUnknown(eu);
-                    services.addServiceCallError(stc, e);
-                }
-                services.next();
-            }
+            r0 = (await this.tryUtxoStatusProviders(services, output, outputFormat, outpoint, logger)) ?? r0;
             if (r0.status === 'success')
                 break;
             await (0, utilityHelpers_1.wait)(2000);
         }
-        logger === null || logger === void 0 ? void 0 : logger.groupEnd();
+        logger?.groupEnd();
         return r0;
     }
+    async tryUtxoStatusProviders(services, output, outputFormat, outpoint, logger) {
+        for (let tries = 0; tries < services.count; tries++) {
+            const stc = services.serviceToCall;
+            try {
+                const r = await stc.service(output, outputFormat, outpoint);
+                logger?.log(`${stc.providerName} status ${r.status}`);
+                if (r.status === 'success') {
+                    services.addServiceCallSuccess(stc);
+                    return r;
+                }
+                if (r.error != null)
+                    services.addServiceCallError(stc, r.error);
+                else
+                    services.addServiceCallFailure(stc);
+            }
+            catch (error_) {
+                services.addServiceCallError(stc, WalletError_1.WalletError.fromUnknown(error_));
+            }
+            services.next();
+        }
+        return undefined;
+    }
     async getScriptHashHistory(hash, useNext, logger) {
         const services = this.getScriptHashHistoryServices;
-        if (useNext)
+        if (useNext === true)
             services.next();
         let r0 = {
             name: '<noservices>',
@@ -285,32 +339,45 @@ class Services {
             error: new WERR_errors_1.WERR_INTERNAL('No services available.'),
             history: []
         };
-        logger === null || logger === void 0 ? void 0 : logger.group(`services getScriptHashHistory`);
+        logger?.group('services getScriptHashHistory');
         for (let tries = 0; tries < services.count; tries++) {
             const stc = services.serviceToCall;
             try {
                 const r = await stc.service(hash);
-                logger === null || logger === void 0 ? void 0 : logger.log(`${stc.providerName} status ${r.status}`);
+                logger?.log(`${stc.providerName} status ${r.status}`);
                 if (r.status === 'success') {
                     r0 = r;
                     break;
                 }
-                else {
-                    if (r.error)
-                        services.addServiceCallError(stc, r.error);
-                    else
-                        services.addServiceCallFailure(stc);
-                }
+                if (r.error != null)
+                    services.addServiceCallError(stc, r.error);
+                else
+                    services.addServiceCallFailure(stc);
             }
-            catch (eu) {
-                const e = WalletError_1.WalletError.fromUnknown(eu);
+            catch (error_) {
+                const e = WalletError_1.WalletError.fromUnknown(error_);
                 services.addServiceCallError(stc, e);
             }
             services.next();
         }
-        logger === null || logger === void 0 ? void 0 : logger.groupEnd();
+        logger?.groupEnd();
         return r0;
     }
+    postBeefMode = 'UntilSuccess';
+    /**
+     * Soft timeout used for each provider call in `UntilSuccess` mode.
+     * This bounds request latency when a provider hangs before failover.
+     */
+    postBeefUntilSuccessSoftTimeoutMs = 5000;
+    /**
+     * Additional soft-timeout budget (ms) per KiB of serialized Beef payload.
+     * Helps avoid false timeout failover on legitimately large submissions.
+     */
+    postBeefUntilSuccessSoftTimeoutPerKbMs = 50;
+    /**
+     * Upper bound for adaptive soft-timeout in `UntilSuccess` mode.
+     */
+    postBeefUntilSuccessSoftTimeoutMaxMs = 30000;
     /**
      *
      * @param beef
@@ -318,44 +385,39 @@ class Services {
      * @returns
      */
     async postBeef(beef, txids, logger) {
-        var _a;
         let rs = [];
         const services = this.postBeefServices;
         const stcs = services.allServicesToCall;
         const softTimeoutMs = this.getPostBeefSoftTimeoutMs(beef);
-        logger === null || logger === void 0 ? void 0 : logger.group(`services postBeef`);
+        logger?.group('services postBeef');
         switch (this.postBeefMode) {
             case 'UntilSuccess':
-                {
-                    for (const stc of stcs) {
-                        const r = await callService(stc, softTimeoutMs);
-                        logger === null || logger === void 0 ? void 0 : logger.log(`${stc.providerName} status ${r.status}`);
-                        rs.push(r);
-                        if (r.status === 'success')
-                            break;
-                        const softTimedOut = ((_a = r.notes) === null || _a === void 0 ? void 0 : _a.some(n => n.what === 'postBeefServiceTimeout')) === true;
-                        if (!softTimedOut && r.txidResults && r.txidResults.every(txr => txr.serviceError)) {
-                            // move this service to the end of the list
-                            this.postBeefServices.moveServiceToLast(stc);
-                        }
+                for (const stc of stcs) {
+                    const r = await callService(stc, softTimeoutMs);
+                    logger?.log(`${stc.providerName} status ${r.status}`);
+                    rs.push(r);
+                    if (r.status === 'success')
+                        break;
+                    const softTimedOut = r.notes?.some(n => n.what === 'postBeefServiceTimeout') === true;
+                    if (!softTimedOut && r.txidResults?.every(txr => txr.serviceError)) {
+                        // move this service to the end of the list
+                        this.postBeefServices.moveServiceToLast(stc);
                     }
                 }
                 break;
             case 'PromiseAll':
-                {
-                    rs = await Promise.all(stcs.map(async (stc) => {
-                        const r = await callService(stc);
-                        return r;
-                    }));
-                }
+                rs = await Promise.all(stcs.map(async (stc) => {
+                    const r = await callService(stc);
+                    return r;
+                }));
                 break;
         }
-        logger === null || logger === void 0 ? void 0 : logger.groupEnd();
+        logger?.groupEnd();
         return rs;
         async function callService(stc, timeoutMs) {
             const callPromise = stc.service(beef, txids);
             let r;
-            if (!timeoutMs || timeoutMs <= 0) {
+            if (timeoutMs == null || timeoutMs <= 0) {
                 r = await callPromise;
             }
             else {
@@ -364,7 +426,7 @@ class Services {
                     timeoutHandle = setTimeout(() => resolve(makeServiceTimeoutResult(stc.providerName, txids, timeoutMs)), timeoutMs);
                 });
                 r = await Promise.race([callPromise, timeoutPromise]);
-                if (timeoutHandle)
+                if (timeoutHandle != null)
                     clearTimeout(timeoutHandle);
                 // Avoid unhandled rejection after timeout race wins.
                 void callPromise.catch(() => undefined);
@@ -372,13 +434,11 @@ class Services {
             if (r.status === 'success') {
                 services.addServiceCallSuccess(stc);
             }
+            else if (r.error != null) {
+                services.addServiceCallError(stc, r.error);
+            }
             else {
-                if (r.error) {
-                    services.addServiceCallError(stc, r.error);
-                }
-                else {
-                    services.addServiceCallFailure(stc);
-                }
+                services.addServiceCallFailure(stc);
             }
             return r;
         }
@@ -408,105 +468,131 @@ class Services {
     }
     async getRawTx(txid, useNext) {
         const services = this.getRawTxServices;
-        if (useNext)
+        if (useNext === true)
             services.next();
         const r0 = { txid };
         for (let tries = 0; tries < services.count; tries++) {
             const stc = services.serviceToCall;
             try {
-                const r = await stc.service(txid, this.chain);
-                if (r.rawTx) {
-                    const hash = (0, utilityHelpers_noBuffer_1.asString)((0, utilityHelpers_1.doubleSha256BE)(r.rawTx));
-                    // Confirm transaction hash matches txid
-                    if (hash === (0, utilityHelpers_noBuffer_1.asString)(txid)) {
-                        // If we have a match, call it done.
-                        r0.rawTx = r.rawTx;
-                        r0.name = r.name;
-                        r0.error = undefined;
-                        services.addServiceCallSuccess(stc);
-                        break;
-                    }
-                    r.error = new WERR_errors_1.WERR_INTERNAL(`computed txid ${hash} doesn't match requested value ${txid}`);
-                    r.rawTx = undefined;
-                }
-                if (r.error)
-                    services.addServiceCallError(stc, r.error);
-                else if (!r.rawTx)
-                    services.addServiceCallSuccess(stc, `not found`);
-                else
-                    services.addServiceCallFailure(stc);
-                if (r.error && !r0.error && !r0.rawTx)
-                    // If we have an error and didn't before...
-                    r0.error = r.error;
+                const done = this.applyRawTxResult(r0, txid, await stc.service(txid, this.chain), services, stc);
+                if (done)
+                    break;
             }
-            catch (eu) {
-                const e = WalletError_1.WalletError.fromUnknown(eu);
-                services.addServiceCallError(stc, e);
+            catch (error_) {
+                services.addServiceCallError(stc, WalletError_1.WalletError.fromUnknown(error_));
             }
             services.next();
         }
         return r0;
     }
-    async invokeChaintracksWithRetry(method) {
-        if (!this.options.chaintracks)
+    applyRawTxResult(r0, txid, r, services, stc) {
+        if (r.rawTx != null) {
+            const hash = (0, utilityHelpers_noBuffer_1.asString)((0, utilityHelpers_1.doubleSha256BE)(r.rawTx));
+            if (hash === (0, utilityHelpers_noBuffer_1.asString)(txid)) {
+                r0.rawTx = r.rawTx;
+                r0.name = r.name;
+                r0.error = undefined;
+                services.addServiceCallSuccess(stc);
+                return true;
+            }
+            r.error = new WERR_errors_1.WERR_INTERNAL(`computed txid ${hash} doesn't match requested value ${txid}`);
+            r.rawTx = undefined;
+        }
+        if (r.error != null)
+            services.addServiceCallError(stc, r.error);
+        else
+            services.addServiceCallSuccess(stc, 'not found');
+        // If we have an error and didn't before, capture it.
+        if (r.error != null && r0.error == null && r0.rawTx == null)
+            r0.error = r.error;
+        return false;
+    }
+    async invokeChaintracksWithRetry(method, operation = 'unknown') {
+        if (this.options.chaintracks == null) {
             throw new WERR_errors_1.WERR_INVALID_PARAMETER('options.chaintracks', 'valid for this service operation.');
+        }
+        if (!this.telemetry.enabled)
+            return await this.invokeChaintracksWithRetryCore(method);
+        return await this.telemetry.withSpan('wallet.chaintracks.request', {
+            component: 'wallet-services',
+            kind: 'client',
+            attributes: {
+                'chaintracks.operation': operation
+            }
+        }, async (span) => await this.invokeChaintracksWithRetryCore(method, span));
+    }
+    async invokeChaintracksWithRetryCore(method, parent) {
         for (let retry = 0; retry < 3; retry++) {
             try {
-                const r = await method();
+                const r = parent == null
+                    ? await method()
+                    : await this.telemetry.withSpan('wallet.chaintracks.attempt', {
+                        component: 'wallet-services',
+                        kind: 'client',
+                        parent: parent.context,
+                        attributes: {
+                            'retry.attempt': retry + 1
+                        }
+                    }, method);
                 return r;
             }
-            catch (eu) {
-                const e = WalletError_1.WalletError.fromUnknown(eu);
-                if (e.code != 'ECONNRESET')
-                    throw eu;
+            catch (error_) {
+                const e = WalletError_1.WalletError.fromUnknown(error_);
+                if (e.code !== 'ECONNRESET')
+                    throw error_;
             }
         }
         throw new WERR_errors_1.WERR_INVALID_OPERATION('hashToHeader service unavailable');
     }
     async getHeaderForHeight(height) {
         const method = async () => {
-            const header = await this.options.chaintracks.findHeaderForHeight(height);
-            if (!header)
+            const chaintracks = this.options.chaintracks;
+            const header = await chaintracks.findHeaderForHeight(height);
+            if (header == null)
                 throw new WERR_errors_1.WERR_INVALID_PARAMETER('hash', `valid height '${height}' on mined chain ${this.chain}`);
             return toBinaryBaseBlockHeader(header);
         };
-        return this.invokeChaintracksWithRetry(method);
+        return await this.invokeChaintracksWithRetry(method, 'find_header_for_height');
     }
     async getHeight() {
         const method = async () => {
-            return await this.options.chaintracks.currentHeight();
+            const chaintracks = this.options.chaintracks;
+            return await chaintracks.currentHeight();
         };
-        return this.invokeChaintracksWithRetry(method);
+        return await this.invokeChaintracksWithRetry(method, 'current_height');
     }
     async hashToHeader(hash) {
         const method = async () => {
-            const header = await this.options.chaintracks.findHeaderForBlockHash(hash);
+            const chaintracks = this.options.chaintracks;
+            const header = await chaintracks.findHeaderForBlockHash(hash);
             return header;
         };
-        let header = await this.invokeChaintracksWithRetry(method);
-        if (!header) {
-            header = await this.whatsonchain.getBlockHeaderByHash(hash);
-        }
-        if (!header)
+        let header = await this.invokeChaintracksWithRetry(method, 'find_header_for_hash');
+        header ??= await this.whatsonchain.getBlockHeaderByHash(hash);
+        if (header == null)
             throw new WERR_errors_1.WERR_INVALID_PARAMETER('hash', `valid blockhash '${hash}' on mined chain ${this.chain}`);
         return header;
     }
     async getMerklePath(txid, useNext, logger) {
         const services = this.getMerklePathServices;
-        if (useNext)
+        if (useNext === true)
             services.next();
         const r0 = { notes: [] };
-        logger === null || logger === void 0 ? void 0 : logger.group(`services getMerklePath`);
+        logger?.group('services getMerklePath');
         for (let tries = 0; tries < services.count; tries++) {
             const stc = services.serviceToCall;
             try {
                 const r = await stc.service(txid, this);
-                if (r.notes)
+                if (r.notes != null) {
+                    r0.notes = r0.notes ?? [];
                     r0.notes.push(...r.notes);
-                if (!r0.name)
-                    r0.name = r.name;
-                if (r.merklePath) {
-                    logger === null || logger === void 0 ? void 0 : logger.log(`${stc.providerName} has merklePath`);
+                }
+                r0.name ??= r.name;
+                if (r.merklePath == null) {
+                    logger?.log(`${stc.providerName} no merklePath`);
+                }
+                else {
+                    logger?.log(`${stc.providerName} has merklePath`);
                     // If we have a proof, call it done.
                     r0.merklePath = r.merklePath;
                     r0.header = r.header;
@@ -515,20 +601,17 @@ class Services {
                     services.addServiceCallSuccess(stc);
                     break;
                 }
-                else {
-                    logger === null || logger === void 0 ? void 0 : logger.log(`${stc.providerName} no merklePath`);
-                }
-                if (r.error)
+                if (r.error != null)
                     services.addServiceCallError(stc, r.error);
                 else
                     services.addServiceCallFailure(stc);
-                if (r.error && !r0.error) {
+                if (r.error != null && r0.error == null) {
                     // If we have an error and didn't before...
                     r0.error = r.error;
                 }
             }
-            catch (eu) {
-                const e = WalletError_1.WalletError.fromUnknown(eu);
+            catch (error_) {
+                const e = WalletError_1.WalletError.fromUnknown(error_);
                 services.addServiceCallError(stc, e);
             }
             services.next();
@@ -536,80 +619,77 @@ class Services {
         return r0;
     }
     async updateFiatExchangeRates(targetCurrencies, updateMsecs) {
-        var _a, _b, _c, _d, _e, _f;
-        updateMsecs || (updateMsecs = 1000 * 60 * 60 * 24);
+        updateMsecs ??= 1000 * 60 * 60 * 24;
         const freshnessDate = new Date(Date.now() - updateMsecs);
         const stored = this.options.fiatExchangeRates;
-        const storedRates = (_a = stored.rates) !== null && _a !== void 0 ? _a : {};
+        const storedRates = stored.rates ?? {};
+        const toFetch = this.collectStaleCurrencies(targetCurrencies, storedRates, stored, freshnessDate);
+        if (toFetch.length === 0) {
+            this.options.fiatExchangeRates = {
+                timestamp: stored.timestamp,
+                base: stored.base,
+                rates: storedRates,
+                rateTimestamps: stored.rateTimestamps
+            };
+            return this.options.fiatExchangeRates;
+        }
+        const fetched = await this.fetchFiatRates(toFetch);
+        if (fetched == null) {
+            if (Object.keys(storedRates).length > 0)
+                return stored;
+            throw new WERR_errors_1.WERR_INTERNAL();
+        }
+        this.options.fiatExchangeRates = this.mergeFiatRates(stored, storedRates, fetched);
+        return this.options.fiatExchangeRates;
+    }
+    collectStaleCurrencies(targetCurrencies, storedRates, stored, freshnessDate) {
         const toFetch = [];
         for (const c of targetCurrencies) {
             if (c === 'USD') {
-                if (typeof storedRates.USD !== 'number') {
+                if (typeof storedRates.USD !== 'number')
                     storedRates.USD = 1;
-                }
                 continue;
             }
             const v = storedRates[c];
-            const ts = (_c = (_b = stored.rateTimestamps) === null || _b === void 0 ? void 0 : _b[c]) !== null && _c !== void 0 ? _c : stored.timestamp;
+            const ts = stored.rateTimestamps?.[c] ?? stored.timestamp;
             const fresh = typeof v === 'number' && ts instanceof Date && ts > freshnessDate;
-            if (!fresh) {
+            if (!fresh)
                 toFetch.push(c);
-            }
-        }
-        if (toFetch.length === 0) {
-            this.options.fiatExchangeRates = {
-                timestamp: stored.timestamp,
-                base: stored.base,
-                rates: storedRates,
-                rateTimestamps: stored.rateTimestamps
-            };
-            return this.options.fiatExchangeRates;
         }
+        return toFetch;
+    }
+    async fetchFiatRates(toFetch) {
         const services = this.updateFiatExchangeRateServices.clone();
-        let fetched;
         for (let tries = 0; tries < services.count; tries++) {
             const stc = services.serviceToCall;
             try {
                 const r = await stc.service(toFetch, this.options);
-                if (toFetch.every(c => { var _a; return c === 'USD' || typeof ((_a = r.rates) === null || _a === void 0 ? void 0 : _a[c]) === 'number'; })) {
+                if (toFetch.every(c => c === 'USD' || typeof r.rates?.[c] === 'number')) {
                     services.addServiceCallSuccess(stc);
-                    fetched = r;
-                    break;
-                }
-                else {
-                    services.addServiceCallFailure(stc);
+                    return r;
                 }
+                services.addServiceCallFailure(stc);
             }
-            catch (eu) {
-                const e = WalletError_1.WalletError.fromUnknown(eu);
-                services.addServiceCallError(stc, e);
+            catch (error_) {
+                services.addServiceCallError(stc, WalletError_1.WalletError.fromUnknown(error_));
             }
             services.next();
         }
-        if (!fetched) {
-            if (stored && Object.keys(storedRates).length > 0) {
-                return stored;
-            }
-            throw new WERR_errors_1.WERR_INTERNAL();
-        }
+        return undefined;
+    }
+    mergeFiatRates(stored, storedRates, fetched) {
         const nextRates = { ...storedRates };
-        const nextTimestamps = { ...((_d = stored.rateTimestamps) !== null && _d !== void 0 ? _d : {}) };
-        const fetchedCurrencies = Object.keys((_e = fetched.rates) !== null && _e !== void 0 ? _e : {});
-        for (const c of fetchedCurrencies) {
-            const v = (_f = fetched.rates) === null || _f === void 0 ? void 0 : _f[c];
+        const nextTimestamps = { ...stored.rateTimestamps };
+        for (const c of fetched.rates != null ? Object.keys(fetched.rates) : []) {
+            const v = fetched.rates?.[c];
             if (typeof v === 'number') {
                 nextRates[c] = v;
                 nextTimestamps[c] = fetched.timestamp;
             }
         }
-        const nextTimestamp = new Date(Math.max(stored.timestamp instanceof Date ? stored.timestamp.getTime() : new Date(stored.timestamp).getTime(), fetched.timestamp.getTime()));
-        this.options.fiatExchangeRates = {
-            timestamp: nextTimestamp,
-            base: stored.base,
-            rates: nextRates,
-            rateTimestamps: nextTimestamps
-        };
-        return this.options.fiatExchangeRates;
+        const storedMs = stored.timestamp instanceof Date ? stored.timestamp.getTime() : new Date(stored.timestamp).getTime();
+        const nextTimestamp = new Date(Math.max(storedMs, fetched.timestamp.getTime()));
+        return { timestamp: nextTimestamp, base: stored.base, rates: nextRates, rateTimestamps: nextTimestamps };
     }
     async nLockTimeIsFinal(tx) {
         const MAXINT = 0xffffffff;
@@ -647,10 +727,9 @@ class Services {
     }
 }
 exports.Services = Services;
-Services.getStatusForTxidsBatchLimit = 20;
 function validateScriptHash(output, outputFormat) {
     let b = (0, utilityHelpers_noBuffer_1.asArray)(output);
-    if (!outputFormat) {
+    if (outputFormat == null) {
         if (b.length === 32)
             outputFormat = 'hashLE';
         else
@@ -666,7 +745,7 @@ function validateScriptHash(output, outputFormat) {
             b = (0, utilityHelpers_1.sha256Hash)(b).reverse();
             break;
         default:
-            throw new WERR_errors_1.WERR_INVALID_PARAMETER('outputFormat', `not be ${outputFormat}`);
+            throw new WERR_errors_1.WERR_INVALID_PARAMETER('outputFormat', `not be ${String(outputFormat)}`);
     }
     return (0, utilityHelpers_noBuffer_1.asString)(b);
 }