@bsv/wallet-toolbox-client 2.5.0 → 2.6.0

package/out/index.client.cjs

@@ -1005,6 +1005,7 @@ function toWalletNetwork(chain) {
 	switch (chain) {
 		case "main": return "mainnet";
 		case "test":
+		case "stn":
 		case "ttn":
 		case "tstn":
 		case "mock": return "testnet";
@@ -1018,6 +1019,7 @@ function toLookupNetworkPreset(chain) {
 	switch (chain) {
 		case "main": return "mainnet";
 		case "test": return "testnet";
+		case "stn":
 		case "ttn":
 		case "tstn":
 		case "mock": return "local";
@@ -11767,9 +11769,7 @@ function genesisHeader(chain) {
 			height: 0,
 			hash: "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f"
 		};
-		case "test":
-		case "ttn":
-		case "tstn": return {
+		case "test": return {
 			version: 1,
 			previousHash: "0000000000000000000000000000000000000000000000000000000000000000",
 			merkleRoot: "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b",
@@ -11779,6 +11779,36 @@ function genesisHeader(chain) {
 			height: 0,
 			hash: "000000000933ea01ad0ee984209779baaec3ced90fa3f408719526f8d77f4943"
 		};
+		case "stn": return {
+			version: 1,
+			previousHash: "0000000000000000000000000000000000000000000000000000000000000000",
+			merkleRoot: "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b",
+			time: 1296688602,
+			bits: 486604799,
+			nonce: 173779992,
+			height: 0,
+			hash: "6b38bdbcd73a19f7889d23e1fa6166a9de71affceca60ca3bb1b28af8135c594"
+		};
+		case "ttn": return {
+			version: 1,
+			previousHash: "0000000000000000000000000000000000000000000000000000000000000000",
+			merkleRoot: "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b",
+			time: 1755606836,
+			bits: 486604799,
+			nonce: 1092578460,
+			height: 0,
+			hash: "000000000499eabba0a88f5b3747231c74b9191c1a4a04b2c2ea817976b7776d"
+		};
+		case "tstn": return {
+			version: 1,
+			previousHash: "0000000000000000000000000000000000000000000000000000000000000000",
+			merkleRoot: "64452e5b25c65e492ad6a4f5ce9f427ca986626c28315d88de920d66e28cc98f",
+			time: 1782864e3,
+			bits: 486604799,
+			nonce: 1780488216,
+			height: 0,
+			hash: "000000005d221c0e023cb56b5682cf094f32cd959958b40bc931e5797cae706c"
+		};
 		case "mock": throw new Error("genesisHeader does not support 'mock' chain. Mock chain generates its own genesis block.");
 	}
 }
@@ -19306,10 +19336,11 @@ var Chaintracks = class {
 	startupError = null;
 	subscriberCallbacksEnabled = false;
 	stopMainThread = true;
-	lastPresentHeight = 0;
+	lastPresentHeight = -1;
 	lastPresentHeightMsecs = 0;
 	lastPresentHeightMaxAge = 60 * 1e3;
 	lock = new SingleWriterMultiReaderLock();
+	sourceStatus = /* @__PURE__ */ new Map();
 	constructor(options) {
 		this.options = options;
 		if (options.storage == null) throw new Error("storage is required.");
@@ -19320,6 +19351,22 @@ var Chaintracks = class {
 		this.storage = options.storage;
 		this.bulkIngestors = options.bulkIngestors;
 		this.liveIngestors = options.liveIngestors;
+		for (const [index, source] of this.bulkIngestors.entries()) {
+			const name = this.sourceName("bulk", index, source);
+			this.sourceStatus.set(name, {
+				name,
+				role: "bulk",
+				state: "unknown"
+			});
+		}
+		for (const [index, source] of this.liveIngestors.entries()) {
+			const name = this.sourceName("live", index, source);
+			this.sourceStatus.set(name, {
+				name,
+				role: "live",
+				state: "unknown"
+			});
+		}
 		this.addLiveRecursionLimit = options.addLiveRecursionLimit;
 		if (options.logging != null) this.log = options.logging;
 		this.storage.log = this.log;
@@ -19334,19 +19381,36 @@ var Chaintracks = class {
 	*/
 	async getPresentHeight() {
 		const now = Date.now();
-		if (this.lastPresentHeight && now - this.lastPresentHeightMsecs < this.lastPresentHeightMaxAge) return this.lastPresentHeight;
-		const presentHeights = [];
-		for (const bulk of this.bulkIngestors) try {
-			const presentHeight = await bulk.getPresentHeight();
-			if (presentHeight) presentHeights.push(presentHeight);
-		} catch (uerr) {
-			console.error(uerr);
-		}
-		const presentHeight = presentHeights.length > 0 ? Math.max(...presentHeights) : void 0;
-		if (!presentHeight) throw new Error("At least one bulk ingestor must implement getPresentHeight.");
-		this.lastPresentHeight = presentHeight;
-		this.lastPresentHeightMsecs = now;
-		return presentHeight;
+		if (this.lastPresentHeight >= 0 && now - this.lastPresentHeightMsecs < this.lastPresentHeightMaxAge) return this.lastPresentHeight;
+		for (const [index, bulk] of this.bulkIngestors.entries()) {
+			const source = this.sourceName("bulk", index, bulk);
+			try {
+				const presentHeight = await bulk.getPresentHeight();
+				if (presentHeight != null && Number.isInteger(presentHeight) && presentHeight >= 0) {
+					this.markSourceSuccess(source, "bulk");
+					this.lastPresentHeight = presentHeight;
+					this.lastPresentHeightMsecs = now;
+					return presentHeight;
+				}
+			} catch (uerr) {
+				const error = WalletError.fromUnknown(uerr);
+				this.markSourceFailure(source, "bulk", error);
+				this.log(`Present-height source ${source} failed: ${error.message}`);
+			}
+		}
+		if (this.lastPresentHeight >= 0) return this.lastPresentHeight;
+		try {
+			const ranges = await this.storage.getAvailableHeightRanges();
+			const localHeight = Math.max(ranges.bulk.maxHeight, ranges.live.maxHeight);
+			if (localHeight >= 0) {
+				this.lastPresentHeight = localHeight;
+				this.lastPresentHeightMsecs = now;
+				return localHeight;
+			}
+		} catch (error) {
+			this.log(`Unable to read the locally validated ChainTracks height: ${WalletError.fromUnknown(error).message}`);
+		}
+		throw new Error("No present-height source or locally validated headers are available.");
 	}
 	async currentHeight() {
 		return await this.getPresentHeight();
@@ -19397,7 +19461,7 @@ var Chaintracks = class {
 			for (const bulkIn of this.bulkIngestors) await bulkIn.setStorage(this.storage, this.log);
 			for (const liveIn of this.liveIngestors) await liveIn.setStorage(this.storage, this.log);
 			this.stopMainThread = false;
-			for (const liveIngestor of this.liveIngestors) this.promises.push(this.runLiveIngestor(liveIngestor));
+			for (const [index, liveIngestor] of this.liveIngestors.entries()) this.promises.push(this.runLiveIngestor(liveIngestor, index));
 			this.promises.push(this.mainThreadShiftLiveHeaders());
 			while (!this.available && this.startupError == null) await wait(100);
 			if (this.startupError != null) throw this.startupError;
@@ -19424,10 +19488,12 @@ var Chaintracks = class {
 	async listening() {
 		return await this.makeAvailable();
 	}
-	async runLiveIngestor(liveIngestor) {
+	async runLiveIngestor(liveIngestor, index) {
 		let restartCount = 0;
 		const name = liveIngestor.constructor.name;
+		const source = this.sourceName("live", index, liveIngestor);
 		while (!this.stopMainThread) try {
+			this.markSourceSuccess(source, "live");
 			await liveIngestor.startListening(this.liveHeaders);
 			if (this.stopMainThread) return;
 			restartCount++;
@@ -19438,6 +19504,7 @@ var Chaintracks = class {
 			if (this.stopMainThread) return;
 			restartCount++;
 			const e = WalletError.fromUnknown(error_);
+			this.markSourceFailure(source, "live", e);
 			const waitMsecs = this.liveIngestorRestartWaitMsecs(restartCount);
 			this.log(`Live ingestor ${name} failed restart=${restartCount} retryMsecs=${waitMsecs}: ${e.stack ?? e.message}`);
 			await wait(waitMsecs);
@@ -19485,7 +19552,8 @@ var Chaintracks = class {
 			storage: this.storage.constructor.name,
 			bulkIngestors: this.bulkIngestors.map((bulkIngestor) => bulkIngestor.constructor.name),
 			liveIngestors: this.liveIngestors.map((liveIngestor) => liveIngestor.constructor.name),
-			packages: []
+			packages: [],
+			sources: Array.from(this.sourceStatus.values()).map((status) => ({ ...status }))
 		};
 	}
 	async getHeaders(height, count) {
@@ -19568,26 +19636,30 @@ var Chaintracks = class {
 		let madeProgress = false;
 		let hadSuccess = false;
 		let done = false;
-		for (const bulk of this.bulkIngestors) try {
-			const beforeBulkMax = before.bulk.maxHeight;
-			const beforeLiveRange = HeightRange.from(newLiveHeaders);
-			const r = await bulk.synchronize(presentHeight, before, newLiveHeaders);
-			hadSuccess = true;
-			newLiveHeaders = r.liveHeaders;
-			after = await this.storage.getAvailableHeightRanges();
-			const added = after.bulk.above(before.bulk);
-			const afterLiveRange = HeightRange.from(newLiveHeaders);
-			if (after.bulk.maxHeight > beforeBulkMax || afterLiveRange.maxHeight > beforeLiveRange.maxHeight) madeProgress = true;
-			before = after;
-			this.log(`Bulk Ingestor: ${added.length} added with ${newLiveHeaders.length} live headers from ${bulk.constructor.name}`);
-			if (r.done) {
-				done = true;
-				break;
+		for (const [index, bulk] of this.bulkIngestors.entries()) {
+			const source = this.sourceName("bulk", index, bulk);
+			try {
+				const beforeBulkMax = before.bulk.maxHeight;
+				const beforeLiveRange = HeightRange.from(newLiveHeaders);
+				const r = await bulk.synchronize(presentHeight, before, newLiveHeaders);
+				hadSuccess = true;
+				this.markSourceSuccess(source, "bulk");
+				newLiveHeaders = r.liveHeaders;
+				after = await this.storage.getAvailableHeightRanges();
+				const added = after.bulk.above(before.bulk);
+				const afterLiveRange = HeightRange.from(newLiveHeaders);
+				if (after.bulk.maxHeight > beforeBulkMax || afterLiveRange.maxHeight > beforeLiveRange.maxHeight) madeProgress = true;
+				before = after;
+				this.log(`Bulk Ingestor: ${added.length} added with ${newLiveHeaders.length} live headers from ${bulk.constructor.name}`);
+				if (r.done) {
+					done = true;
+					break;
+				}
+			} catch (error_) {
+				const e = bulkSyncError = WalletError.fromUnknown(error_);
+				this.markSourceFailure(source, "bulk", e);
+				this.log(`bulk sync error: ${e.message}`);
 			}
-		} catch (error_) {
-			const e = bulkSyncError = WalletError.fromUnknown(error_);
-			this.log(`bulk sync error: ${e.message}`);
-			if (!this.available) break;
 		}
 		if (!this.available && bulkSyncError != null && !hadSuccess) this.startupError = bulkSyncError;
 		return {
@@ -19597,10 +19669,41 @@ var Chaintracks = class {
 			madeProgress
 		};
 	}
+	sourceName(role, index, source) {
+		return `${role}[${index}]:${source.constructor.name}`;
+	}
+	markSourceSuccess(name, role) {
+		this.sourceStatus.set(name, {
+			...this.sourceStatus.get(name),
+			name,
+			role,
+			state: "healthy",
+			lastSuccess: (/* @__PURE__ */ new Date()).toISOString(),
+			error: void 0
+		});
+	}
+	markSourceFailure(name, role, error) {
+		this.sourceStatus.set(name, {
+			...this.sourceStatus.get(name),
+			name,
+			role,
+			state: "degraded",
+			lastFailure: (/* @__PURE__ */ new Date()).toISOString(),
+			error: error.message
+		});
+	}
 	async getMissingBlockHeader(hash) {
-		for (const live of this.liveIngestors) {
-			const header = await live.getHeaderByHash(hash);
-			if (header != null) return header;
+		for (const [index, live] of this.liveIngestors.entries()) {
+			const source = this.sourceName("live", index, live);
+			try {
+				const header = await live.getHeaderByHash(hash);
+				this.markSourceSuccess(source, "live");
+				if (header != null) return header;
+			} catch (error) {
+				const resolved = WalletError.fromUnknown(error);
+				this.markSourceFailure(source, "live", resolved);
+				this.log(`Header lookup source ${source} failed: ${resolved.message}`);
+			}
 		}
 	}
 	invalidInsertHeaderResult(ihr) {
@@ -19933,6 +20036,9 @@ var GoChaintracksServiceClient = class {
 	chain;
 	baseUrl;
 	fetcher;
+	requestTimeoutMsecs;
+	reconnectWaitMsecs;
+	reconnectWaitMaxMsecs;
 	subscriptions = /* @__PURE__ */ new Map();
 	nextSubscriptionId = 1;
 	constructor(chain, serviceUrl, options = {}) {
@@ -19946,6 +20052,15 @@ var GoChaintracksServiceClient = class {
 		}
 		this.baseUrl = `${base}${prefix}`;
 		this.fetcher = options.fetch ?? fetch;
+		this.requestTimeoutMsecs = options.requestTimeoutMsecs ?? 3e4;
+		this.reconnectWaitMsecs = options.reconnectWaitMsecs ?? 1e3;
+		this.reconnectWaitMaxMsecs = options.reconnectWaitMaxMsecs ?? 6e4;
+		for (const [name, value] of [
+			["requestTimeoutMsecs", this.requestTimeoutMsecs],
+			["reconnectWaitMsecs", this.reconnectWaitMsecs],
+			["reconnectWaitMaxMsecs", this.reconnectWaitMaxMsecs]
+		]) if (!Number.isSafeInteger(value) || value < 1) throw new Error(`${name} must be a positive integer.`);
+		if (this.reconnectWaitMaxMsecs < this.reconnectWaitMsecs) throw new Error("reconnectWaitMaxMsecs must be greater than or equal to reconnectWaitMsecs.");
 	}
 	async currentHeight() {
 		return await this.getPresentHeight();
@@ -19955,12 +20070,8 @@ var GoChaintracksServiceClient = class {
 		return h != null && root === asString(h.merkleRoot);
 	}
 	async getChain() {
-		try {
-			const r = await this.getJson("/network");
-			return this.normalizeChain(r.network);
-		} catch {
-			return this.chain;
-		}
+		const r = await this.getJson("/network");
+		return this.normalizeChain(typeof r === "string" ? r : r.network);
 	}
 	async getInfo() {
 		const tip = await this.findChainTipHeader();
@@ -19975,11 +20086,11 @@ var GoChaintracksServiceClient = class {
 		};
 	}
 	async getPresentHeight() {
-		return (await this.getJson("/height")).height;
+		const result = await this.getJson("/height");
+		return typeof result === "number" ? result : result.height;
 	}
 	async getHeaders(height, count) {
-		const bytes = await this.getBinary(`/headers.bin?height=${height}&count=${count}`);
-		return Buffer.from(bytes).toString("hex");
+		return asString(await this.getBinary(`/headers.bin?height=${height}&count=${count}`));
 	}
 	async findChainTipHeader() {
 		return await this.getJson("/tip");
@@ -20035,7 +20146,7 @@ var GoChaintracksServiceClient = class {
 	async subscribe(type, path, onPayload) {
 		const id = `${type}-${this.nextSubscriptionId++}`;
 		const abort = new AbortController();
-		const done = this.runSse(path, abort.signal, onPayload);
+		const done = this.runSseWithReconnect(path, abort.signal, onPayload);
 		this.subscriptions.set(id, {
 			id,
 			type,
@@ -20047,30 +20158,75 @@ var GoChaintracksServiceClient = class {
 		});
 		return id;
 	}
-	async runSse(path, signal, onPayload) {
-		const response = await this.fetcher(this.url(path), {
-			headers: { Accept: "text/event-stream" },
-			signal
+	async runSseWithReconnect(path, signal, onPayload) {
+		let failures = 0;
+		while (!signal.aborted) {
+			try {
+				failures = await this.runSse(path, signal, onPayload) ? 0 : failures + 1;
+			} catch {
+				if (signal.aborted) return;
+				failures++;
+			}
+			const multiplier = Math.min(2 ** Math.max(0, failures - 1), 64);
+			const delay = Math.min(this.reconnectWaitMsecs * multiplier, this.reconnectWaitMaxMsecs);
+			await this.waitForReconnect(delay, signal);
+		}
+	}
+	async waitForReconnect(msecs, signal) {
+		if (signal.aborted || msecs <= 0) return;
+		await new Promise((resolve) => {
+			let timeout;
+			const onAbort = () => done();
+			const done = () => {
+				clearTimeout(timeout);
+				signal.removeEventListener("abort", onAbort);
+				resolve();
+			};
+			timeout = setTimeout(done, msecs);
+			signal.addEventListener("abort", onAbort, { once: true });
 		});
-		if (!response.ok) throw new Error(`GET ${this.url(path)} failed ${response.status} ${response.statusText}`);
-		if (response.body == null) throw new Error(`GET ${this.url(path)} returned no response body`);
-		const reader = response.body.getReader();
-		const decoder = new TextDecoder();
-		let buffer = "";
+	}
+	async runSse(path, signal, onPayload) {
+		const controller = new AbortController();
+		const onAbort = () => controller.abort();
+		signal.addEventListener("abort", onAbort, { once: true });
+		const timeout = setTimeout(() => controller.abort(), this.requestTimeoutMsecs);
+		let receivedEvent = false;
+		const observePayload = (payload) => {
+			receivedEvent = true;
+			onPayload(payload);
+		};
 		try {
-			for (;;) {
-				const { done, value } = await reader.read();
-				if (done) break;
-				buffer += decoder.decode(value, { stream: true });
-				buffer = this.processSseBuffer(buffer, onPayload);
+			const response = await this.fetcher(this.url(path), {
+				headers: { Accept: "text/event-stream" },
+				signal: controller.signal
+			});
+			clearTimeout(timeout);
+			if (!response.ok) throw new Error(`GET ${this.url(path)} failed ${response.status} ${response.statusText}`);
+			if (response.body == null) throw new Error(`GET ${this.url(path)} returned no response body`);
+			const reader = response.body.getReader();
+			const decoder = new TextDecoder();
+			let buffer = "";
+			try {
+				for (;;) {
+					const { done, value } = await reader.read();
+					if (done) break;
+					buffer += decoder.decode(value, { stream: true });
+					buffer = this.processSseBuffer(buffer, observePayload);
+				}
+				buffer += decoder.decode();
+				this.processSseBuffer(`${buffer}\n\n`, observePayload);
+			} finally {
+				reader.releaseLock();
 			}
-			buffer += decoder.decode();
-			this.processSseBuffer(`${buffer}\n\n`, onPayload);
 		} finally {
-			reader.releaseLock();
+			clearTimeout(timeout);
+			signal.removeEventListener("abort", onAbort);
 		}
+		return receivedEvent;
 	}
 	processSseBuffer(buffer, onPayload) {
+		buffer = buffer.replaceAll("\r\n", "\n");
 		for (;;) {
 			const boundary = buffer.indexOf("\n\n");
 			if (boundary < 0) return buffer;
@@ -20089,32 +20245,51 @@ var GoChaintracksServiceClient = class {
 		return r;
 	}
 	async getJsonOrUndefined(path) {
-		const response = await this.fetcher(this.url(path), { headers: { Accept: "application/json" } });
+		const response = await this.fetchWithTimeout(this.url(path), { headers: { Accept: "application/json" } });
 		if (response.status === 404) return void 0;
 		if (!response.ok) throw new Error(`GET ${this.url(path)} failed ${response.status} ${response.statusText}`);
-		return await response.json();
+		const value = await response.json();
+		if (value != null && typeof value === "object" && "status" in value) {
+			const envelope = value;
+			if (envelope.status === "success") return envelope.value;
+			if (envelope.status === "error") throw new Error(envelope.description ?? `GET ${this.url(path)} failed`);
+		}
+		return value;
 	}
 	async getBinary(path) {
-		const response = await this.fetcher(this.url(path), { headers: { Accept: "application/octet-stream" } });
+		const response = await this.fetchWithTimeout(this.url(path), { headers: { Accept: "application/octet-stream" } });
 		if (!response.ok) throw new Error(`GET ${this.url(path)} failed ${response.status} ${response.statusText}`);
 		return new Uint8Array(await response.arrayBuffer());
 	}
+	async fetchWithTimeout(url, init) {
+		const controller = new AbortController();
+		const timeout = setTimeout(() => controller.abort(), this.requestTimeoutMsecs);
+		try {
+			return await this.fetcher(url, {
+				...init,
+				signal: controller.signal
+			});
+		} finally {
+			clearTimeout(timeout);
+		}
+	}
 	url(path) {
 		return `${this.baseUrl}${path}`;
 	}
 	normalizeChain(network) {
-		switch (network) {
+		switch (network.trim().toLowerCase()) {
 			case "main":
 			case "mainnet": return "main";
 			case "test":
 			case "testnet": return "test";
+			case "stn":
+			case "scalingtestnet": return "stn";
 			case "ttn":
 			case "teratest":
 			case "teratestnet": return "ttn";
 			case "tstn":
-			case "teranodescalingtestnet":
-			case "scalingtestnet": return "tstn";
-			default: return this.chain;
+			case "teranodescalingtestnet": return "tstn";
+			default: throw new Error(`Unsupported ChainTracks upstream network '${network}'.`);
 		}
 	}
 };
@@ -21447,31 +21622,45 @@ var ServiceCollection = class ServiceCollection {
 //#endregion
 //#region ../src/services/networkConfig.ts
 /**
-* Runtime service-endpoint configuration for the `tstn` (Teranode Scaling Test Net) network.
+* Runtime service-endpoint configuration for Teranode networks that do not
+* have a public, operator-independent service endpoint.
 *
-* Unlike `main`, `test`, and `ttn`, the tstn service endpoints are not public and must not be
+* Unlike `main`, `test`, and `ttn`, the stn/tstn service endpoints are not public and must not be
 * hardcoded in this (public) source tree. They are supplied at runtime through environment
 * variables:
 *
+*   STN_ARCADE_URL        STN Arcade broadcaster / ARC endpoint base.
+*   STN_CHAINTRACKS_URL   STN ChainTracks service URL.
 *   TSTN_ARCADE_URL       Arcade broadcaster / ARC endpoint base. Also the fallback host for
 *                         ChainTracks when TSTN_CHAINTRACKS_URL is unset
 *                         (`${TSTN_ARCADE_URL}/chaintracks/v1`, mirroring the ttn layout).
 *   TSTN_CHAINTRACKS_URL  ChainTracks service URL.
 *
-* tstn runs only Arcade (broadcast + merkle proofs) and ChainTracks (headers); there is no
-* WhatsOnChain / block-explorer service for tstn, so no WhatsOnChain endpoint is configured and
+* stn/tstn run only operator-configured Arcade and ChainTracks services; there is no
+* documented WhatsOnChain service for them, so no WhatsOnChain endpoint is configured and
 * the WhatsOnChain-only lookups (raw tx, utxo status, txid status, script-hash history) are not
-* available on tstn.
+* available on stn/tstn.
 *
-* `process` is accessed defensively so importing this module remains safe in browser bundles;
-* tstn is a server-side network and these variables are only read when the selected chain is
-* tstn.
+* `process` is accessed defensively so importing this module remains safe in
+* browser bundles. Browser applications can still supply an explicit
+* ChaintracksClientApi without relying on environment variables.
 */
 function readEnv(name) {
 	const value = (typeof process !== "undefined" ? process.env : void 0)?.[name];
 	return value != null && value.trim() !== "" ? value.trim() : void 0;
 }
-const stripTrailingSlash = (url) => {
+/** Credential-free public Arcade host for supported networks. */
+function publicArcadeUrl(chain) {
+	switch (chain) {
+		case "main": return "https://arcade-v2-us-1.bsvblockchain.tech";
+		case "test": return "https://arcade-v2-testnet-us-1.bsvblockchain.tech";
+		case "ttn": return "https://arcade-v2-ttn-us-1.bsvblockchain.tech";
+		case "stn":
+		case "tstn":
+		case "mock": return;
+	}
+}
+const stripTrailingSlash$1 = (url) => {
 	let end = url.length;
 	while (end > 0 && url[end - 1] === "/") end--;
 	return url.slice(0, end);
@@ -21480,6 +21669,10 @@ const stripTrailingSlash = (url) => {
 function tstnArcadeUrl() {
 	return readEnv("TSTN_ARCADE_URL");
 }
+/** Arcade broadcaster / ARC endpoint for stn, or `undefined` when unset. */
+function stnArcadeUrl() {
+	return readEnv("STN_ARCADE_URL");
+}
 /**
 * ChainTracks service URL for tstn. Falls back to `${TSTN_ARCADE_URL}/chaintracks/v1` when
 * `TSTN_CHAINTRACKS_URL` is unset (mirrors the ttn layout). Throws when neither is configured.
@@ -21488,20 +21681,53 @@ function tstnChaintracksUrl() {
 	const explicit = readEnv("TSTN_CHAINTRACKS_URL");
 	if (explicit != null) return explicit;
 	const arcade = tstnArcadeUrl();
-	if (arcade != null) return `${stripTrailingSlash(arcade)}/chaintracks/v1`;
+	if (arcade != null) return `${stripTrailingSlash$1(arcade)}/chaintracks/v1`;
 	throw new Error("tstn chain requires a ChainTracks URL: set TSTN_CHAINTRACKS_URL (or TSTN_ARCADE_URL) in the environment.");
 }
+/**
+* ChainTracks service URL for stn. Falls back to the configured Arcade host's
+* legacy-compatible path when STN_CHAINTRACKS_URL is unset.
+*/
+function stnChaintracksUrl() {
+	const explicit = readEnv("STN_CHAINTRACKS_URL");
+	if (explicit != null) return explicit;
+	const arcade = stnArcadeUrl();
+	if (arcade != null) return `${stripTrailingSlash$1(arcade)}/chaintracks/v1`;
+	throw new Error("stn chain requires a ChainTracks URL: set STN_CHAINTRACKS_URL (or STN_ARCADE_URL) in the environment.");
+}
 //#endregion
 //#region ../src/services/createDefaultWalletServicesOptions.ts
+function stripTrailingSlash(value) {
+	let end = value.length;
+	while (end > 0 && value[end - 1] === "/") end--;
+	return value.slice(0, end);
+}
+function configuredChaintracksClient(chain, serviceUrl) {
+	let path = "";
+	try {
+		path = stripTrailingSlash(new URL(serviceUrl).pathname);
+	} catch {}
+	if (path.endsWith("/v2")) return new GoChaintracksServiceClient(chain, serviceUrl);
+	return new ChaintracksServiceClient(chain, serviceUrl);
+}
+/**
+* Returns the credential-free default ChainTracks client for a supported
+* public network, or an operator-configured client for stn/tstn.
+*/
+function createDefaultChaintracksClient(chain) {
+	switch (chain) {
+		case "main":
+		case "test":
+		case "ttn": return new GoChaintracksServiceClient(chain, arcadeDefaultUrl(chain), { apiPrefix: "/chaintracks/v2" });
+		case "stn": return configuredChaintracksClient(chain, stnChaintracksUrl());
+		case "tstn": return configuredChaintracksClient(chain, tstnChaintracksUrl());
+	}
+}
 function createDefaultWalletServicesOptions(...[chain, arcCallbackUrl, arcCallbackToken, taalArcApiKey, gorillaPoolArcApiKey, bitailsApiKey, deploymentId, chaintracks, arcadeUrl, arcadeApiKey, arcadeCallbackToken]) {
 	if (chain === "mock") throw new Error("createDefaultWalletServicesOptions does not support 'mock' chain. Use MockServices directly.");
 	deploymentId ||= `wallet-toolbox-${randomBytesHex(16)}`;
-	let chaintracksUrl;
-	if (chain === "ttn") chaintracksUrl = "https://arcade-v2-ttn-us-1.bsvblockchain.tech/chaintracks/v1";
-	else if (chain === "tstn") chaintracksUrl = tstnChaintracksUrl();
-	else chaintracksUrl = `https://${chain}net-chaintracks.babbage.systems`;
 	const chaintracksFiatExchangeRatesUrl = "https://mainnet-chaintracks.babbage.systems/getFiatExchangeRates";
-	chaintracks ||= new ChaintracksServiceClient(chain, chaintracksUrl);
+	chaintracks ||= createDefaultChaintracksClient(chain);
 	const o = {
 		chain,
 		taalApiKey: void 0,
@@ -21559,14 +21785,15 @@ function createDefaultWalletServicesOptions(...[chain, arcCallbackUrl, arcCallba
 }
 /**
 * Default Arcade (bsv-blockchain/arcade) endpoint per chain.
-* Returns undefined when no public default is known for the chain (e.g. testnet not yet deployed).
+* Returns undefined when no public default is known for the chain.
 */
 function arcadeDefaultUrl(chain) {
 	switch (chain) {
-		case "main": return "https://arcade-v2-us-1.bsvblockchain.tech";
-		case "ttn": return "https://arcade-v2-ttn-us-1.bsvblockchain.tech";
+		case "main":
+		case "test":
+		case "ttn": return publicArcadeUrl(chain);
+		case "stn": return stnArcadeUrl();
 		case "tstn": return tstnArcadeUrl();
-		case "test": return;
 		case "mock": return;
 	}
 }
@@ -21574,6 +21801,7 @@ function arcDefaultUrl(chain) {
 	switch (chain) {
 		case "main": return "https://arc.taal.com";
 		case "test": return "https://arc-test.taal.com";
+		case "stn": return stnArcadeUrl() ?? "";
 		case "ttn": return "https://arcade-v2-ttn-us-1.bsvblockchain.tech/";
 		case "tstn": return tstnArcadeUrl() ?? "";
 		case "mock": return "";
@@ -22955,7 +23183,7 @@ var Services = class Services {
 	telemetry;
 	constructor(optionsOrChain) {
 		this.chain = typeof optionsOrChain === "string" ? optionsOrChain : optionsOrChain.chain;
-		if (this.chain === "mock") throw new WERR_INVALID_PARAMETER("chain", "'main', 'test', 'ttn', or 'tstn'. Use MockServices for 'mock' chain.");
+		if (this.chain === "mock") throw new 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 _bsv_sdk.Telemetry(this.options.telemetry);
 		this.whatsonchain = new WhatsOnChain(this.chain, { apiKey: this.options.whatsOnChainApiKey }, this);
@@ -22969,7 +23197,7 @@ var Services = class Services {
 		if (this.options.arcGorillaPoolUrl != null && this.options.arcGorillaPoolUrl !== "") this.arcGorillaPool = new ARC(this.options.arcGorillaPoolUrl, this.options.arcGorillaPoolConfig, "arcGorillaPool");
 		if (this.options.arcadeUrl != null && this.options.arcadeUrl !== "") this.arcade = new Arcade(this.options.arcadeUrl, this.options.arcadeConfig, "arcade");
 		const hasBitails = this.chain === "main" || this.chain === "test";
-		const hasWhatsOnChain = this.chain !== "tstn";
+		const hasWhatsOnChain = this.chain === "main" || this.chain === "test";
 		if (hasBitails) this.bitails = new Bitails(this.chain, { apiKey: this.options.bitailsApiKey });
 		return {
 			hasBitails,
@@ -23683,9 +23911,22 @@ function classifyMerklePathResponse(status, statusText, retry) {
 //#endregion
 //#region ../src/services/providers/WhatsOnChain.ts
 var WhatsOnChainNoServices = class extends SdkWhatsOnChain {
+	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;
+	}
+	async requestWithAnonymousAuthFallback(url, requestOptions) {
+		await this.requestGate?.();
+		const response = await this.httpClient.request(url, requestOptions);
+		if (response.status !== 401 && response.status !== 403 || this.apiKey.trim() === "") return response;
+		if (this.requestGate != null) await this.requestGate();
+		else await wait(350);
+		return await this.httpClient.request(url, {
+			method: "GET",
+			headers: { Accept: "application/json" }
+		});
 	}
 	/**
 	* POST
@@ -24094,7 +24335,7 @@ var WhatsOnChainNoServices = class extends SdkWhatsOnChain {
 		};
 		const url = `${this.URL}/block/${hash}/header`;
 		for (let retry = 0; retry < 2; retry++) {
-			const response = await this.httpClient.request(url, requestOptions);
+			const response = await this.requestWithAnonymousAuthFallback(url, requestOptions);
 			if (response.statusText === "Too Many Requests" && retry < 2) {
 				await wait(2e3);
 				continue;
@@ -24112,7 +24353,7 @@ var WhatsOnChainNoServices = class extends SdkWhatsOnChain {
 		};
 		const url = `${this.URL}/chain/info`;
 		for (let retry = 0; retry < 2; retry++) {
-			const response = await this.httpClient.request(url, requestOptions);
+			const response = await this.requestWithAnonymousAuthFallback(url, requestOptions);
 			if (response.statusText === "Too Many Requests" && retry < 2) {
 				await wait(2e3);
 				continue;
@@ -24298,12 +24539,16 @@ var WhatsOnChainServices = class WhatsOnChainServices {
 			timeout: 3e4,
 			userAgent: "BabbageWhatsOnChainServices",
 			enableCache: true,
-			chainInfoMsecs: 5e3
+			chainInfoMsecs: 5e3,
+			minRequestIntervalMsecs: 350
 		};
 	}
 	static chainInfo = [];
 	static chainInfoTime = [];
 	static chainInfoMsecs = [];
+	static chainInfoPromise = {};
+	static requestTail = Promise.resolve();
+	static nextRequestMsecs = 0;
 	chain;
 	woc;
 	constructor(options) {
@@ -24312,7 +24557,8 @@ var WhatsOnChainServices = class WhatsOnChainServices {
 			apiKey: this.options.apiKey,
 			timeout: this.options.timeout,
 			userAgent: this.options.userAgent,
-			enableCache: this.options.enableCache
+			enableCache: this.options.enableCache,
+			requestGate: async () => await this.waitForRateLimit()
 		};
 		this.chain = options.chain;
 		const chainInfoMsecs = WhatsOnChainServices.chainInfoMsecs;
@@ -24330,7 +24576,16 @@ var WhatsOnChainServices = class WhatsOnChainServices {
 		let update = chainInfo[this.chain] === void 0;
 		if (!update && chainInfoTime[this.chain] !== void 0) update = now.getTime() - chainInfoTime[this.chain].getTime() > chainInfoMsecs[this.chain];
 		if (update) {
-			chainInfo[this.chain] = await this.woc.getChainInfo();
+			let pending = WhatsOnChainServices.chainInfoPromise[this.chain];
+			if (pending == null) {
+				pending = this.woc.getChainInfo();
+				WhatsOnChainServices.chainInfoPromise[this.chain] = pending;
+			}
+			try {
+				chainInfo[this.chain] = await pending;
+			} finally {
+				if (WhatsOnChainServices.chainInfoPromise[this.chain] === pending) delete WhatsOnChainServices.chainInfoPromise[this.chain];
+			}
 			chainInfoTime[this.chain] = now;
 		}
 		if (!chainInfo[this.chain]) throw new Error("Unexpected failure to update chainInfo.");
@@ -24348,10 +24603,12 @@ var WhatsOnChainServices = class WhatsOnChainServices {
 	*/
 	async getHeaders(fetch) {
 		fetch ||= new ChaintracksFetch();
+		await this.waitForRateLimit();
 		return await fetch.fetchJson(`https://api.whatsonchain.com/v1/bsv/${this.chain}/block/headers`);
 	}
 	async getHeaderByteFileLinks(neededRange, fetch) {
 		fetch ||= new ChaintracksFetch();
+		await this.waitForRateLimit();
 		const files = await fetch.fetchJson(`https://api.whatsonchain.com/v1/bsv/${this.chain}/block/headers/resources`);
 		const r = [];
 		let range;
@@ -24364,6 +24621,21 @@ var WhatsOnChainServices = class WhatsOnChainServices {
 		}
 		return r;
 	}
+	async waitForRateLimit() {
+		let release;
+		const previous = WhatsOnChainServices.requestTail;
+		WhatsOnChainServices.requestTail = new Promise((resolve) => {
+			release = resolve;
+		});
+		await previous;
+		try {
+			const delay = Math.max(0, WhatsOnChainServices.nextRequestMsecs - Date.now());
+			if (delay > 0) await wait(delay);
+			WhatsOnChainServices.nextRequestMsecs = Date.now() + (this.options.minRequestIntervalMsecs ?? 350);
+		} finally {
+			release();
+		}
+	}
 };
 function wocGetHeadersHeaderToBlockHeader(h) {
 	const bits = typeof h.bits === "string" ? Number.parseInt(h.bits, 16) : h.bits;
@@ -24424,6 +24696,51 @@ var BulkIngestorWhatsOnChainCdn = class extends BulkIngestorBase {
 	}
 };
 //#endregion
+//#region ../src/services/chaintracker/chaintracks/Ingest/BulkIngestorChaintracks.ts
+/**
+* Uses a go-chaintracks/Arcade-compatible service as a validated bulk source.
+* Retrieved bytes still pass through ChainTracks' local serialization, hash,
+* continuity, and genesis checks before storage.
+*/
+var BulkIngestorChaintracks = class extends BulkIngestorBase {
+	chaintracks;
+	maxHeadersPerRequest;
+	networkChecked = false;
+	constructor(options) {
+		super(options);
+		this.chaintracks = options.chaintracks;
+		this.maxHeadersPerRequest = options.maxHeadersPerRequest ?? 1e3;
+		if (!Number.isInteger(this.maxHeadersPerRequest) || this.maxHeadersPerRequest < 1) throw new Error("maxHeadersPerRequest must be a positive integer.");
+	}
+	async getPresentHeight() {
+		await this.ensureNetwork();
+		return await this.chaintracks.getPresentHeight();
+	}
+	async fetchHeaders(_before, fetchRange, bulkRange, priorLiveHeaders) {
+		if (fetchRange.isEmpty) return priorLiveHeaders;
+		await this.ensureNetwork();
+		let liveHeaders = priorLiveHeaders;
+		let height = fetchRange.minHeight;
+		while (height <= fetchRange.maxHeight) {
+			const requested = Math.min(this.maxHeadersPerRequest, fetchRange.maxHeight - height + 1);
+			const bytes = asUint8Array(await this.chaintracks.getHeaders(height, requested));
+			if (bytes.length === 0) throw new Error(`ChainTracks upstream returned no headers at height ${height}.`);
+			if (bytes.length % 80 !== 0 || bytes.length > requested * 80) throw new Error(`ChainTracks upstream returned ${bytes.length} bytes for ${requested} headers at height ${height}.`);
+			const headers = deserializeBlockHeaders(height, bytes);
+			liveHeaders = await this.storage().addBulkHeaders(headers, bulkRange, liveHeaders);
+			height += headers.length;
+			if (headers.length < requested && height <= fetchRange.maxHeight) throw new Error(`ChainTracks upstream returned ${headers.length} of ${requested} headers at height ${height - headers.length}.`);
+		}
+		return liveHeaders;
+	}
+	async ensureNetwork() {
+		if (this.networkChecked) return;
+		const actual = await this.chaintracks.getChain();
+		if (actual !== this.chain) throw new Error(`ChainTracks upstream network '${actual}' does not match configured chain '${this.chain}'.`);
+		this.networkChecked = true;
+	}
+};
+//#endregion
 //#region ../src/services/chaintracker/chaintracks/Ingest/LiveIngestorWhatsOnChainPoll.ts
 /**
 * Reports new headers by polling periodically.
@@ -24530,9 +24847,17 @@ var LiveIngestorChaintracksSSE = class extends LiveIngestorBase {
 	}
 	async startListening(liveHeaders) {
 		this.stopped = false;
-		this.subscriptionId = await this.options.chaintracks.subscribeHeaders((header) => {
+		const actual = await this.options.chaintracks.getChain();
+		if (actual !== this.chain) throw new Error(`ChainTracks upstream network '${actual}' does not match configured chain '${this.chain}'.`);
+		if (this.stopped) return;
+		const subscriptionId = await this.options.chaintracks.subscribeHeaders((header) => {
 			if (!this.stopped) liveHeaders.push(header);
 		});
+		if (this.stopped) {
+			await this.options.chaintracks.unsubscribe(subscriptionId);
+			return;
+		}
+		this.subscriptionId = subscriptionId;
 		await new Promise((resolve) => {
 			this.resolveStopped = resolve;
 			if (this.stopped) resolve();
@@ -24545,7 +24870,9 @@ var LiveIngestorChaintracksSSE = class extends LiveIngestorBase {
 		if (subscriptionId != null) this.options.chaintracks.unsubscribe(subscriptionId).catch((e) => {
 			this.log(`LiveIngestorChaintracksSSE unsubscribe failed: ${e}`);
 		});
-		this.resolveStopped?.();
+		const resolveStopped = this.resolveStopped;
+		this.resolveStopped = void 0;
+		resolveStopped?.();
 	}
 	async shutdown() {
 		this.stopListening();
@@ -25241,6 +25568,27 @@ var ChaintracksStorageNoDb = class ChaintracksStorageNoDb extends ChaintracksSto
 		tipHeaderId: 0,
 		hashToHeaderId: /* @__PURE__ */ new Map()
 	};
+	static stnData = {
+		chain: "stn",
+		liveHeaders: /* @__PURE__ */ new Map(),
+		maxHeaderId: 0,
+		tipHeaderId: 0,
+		hashToHeaderId: /* @__PURE__ */ new Map()
+	};
+	static ttnData = {
+		chain: "ttn",
+		liveHeaders: /* @__PURE__ */ new Map(),
+		maxHeaderId: 0,
+		tipHeaderId: 0,
+		hashToHeaderId: /* @__PURE__ */ new Map()
+	};
+	static tstnData = {
+		chain: "tstn",
+		liveHeaders: /* @__PURE__ */ new Map(),
+		maxHeaderId: 0,
+		tipHeaderId: 0,
+		hashToHeaderId: /* @__PURE__ */ new Map()
+	};
 	constructor(options) {
 		super(options);
 	}
@@ -25248,10 +25596,11 @@ var ChaintracksStorageNoDb = class ChaintracksStorageNoDb extends ChaintracksSto
 	async getData() {
 		switch (this.chain) {
 			case "main": return ChaintracksStorageNoDb.mainData;
-			case "test":
-			case "ttn":
-			case "tstn": return ChaintracksStorageNoDb.testData;
-			default: throw new WERR_INVALID_PARAMETER("chain", `'main', 'test', 'ttn', or 'tstn'. '${this.chain}' is unsupported.`);
+			case "test": return ChaintracksStorageNoDb.testData;
+			case "stn": return ChaintracksStorageNoDb.stnData;
+			case "ttn": return ChaintracksStorageNoDb.ttnData;
+			case "tstn": return ChaintracksStorageNoDb.tstnData;
+			default: throw new WERR_INVALID_PARAMETER("chain", `'main', 'test', 'stn', 'ttn', or 'tstn'. '${this.chain}' is unsupported.`);
 		}
 	}
 	async deleteLiveBlockHeaders() {
@@ -25840,7 +26189,7 @@ var ChaintracksStorageIdb = class extends ChaintracksStorageBase {
 //#endregion
 //#region ../src/services/chaintracker/chaintracks/configureChaintracksIngestors.ts
 function resolveDefaultChaintracksArguments(args) {
-	const [chain, whatsonchainApiKey = "", maxPerFile = 1e5, maxRetained = 2, fetch = new ChaintracksFetch(), cdnUrl = "https://cdn.projectbabbage.com/blockheaders/", liveHeightThreshold = 2e3, reorgHeightThreshold = 400, bulkMigrationChunkSize = 500, batchInsertLimit = 400, addLiveRecursionLimit = 36] = args;
+	const [chain, whatsonchainApiKey = "", maxPerFile = 1e5, maxRetained = 2, fetch = new ChaintracksFetch(), cdnUrl = chain === "main" || chain === "test" ? "https://cdn.projectbabbage.com/blockheaders/" : "", liveHeightThreshold = 2e3, reorgHeightThreshold = 400, bulkMigrationChunkSize = 500, batchInsertLimit = 400, addLiveRecursionLimit = 36, sources = {}] = args;
 	return {
 		chain,
 		whatsonchainApiKey,
@@ -25852,11 +26201,12 @@ function resolveDefaultChaintracksArguments(args) {
 		reorgHeightThreshold,
 		bulkMigrationChunkSize,
 		batchInsertLimit,
-		addLiveRecursionLimit
+		addLiveRecursionLimit,
+		sources
 	};
 }
 function toDefaultChaintracksArguments(params) {
-	return [
+	const args = [
 		params.chain,
 		params.whatsonchainApiKey,
 		params.maxPerFile,
@@ -25869,6 +26219,8 @@ function toDefaultChaintracksArguments(params) {
 		params.batchInsertLimit,
 		params.addLiveRecursionLimit
 	];
+	if (Object.keys(params.sources).length > 0) args.push(params.sources);
+	return args;
 }
 function createDefaultBulkFileDataManager(params) {
 	return new BulkFileDataManager({
@@ -25911,7 +26263,7 @@ function createAndStartDefaultChaintracks(args, createOptions) {
 * The caller is responsible for providing the storage implementation.
 */
 function buildChaintracksOptionsWithIngestors(params, storage) {
-	const { chain, whatsonchainApiKey, maxPerFile, fetch, cdnUrl, addLiveRecursionLimit } = params;
+	const { chain, whatsonchainApiKey, maxPerFile, fetch, cdnUrl, addLiveRecursionLimit, sources } = params;
 	const co = {
 		chain,
 		storage,
@@ -25922,35 +26274,58 @@ function buildChaintracksOptionsWithIngestors(params, storage) {
 		readonly: false
 	};
 	const jsonResource = `${chain}NetBlockHeaders.json`;
-	const bulkCdnOptions = {
-		chain,
-		jsonResource,
-		fetch,
-		cdnUrl,
-		maxPerFile
-	};
-	co.bulkIngestors.push(new BulkIngestorCDNBabbage(bulkCdnOptions));
-	const wocOptions = {
-		chain,
-		apiKey: whatsonchainApiKey,
-		timeout: 3e4,
-		userAgent: "BabbageWhatsOnChainServices",
-		enableCache: true,
-		chainInfoMsecs: 5e3
-	};
-	const bulkOptions = {
-		...wocOptions,
-		jsonResource,
-		idleWait: 5e3
-	};
-	co.bulkIngestors.push(new BulkIngestorWhatsOnChainCdn(bulkOptions));
-	const liveOptions = {
-		...wocOptions,
-		idleWait: 1e5
-	};
-	co.liveIngestors.push(new LiveIngestorWhatsOnChainPoll(liveOptions));
+	if (!sources.disableCdn && cdnUrl !== "") {
+		const bulkCdnOptions = {
+			chain,
+			jsonResource,
+			fetch,
+			cdnUrl,
+			maxPerFile
+		};
+		co.bulkIngestors.push(new BulkIngestorCDNBabbage(bulkCdnOptions));
+	}
+	const chaintracksSource = sources.chaintracks ?? (sources.disableChaintracks ? void 0 : createPublicChaintracksSource(chain));
+	if (chaintracksSource != null) {
+		co.bulkIngestors.push(new BulkIngestorChaintracks({
+			chain,
+			jsonResource,
+			chaintracks: chaintracksSource,
+			maxHeadersPerRequest: sources.remoteMaxHeadersPerRequest
+		}));
+		co.liveIngestors.push(new LiveIngestorChaintracksSSE({
+			chain,
+			chaintracks: chaintracksSource
+		}));
+	}
+	if ((chain === "main" || chain === "test") && !sources.disableWhatsOnChain) {
+		const wocOptions = {
+			chain,
+			apiKey: whatsonchainApiKey,
+			timeout: 3e4,
+			userAgent: "BabbageWhatsOnChainServices",
+			enableCache: true,
+			chainInfoMsecs: 5e3
+		};
+		const bulkOptions = {
+			...wocOptions,
+			jsonResource,
+			idleWait: 5e3
+		};
+		co.bulkIngestors.push(new BulkIngestorWhatsOnChainCdn(bulkOptions));
+		const liveOptions = {
+			...wocOptions,
+			idleWait: 1e5
+		};
+		co.liveIngestors.push(new LiveIngestorWhatsOnChainPoll(liveOptions));
+	}
+	if (co.bulkIngestors.length === 0 || co.liveIngestors.length === 0) throw new Error(`ChainTracks ${chain} requires at least one bulk and live source. Configure sources.chaintracks for Teranode networks.`);
 	return co;
 }
+function createPublicChaintracksSource(chain) {
+	const serviceUrl = publicArcadeUrl(chain);
+	if (serviceUrl == null) return void 0;
+	return new GoChaintracksServiceClient(chain, serviceUrl, { apiPrefix: "/chaintracks/v2" });
+}
 //#endregion
 //#region ../src/services/chaintracker/chaintracks/createDefaultNoDbChaintracksOptions.ts
 function createDefaultNoDbChaintracksOptions(...args) {
@@ -34546,6 +34921,7 @@ exports.BulkFilesReaderStorage = BulkFilesReaderStorage;
 exports.BulkIngestorBase = BulkIngestorBase;
 exports.BulkIngestorCDN = BulkIngestorCDN;
 exports.BulkIngestorCDNBabbage = BulkIngestorCDNBabbage;
+exports.BulkIngestorChaintracks = BulkIngestorChaintracks;
 exports.BulkIngestorWhatsOnChainCdn = BulkIngestorWhatsOnChainCdn;
 exports.BulkStorageBase = BulkStorageBase;
 exports.CWIStyleWalletManager = CWIStyleWalletManager;
@@ -34624,7 +35000,12 @@ exports.asBsvSdkTx = asBsvSdkTx;
 exports.asString = asString;
 exports.asUint8Array = asUint8Array;
 exports.brc29ProtocolID = brc29ProtocolID;
+exports.buildChaintracksOptionsWithIngestors = buildChaintracksOptionsWithIngestors;
 exports.convertProofToMerklePath = convertProofToMerklePath;
+exports.createAndStartDefaultChaintracks = createAndStartDefaultChaintracks;
+exports.createDefaultBulkFileDataManager = createDefaultBulkFileDataManager;
+exports.createDefaultChaintracksClient = createDefaultChaintracksClient;
+exports.createDefaultChaintracksStorageOptions = createDefaultChaintracksStorageOptions;
 exports.createDefaultIdbChaintracksOptions = createDefaultIdbChaintracksOptions;
 exports.createDefaultNoDbChaintracksOptions = createDefaultNoDbChaintracksOptions;
 exports.createDefaultWalletServicesOptions = createDefaultWalletServicesOptions;
@@ -34666,6 +35047,7 @@ exports.partitionActionLabels = partitionActionLabels;
 exports.randomBytes = randomBytes;
 exports.randomBytesBase64 = randomBytesBase64;
 exports.randomBytesHex = randomBytesHex;
+exports.resolveDefaultChaintracksArguments = resolveDefaultChaintracksArguments;
 Object.defineProperty(exports, "sdk", {
 	enumerable: true,
 	get: function() {
@@ -34676,9 +35058,11 @@ exports.selectBulkHeaderFiles = selectBulkHeaderFiles;
 exports.sha256Hash = sha256Hash;
 exports.stampLog = stampLog;
 exports.stampLogFormat = stampLogFormat;
+exports.startChaintracks = startChaintracks;
 exports.tableAuthSessionToPeerSession = tableAuthSessionToPeerSession;
 exports.throwDummyReviewActions = throwDummyReviewActions;
 exports.toBinaryBaseBlockHeader = toBinaryBaseBlockHeader;
+exports.toDefaultChaintracksArguments = toDefaultChaintracksArguments;
 exports.toLookupNetworkPreset = toLookupNetworkPreset;
 exports.toWalletNetwork = toWalletNetwork;
 exports.transactionColumnsWithoutRawTx = transactionColumnsWithoutRawTx;