@pkcprotocol/pkc-js 0.0.73 → 0.0.75

package/dist/bundled/chunks/helia-for-pkc-DooZDxJi.js

@@ -1,495 +0,0 @@
-import { L as hideClassPrivateProps, R as ipnsNameToIpnsOverPubsubTopic, _r as PKCError, yr as logger_default } from "./schema-DMHTAMSM.js";
-import { a as fetchBlockWithStalledSessionFailover, i as directFetchIpnsRecordFromProviders, n as cacheIpnsRecordInPubsubLocalStore, o as getHeliaDebugContext, r as connectToPubsubPeers, s as selectBitswapSessionSeedPeers } from "./util-hdyyy-HI.js";
-import { CID } from "multiformats/cid";
-import { peerIdFromString } from "@libp2p/peer-id";
-import { EventEmitter as EventEmitter$1 } from "events";
-import { createHelia, libp2pDefaults } from "helia";
-import { ipns } from "@helia/ipns";
-import { multihashToIPNSRoutingKey, unmarshalIPNSRecord } from "ipns";
-import { ipnsValidator } from "ipns/validator";
-import { gossipsub } from "@libp2p/gossipsub";
-import { identify } from "@libp2p/identify";
-import { bitswap } from "@helia/block-brokers";
-import { MemoryBlockstore } from "blockstore-core";
-import { delegatedRoutingV1HttpApiClientContentRouting } from "@helia/delegated-routing-v1-http-api-client";
-import { NotFoundError } from "@libp2p/interface";
-import { unixfs } from "@helia/unixfs";
-import { fetch } from "@libp2p/fetch";
-import { pubsub } from "@helia/ipns/routing";
-//#region dist/node/runtime/node/libp2p-extra-transports.js
-const extraLibp2pTransports = [];
-//#endregion
-//#region dist/node/helia/libp2pjsClient.js
-var Libp2pJsClient = class {
-	/**
-	* The running Helia node backing this libp2p-js client — the public, semver-covered way for
-	* consumers that share the node (e.g. @bitsocial/pubsub-voting, bitsocial-seeder) to reach it,
-	* instead of the private `_helia` field (issue #221).
-	*
-	* The returned node is guaranteed to carry, in addition to Helia's own surface:
-	* - `libp2p.services.pubsub` — the gossipsub service registered at node construction
-	* - `libp2p.services.fetch` — the `@libp2p/fetch` service registered at node construction
-	* - `blockstore` — the node's block storage (bitswap-backed retrieval)
-	* - `libp2p.contentRouting` — the delegated-routing aggregation over `httpRoutersOptions`
-	*
-	* A breaking change to what this accessor returns is a breaking pkc-js release.
-	*/
-	get heliaNode() {
-		return this._helia;
-	}
-	constructor(libp2pJsClientOptions) {
-		this._helia = libp2pJsClientOptions.helia;
-		this._heliaUnixfs = libp2pJsClientOptions.heliaUnixfs;
-		this._heliaIpnsRouter = libp2pJsClientOptions.heliaIpnsRouter;
-		this.heliaWithKuboRpcClientFunctions = libp2pJsClientOptions.heliaWithKuboRpcClientFunctions;
-		this._libp2pJsClientsOptions = libp2pJsClientOptions.libp2pJsClientsOptions;
-		this._mergedHeliaOptions = libp2pJsClientOptions.mergedHeliaOptions;
-		this.key = libp2pJsClientOptions.key;
-		this.countOfUsesOfInstance = libp2pJsClientOptions.countOfUsesOfInstance;
-		hideClassPrivateProps(this);
-	}
-};
-//#endregion
-//#region dist/node/helia/dial-transport-filter.js
-const DENIED_DIAL_TRANSPORTS_BY_DEFAULT = [
-	"webrtc",
-	"webrtc-direct",
-	"webtransport"
-];
-function multiaddrUsesDeniedTransport(multiaddr) {
-	const componentNames = multiaddr.getComponents().map((component) => component.name);
-	return DENIED_DIAL_TRANSPORTS_BY_DEFAULT.some((deniedProto) => componentNames.includes(deniedProto));
-}
-function createDefaultDialTransportGater() {
-	return { denyDialMultiaddr: (multiaddr) => multiaddrUsesDeniedTransport(multiaddr) };
-}
-//#endregion
-//#region dist/node/helia/helia-for-pkc.js
-const log = logger_default("pkc-js:libp2p-js");
-const libp2pJsClients = {};
-const creatingLibp2pJsClients = {};
-const DELEGATED_ROUTING_CONCURRENT_REQUESTS = 32;
-function getDelegatedRoutingFields(routers) {
-	const routersObj = {};
-	for (let i = 0; i < routers.length; i++) {
-		const factory = delegatedRoutingV1HttpApiClientContentRouting({
-			url: routers[i],
-			concurrentRequests: DELEGATED_ROUTING_CONCURRENT_REQUESTS
-		});
-		routersObj["delegatedRouting" + i] = (components) => {
-			const routing = factory(components);
-			routing.get = async () => {
-				throw new NotFoundError("pkc HTTP routers do not serve IPNS records");
-			};
-			routing.put = async () => {};
-			const routerUrl = routers[i];
-			const originalFindProviders = routing.findProviders.bind(routing);
-			routing.findProviders = async function* (cid, options) {
-				try {
-					yield* originalFindProviders(cid, options);
-				} catch (e) {
-					log.trace("Content router", routerUrl, "errored during findProviders; treating it as returning no providers", e);
-				}
-			};
-			return routing;
-		};
-	}
-	return routersObj;
-}
-async function createLibp2pJsClientOrUseExistingOne(pkcOptions) {
-	if (!pkcOptions.httpRoutersOptions?.length) throw Error("You need to have pkc.httpRouterOptions to set up helia");
-	const existingClient = libp2pJsClients[pkcOptions.key];
-	if (existingClient) {
-		existingClient.countOfUsesOfInstance++;
-		return existingClient;
-	}
-	const creatingClientPromise = creatingLibp2pJsClients[pkcOptions.key];
-	if (creatingClientPromise) {
-		const client = await creatingClientPromise;
-		client.countOfUsesOfInstance++;
-		return client;
-	}
-	creatingLibp2pJsClients[pkcOptions.key] = (async () => {
-		const mergedHeliaInit = {
-			libp2p: {
-				addresses: { listen: [] },
-				peerDiscovery: void 0,
-				transports: [...libp2pDefaults().transports ?? [], ...extraLibp2pTransports],
-				connectionMonitor: { abortConnectionOnPingFailure: false },
-				connectionGater: createDefaultDialTransportGater(),
-				...pkcOptions.libp2pOptions,
-				services: {
-					identify: identify(),
-					pubsub: gossipsub(),
-					fetch: fetch(),
-					...getDelegatedRoutingFields(pkcOptions.httpRoutersOptions),
-					...pkcOptions.libp2pOptions?.services
-				}
-			},
-			blockstore: new MemoryBlockstore(),
-			blockBrokers: [bitswap()],
-			start: false,
-			...pkcOptions.heliaOptions
-		};
-		const helia = await createHelia(mergedHeliaInit);
-		helia.routing.routers = helia.routing.routers.filter((r) => r.constructor.name !== "HTTPGatewayRouter");
-		log("Initialized libp2pjs helia with key", pkcOptions.key, "peer id", helia.libp2p.peerId.toString());
-		const pubsubEventHandler = new EventEmitter$1();
-		helia.libp2p.services.pubsub.addEventListener("message", (evt) => {
-			log.trace(`Event from helia libp2p pubsub: on pubsub topic (string, e.g. community address) ${evt.detail.topic}`);
-			const msgFormatted = {
-				data: evt.detail.data,
-				topic: evt.detail.topic,
-				type: evt.detail.type
-			};
-			pubsubEventHandler.emit(evt.detail.topic, msgFormatted);
-		});
-		const heliaFs = unixfs(helia);
-		const asHeliaCatCid = (ipfsPathOrCid) => {
-			CID.parse(ipfsPathOrCid.split("/")[0]);
-			return ipfsPathOrCid;
-		};
-		const MAX_BITSWAP_SESSION_SEED_PEERS = 3;
-		const getBitswapSessionSeedPeers = (scopeIpnsPubsubTopic) => {
-			const pubsub = helia.libp2p.services.pubsub;
-			return selectBitswapSessionSeedPeers({
-				connectedPeers: helia.libp2p.getPeers(),
-				scopedPubsubSubscriberPeerIdStrings: scopeIpnsPubsubTopic ? pubsub.getSubscribers(scopeIpnsPubsubTopic).map(String) : [],
-				pubsubSubscriberPeerIdStrings: pubsub.getTopics().flatMap((topic) => pubsub.getSubscribers(topic).map(String)),
-				maxSeeds: MAX_BITSWAP_SESSION_SEED_PEERS
-			});
-		};
-		const KUBO_DURATION_UNIT_TO_MS = {
-			ns: 1e-6,
-			us: .001,
-			µs: .001,
-			ms: 1,
-			s: 1e3,
-			m: 6e4,
-			h: 36e5
-		};
-		const parseKuboStyleTimeoutMs = (timeout) => {
-			if (timeout === void 0 || timeout === null) return void 0;
-			if (typeof timeout === "number" && Number.isFinite(timeout) && timeout > 0) return timeout;
-			if (typeof timeout === "string") {
-				let totalMs = 0;
-				let matchedLength = 0;
-				for (const component of timeout.matchAll(/(\d+(?:\.\d+)?)(ns|us|µs|ms|s|m|h)/g)) {
-					totalMs += parseFloat(component[1]) * KUBO_DURATION_UNIT_TO_MS[component[2]];
-					matchedLength += component[0].length;
-				}
-				if (matchedLength === timeout.length && totalMs > 0) return totalMs;
-			}
-			throw new PKCError("ERR_INVALID_KUBO_STYLE_TIMEOUT", { invalidTimeout: timeout });
-		};
-		const SESSION_NO_PROVIDERS_RETRY_BASE_DELAY_MS = 500;
-		const isCausedByInsufficientProviders = (error) => {
-			if (!(error instanceof Error)) return false;
-			if (error.name === "InsufficientProvidersError") return true;
-			if (error instanceof AggregateError && error.errors.some(isCausedByInsufficientProviders)) return true;
-			return isCausedByInsufficientProviders(error.cause);
-		};
-		const delayAbortable = (ms, signal) => new Promise((resolve) => {
-			if (signal.aborted) return resolve();
-			const onAbort = () => {
-				clearTimeout(timer);
-				resolve();
-			};
-			const timer = setTimeout(() => {
-				signal.removeEventListener("abort", onAbort);
-				resolve();
-			}, ms);
-			signal.addEventListener("abort", onAbort, { once: true });
-		});
-		const ipnsPubsubRouter = pubsub(helia);
-		const ipnsPubsubLocalStore = ipnsPubsubRouter.localStore;
-		const ipnsNameResolver = ipns(helia, { routers: [ipnsPubsubRouter] });
-		ipnsNameResolver.routers = ipnsNameResolver.routers.filter((r) => r?.constructor?.name !== "LocalStoreRouting");
-		const WARMUP_MAX_PEERS = 4;
-		const warmupPromisesByTopic = /* @__PURE__ */ new Map();
-		const warmupForTopic = (topic, options) => {
-			if (helia.libp2p.services.pubsub.getSubscribers(topic).length > 0) return Promise.resolve();
-			const existing = warmupPromisesByTopic.get(topic);
-			if (existing) return existing;
-			const p = connectToPubsubPeers({
-				helia,
-				pubsubTopic: topic,
-				maxPeers: WARMUP_MAX_PEERS,
-				options,
-				log: logger_default("pkc-js:helia:pubsub:warmup")
-			}).then(() => void 0).finally(() => {
-				warmupPromisesByTopic.delete(topic);
-			});
-			warmupPromisesByTopic.set(topic, p);
-			return p;
-		};
-		const throwIfHeliaIsStoppingOrStopped = () => {
-			if (helia.libp2p.status === "stopped" || helia.libp2p.status === "stopping") throw new PKCError("ERR_HELIAS_STOPPING_OR_STOPPED", {
-				heliaKey: pkcOptions.key,
-				helia,
-				...getHeliaDebugContext(helia)
-			});
-		};
-		const heliaWithKuboRpcClientShape = {
-			name: { resolve: (ipnsName, options) => {
-				throwIfHeliaIsStoppingOrStopped();
-				async function* generator() {
-					const currentName = typeof ipnsName === "string" ? ipnsName : ipnsName.toString();
-					const ipnsNameAsPeerId = peerIdFromString(currentName);
-					log.trace("Resolving ipns name", currentName, "with options", options);
-					const ipnsPubsubTopic = ipnsNameToIpnsOverPubsubTopic(ipnsNameAsPeerId.toString());
-					const routingKey = multihashToIPNSRoutingKey(ipnsNameAsPeerId.toMultihash());
-					let directFetchOutcome = { attempted: false };
-					{
-						if (!helia.libp2p.services.pubsub.getTopics().includes(ipnsPubsubTopic)) helia.libp2p.services.pubsub.subscribe(ipnsPubsubTopic);
-						warmupForTopic(ipnsPubsubTopic, options).catch((e) => log.trace("Fire-and-forget warmup failed for", ipnsPubsubTopic, e));
-						const directStart = Date.now();
-						try {
-							const direct = await directFetchIpnsRecordFromProviders({
-								helia,
-								pubsubTopic: ipnsPubsubTopic,
-								routingKey,
-								maxPeers: WARMUP_MAX_PEERS,
-								validate: ipnsValidator,
-								options,
-								log: logger_default("pkc-js:helia:ipns:direct-fetch")
-							});
-							if (direct) {
-								directFetchOutcome = {
-									attempted: true,
-									hit: true,
-									durationMs: direct.durationMs,
-									source: direct.source,
-									peerId: direct.peerId
-								};
-								const record = unmarshalIPNSRecord(direct.recordBytes);
-								try {
-									await cacheIpnsRecordInPubsubLocalStore({
-										localStore: ipnsPubsubLocalStore,
-										routingKey,
-										marshalledRecord: direct.recordBytes
-									});
-								} catch (cacheErr) {
-									log.trace("Failed to cache direct-fetched IPNS record at the pubsub routing layer for", ipnsPubsubTopic, cacheErr);
-								}
-								yield record.value;
-								return;
-							}
-							directFetchOutcome = {
-								attempted: true,
-								hit: false,
-								durationMs: Date.now() - directStart
-							};
-						} catch (directErr) {
-							if (options?.signal?.aborted) throw directErr;
-							directFetchOutcome = {
-								attempted: true,
-								hit: false,
-								durationMs: Date.now() - directStart,
-								error: directErr
-							};
-							log.trace("Direct IPNS fetch path errored for", ipnsPubsubTopic, directErr);
-						}
-					}
-					let warmupOutcome = { attempted: false };
-					if (helia.libp2p.services.pubsub.getSubscribers(ipnsPubsubTopic).length === 0) {
-						const warmupStart = Date.now();
-						try {
-							await warmupForTopic(ipnsPubsubTopic, options);
-							warmupOutcome = {
-								attempted: true,
-								durationMs: Date.now() - warmupStart,
-								subscribersAfterWarmup: helia.libp2p.services.pubsub.getSubscribers(ipnsPubsubTopic).length
-							};
-						} catch (warmupErr) {
-							warmupOutcome = {
-								attempted: true,
-								durationMs: Date.now() - warmupStart,
-								error: warmupErr
-							};
-							log.error("Pre-resolve peer warmup failed for", ipnsPubsubTopic, warmupErr);
-						}
-					}
-					let recordBytes;
-					const routerErrors = [];
-					for (const router of ipnsNameResolver.routers) try {
-						const got = await router.get(routingKey, {
-							...options,
-							validate: false
-						});
-						if (got) {
-							recordBytes = got;
-							break;
-						}
-					} catch (err) {
-						routerErrors.push(err);
-					}
-					if (!recordBytes) throw new PKCError("ERR_RESOLVED_IPNS_P2P_TO_UNDEFINED", {
-						ipnsName,
-						currentName,
-						ipnsPubsubTopic,
-						ipnsResolveOptions: options,
-						directFetchOutcome,
-						warmupOutcome,
-						routerErrors,
-						subscribersAtResolveTime: helia.libp2p.services.pubsub.getSubscribers(ipnsPubsubTopic).length,
-						httpRouters: pkcOptions.httpRoutersOptions,
-						...getHeliaDebugContext(helia)
-					});
-					await ipnsValidator(routingKey, recordBytes);
-					yield unmarshalIPNSRecord(recordBytes).value;
-				}
-				return generator();
-			} },
-			cat(ipfsPath, options) {
-				throwIfHeliaIsStoppingOrStopped();
-				const rootCid = CID.parse(ipfsPath.split("/")[0]);
-				const timeoutMs = parseKuboStyleTimeoutMs(options?.timeout);
-				const { bitswapSessionSeedScopeIpnsPubsubTopic, ...unixfsCatOptions } = options ?? {};
-				return (async function* () {
-					const controller = new AbortController();
-					const callerSignal = options?.signal;
-					const abortFromCallerSignal = () => controller.abort(callerSignal?.reason);
-					if (callerSignal?.aborted) abortFromCallerSignal();
-					else callerSignal?.addEventListener("abort", abortFromCallerSignal, { once: true });
-					const timeoutTimer = timeoutMs !== void 0 ? setTimeout(() => controller.abort(new PKCError("ERR_FETCH_CID_P2P_TIMEOUT", {
-						ipfsPath,
-						timeoutMs
-					})), timeoutMs) : void 0;
-					try {
-						for (let attempt = 0;; attempt++) {
-							const session = helia.blockstore.createSession(rootCid, { providers: getBitswapSessionSeedPeers(bitswapSessionSeedScopeIpnsPubsubTopic) });
-							const sessionGet = session.get.bind(session);
-							const fallbackGet = helia.blockstore.get.bind(helia.blockstore);
-							session.get = (blockCid, blockGetOptions) => fetchBlockWithStalledSessionFailover({
-								cid: blockCid,
-								sessionGet,
-								fallbackGet,
-								stallTimeoutMs: heliaWithKuboRpcClientShape._bitswapSessionStalledGetFailoverMs ?? 2500,
-								options: blockGetOptions,
-								log
-							});
-							let yieldedAnyBytes = false;
-							try {
-								const catIterable = unixfs({ blockstore: session }).cat(asHeliaCatCid(ipfsPath), {
-									...unixfsCatOptions,
-									signal: controller.signal
-								});
-								for await (const chunk of catIterable) {
-									yieldedAnyBytes = true;
-									yield chunk;
-								}
-								return;
-							} catch (catError) {
-								if (controller.signal.aborted) throw controller.signal.reason instanceof Error ? controller.signal.reason : catError;
-								if (yieldedAnyBytes || !isCausedByInsufficientProviders(catError)) throw catError;
-								log.trace("Bitswap session found no providers for", ipfsPath, "- retrying, attempt", attempt + 1);
-							} finally {
-								session.close();
-							}
-							await delayAbortable(Math.min(SESSION_NO_PROVIDERS_RETRY_BASE_DELAY_MS * 2 ** attempt, 8e3), controller.signal);
-							if (controller.signal.aborted) {
-								if (controller.signal.reason instanceof Error) throw controller.signal.reason;
-								throw new PKCError("ERR_FETCH_CID_P2P_TIMEOUT", {
-									ipfsPath,
-									timeoutMs
-								});
-							}
-						}
-					} finally {
-						if (timeoutTimer !== void 0) clearTimeout(timeoutTimer);
-						callerSignal?.removeEventListener("abort", abortFromCallerSignal);
-					}
-				})();
-			},
-			pubsub: {
-				ls: async () => helia.libp2p.services.pubsub.getTopics(),
-				peers: async (topic, options) => helia.libp2p.services.pubsub.getSubscribers(topic),
-				publish: async (topic, data, options) => {
-					throwIfHeliaIsStoppingOrStopped();
-					const wasAlreadySubscribed = helia.libp2p.services.pubsub.getTopics().includes(topic);
-					if (!wasAlreadySubscribed) helia.libp2p.services.pubsub.subscribe(topic);
-					try {
-						await warmupForTopic(topic, options);
-						log("Published new data to pubsub topic (string, e.g. community address)", topic, "Direct gossipsub recipients (libp2p peer IDs, NOT signer/community addresses):", (await helia.libp2p.services.pubsub.publish(topic, data)).recipients.map((p) => p.toString()));
-					} finally {
-						if (!wasAlreadySubscribed) helia.libp2p.services.pubsub.unsubscribe(topic);
-					}
-				},
-				subscribe: async (topic, handler, options) => {
-					throwIfHeliaIsStoppingOrStopped();
-					pubsubEventHandler.on(topic, handler);
-					const warmupPromise = warmupForTopic(topic, options);
-					helia.libp2p.services.pubsub.subscribe(topic);
-					await warmupPromise;
-				},
-				unsubscribe: async (topic, handler, options) => {
-					throwIfHeliaIsStoppingOrStopped();
-					pubsubEventHandler.removeListener(topic, handler);
-					if (pubsubEventHandler.listenerCount(topic) === 0) helia.libp2p.services.pubsub.unsubscribe(topic);
-				}
-			},
-			async add(entry, options) {
-				throw Error("Helia 'add' is not supported at the moment in pkc-js API");
-			},
-			async stop(options) {
-				const clientFromMap = libp2pJsClients[pkcOptions.key];
-				if (!clientFromMap) return;
-				if (clientFromMap.countOfUsesOfInstance <= 0) return;
-				clientFromMap.countOfUsesOfInstance--;
-				if (clientFromMap.countOfUsesOfInstance === 0) {
-					delete libp2pJsClients[pkcOptions.key];
-					for (const router of ipnsNameResolver.routers) {
-						const lifecycle = router;
-						if (typeof lifecycle.stop === "function") try {
-							await lifecycle.stop();
-						} catch (e) {
-							log.error("Error stopping IPNS router", router?.constructor?.name, e);
-						}
-					}
-					for (const topic of helia.libp2p.services.pubsub.getTopics()) helia.libp2p.services.pubsub.unsubscribe(topic);
-					for (const connection of helia.libp2p.getConnections()) try {
-						connection.abort(/* @__PURE__ */ new Error("pkc-js libp2p instance is stopping"));
-					} catch (e) {
-						log.error("Error aborting libp2p connection during stop", e);
-					}
-					try {
-						await helia.stop();
-					} catch (e) {
-						log.error("Error stopping helia", e);
-					}
-					log("Helia/libp2p-js stopped with key", pkcOptions.key, "and peer id", helia.libp2p.peerId.toString());
-				}
-			}
-		};
-		const originalSubscribe = helia.libp2p.services.pubsub.subscribe.bind(helia.libp2p.services.pubsub);
-		helia.libp2p.services.pubsub.subscribe = (topic) => {
-			throwIfHeliaIsStoppingOrStopped();
-			warmupForTopic(topic).catch((err) => log.error("warmup failed for topic", topic, err));
-			originalSubscribe(topic);
-		};
-		const client = new Libp2pJsClient({
-			helia,
-			heliaWithKuboRpcClientFunctions: heliaWithKuboRpcClientShape,
-			heliaUnixfs: heliaFs,
-			heliaIpnsRouter: ipnsNameResolver,
-			mergedHeliaOptions: mergedHeliaInit,
-			countOfUsesOfInstance: 1,
-			libp2pJsClientsOptions: pkcOptions,
-			key: pkcOptions.key
-		});
-		await helia.start();
-		log("Helia/libp2p-js started with key", pkcOptions.key, "and peer id", helia.libp2p.peerId.toString());
-		libp2pJsClients[pkcOptions.key] = client;
-		return client;
-	})();
-	const createdClientPromise = creatingLibp2pJsClients[pkcOptions.key];
-	if (!createdClientPromise) throw new Error("Missing creation promise after initialization");
-	try {
-		return await createdClientPromise;
-	} finally {
-		delete creatingLibp2pJsClients[pkcOptions.key];
-	}
-}
-//#endregion
-export { createLibp2pJsClientOrUseExistingOne };