applesauce-loaders 0.10.0 → 0.12.0

package/dist/loaders/dns-identity-loader.js

@@ -0,0 +1,66 @@
+import { unixNow } from "applesauce-core/helpers";
+import { getIdentitiesFromJson, IdentityStatus, normalizeIdentityJson, } from "../helpers/dns-identity.js";
+export class DnsIdentityLoader {
+    cache;
+    identities = new Map();
+    /** The fetch implementation this class should use */
+    fetch = fetch;
+    /** How long an identity should be kept until its considered expired (in seconds) defaults to 1 week */
+    expiration = 60 * 60 * 24 * 7;
+    constructor(cache) {
+        this.cache = cache;
+    }
+    /** Makes an http request to fetch an identity */
+    async fetchIdentity(name, domain) {
+        const { fetch } = this;
+        const checked = unixNow();
+        try {
+            const res = await fetch(`https://${domain}/.well-known/nostr.json?name=${name}`, { redirect: "manual" });
+            if (res.status !== 200)
+                throw Error("Wrong response code");
+            const json = await res.json().then(normalizeIdentityJson);
+            const identities = getIdentitiesFromJson(domain, json, checked);
+            // save all identities to cache
+            if (this.cache && Object.values(identities).length > 0)
+                this.cache.save(identities);
+            for (const [address, identity] of Object.entries(identities))
+                this.identities.set(address, identity);
+            return identities[name + "@" + domain] || { name, domain, checked, status: IdentityStatus.Missing };
+        }
+        catch (error) {
+            if (error instanceof Error)
+                return { name, domain, checked, status: IdentityStatus.Error, error: error.message };
+            else
+                return { name, domain, checked, status: IdentityStatus.Error, error: "Unknown" };
+        }
+    }
+    /** Loads an identity from the cache or fetches it */
+    async loadIdentity(name, domain) {
+        let identity;
+        if (this.cache)
+            identity = await this.cache.load(name + "@" + domain);
+        // fetch the identity if its not in cache, or if its expired
+        if (!identity || unixNow() - identity.checked > this.expiration)
+            return await this.fetchIdentity(name, domain);
+        else
+            return identity;
+    }
+    requesting = new Map();
+    /** Requests an identity to be loaded */
+    requestIdentity(name, domain) {
+        const key = name + "@" + domain;
+        let existing = this.identities.get(key);
+        if (existing)
+            return Promise.resolve(existing);
+        let ongoing = this.requesting.get(key);
+        if (!ongoing) {
+            ongoing = this.loadIdentity(name, domain);
+            this.requesting.set(key, ongoing);
+        }
+        return ongoing;
+    }
+    /** Checks if an identity is loaded */
+    getIdentity(name, domain) {
+        return this.identities.get(name + "@" + domain);
+    }
+}

package/dist/loaders/index.d.ts

@@ -1,3 +1,10 @@
 export * from "./loader.js";
 export * from "./replaceable-loader.js";
-export * from "./single-relay-replaceable-loader.js";
+export * from "./single-event-loader.js";
+export * from "./user-sets-loader.js";
+export * from "./timeline-loader.js";
+export * from "./relay-timeline-loader.js";
+export * from "./cache-timeline-loader.js";
+export * from "./tag-value-loader.js";
+export * from "./request-loader.js";
+export * from "./dns-identity-loader.js";

package/dist/loaders/index.js

@@ -1,3 +1,10 @@
 export * from "./loader.js";
 export * from "./replaceable-loader.js";
-export * from "./single-relay-replaceable-loader.js";
+export * from "./single-event-loader.js";
+export * from "./user-sets-loader.js";
+export * from "./timeline-loader.js";
+export * from "./relay-timeline-loader.js";
+export * from "./cache-timeline-loader.js";
+export * from "./tag-value-loader.js";
+export * from "./request-loader.js";
+export * from "./dns-identity-loader.js";

package/dist/loaders/loader.d.ts

@@ -1,14 +1,20 @@
-import { Observable, OperatorFunction, Subject, Subscribable } from "rxjs";
+import { Filter, NostrEvent } from "nostr-tools";
+import { InteropObservable, Observable, OperatorFunction, Subject, Subscribable } from "rxjs";
+export type RelayFilterMap<T = Filter> = {
+    [relay: string]: T[];
+};
+export type CacheRequest = (filters: Filter[]) => Observable<NostrEvent>;
 export interface ILoader<T, R> extends Subscribable<R> {
     next: (value: T) => void;
     pipe: Observable<R>["pipe"];
 }
 /** Base loader class */
