@rhinestone/shared-configs 1.7.16 → 1.8.0

package/dist/src/__tests__/chainFactsClient.test.js

@@ -0,0 +1,460 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const bun_test_1 = require("bun:test");
+const node_crypto_1 = require("node:crypto");
+const chainFactsClient_1 = require("../chainFactsClient");
+const index_1 = require("../index");
+const packageVersion_1 = require("../generated/packageVersion");
+const REMOTE_URL = "https://example.invalid/chain-facts.json";
+const SIGNATURE_URL = `${REMOTE_URL}.sig`;
+const ETHEREUM = String(index_1.MainnetNetwork.ETHEREUM);
+// A real P-256 keypair, signing in DER exactly as KMS ECDSA_SHA_256 does, so
+// these tests exercise the same bytes production will see rather than a
+// convenient stand-in.
+function makeSigner() {
+    const { publicKey, privateKey } = (0, node_crypto_1.generateKeyPairSync)("ec", {
+        namedCurve: "P-256",
+    });
+    return {
+        publicKey: publicKey.export({ type: "spki", format: "der" }).toString("base64"),
+        sign: (bytes) => (0, node_crypto_1.sign)("sha256", Buffer.from(bytes), privateKey).toString("base64"),
+    };
+}
+const signer = makeSigner();
+const realFetch = globalThis.fetch;
+(0, bun_test_1.afterEach)(() => {
+    globalThis.fetch = realFetch;
+});
+/** Routes by URL, since a read now fetches the artifact and its detached signature. */
+function stubFetch(handler) {
+    globalThis.fetch = ((input, init) => handler(String(input), init));
+}
+/** Serves `body` with a valid signature over its exact serialized bytes. */
+function serveSigned(body, signWith = signer) {
+    const text = JSON.stringify(body);
+    const signature = signWith.sign(text);
+    stubFetch(async (url) => url === SIGNATURE_URL ? new Response(signature) : new Response(text));
+    return text;
+}
+// Defaults to the FULL bundled registry: a payload missing chains the bundled
+// registry has is rejected as stale, so a partial fixture would be testing the
+// staleness guard rather than whatever the test is actually about.
+// Version defaults to the bundled PACKAGE_VERSION: an artifact older than the
+// bundled registry is rejected as stale, so a fixture with an arbitrary version
+// would be testing the staleness guard rather than its actual subject.
+function payload(chains = index_1.chainRegistry, version = packageVersion_1.PACKAGE_VERSION) {
+    return { version, chains };
+}
+function bumpedVersion() {
+    const [major, minor, patch] = packageVersion_1.PACKAGE_VERSION.split("-")[0].split(".");
+    return `${major}.${minor}.${Number(patch) + 1}`;
+}
+function olderVersion() {
+    const [major, minor, patch] = packageVersion_1.PACKAGE_VERSION.split("-")[0].split(".");
+    return `${major}.${minor}.${Math.max(0, Number(patch) - 1)}`;
+}
+function withEthereum(overrides) {
+    return {
+        ...index_1.chainRegistry,
+        [ETHEREUM]: { ...index_1.chainRegistry[ETHEREUM], ...overrides },
+    };
+}
+/** The bundled registry minus one chain — the shape a stale artifact has. */
+function registryMissingOneChain() {
+    const partial = { ...index_1.chainRegistry };
+    delete partial[ETHEREUM];
+    return partial;
+}
+function clientWith(extra = {}) {
+    return (0, chainFactsClient_1.createChainFactsClient)({
+        remoteUrl: REMOTE_URL,
+        publicKey: signer.publicKey,
+        ...extra,
+    });
+}
+(0, bun_test_1.describe)("createChainFactsClient", () => {
+    (0, bun_test_1.describe)("tiers", () => {
+        (0, bun_test_1.it)("serves bundled before any refresh", () => {
+            const snapshot = (0, chainFactsClient_1.createChainFactsClient)().getSnapshot();
+            (0, bun_test_1.expect)(snapshot.source).toBe("bundled");
+            (0, bun_test_1.expect)(snapshot.version).toBeNull();
+            (0, bun_test_1.expect)(snapshot.chains).toBe(index_1.chainRegistry);
+        });
+        (0, bun_test_1.it)("serves bundled when remoteUrl is explicitly disabled", async () => {
+            let fetched = false;
+            stubFetch(async () => {
+                fetched = true;
+                return new Response("{}");
+            });
+            const client = (0, chainFactsClient_1.createChainFactsClient)({ remoteUrl: null });
+            (0, bun_test_1.expect)(await client.refresh()).toBe(false);
+            (0, bun_test_1.expect)(client.getSnapshot().source).toBe("bundled");
+            (0, bun_test_1.expect)(fetched).toBe(false);
+        });
+        (0, bun_test_1.it)("defaults to the published artifact URL and bundled key", async () => {
+            // Asserts the wiring without reaching the network: the stub records where
+            // an unconfigured client would have gone.
+            const seen = [];
+            stubFetch(async (url) => {
+                seen.push(url);
+                throw new Error("no network in tests");
+            });
+            const client = (0, chainFactsClient_1.createChainFactsClient)();
+            (0, bun_test_1.expect)(await client.refresh()).toBe(false);
+            (0, bun_test_1.expect)(seen).toContain("https://facts.rhinestone.dev/latest.json");
+            (0, bun_test_1.expect)(client.getSnapshot().source).toBe("bundled");
+        });
+        (0, bun_test_1.it)("installs the remote payload on a successful refresh", async () => {
+            serveSigned(payload());
+            const client = clientWith();
+            (0, bun_test_1.expect)(await client.refresh()).toBe(true);
+            const snapshot = client.getSnapshot();
+            (0, bun_test_1.expect)(snapshot.source).toBe("remote");
+            (0, bun_test_1.expect)(snapshot.version).toBe(packageVersion_1.PACKAGE_VERSION);
+            (0, bun_test_1.expect)(Object.keys(client.getChainRegistry())).toEqual(Object.keys(index_1.chainRegistry));
+        });
+        (0, bun_test_1.it)("accepts a remote payload that adds chains beyond the bundled set", async () => {
+            serveSigned(payload({ ...index_1.chainRegistry, "424242": index_1.chainRegistry[ETHEREUM] }));
+            const client = clientWith();
+            (0, bun_test_1.expect)(await client.refresh()).toBe(true);
+            (0, bun_test_1.expect)(client.getChainRegistry()["424242"]).toBeDefined();
+        });
+        (0, bun_test_1.it)("keeps an installed remote snapshot when a later refresh fails", async () => {
+            const text = JSON.stringify(payload());
+            const signature = signer.sign(text);
+            let call = 0;
+            stubFetch(async (url) => {
+                call += 1;
+                if (call > 2)
+                    throw new Error("network blip");
+                return url === SIGNATURE_URL
+                    ? new Response(signature)
+                    : new Response(text);
+            });
+            const client = clientWith();
+            (0, bun_test_1.expect)(await client.refresh()).toBe(true);
+            (0, bun_test_1.expect)(await client.refresh()).toBe(false);
+            // The tier only moves forwards — no downgrade back to bundled.
+            (0, bun_test_1.expect)(client.getSnapshot().source).toBe("remote");
+            (0, bun_test_1.expect)(client.getSnapshot().version).toBe(packageVersion_1.PACKAGE_VERSION);
+        });
+    });
+    (0, bun_test_1.describe)("concurrent refreshes", () => {
+        // Without single-flight this reorders: the first call's fetch is held open
+        // while the second completes and installs v2, then the first resolves and
+        // puts v1 back — silently hiding whatever v2 added.
+        (0, bun_test_1.it)("does not let an overlapping refresh install a stale snapshot", async () => {
+            const v1 = JSON.stringify(payload());
+            const v2 = JSON.stringify(payload(index_1.chainRegistry, bumpedVersion()));
+            const sig1 = signer.sign(v1);
+            const sig2 = signer.sign(v2);
+            let releaseFirst;
+            const firstHeld = new Promise((resolve) => {
+                releaseFirst = resolve;
+            });
+            let payloadFetches = 0;
+            stubFetch(async (url) => {
+                if (url === SIGNATURE_URL) {
+                    return new Response(payloadFetches <= 1 ? sig1 : sig2);
+                }
+                payloadFetches += 1;
+                if (payloadFetches === 1) {
+                    await firstHeld; // hold the first read open
+                    return new Response(v1);
+                }
+                return new Response(v2);
+            });
+            const client = clientWith();
+            const first = client.refresh();
+            const second = client.refresh();
+            // Single-flight: the second caller joins the first rather than racing it.
+            releaseFirst?.();
+            const [a, b] = await Promise.all([first, second]);
+            (0, bun_test_1.expect)(a).toBe(true);
+            (0, bun_test_1.expect)(b).toBe(true);
+            (0, bun_test_1.expect)(payloadFetches).toBe(1);
+            // Whatever won, the snapshot is never left older than what was installed.
+            (0, bun_test_1.expect)(client.getSnapshot().version).toBe(packageVersion_1.PACKAGE_VERSION);
+        });
+        (0, bun_test_1.it)("fetches again on a sequential refresh, once the previous one settled", async () => {
+            let fetches = 0;
+            const text = JSON.stringify(payload());
+            const signature = signer.sign(text);
+            stubFetch(async (url) => {
+                if (url === SIGNATURE_URL)
+                    return new Response(signature);
+                fetches += 1;
+                return new Response(text);
+            });
+            const client = clientWith();
+            (0, bun_test_1.expect)(await client.refresh()).toBe(true);
+            (0, bun_test_1.expect)(await client.refresh()).toBe(true);
+            (0, bun_test_1.expect)(fetches).toBe(2);
+        });
+    });
+    (0, bun_test_1.describe)("staleness", () => {
+        // A signature proves provenance, not freshness. If the CDN publish fails
+        // while npm succeeds, a consumer that bumps has a bundled registry newer
+        // than latest.json — validly signed, and it would otherwise override the
+        // newer bundled data and hide the change behind a successful read.
+        (0, bun_test_1.it)("rejects a validly signed artifact from an older release", async () => {
+            serveSigned(payload(index_1.chainRegistry, olderVersion()));
+            const phases = [];
+            const errors = [];
+            const client = clientWith({
+                onError: (e, phase) => {
+                    phases.push(phase);
+                    errors.push(e);
+                },
+            });
+            (0, bun_test_1.expect)(await client.refresh()).toBe(false);
+            (0, bun_test_1.expect)(client.getSnapshot().source).toBe("bundled");
+            (0, bun_test_1.expect)(phases).toEqual(["stale"]);
+            (0, bun_test_1.expect)(String(errors[0])).toContain(packageVersion_1.PACKAGE_VERSION);
+        });
+        // The case chain-id comparison missed: same chains, older content.
+        (0, bun_test_1.it)("rejects an older release even when it carries every bundled chain id", async () => {
+            const sameKeysOlder = { ...index_1.chainRegistry };
+            serveSigned(payload(sameKeysOlder, olderVersion()));
+            const client = clientWith();
+            (0, bun_test_1.expect)(await client.refresh()).toBe(false);
+            (0, bun_test_1.expect)(client.getSnapshot().source).toBe("bundled");
+        });
+        (0, bun_test_1.it)("accepts an artifact from the same release as the bundled registry", async () => {
+            serveSigned(payload());
+            const client = clientWith();
+            (0, bun_test_1.expect)(await client.refresh()).toBe(true);
+        });
+        (0, bun_test_1.it)("accepts a newer release", async () => {
+            serveSigned(payload(index_1.chainRegistry, bumpedVersion()));
+            const client = clientWith();
+            (0, bun_test_1.expect)(await client.refresh()).toBe(true);
+            (0, bun_test_1.expect)(client.getSnapshot().version).toBe(bumpedVersion());
+        });
+        // An unparseable version is a pipeline bug to observe, not a reason to stop
+        // taking chain updates — the signature already establishes provenance.
+        (0, bun_test_1.it)("accepts an artifact whose version cannot be compared", async () => {
+            serveSigned(payload(index_1.chainRegistry, "not-a-semver"));
+            const client = clientWith();
+            (0, bun_test_1.expect)(await client.refresh()).toBe(true);
+        });
+    });
+    (0, bun_test_1.describe)("signature verification", () => {
+        (0, bun_test_1.it)("refuses to read remotely when the publicKey is explicitly cleared", async () => {
+            serveSigned(payload());
+            const phases = [];
+            const client = (0, chainFactsClient_1.createChainFactsClient)({
+                remoteUrl: REMOTE_URL,
+                publicKey: null,
+                onError: (_error, phase) => phases.push(phase),
+            });
+            (0, bun_test_1.expect)(await client.refresh()).toBe(false);
+            (0, bun_test_1.expect)(client.getSnapshot().source).toBe("bundled");
+            (0, bun_test_1.expect)(phases).toEqual(["config"]);
+        });
+        (0, bun_test_1.it)("rejects a payload signed by a key other than the bundled one", async () => {
+            // The default publicKey is the real KMS key, so a locally-signed payload
+            // must fail — this is what stops a rogue endpoint being trusted.
+            serveSigned(payload());
+            const phases = [];
+            const client = (0, chainFactsClient_1.createChainFactsClient)({
+                remoteUrl: REMOTE_URL,
+                onError: (_error, phase) => phases.push(phase),
+            });
+            (0, bun_test_1.expect)(await client.refresh()).toBe(false);
+            (0, bun_test_1.expect)(client.getSnapshot().source).toBe("bundled");
+            (0, bun_test_1.expect)(phases).toEqual(["verify"]);
+        });
+        (0, bun_test_1.it)("rejects a payload signed by a different key", async () => {
+            serveSigned(payload(), makeSigner());
+            const phases = [];
+            const client = clientWith({
+                onError: (_e, phase) => phases.push(phase),
+            });
+            (0, bun_test_1.expect)(await client.refresh()).toBe(false);
+            (0, bun_test_1.expect)(client.getSnapshot().source).toBe("bundled");
+            (0, bun_test_1.expect)(phases).toEqual(["verify"]);
+        });
+        (0, bun_test_1.it)("rejects a payload whose bytes were tampered with after signing", async () => {
+            const original = JSON.stringify(payload());
+            const signature = signer.sign(original);
+            // Flip a byte that certainly exists, so the test really tampers.
+            const tampered = original.replace('"name":"Ethereum"', '"name":"Ethereuq"');
+            (0, bun_test_1.expect)(tampered).not.toBe(original);
+            stubFetch(async (url) => url === SIGNATURE_URL
+                ? new Response(signature)
+                : new Response(tampered));
+            const phases = [];
+            const client = clientWith({
+                onError: (_e, phase) => phases.push(phase),
+            });
+            (0, bun_test_1.expect)(await client.refresh()).toBe(false);
+            (0, bun_test_1.expect)(client.getSnapshot().source).toBe("bundled");
+            (0, bun_test_1.expect)(phases).toEqual(["verify"]);
+        });
+        (0, bun_test_1.it)("rejects a malformed signature without throwing", async () => {
+            stubFetch(async (url) => url === SIGNATURE_URL
+                ? new Response("bm90LWEtc2lnbmF0dXJl")
+                : new Response(JSON.stringify(payload())));
+            const phases = [];
+            const client = clientWith({
+                onError: (_e, phase) => phases.push(phase),
+            });
+            (0, bun_test_1.expect)(await client.refresh()).toBe(false);
+            (0, bun_test_1.expect)(phases).toEqual(["verify"]);
+        });
+        (0, bun_test_1.it)("degrades to bundled when the signature is missing", async () => {
+            stubFetch(async (url) => url === SIGNATURE_URL
+                ? new Response("", { status: 404, statusText: "Not Found" })
+                : new Response(JSON.stringify(payload())));
+            const phases = [];
+            const client = clientWith({
+                onError: (_e, phase) => phases.push(phase),
+            });
+            (0, bun_test_1.expect)(await client.refresh()).toBe(false);
+            (0, bun_test_1.expect)(client.getSnapshot().source).toBe("bundled");
+            (0, bun_test_1.expect)(phases).toEqual(["fetch"]);
+        });
+        // ECDSA is randomised, so r and s vary per signature: roughly half have a
+        // high bit set (DER prepends 0x00) and some are shorter than 32 bytes
+        // (leading zeroes dropped). Both need left-padding into the fixed-width r‖s
+        // form WebCrypto wants, and getting it wrong fails only for *some*
+        // signatures — so sign repeatedly rather than once.
+        (0, bun_test_1.it)("verifies across many signatures, covering DER padding variants", async () => {
+            for (let i = 0; i < 25; i += 1) {
+                const body = payload();
+                body.version = `v${i}`;
+                serveSigned(body);
+                const client = clientWith();
+                (0, bun_test_1.expect)(await client.refresh()).toBe(true);
+                (0, bun_test_1.expect)(client.getSnapshot().version).toBe(`v${i}`);
+            }
+        });
+    });
+    (0, bun_test_1.describe)("never throws", () => {
+        bun_test_1.it.each([
+            [
+                "a network error",
+                () => stubFetch(async () => {
+                    throw new Error("ECONNREFUSED");
+                }),
+                "fetch",
+            ],
+            [
+                "a non-2xx response",
+                () => stubFetch(async () => new Response("", { status: 404, statusText: "Not Found" })),
+                "fetch",
+            ],
+            [
+                "a body that isn't JSON",
+                () => serveSigned("<html>502</html>"),
+                "parse",
+            ],
+        ])("degrades to bundled on %s", async (_label, arrange, expectedPhase) => {
+            arrange();
+            const phases = [];
+            const client = clientWith({
+                onError: (_e, phase) => phases.push(phase),
+            });
+            (0, bun_test_1.expect)(await client.refresh()).toBe(false);
+            (0, bun_test_1.expect)(client.getSnapshot().source).toBe("bundled");
+            (0, bun_test_1.expect)(phases).toEqual([expectedPhase]);
+        });
+        bun_test_1.it.each([
+            ["a payload with no version", { chains: index_1.chainRegistry }],
+            ["a payload with no chains", { version: "v1" }],
+        ])("degrades to bundled on %s", async (_label, body) => {
+            serveSigned(body);
+            const phases = [];
+            const client = clientWith({
+                onError: (_e, phase) => phases.push(phase),
+            });
+            (0, bun_test_1.expect)(await client.refresh()).toBe(false);
+            (0, bun_test_1.expect)(client.getSnapshot().source).toBe("bundled");
+            (0, bun_test_1.expect)(phases).toEqual(["parse"]);
+        });
+        (0, bun_test_1.it)("aborts a stalled response body rather than hanging", async () => {
+            // Headers land immediately; the body stream never completes and only
+            // errors when the request's AbortSignal fires, as real fetch does.
+            stubFetch(async (_url, init) => new Response(new ReadableStream({
+                start(controller) {
+                    init?.signal?.addEventListener("abort", () => controller.error(new DOMException("Aborted", "AbortError")));
+                },
+            })));
+            const errors = [];
+            const client = clientWith({
+                fetchTimeoutMs: 20,
+                onError: (error) => errors.push(error),
+            });
+            (0, bun_test_1.expect)(await client.refresh()).toBe(false);
+            (0, bun_test_1.expect)(client.getSnapshot().source).toBe("bundled");
+            (0, bun_test_1.expect)(errors).toHaveLength(1);
+        }, 1000);
+        (0, bun_test_1.it)("survives an onError callback that itself throws", async () => {
+            stubFetch(async () => {
+                throw new Error("ECONNREFUSED");
+            });
+            const client = clientWith({
+                onError: () => {
+                    throw new Error("buggy logging hook");
+                },
+            });
+            (0, bun_test_1.expect)(await client.refresh()).toBe(false);
+            (0, bun_test_1.expect)(client.getSnapshot().source).toBe("bundled");
+        });
+    });
+    (0, bun_test_1.describe)("payload shape", () => {
+        // Guards against the shape check drifting stricter than the real generated
+        // data: if it ever rejected chains.json, every consumer would silently sit
+        // on bundled forever.
+        (0, bun_test_1.it)("accepts the bundled registry itself, so the check matches real data", async () => {
+            serveSigned({ version: "mirrors-bundled", chains: index_1.chainRegistry });
+            const errors = [];
+            const client = clientWith({ onError: (e) => errors.push(e) });
+            (0, bun_test_1.expect)(await client.refresh()).toBe(true);
+            (0, bun_test_1.expect)(errors).toEqual([]);
+            (0, bun_test_1.expect)(client.getSnapshot().version).toBe("mirrors-bundled");
+        });
+        // Enum *values* are deliberately not validated, so a new settlement layer
+        // or quoter doesn't require every consumer to ship a release first.
+        (0, bun_test_1.it)("accepts unknown enum values and unknown keys, for forward compatibility", async () => {
+            serveSigned(payload(withEthereum({
+                settlementLayers: ["ACROSS", "SOME_FUTURE_LAYER"],
+                swapQuoters: ["some-future-quoter"],
+                someFieldThisBuildPredates: { nested: true },
+            })));
+            const client = clientWith();
+            (0, bun_test_1.expect)(await client.refresh()).toBe(true);
+            (0, bun_test_1.expect)(client.getSnapshot().source).toBe("remote");
+        });
+        bun_test_1.it.each([
+            ["chains is an empty object", {}],
+            ["chains is an array", []],
+            ["a key is not a chain id", { "not-a-chain-id": index_1.chainRegistry[ETHEREUM] }],
+            ["a key has a leading zero", { "01": index_1.chainRegistry[ETHEREUM] }],
+            ["an entry is not an object", { "1": "nope" }],
+        ])("rejects a registry where %s", async (_label, chains) => {
+            serveSigned(payload(chains));
+            const client = clientWith();
+            (0, bun_test_1.expect)(await client.refresh()).toBe(false);
+            (0, bun_test_1.expect)(client.getSnapshot().source).toBe("bundled");
+        });
+        bun_test_1.it.each([
+            ["name", { name: 5 }],
+            ["tokens", { tokens: "not-an-array" }],
+        ])("rejects an entry with a malformed %s", async (_label, overrides) => {
+            serveSigned(payload(withEthereum(overrides)));
+            const client = clientWith();
+            (0, bun_test_1.expect)(await client.refresh()).toBe(false);
+            (0, bun_test_1.expect)(client.getSnapshot().source).toBe("bundled");
+        });
+        // The realistic misconfiguration: pointing the URL at another artifact that
+        // is also keyed by chain id.
+        (0, bun_test_1.it)("rejects a payload that is a different chain-id-keyed blob", async () => {
+            serveSigned(payload({ "1": { providers: ["DRPC", "Alchemy"] } }));
+            const client = clientWith();
+            (0, bun_test_1.expect)(await client.refresh()).toBe(false);
+            (0, bun_test_1.expect)(client.getSnapshot().source).toBe("bundled");
+        });
+    });
+});

