applesauce-loaders 0.10.0 → 0.11.0

package/dist/helpers/__tests__/address-pointer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/helpers/__tests__/address-pointer.test.js

@@ -0,0 +1,19 @@
+import { describe, it, expect } from "vitest";
+import { createFiltersFromAddressPointers } from "../address-pointer.js";
+import { kinds } from "nostr-tools";
+describe("address pointer helpers", () => {
+    describe("createFiltersFromAddressPointers", () => {
+        it("should separate replaceable and parameterized replaceable pointers", () => {
+            expect(createFiltersFromAddressPointers([
+                { kind: kinds.BookmarkList, pubkey: "pubkey" },
+                { kind: kinds.Metadata, pubkey: "pubkey" },
+                { kind: kinds.Metadata, pubkey: "pubkey2" },
+                { kind: kinds.Bookmarksets, identifier: "funny", pubkey: "pubkey" },
+            ])).toEqual(expect.arrayContaining([
+                { kinds: [kinds.Metadata], authors: ["pubkey", "pubkey2"] },
+                { kinds: [kinds.BookmarkList], authors: ["pubkey"] },
+                { "#d": ["funny"], authors: ["pubkey"], kinds: [kinds.Bookmarksets] },
+            ]));
+        });
+    });
+});

package/dist/helpers/address-pointer.d.ts

@@ -1,7 +1,18 @@
 import { AddressPointerWithoutD } from "applesauce-core/helpers";
 import { Filter } from "nostr-tools";
+import { AddressPointer } from "nostr-tools/nip19";
+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;
+};
 /** Converts an array of address pointers to a filter */
-export declare function createFilterFromAddressPointers(pointers: AddressPointerWithoutD[]): Filter;
+export declare function createFilterFromAddressPointers(pointers: AddressPointerWithoutD[] | AddressPointer[]): Filter;
 /** Takes a set of address pointers, groups them, then returns filters for the groups */
 export declare function createFiltersFromAddressPointers(pointers: AddressPointerWithoutD[]): Filter[];
 /** Checks if a relay will understand an address pointer */
