@hashtree/worker 0.1.26 → 0.2.1

package/src/capabilities/blossomTransport.ts

@@ -0,0 +1,179 @@
+import {
+  BlossomStore,
+  type BlossomSigner,
+  type BlossomUploadCallback,
+  fromHex,
+} from '@hashtree/core';
+import { finalizeEvent, generateSecretKey } from 'nostr-tools/pure';
+import type { BlossomServerConfig } from '../protocol.js';
+import {
+  BlossomBandwidthTracker,
+  type BlossomBandwidthStats,
+  type BlossomBandwidthUpdateHandler,
+} from './blossomBandwidthTracker.js';
+
+export const DEFAULT_BLOSSOM_SERVERS: BlossomServerConfig[] = [];
+
+const MAX_CONCURRENT_READ_FETCHES = 12;
+
+let activeReadFetches = 0;
+const pendingReadFetchWaiters: Array<() => void> = [];
+
+export type {
+  BlossomBandwidthServerStats,
+  BlossomBandwidthStats,
+  BlossomBandwidthUpdateHandler,
+} from './blossomBandwidthTracker.js';
+
+function normalizeServerUrl(url: string): string {
+  return url.replace(/\/+$/, '');
+}
+
+function normalizeServers(servers: BlossomServerConfig[] | undefined): BlossomServerConfig[] {
+  const source = servers && servers.length > 0 ? servers : DEFAULT_BLOSSOM_SERVERS;
+  const unique = new Map<string, BlossomServerConfig>();
+  for (const server of source) {
+    const url = normalizeServerUrl(server.url.trim());
+    if (!url) continue;
+    unique.set(url, {
+      url,
+      read: server.read ?? true,
+      write: server.write ?? false,
+    });
+  }
+  return Array.from(unique.values());
+}
+
+function createEphemeralSigner(): BlossomSigner {
+  const secretKey = generateSecretKey();
+  return async (template) => {
+    const event = finalizeEvent({
+      ...template,
+      kind: template.kind as 24242,
+      created_at: template.created_at,
+      content: template.content,
+      tags: template.tags,
+    }, secretKey);
+    return {
+      kind: event.kind,
+      created_at: event.created_at,
+      content: event.content,
+      tags: event.tags,
+      pubkey: event.pubkey,
+      id: event.id,
+      sig: event.sig,
+    };
+  };
+}
+
+function releaseReadFetchSlot(): void {
+  activeReadFetches = Math.max(0, activeReadFetches - 1);
+  pendingReadFetchWaiters.shift()?.();
+}
+
+function withReadFetchSlot<T>(loader: () => Promise<T>): Promise<T> {
+  return new Promise<T>((resolve, reject) => {
+    const start = () => {
+      activeReadFetches += 1;
+      let pending: Promise<T>;
+      try {
+        pending = loader();
+      } catch (error) {
+        releaseReadFetchSlot();
+        reject(error);
+        return;
+      }
+
+      pending
+        .then(resolve, reject)
+        .finally(() => {
+          releaseReadFetchSlot();
+        });
+    };
+
+    if (activeReadFetches < MAX_CONCURRENT_READ_FETCHES) {
+      start();
+      return;
+    }
+
+    pendingReadFetchWaiters.push(start);
+  });
+}
+
+export class BlossomTransport {
+  private servers: BlossomServerConfig[];
+  private readonly signer: BlossomSigner;
+  private readonly bandwidthTracker: BlossomBandwidthTracker;
+  private readonly inflightFetches = new Map<string, Promise<Uint8Array | null>>();
+  private store: BlossomStore;
+
+  constructor(servers?: BlossomServerConfig[], onBandwidthUpdate?: BlossomBandwidthUpdateHandler) {
+    this.servers = normalizeServers(servers);
+    this.signer = createEphemeralSigner();
+    this.bandwidthTracker = new BlossomBandwidthTracker(onBandwidthUpdate);
+    this.store = this.createStore(this.servers);
+  }
+
+  setServers(servers: BlossomServerConfig[]): void {
+    this.servers = normalizeServers(servers);
+    this.store = this.createStore(this.servers);
+  }
+
+  getServers(): BlossomServerConfig[] {
+    return this.servers;
+  }
+
+  getWriteServers(): BlossomServerConfig[] {
+    return this.servers.filter(server => !!server.write);
+  }
+
+  getBandwidthStats(): BlossomBandwidthStats {
+    return this.bandwidthTracker.getStats();
+  }
+
+  private createStore(servers: BlossomServerConfig[], onUploadProgress?: BlossomUploadCallback): BlossomStore {
+    return new BlossomStore({
+      servers,
+      signer: this.signer,
+      onUploadProgress,
+      logger: (entry) => {
+        this.bandwidthTracker.apply(entry);
+      },
+    });
+  }
+
+  createUploadStore(onUploadProgress?: BlossomUploadCallback): BlossomStore {
+    return this.createStore(this.servers, onUploadProgress);
+  }
+
+  async upload(
+    hashHex: string,
+    data: Uint8Array,
+    _mimeType?: string,
+    onUploadProgress?: BlossomUploadCallback
+  ): Promise<void> {
+    if (!this.servers.some(server => server.write)) return;
+    const uploadMimeType = 'application/octet-stream';
+    if (onUploadProgress) {
+      const store = this.createStore(this.servers, onUploadProgress);
+      await store.put(fromHex(hashHex), data, uploadMimeType);
+      return;
+    }
+
+    await this.store.put(fromHex(hashHex), data, uploadMimeType);
+  }
+
+  async fetch(hashHex: string): Promise<Uint8Array | null> {
+    const inflight = this.inflightFetches.get(hashHex);
+    if (inflight) {
+      return inflight;
+    }
+
+    const pending = withReadFetchSlot(() => this.store.get(fromHex(hashHex)))
+      .finally(() => {
+        this.inflightFetches.delete(hashHex);
+      });
+    this.inflightFetches.set(hashHex, pending);
+    return await pending;
+  }
+}