package/dist/src/chainFactsClient.d.ts

@@ -0,0 +1,57 @@
+import type { ChainRegistry } from "./types";
+/** Wire format of the published facts artifact. */
+interface ChainFactsPayload {
+    version: string;
+    chains: ChainRegistry;
+}
+type ChainFactsSource = "remote" | "bundled";
+type ChainFactsErrorPhase = "config" | "fetch" | "verify" | "parse" | "stale";
+interface ChainFactsSnapshot {
+    chains: ChainRegistry;
+    source: ChainFactsSource;
+    /** null for "bundled", which ships with the package and has no version stamp of its own. */
+    version: string | null;
+}
+interface ChainFactsClientOptions {
+    /**
+     * URL serving the facts JSON, with its detached signature at `<url>.sig`.
+     * Defaults to the published artifact; pass `null` to disable remote reads and
+     * always serve the bundled registry.
+     */
+    remoteUrl?: string | null;
+    /**
+     * Base64 SPKI DER of the ECDSA P-256 public key the artifact is signed with —
+     * i.e. exactly what `aws kms get-public-key --query PublicKey --output text`
+     * returns.
+     *
+     * Defaults to the key bundled with this package, so verification needs no
+     * configuration. Because the payload checks are only structural, this
+     * signature is what establishes that the facts came from the release
+     * pipeline; without it a remote read would be trusting whatever answered the
+     * URL. Explicitly clearing it therefore disables the remote tier rather than
+     * reading unverified — there is deliberately no way to opt out of
+     * verification while still reading remotely.
+     */
+    publicKey?: string | null;
+    fetchTimeoutMs?: number;
+    /** Called on every rejected read. Reads never throw, so this is the only way to observe one. */
+    onError?: (error: unknown, phase: ChainFactsErrorPhase) => void;
+}
+interface ChainFactsClient {
+    /** Fetches and installs the remote facts if usable. Resolves to whether they were installed; never rejects. */
+    refresh(): Promise<boolean>;
+    /** The active facts: remote once a refresh has succeeded, otherwise bundled. */
+    getSnapshot(): ChainFactsSnapshot;
+    getChainRegistry(): ChainRegistry;
+}
+/**
+ * Reads chain facts remote-first, falling back to the registry bundled with
+ * this package at publish time. Reads never throw — a failed or malformed
+ * fetch leaves the previous tier in place, so callers always get a usable
+ * registry. `getSnapshot().source` reports which tier served it, so consumers
+ * can alert on having run bundled for longer than expected.
+ */
+declare function createChainFactsClient(options?: ChainFactsClientOptions): ChainFactsClient;
+export { createChainFactsClient };
+export type { ChainFactsClient, ChainFactsClientOptions, ChainFactsErrorPhase, ChainFactsPayload, ChainFactsSnapshot, ChainFactsSource, };
+//# sourceMappingURL=chainFactsClient.d.ts.map