-export declare class Loader<T, R> implements ILoader<T, R> {
-    protected subject: Subject<T>;
-    protected observable: Observable<R>;
-    pipe: Observable<R>["pipe"];
-    subscribe: Observable<R>["subscribe"];
-    constructor(transform: OperatorFunction<T, R>);
-    next(value: T): void;
+export declare class Loader<Input, Output> implements ILoader<Input, Output>, InteropObservable<Output> {
+    protected subject: Subject<Input>;
+    observable: Observable<Output>;
+    pipe: Observable<Output>["pipe"];
+    subscribe: Observable<Output>["subscribe"];
+    constructor(transform: OperatorFunction<Input, Output>);
+    next(value: Input): void;
+    [Symbol.observable](): Observable<Output>;
 }

package/dist/loaders/loader.js

@@ -1,4 +1,4 @@
-import { Subject } from "rxjs";
+import { share, Subject } from "rxjs";
 /** Base loader class */
 export class Loader {
     subject = new Subject();
@@ -6,7 +6,9 @@ export class Loader {
     pipe;
     subscribe;
     constructor(transform) {
-        this.observable = this.subject.pipe(transform);
+        this.observable = this.subject.pipe(transform, 
+        // only create a single instance of the transformer
+        share());
         // copy pipe function
         this.pipe = this.observable.pipe.bind(this.observable);
         this.subscribe = this.observable.subscribe.bind(this.observable);
@@ -14,4 +16,7 @@ export class Loader {
     next(value) {
         this.subject.next(value);
     }
+    [Symbol.observable]() {
+        return this.observable;
+    }
 }

package/dist/loaders/relay-timeline-loader.d.ts

@@ -0,0 +1,24 @@
+import { EventPacket, RxNostr } from "rx-nostr";
+import { BehaviorSubject } from "rxjs";
+import { logger } from "applesauce-core";
+import { Filter } from "nostr-tools";
+import { Loader } from "./loader.js";
+export type TimelessFilter = Omit<Filter, "since" | "until">;
+export type RelayTimelineLoaderOptions = {
+    /** default number of events to request in each batch */
+    limit?: number;
+};
+/** A loader that can be used to load a timeline in chunks */
+export declare class RelayTimelineLoader extends Loader<number | void, EventPacket> {
+    relay: string;
+    filters: TimelessFilter[];
+    id: string;
+    loading$: BehaviorSubject<boolean>;
+    get loading(): boolean;
+    /** current "until" timestamp */
+    cursor: number;
+    /** if the timeline is complete */
+    complete: boolean;
+    protected log: typeof logger;
+    constructor(rxNostr: RxNostr, relay: string, filters: TimelessFilter[], opts?: RelayTimelineLoaderOptions);
+}

package/dist/loaders/relay-timeline-loader.js

@@ -0,0 +1,70 @@
+import { createRxOneshotReq } from "rx-nostr";
+import { BehaviorSubject, filter, map, Observable } from "rxjs";
+import { logger } from "applesauce-core";
+import { nanoid } from "nanoid";
+import { unixNow } from "applesauce-core/helpers";
+import { Loader } from "./loader.js";
+/** A loader that can be used to load a timeline in chunks */
+export class RelayTimelineLoader extends Loader {
+    relay;
+    filters;
+    id = nanoid(8);
+    loading$ = new BehaviorSubject(false);
+    get loading() {
+        return this.loading$.value;
+    }
+    /** current "until" timestamp */
+    cursor = Infinity;
+    /** if the timeline is complete */
+    complete = false;
+    log = logger.extend("RelayTimelineLoader");
+    constructor(rxNostr, relay, filters, opts) {
+        super((source) => new Observable((observer) => {
+            return source
+                .pipe(filter(() => !this.loading && !this.complete), map((limit) => {
+                // build next batch filters
+                return filters.map((filter) => ({
+                    limit: limit || opts?.limit,
+                    ...filter,
+                    // limit curser to now
+                    until: Math.min(unixNow(), this.cursor),
+                }));
+            }), 
+            // ignore empty filters
+            filter((filters) => filters.length > 0))
+                .subscribe((filters) => {
+                // make batch request
+                let count = 0;
+                const req = createRxOneshotReq({ filters, rxReqId: this.id });
+                this.loading$.next(true);
+                this.log(`Next batch starting at ${filters[0].until} limit ${filters[0].limit}`);
+                rxNostr.use(req, { on: { relays: [relay] } }).subscribe({
+                    next: (packet) => {
+                        // update cursor when event is received
+                        this.cursor = Math.min(packet.event.created_at - 1, this.cursor);
+                        count++;
+                        // forward packet
+                        observer.next(packet);
+                    },
+                    error: (err) => observer.error(err),
+                    complete: () => {
+                        // set loading to false when batch completes
+                        this.loading$.next(false);
+                        // set complete the observable if 0 events where returned
+                        if (count === 0) {
+                            observer.complete();
+                            this.log(`Got ${count} event, Complete`);
+                        }
+                        else {
+                            this.log(`Finished batch, got ${count} events`);
+                        }
+                    },
+                });
+            });
+        }));
+        this.relay = relay;
+        this.filters = filters;
+        // create a unique logger for this instance
+        this.log = this.log.extend(relay);
+    }
+}

package/dist/loaders/replaceable-loader.d.ts

@@ -1,31 +1,23 @@
-import { Observable } from "rxjs";
 import { EventPacket, RxNostr } from "rx-nostr";
-import { Filter, NostrEvent } from "nostr-tools";
 import { logger } from "applesauce-core";
-import { Loader } from "./loader.js";
-export type LoadableAddressPointer = {
-    kind: number;
-    pubkey: string;
-    /** Optional "d" tag for paramaritized replaceable */
-    identifier?: string;
-    /** Relays to load from */
-    relays?: string[];
-    /** Load this address pointer even if it has already been loaded */
-    force?: boolean;
-};
-export type CacheRequest = (filters: Filter[]) => Observable<NostrEvent>;
+import { CacheRequest, Loader } from "./loader.js";
+import { LoadableAddressPointer } from "../helpers/address-pointer.js";
 export type ReplaceableLoaderOptions = {
     /**
      * Time interval to buffer requests in ms
      * @default 1000
      */
     bufferTime?: number;
-    /** Request events from the cache first */
+    /** A method used to load events from a local cache */
     cacheRequest?: CacheRequest;
     /** Fallback lookup relays to check when event cant be found */
     lookupRelays?: string[];
 };
 export declare class ReplaceableLoader extends Loader<LoadableAddressPointer, EventPacket> {
     log: typeof logger;
+    /** A method used to load events from a local cache */
+    cacheRequest?: CacheRequest;
+    /** Fallback lookup relays to check when event cant be found */
+    lookupRelays?: string[];
     constructor(rxNostr: RxNostr, opts?: ReplaceableLoaderOptions);
 }

package/dist/loaders/replaceable-loader.js

@@ -1,23 +1,16 @@
-import { share, tap, from, filter, bufferTime, map, mergeMap } from "rxjs";
-import { getEventUID, getReplaceableUID, markFromCache } from "applesauce-core/helpers";
+import { tap, filter, bufferTime, map } from "rxjs";
+import { createRxOneshotReq } from "rx-nostr";
+import { getEventUID, markFromCache, mergeRelaySets } from "applesauce-core/helpers";
 import { logger } from "applesauce-core";
 import { nanoid } from "nanoid";
 import { Loader } from "./loader.js";
 import { generatorSequence } from "../operators/generator-sequence.js";
-import { replaceableRequest } from "../operators/address-pointers-request.js";
-import { createFiltersFromAddressPointers, getAddressPointerId, getRelaysFromPointers, isLoadableAddressPointer, } from "../helpers/address-pointer.js";
-import { unique } from "../helpers/array.js";
-/** deep clone a loadable pointer to ensure its safe to modify */
-function cloneLoadablePointer(pointer) {
-    const clone = { ...pointer };
-    if (pointer.relays)
-        clone.relays = [...pointer.relays];
-    return clone;
-}
+import { consolidateAddressPointers, createFiltersFromAddressPointers, getAddressPointerId, getRelaysFromPointers, isLoadableAddressPointer, } from "../helpers/address-pointer.js";
+import { getDefaultReadRelays } from "../helpers/rx-nostr.js";
+import { distinctRelaysBatch } from "../operators/distinct-relays.js";
 /** A generator that tries to load the address pointers from the cache first, then tries the relays */
 function* cacheFirstSequence(rxNostr, pointers, log, opts) {
-    const id = nanoid(8);
-    log = log.extend(id);
+    const id = nanoid(4);
     let remaining = Array.from(pointers);
     const pointerRelays = Array.from(getRelaysFromPointers(pointers));
     // handle previous step results and decide if to exit
@@ -26,40 +19,40 @@ function* cacheFirstSequence(rxNostr, pointers, log, opts) {
             const coordinates = new Set(results.map((p) => getEventUID(p.event)));
             // if there where results, filter out any pointers that where found
             remaining = remaining.filter((pointer) => {
-                const found = coordinates.has(getReplaceableUID(pointer.kind, pointer.pubkey, pointer.identifier));
+                const found = coordinates.has(getAddressPointerId(pointer));
                 if (found && pointer.force !== true)
                     return false;
                 else
                     return true;
             });
-            if (remaining.length === 0)
+            // If there are none left, complete
+            if (remaining.length === 0) {
+                log(`[${id}] Complete`);
                 return true;
+            }
         }
         return false;
     };
     // first attempt, load from cache relays
     if (opts?.cacheRequest) {
-        log(`Checking cache`, remaining);
-        const results = yield from([remaining]).pipe(
-        // convert pointers to filters
-        map(createFiltersFromAddressPointers), 
-        // make requests
-        mergeMap((filters) => opts.cacheRequest(filters)), 
+        log(`[${id}] Checking cache`, remaining);
+        const filters = createFiltersFromAddressPointers(remaining);
+        const results = yield opts.cacheRequest(filters).pipe(
         // mark the event as from the cache
         tap((event) => markFromCache(event)), 
         // convert to event packets
-        map((e) => ({ event: e, from: "cache", subId: "cache", type: "EVENT" })));
+        map((e) => ({ event: e, from: "", subId: "replaceable-loader", type: "EVENT" })));
         if (handleResults(results))
             return;
     }
     // load from pointer relays and default relays
-    const defaultRelays = Object.entries(rxNostr.getDefaultRelays())
-        .filter(([_relay, config]) => config.read)
-        .map(([relay]) => relay);
-    const remoteRelays = [...pointerRelays, ...defaultRelays];
+    const defaultRelays = getDefaultReadRelays(rxNostr);
+    const remoteRelays = mergeRelaySets(pointerRelays, defaultRelays);
     if (remoteRelays.length > 0) {
-        log(`Requesting`, remoteRelays, remaining);
-        const results = yield from([remaining]).pipe(replaceableRequest(rxNostr, id, remoteRelays));
+        log(`[${id}] Requesting`, remoteRelays, remaining);
+        const filters = createFiltersFromAddressPointers(remaining);
+        const req = createRxOneshotReq({ filters, rxReqId: id });
+        const results = yield rxNostr.use(req, { on: { relays: remoteRelays } });
         if (handleResults(results))
             return;
     }
@@ -68,96 +61,46 @@ function* cacheFirstSequence(rxNostr, pointers, log, opts) {
         // make sure we aren't asking a relay twice
         const relays = opts.lookupRelays.filter((r) => !pointerRelays.includes(r));
         if (relays.length > 0) {
-            log(`Request from lookup`, relays, remaining);
-            const results = yield from([remaining]).pipe(replaceableRequest(rxNostr, id, relays));
+            log(`[${id}] Request from lookup`, relays, remaining);
+            const filters = createFiltersFromAddressPointers(remaining);
+            const req = createRxOneshotReq({ filters, rxReqId: id });
+            const results = yield rxNostr.use(req, { on: { relays } });
             if (handleResults(results))
                 return;
         }
     }
 }
-/** Batches address pointers and consolidates them */
-function multiRelayBatcher(buffer) {
-    const requestedFrom = new Map();
-    const requestedDefault = new Set();
-    return (source) => source.pipe(
-    // buffer on time
-    bufferTime(buffer), 
-    // ignore empty buffers
-    filter((buffer) => buffer.length > 0), 
-    // consolidate buffered pointers
-    map((pointers) => {
-        const byId = new Map();
-        for (const pointer of pointers) {
-            const id = getAddressPointerId(pointer);
-            if (byId.has(id)) {
-                // duplicate, merge pointers
-                const current = byId.get(id);
-                // merge relays
-                if (pointer.relays) {
-                    if (current.relays)
-                        current.relays = unique([...current.relays, ...pointer.relays]);
-                    else
-                        current.relays = pointer.relays;
-                }
-                // merge force flag
-                if (pointer.force !== undefined) {
-                    current.force = current.force || pointer.force;
-                }
-            }
-            else
-                byId.set(id, cloneLoadablePointer(pointer));
-        }
-        // return consolidated pointers
-        return Array.from(byId.values());
-    }), 
-    // ignore empty buffer
-    filter((buffer) => buffer.length > 0), 
-    // ensure pointers are only requested from each relay once
-    map((pointers) => {
-        return pointers.filter((pointer) => {
-            const id = getAddressPointerId(pointer);
-            // skip if forced
-            if (pointer.force)
-                return true;
-            // skip if already requested from default relays
-            if (!pointer.relays) {
-                if (requestedDefault.has(id))
-                    return false;
-                else {
-                    requestedDefault.add(id);
-                    return true;
-                }
-            }
-            let set = requestedFrom.get(id);
-            if (!set) {
-                set = new Set();
-                requestedFrom.set(id, set);
-            }
-            // remove any relays that have already been used
-            pointer.relays = pointer.relays.filter((relay) => !set.has(relay));
-            // remember used relays
-            for (const relay of pointer.relays)
-                set.add(relay);
-            // if there are no new relays, ignore pointer
-            return pointer.relays.length > 0;
-        });
-    }), 
-    // ignore empty buffer
-    filter((buffer) => buffer.length > 0));
-}
 export class ReplaceableLoader extends Loader {
     log = logger.extend("ReplaceableLoader");
+    /** A method used to load events from a local cache */
+    cacheRequest;
+    /** Fallback lookup relays to check when event cant be found */
+    lookupRelays;
     constructor(rxNostr, opts) {
         super((source) => {
             return source.pipe(
             // filter out invalid pointers
             filter(isLoadableAddressPointer), 
-            // batch and filter
-            multiRelayBatcher(opts?.bufferTime ?? 1000), 
+            // buffer on time
+            bufferTime(opts?.bufferTime ?? 1000), 
+            // ignore empty buffers
+            filter((buffer) => buffer.length > 0), 
+            // only fetch from each relay once
+            distinctRelaysBatch(getAddressPointerId), 
+            // consolidate buffered pointers
+            map(consolidateAddressPointers), 
+            // ignore empty buffer
+            filter((buffer) => buffer.length > 0), 
             // check cache, relays, lookup relays in that order
-            generatorSequence((pointers) => cacheFirstSequence(rxNostr, pointers, this.log, opts)), 
-            // share the response with all subscribers
-            share());
+            generatorSequence((pointers) => cacheFirstSequence(rxNostr, pointers, this.log, {
+                cacheRequest: this.cacheRequest,
+                lookupRelays: this.lookupRelays,
+            }), 
+            // there will always be more events, never complete
+            false));
         });
+        // set options
+        this.cacheRequest = opts?.cacheRequest;
+        this.lookupRelays = opts?.lookupRelays;
     }
 }

package/dist/loaders/request-loader.d.ts

@@ -0,0 +1,30 @@
+import { IEventStore, QueryStore } from "applesauce-core";
+import { ProfilePointer } from "nostr-tools/nip19";
+import { Observable } from "rxjs";
+import { ReplaceableLoader } from "./replaceable-loader.js";
+import { LoadableAddressPointer } from "../helpers/address-pointer.js";
+/** A special Promised based loader built on the {@link QueryStore} */
+export declare class RequestLoader {
+    store: QueryStore;
+    requestTimeout: number;
+    replaceableLoader?: ReplaceableLoader;
+    constructor(store: QueryStore);
+    protected runWithTimeout<T extends unknown, Args extends Array<any>>(queryConstructor: (...args: Args) => {
+        key: string;
+        run: (events: IEventStore, store: QueryStore) => Observable<T>;
+    }, ...args: Args): Promise<NonNullable<T>>;
+    protected checkReplaceable(): ReplaceableLoader;
+    /** Requests a single replaceable event */
+    replaceable(pointer: LoadableAddressPointer, force?: boolean): Promise<import("nostr-tools").Event>;
+    /** Loads a pubkeys profile */
+    profile(pointer: ProfilePointer, force?: boolean): Promise<import("applesauce-core/helpers").ProfileContent>;
+    /** Loads a pubkeys profile */
+    mailboxes(pointer: ProfilePointer, force?: boolean): Promise<{
+        inboxes: string[];
+        outboxes: string[];
+    }>;
+    /** Loads a pubkeys profile */
+    contacts(pointer: ProfilePointer, force?: boolean): Promise<ProfilePointer[]>;
+    /** Loads a pubkeys blossom servers */
+    blossomServers(pointer: ProfilePointer, force?: boolean): Promise<URL[]>;
+}

package/dist/loaders/request-loader.js

@@ -0,0 +1,57 @@
+import { kinds } from "nostr-tools";
+import { MailboxesQuery, ProfileQuery, ReplaceableQuery, UserBlossomServersQuery, UserContactsQuery, } from "applesauce-core/queries";
+import { getObservableValue, simpleTimeout } from "applesauce-core/observable";
+import { filter } from "rxjs";
+import { BLOSSOM_SERVER_LIST_KIND } from "applesauce-core/helpers";
+/** A special Promised based loader built on the {@link QueryStore} */
+export class RequestLoader {
+    store;
+    requestTimeout = 10_000;
+    replaceableLoader;
+    constructor(store) {
+        this.store = store;
+    }
+    // hacky method to run queries with timeouts
+    async runWithTimeout(queryConstructor, ...args) {
+        return getObservableValue(this.store.createQuery(queryConstructor, ...args).pipe(
+        // ignore undefined and null values
+        filter((v) => v !== undefined && v !== null), 
+        // timeout with an error is not values
+        simpleTimeout(this.requestTimeout)));
+    }
+    checkReplaceable() {
+        if (!this.replaceableLoader)
+            throw new Error("Missing ReplaceableLoader");
+        return this.replaceableLoader;
+    }
+    /** Requests a single replaceable event */
+    replaceable(pointer, force) {
+        this.checkReplaceable().next({ ...pointer, force });
+        return this.runWithTimeout(ReplaceableQuery, pointer.kind, pointer.pubkey, pointer.identifier);
+    }
+    /** Loads a pubkeys profile */
+    profile(pointer, force) {
+        this.checkReplaceable().next({ kind: kinds.Metadata, pubkey: pointer.pubkey, relays: pointer.relays, force });
+        return this.runWithTimeout(ProfileQuery, pointer.pubkey);
+    }
+    /** Loads a pubkeys profile */
+    mailboxes(pointer, force) {
+        this.checkReplaceable().next({ kind: kinds.RelayList, pubkey: pointer.pubkey, relays: pointer.relays, force });
+        return this.runWithTimeout(MailboxesQuery, pointer.pubkey);
+    }
+    /** Loads a pubkeys profile */
+    contacts(pointer, force) {
+        this.checkReplaceable().next({ kind: kinds.Contacts, pubkey: pointer.pubkey, relays: pointer.relays, force });
+        return this.runWithTimeout(UserContactsQuery, pointer.pubkey);
+    }
+    /** Loads a pubkeys blossom servers */
+    blossomServers(pointer, force) {
+        this.checkReplaceable().next({
+            kind: BLOSSOM_SERVER_LIST_KIND,
+            pubkey: pointer.pubkey,
+            relays: pointer.relays,
+            force,
+        });
+        return this.runWithTimeout(UserBlossomServersQuery, pointer.pubkey);
+    }
+}

package/dist/loaders/single-event-loader.d.ts

@@ -0,0 +1,26 @@
+import { EventPacket, RxNostr } from "rx-nostr";
+import { logger } from "applesauce-core";
+import { CacheRequest, Loader } from "./loader.js";
+export type LoadableEventPointer = {
+    id: string;
+    /** Relays to load from */
+    relays?: string[];
+};
+export type SingleEventLoaderOptions = {
+    /**
+     * Time interval to buffer requests in ms
+     * @default 1000
+     */
+    bufferTime?: number;
+    /** A method used to load events from a local cache */
+    cacheRequest?: CacheRequest;
+    /**
+     * How long the loader should wait before it allows an event pointer to be refreshed from a relay
+     * @default 60000
+     */
+    refreshTimeout?: number;
+};
+export declare class SingleEventLoader extends Loader<LoadableEventPointer, EventPacket> {
+    log: typeof logger;
+    constructor(rxNostr: RxNostr, opts?: SingleEventLoaderOptions);
+}