package/src/capabilities/connectivity.ts

@@ -0,0 +1,54 @@
+import type { BlossomServerConfig, ConnectivityState } from '../protocol.js';
+
+const PROBE_TIMEOUT_MS = 3500;
+const DUMMY_HASH = '0000000000000000000000000000000000000000000000000000000000000000';
+
+function stripTrailingSlash(url: string): string {
+  return url.replace(/\/+$/, '');
+}
+
+async function probe(url: string): Promise<boolean> {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS);
+  try {
+    const res = await fetch(url, {
+      method: 'HEAD',
+      // Connectivity checks should not fail just because cross-origin response
+      // headers are restricted. If the fetch resolves in no-cors mode, the
+      // endpoint is reachable.
+      mode: 'no-cors',
+      signal: controller.signal,
+      cache: 'no-store',
+    });
+    if (res.type === 'opaque') {
+      return true;
+    }
+    return res.status >= 100;
+  } catch {
+    return false;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+export async function probeConnectivity(servers: BlossomServerConfig[]): Promise<ConnectivityState> {
+  const readServers = servers.filter(server => server.read !== false);
+  const writeServers = servers.filter(server => server.write);
+
+  const [readResults, writeResults] = await Promise.all([
+    Promise.all(readServers.map(server => probe(`${stripTrailingSlash(server.url)}/${DUMMY_HASH}.bin`))),
+    Promise.all(writeServers.map(server => probe(`${stripTrailingSlash(server.url)}/upload`))),
+  ]);
+
+  const reachableReadServers = readResults.filter(Boolean).length;
+  const reachableWriteServers = writeResults.filter(Boolean).length;
+
+  return {
+    online: typeof navigator === 'undefined' ? true : navigator.onLine,
+    reachableReadServers,
+    totalReadServers: readServers.length,
+    reachableWriteServers,
+    totalWriteServers: writeServers.length,
+    updatedAt: Date.now(),
+  };
+}

package/src/capabilities/idbStorage.ts

@@ -0,0 +1,94 @@
+import { fromHex, sha256, toHex } from '@hashtree/core';
+import { DexieStore } from '@hashtree/dexie';
+
+export interface StorageStats {
+  items: number;
+  bytes: number;
+  maxBytes: number;
+}
+
+export class IdbBlobStorage {
+  private readonly store: DexieStore;
+  private maxBytes: number;
+  private writesSinceEviction = 0;
+  private evictionPromise: Promise<void> | null = null;
+
+  private static readonly EVICTION_WRITE_INTERVAL = 32;
+
+  constructor(dbName: string, maxBytes: number) {
+    this.store = new DexieStore(dbName);
+    this.maxBytes = maxBytes;
+  }
+
+  setMaxBytes(maxBytes: number): void {
+    this.maxBytes = maxBytes;
+  }
+
+  getMaxBytes(): number {
+    return this.maxBytes;
+  }
+
+  async put(data: Uint8Array): Promise<string> {
+    const hashHex = toHex(await sha256(data));
+    await this.store.put(fromHex(hashHex), data);
+    void this.scheduleEviction();
+    return hashHex;
+  }
+
+  async putByHash(hashHex: string, data: Uint8Array): Promise<void> {
+    const computed = toHex(await sha256(data));
+    if (computed !== hashHex) {
+      throw new Error('Hash mismatch while caching fetched blob');
+    }
+    await this.store.put(fromHex(hashHex), data);
+    void this.scheduleEviction();
+  }
+
+  async putByHashTrusted(hashHex: string, data: Uint8Array): Promise<void> {
+    await this.store.put(fromHex(hashHex), data);
+    void this.scheduleEviction();
+  }
+
+  async get(hashHex: string): Promise<Uint8Array | null> {
+    return this.store.get(fromHex(hashHex));
+  }
+
+  async has(hashHex: string): Promise<boolean> {
+    return this.store.has(fromHex(hashHex));
+  }
+
+  async delete(hashHex: string): Promise<boolean> {
+    return this.store.delete(fromHex(hashHex));
+  }
+
+  async getStats(): Promise<StorageStats> {
+    const [items, bytes] = await Promise.all([
+      this.store.count(),
+      this.store.totalBytes(),
+    ]);
+    return { items, bytes, maxBytes: this.maxBytes };
+  }
+
+  close(): void {
+    this.store.close();
+  }
+
+  private scheduleEviction(): void {
+    this.writesSinceEviction += 1;
+    if (this.writesSinceEviction < IdbBlobStorage.EVICTION_WRITE_INTERVAL) {
+      return;
+    }
+    this.writesSinceEviction = 0;
+
+    if (this.evictionPromise) {
+      return;
+    }
+
+    this.evictionPromise = this.store
+      .evict(this.maxBytes)
+      .then(() => {})
+      .finally(() => {
+        this.evictionPromise = null;
+      });
+  }
+}