package/dist/src/chainFactsClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chainFactsClient.d.ts","sourceRoot":"","sources":["../../src/chainFactsClient.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAI7C,mDAAmD;AACnD,UAAU,iBAAiB;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,aAAa,CAAC;CACvB;AAED,KAAK,gBAAgB,GAAG,QAAQ,GAAG,SAAS,CAAC;AAE7C,KAAK,oBAAoB,GAAG,QAAQ,GAAG,OAAO,GAAG,QAAQ,GAAG,OAAO,GAAG,OAAO,CAAC;AAE9E,UAAU,kBAAkB;IAC1B,MAAM,EAAE,aAAa,CAAC;IACtB,MAAM,EAAE,gBAAgB,CAAC;IACzB,4FAA4F;IAC5F,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB;AAED,UAAU,uBAAuB;IAC/B;;;;OAIG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B;;;;;;;;;;;;OAYG;IACH,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,gGAAgG;IAChG,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,oBAAoB,KAAK,IAAI,CAAC;CACjE;AAED,UAAU,gBAAgB;IACxB,+GAA+G;IAC/G,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAC5B,gFAAgF;IAChF,WAAW,IAAI,kBAAkB,CAAC;IAClC,gBAAgB,IAAI,aAAa,CAAC;CACnC;AAyKD;;;;;;GAMG;AACH,iBAAS,sBAAsB,CAC7B,OAAO,GAAE,uBAA4B,GACpC,gBAAgB,CAyKlB;AAED,OAAO,EAAE,sBAAsB,EAAE,CAAC;AAClC,YAAY,EACV,gBAAgB,EAChB,uBAAuB,EACvB,oBAAoB,EACpB,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,GACjB,CAAC"}