@@ -11,6 +22,8 @@ export declare function groupAddressPointersByKind(pointers: AddressPointerWitho
 /** Group an array of address pointers by pubkey */
 export declare function groupAddressPointersByPubkey(pointers: AddressPointerWithoutD[]): Map<string, AddressPointerWithoutD[]>;
 /** Groups address pointers by kind or pubkey depending on which is most optimal */
-export declare function groupAddressPointersByPubkeyOrKind(pointers: AddressPointerWithoutD[]): Map<number, AddressPointerWithoutD[]> | Map<string, AddressPointerWithoutD[]>;
+export declare function groupAddressPointersByPubkeyOrKind(pointers: AddressPointerWithoutD[]): Map<string, AddressPointerWithoutD[]> | Map<number, AddressPointerWithoutD[]>;
 export declare function getRelaysFromPointers(pointers: AddressPointerWithoutD[]): Set<string>;
 export declare function getAddressPointerId<T extends AddressPointerWithoutD>(pointer: T): string;
+/** deduplicates an array of address pointers and merges their relays array */
+export declare function consolidateAddressPointers(pointers: LoadableAddressPointer[]): LoadableAddressPointer[];

package/dist/helpers/address-pointer.js

@@ -1,4 +1,4 @@
-import { getReplaceableUID } from "applesauce-core/helpers";
+import { getReplaceableUID, mergeRelaySets } from "applesauce-core/helpers";
 import { isParameterizedReplaceableKind, isReplaceableKind } from "nostr-tools/kinds";
 import { unique } from "./array.js";
 /** Converts an array of address pointers to a filter */
@@ -13,8 +13,19 @@ export function createFilterFromAddressPointers(pointers) {
 }
 /** Takes a set of address pointers, groups them, then returns filters for the groups */
 export function createFiltersFromAddressPointers(pointers) {
-    const groups = groupAddressPointersByPubkeyOrKind(pointers);
-    return Array.from(groups.values()).map((pointers) => createFilterFromAddressPointers(pointers));
+    // split the points in to two groups so they they don't mix in the filters
+    const parameterizedReplaceable = pointers.filter((p) => isParameterizedReplaceableKind(p.kind));
+    const replaceable = pointers.filter((p) => isReplaceableKind(p.kind));
+    const filters = [];
+    if (replaceable.length > 0) {
+        const groups = groupAddressPointersByPubkeyOrKind(replaceable);
+        filters.push(...Array.from(groups.values()).map(createFilterFromAddressPointers));
+    }
+    if (parameterizedReplaceable.length > 0) {
+        const groups = groupAddressPointersByPubkeyOrKind(parameterizedReplaceable);
+        filters.push(...Array.from(groups.values()).map(createFilterFromAddressPointers));
+    }
+    return filters;
 }
 /** Checks if a relay will understand an address pointer */
 export function isLoadableAddressPointer(pointer) {
@@ -49,7 +60,7 @@ export function groupAddressPointersByPubkey(pointers) {
 export function groupAddressPointersByPubkeyOrKind(pointers) {
     const kinds = new Set(pointers.map((p) => p.kind));
     const pubkeys = new Set(pointers.map((p) => p.pubkey));
-    return pubkeys.size > kinds.size ? groupAddressPointersByKind(pointers) : groupAddressPointersByPubkey(pointers);
+    return pubkeys.size < kinds.size ? groupAddressPointersByPubkey(pointers) : groupAddressPointersByKind(pointers);
 }
 export function getRelaysFromPointers(pointers) {
     const relays = new Set();
@@ -65,3 +76,36 @@ export function getRelaysFromPointers(pointers) {
 export function getAddressPointerId(pointer) {
     return getReplaceableUID(pointer.kind, pointer.pubkey, pointer.identifier);
 }
+/** 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;
+}
+/** deduplicates an array of address pointers and merges their relays array */
+export function consolidateAddressPointers(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 = mergeRelaySets(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());
+}

package/dist/helpers/array.d.ts

@@ -1,4 +1,2 @@
 /** Does not preserve order */
 export declare function unique<T>(arr: T[]): T[];
-/** split array into a set of arrays no larger than batchSize */
-export declare function reduceToBatches<T>(arr: T[], batchSize: number): T[][];

package/dist/helpers/array.js

@@ -2,20 +2,3 @@
 export function unique(arr) {
     return Array.from(new Set(arr));
 }
-/** split array into a set of arrays no larger than batchSize */
-export function reduceToBatches(arr, batchSize) {
-    const batches = [];
-    for (const value of arr) {
-        if (batches.length === 0) {
-            batches.push([value]);
-            continue;
-        }
-        const current = batches[batches.length - 1];
-        if (current.length <= batchSize) {
-            current.push(value);
-        }
-        else
-            batches.push([value]);
-    }
-    return batches;
-}

package/dist/helpers/dns-identity.d.ts

@@ -0,0 +1,40 @@
+export type DomainIdentityJson = {
+    names?: Record<string, string | undefined>;
+    relays?: Record<string, string[]>;
+    nip46?: Record<string, string[]>;
+};
+export declare enum IdentityStatus {
+    /** Got error when fetching identity document */
+    Error = "error",
+    /** Identity missing from document */
+    Missing = "missing",
+    /** Identity was found */
+    Found = "found"
+}
+export type BaseIdentity = {
+    name: string;
+    domain: string;
+    /** The unix timestamp of when the identity was checked */
+    checked: number;
+};
+export type ErrorIdentity = BaseIdentity & {
+    status: IdentityStatus.Error;
+    error: string;
+};
+export type MissingIdentity = BaseIdentity & {
+    status: IdentityStatus.Missing;
+};
+export type KnownIdentity = BaseIdentity & {
+    status: IdentityStatus.Found;
+    pubkey: string;
+    relays?: string[];
+    hasNip46?: boolean;
+    nip46Relays?: string[];
+};
+export type Identity = KnownIdentity | ErrorIdentity | MissingIdentity;
+/** Gets an Identity from the .well-known/nostr.json document */
+export declare function getIdentityFromJson(name: string, domain: string, json: DomainIdentityJson, checked?: number): MissingIdentity | KnownIdentity;
+/** Returns all Identifies in a json document */
+export declare function getIdentitiesFromJson(domain: string, json: DomainIdentityJson, checked?: number): Record<string, Identity>;
+/** convert all keys in names, and relays to lower case */
+export declare function normalizeIdentityJson(json: DomainIdentityJson): DomainIdentityJson;

package/dist/helpers/dns-identity.js

@@ -0,0 +1,50 @@
+import { unixNow } from "applesauce-core/helpers";
+export var IdentityStatus;
+(function (IdentityStatus) {
+    /** Got error when fetching identity document */
+    IdentityStatus["Error"] = "error";
+    /** Identity missing from document */
+    IdentityStatus["Missing"] = "missing";
+    /** Identity was found */
+    IdentityStatus["Found"] = "found";
+})(IdentityStatus || (IdentityStatus = {}));
+/** Gets an Identity from the .well-known/nostr.json document */
+export function getIdentityFromJson(name, domain, json, checked = unixNow()) {
+    const common = { name, domain, checked };
+    if (!json.names)
+        return { ...common, status: IdentityStatus.Missing };
+    const pubkey = json.names[name];
+    if (!pubkey)
+        return { ...common, status: IdentityStatus.Missing };
+    const relays = json.relays?.[pubkey];
+    const hasNip46 = !!json.nip46;
+    const nip46Relays = json.nip46?.[pubkey];
+    return { ...common, pubkey, relays, nip46Relays, hasNip46, status: IdentityStatus.Found };
+}
+/** Returns all Identifies in a json document */
+export function getIdentitiesFromJson(domain, json, checked = unixNow()) {
+    if (!json.names)
+        return {};
+    return Object.keys(json.names).reduce((dir, name) => {
+        const address = `${name}@${domain}`;
+        const identity = getIdentityFromJson(name, domain, json, checked);
+        dir[address] = identity;
+        return dir;
+    }, {});
+}
+/** convert all keys in names, and relays to lower case */
+export function normalizeIdentityJson(json) {
+    if (json.names) {
+        for (const [name, pubkey] of Object.entries(json.names)) {
+            delete json.names[name];
+            json.names[name.toLowerCase()] = pubkey;
+        }
+    }
+    if (json.relays) {
+        for (const [name, pubkey] of Object.entries(json.relays)) {
+            delete json.relays[name];
+            json.relays[name.toLowerCase()] = pubkey;
+        }
+    }
+    return json;
+}

package/dist/helpers/event-pointer.d.ts

@@ -0,0 +1,5 @@
+/** deduplicates an array of event pointers and merges their relays array */
+export declare function consolidateEventPointers<T extends {
+    id: string;
+    relays?: string[];
+}>(pointers: T[]): T[];

package/dist/helpers/event-pointer.js

@@ -0,0 +1,19 @@
+/** deduplicates an array of event pointers and merges their relays array */
+export function consolidateEventPointers(pointers) {
+    let ids = new Map();
+    for (let pointer of pointers) {
+        let existing = ids.get(pointer.id);
+        if (existing) {
+            // merge relays
+            if (pointer.relays) {
+                if (!existing.relays)
+                    existing.relays = [...pointer.relays];
+                else
+                    existing.relays = [...existing.relays, ...pointer.relays.filter((r) => !existing.relays.includes(r))];
+            }
+        }
+        else
+            ids.set(pointer.id, pointer);
+    }
+    return Array.from(ids.values());
+}

package/dist/helpers/index.d.ts

@@ -0,0 +1 @@
+export * from "./dns-identity.js";

package/dist/helpers/index.js

@@ -0,0 +1 @@
+export * from "./dns-identity.js";

package/dist/helpers/pointer.d.ts

@@ -0,0 +1,11 @@
+export declare function groupByRelay<T extends {
+    relays?: string[];
+}>(pointers: T[], defaultKey?: string): Map<string, T[]>;
+export interface MessageWithRelay {
+    relays?: string[];
+    /** Ignore timeout and force message through */
+    force?: boolean;
+    [key: string]: any;
+}
+/** Ensures that a message only is requested from each relay once in timeout */
+export declare function removePreviouslyUsedRelays<T extends MessageWithRelay>(message: T, keyFn: (message: T) => string, cache: Map<string, number>, timeout?: number): T | null;

package/dist/helpers/pointer.js

@@ -0,0 +1,47 @@
+export function groupByRelay(pointers, defaultKey) {
+    let byRelay = new Map();
+    for (const pointer of pointers) {
+        let relays = pointer.relays?.length ? pointer.relays : defaultKey ? [defaultKey] : [];
+        for (const relay of relays) {
+            if (!byRelay.has(relay))
+                byRelay.set(relay, [pointer]);
+            else
+                byRelay.get(relay)?.push(pointer);
+        }
+    }
+    return byRelay;
+}
+/** Ensures that a message only is requested from each relay once in timeout */
+export function removePreviouslyUsedRelays(message, keyFn, cache, timeout = 60_000) {
+    if (message.force)
+        return message;
+    let key = keyFn(message);
+    let now = Date.now();
+    if (message.relays) {
+        // requesting from specific relays
+        let relays = message.relays;
+        relays = relays.filter((relay) => {
+            let relayKey = key + " " + relay;
+            let last = cache.get(relayKey);
+            if (!last || now >= last + timeout) {
+                cache.set(relayKey, now);
+                return true;
+            }
+            else
+                return false;
+        });
+        if (relays.length === 0)
+            return null;
+        return { ...message, relays };
+    }
+    else {
+        // requesting from default relays
+        let last = cache.get(key);
+        if (!last || now >= last + timeout) {
+            cache.set(key, now);
+            return message;
+        }
+        else
+            return null;
+    }
+}

package/dist/helpers/rx-nostr.d.ts

@@ -0,0 +1,2 @@
+import { RxNostr } from "rx-nostr";
+export declare function getDefaultReadRelays(rxNostr: RxNostr): string[];

package/dist/helpers/rx-nostr.js

@@ -0,0 +1,5 @@
+export function getDefaultReadRelays(rxNostr) {
+    return Object.entries(rxNostr.getDefaultRelays())
+        .filter(([_, config]) => config.read)
+        .map(([relay]) => relay);
+}

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export * as Loaders from "./loaders/index.js";
+export * from "./loaders/index.js";
 export * as Operators from "./operators/index.js";

package/dist/index.js

@@ -1,2 +1,2 @@
-export * as Loaders from "./loaders/index.js";
+export * from "./loaders/index.js";
 export * as Operators from "./operators/index.js";

package/dist/loaders/__tests__/dns-identity-loader.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,59 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { DnsIdentityLoader } from "../dns-identity-loader.js";
+import { unixNow } from "applesauce-core/helpers";
+import { IdentityStatus } from "../../helpers/dns-identity.js";
+let loader;
+beforeEach(() => {
+    loader = new DnsIdentityLoader();
+});
+describe("fetch", () => {
+    it("should not assign this in fetch method", async () => {
+        const loader = new DnsIdentityLoader();
+        let that = undefined;
+        function custom() {
+            //@ts-expect-error
+            that = this;
+            throw new Error("not implemented");
+        }
+        // @ts-expect-error
+        loader.fetch = custom;
+        await loader.fetchIdentity("_", "hzrd149.com");
+        expect(that).not.toBe(loader);
+    });
+});
+describe("requestIdentity", () => {
+    it("should load from cache first", async () => {
+        const cache = {
+            save: vi.fn().mockResolvedValue(undefined),
+            load: vi.fn().mockResolvedValue({
+                name: "_",
+                domain: "hzrd149.com",
+                pubkey: "pubkey",
+                checked: unixNow(),
+                status: IdentityStatus.Found,
+            }),
+        };
+        loader.cache = cache;
+        loader.fetch = vi.fn().mockRejectedValue(new Error("error"));
+        await loader.requestIdentity("_", "hzrd149.com");
+        expect(cache.load).toHaveBeenCalledWith("_@hzrd149.com");
+        expect(loader.fetch).not.toHaveBeenCalled();
+    });
+    it("should fetch if cache is too old", async () => {
+        const cache = {
+            save: vi.fn().mockResolvedValue(undefined),
+            load: vi.fn().mockResolvedValue({
+                name: "_",
+                domain: "hzrd149.com",
+                pubkey: "pubkey",
+                checked: unixNow() - 60 * 60 * 24 * 7 * 2,
+                status: IdentityStatus.Found,
+            }),
+        };
+        loader.cache = cache;
+        loader.fetch = vi.fn().mockRejectedValue(new Error("error"));
+        await loader.requestIdentity("_", "hzrd149.com");
+        expect(cache.load).toHaveBeenCalledWith("_@hzrd149.com");
+        expect(loader.fetch).toHaveBeenCalled();
+    });
+});

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,26 @@
+import { expect, it } from "vitest";
+// import { createMockRelay, MockRelay } from "vitest-nostr";
+// import { createRxNostr } from "rx-nostr";
+// import { verifier } from "rx-nostr-crypto";
+// import { RelayTimelineLoader } from "./relay-timeline-loader.js";
+// let relay: MockRelay;
+// beforeEach(async () => {
+//   relay = createMockRelay("ws://localhost:1234");
+// });
+it("should complete when 0 events are returned", async () => {
+    // const rxNostr = createRxNostr({ verifier });
+    // const loader = new RelayTimelineLoader(rxNostr, "ws://localhost:1234", [{ kinds: [1] }]);
+    // let received = 0;
+    // loader.subscribe(() => received++);
+    // // load first page
+    // loader.next(100);
+    // expect(loader.loading).toBe(true);
+    // await relay.connected;
+    // await expect(relay).toReceiveREQ();
+    // relay.emitEVENT(loader.id, faker.event({ kind: 1 }));
+    // relay.emitEOSE(loader.id);
+    // await new Promise((res) => setTimeout(res, 0));
+    // expect(received).toBe(1);
+    // expect(loader.loading).toBe(false);
+    expect(true).toBeTruthy();
+});

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

@@ -0,0 +1 @@
+export {};

package/dist/loaders/__tests__/request-loader.test.js

@@ -0,0 +1,37 @@
+import { Subject } from "rxjs";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { TimeoutError } from "applesauce-core/observable";
+import { EventStore, QueryStore } from "applesauce-core";
+import { RequestLoader } from "../request-loader.js";
+let eventStore;
+let queryStore;
+let loader;
+beforeEach(() => {
+    eventStore = new EventStore();
+    queryStore = new QueryStore(eventStore);
+    loader = new RequestLoader(queryStore);
+    // @ts-expect-error
+    loader.replaceableLoader = new Subject();
+    vi.spyOn(loader.replaceableLoader, "next").mockImplementation(() => { });
+});
+describe("profile", () => {
+    it("should return a promise that resolves", async () => {
+        const p = loader.profile({ pubkey: "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d" });
+        expect(loader.replaceableLoader.next).toHaveBeenCalledWith(expect.objectContaining({ pubkey: "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d" }));
+        eventStore.add({
+            content: '{"name":"fiatjaf","about":"~","picture":"https://fiatjaf.com/static/favicon.jpg","nip05":"_@fiatjaf.com","lud16":"fiatjaf@zbd.gg","website":"https://nostr.technology"}',
+            created_at: 1738588530,
+            id: "c43be8b4634298e97dde3020a5e6aeec37d7f5a4b0259705f496e81a550c8f8b",
+            kind: 0,
+            pubkey: "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d",
+            sig: "202a1bf6a58943d660c1891662dbdda142aa8e5bca9d4a3cb03cde816ad3bdda6f4ec3b880671506c2820285b32218a0afdec2d172de9694d83972190ab4f9da",
+            tags: [],
+        });
+        expect(await p).toEqual(expect.objectContaining({ name: "fiatjaf" }));
+    });
+    it("should reject with TimeoutError after 10 seconds", async () => {
+        // reduce timeout for tests
+        loader.requestTimeout = 10;
+        await expect(loader.profile({ pubkey: "3bf0c63fcb93463407af97a5e5ee64fa883d107ef9e558472c4eb9aaaefa459d" })).rejects.toThrow(TimeoutError);
+    });
+});

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

@@ -0,0 +1,22 @@
+import { EventPacket } from "rx-nostr";
+import { BehaviorSubject } from "rxjs";
+import { logger } from "applesauce-core";
+import { CacheRequest, Loader } from "./loader.js";
+import { TimelessFilter } from "./relay-timeline-loader.js";
+export type CacheTimelineLoaderOptions = {
+    /** 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 CacheTimelineLoader extends Loader<number | void, EventPacket> {
+    filters: TimelessFilter[];
+    id: string;
+    loading$: BehaviorSubject<boolean>;
+    get loading(): boolean;
+    /** current "until" timestamp */
+    cursor: number;
+    /** set to true when 0 events are returned from last batch */
+    eose: boolean;
+    protected log: typeof logger;
+    constructor(cacheRequest: CacheRequest, filters: TimelessFilter[], opts?: CacheTimelineLoaderOptions);
+}

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

@@ -0,0 +1,61 @@
+import { BehaviorSubject, filter, map, mergeMap, tap } from "rxjs";
+import { markFromCache, unixNow } from "applesauce-core/helpers";
+import { logger } from "applesauce-core";
+import { nanoid } from "nanoid";
+import { Loader } from "./loader.js";
+/** A loader that can be used to load a timeline in chunks */
+export class CacheTimelineLoader extends Loader {
+    filters;
+    id = nanoid(8);
+    loading$ = new BehaviorSubject(false);
+    get loading() {
+        return this.loading$.value;
+    }
+    /** current "until" timestamp */
+    cursor = Infinity;
+    /** set to true when 0 events are returned from last batch */
+    eose = false;
+    log = logger.extend("CacheTimelineLoader");
+    constructor(cacheRequest, filters, opts) {
+        super((source) => source.pipe(filter(() => !this.loading && !this.eose), 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), mergeMap((filters) => {
+            // make batch request
+            let count = 0;
+            this.loading$.next(true);
+            this.log(`Next batch starting at ${filters[0].until} limit ${filters[0].limit}`);
+            return cacheRequest(filters).pipe(tap({
+                next: (event) => {
+                    // mark event from cache
+                    markFromCache(event);
+                    // update cursor when event is received
+                    this.cursor = Math.min(event.created_at - 1, this.cursor);
+                    count++;
+                },
+                complete: () => {
+                    // set loading to false when batch completes
+                    this.loading$.next(false);
+                    // set eose if no events where returned
+                    if (count === 0) {
+                        this.eose = true;
+                        this.log(`Got ${count} event, Complete`);
+                    }
+                    else {
+                        this.log(`Finished batch, got ${count} events`);
+                    }
+                },
+            }), map((event) => ({ event, from: "", subId: "cache-timeline-loader", type: "EVENT" })));
+        })));
+        this.filters = filters;
+        // create a unique logger for this instance
+        this.log = this.log.extend("cache");
+    }
+}

package/dist/loaders/dns-identity-loader.d.ts

@@ -0,0 +1,25 @@
+import { Identity } from "../helpers/dns-identity.js";
+export type AsyncIdentityCache = {
+    /** Saves a batch of identities */
+    save: (identities: Record<string, Identity>) => Promise<void> | void;
+    /** Loads a single identity */
+    load: (address: string) => Promise<Identity | undefined> | Identity | undefined;
+};
+export declare class DnsIdentityLoader {
+    cache?: AsyncIdentityCache | undefined;
+    identities: Map<string, Identity>;
+    /** The fetch implementation this class should use */
+    fetch: (url: string, init: RequestInit) => Promise<Response>;
+    /** How long an identity should be kept until its considered expired (in seconds) defaults to 1 week */
+    expiration: number;
+    constructor(cache?: AsyncIdentityCache | undefined);
+    /** Makes an http request to fetch an identity */
+    fetchIdentity(name: string, domain: string): Promise<Identity>;
+    /** Loads an identity from the cache or fetches it */
+    loadIdentity(name: string, domain: string): Promise<Identity>;
+    private requesting;
+    /** Requests an identity to be loaded */
+    requestIdentity(name: string, domain: string): Promise<Identity>;
+    /** Checks if an identity is loaded */
+    getIdentity(name: string, domain: string): Identity | undefined;
+}