@artblocks/abx-storage 0.1.0-alpha.8 → 0.1.0

package/dist/migrate.d.ts

@@ -0,0 +1,37 @@
+/**
+ * The storage half of a resolver migration: re-pinning node-custody images to a durable backend.
+ *
+ * The rest of the migration — reconciling a destination resolver's off-chain state against a
+ * source resolver's served JSON (`buildMigrationPlan`/`verifyParity`) — is pure fetch-based
+ * reconciliation with no storage dependency, so it lives in `@artblocks/abx-sdk`'s `migrate.ts`.
+ * This module is the one piece that needs an actual byte-custody backend: turning a
+ * {@link NodeCustodyImage} (bytes that live only on the soon-to-be-decommissioned source host)
+ * into a portable, durable locator.
+ */
+import { type StorageBackend } from './backend.js';
+import type { NodeCustodyImage } from '@artblocks/abx-sdk';
+/**
+ * Re-pin node-custody images to a DURABLE backend so the destination never depends on the
+ * (soon-to-be-decommissioned) source host. For each image: fetch the bytes from the source,
+ * **verify** them against the on-chain hash (trustless — we trust the chain, not the old node),
+ * then `put` them to the destination operator's own backend and read back a portable locator.
+ *
+ * If the configured backend isn't durable (no `locator` — fs/cloud serve only through their own
+ * node, so re-pinning there just moves the single-host dependency), we re-pin NOTHING and report
+ * every image as `needsDurableBackend`: the right move is to configure IPFS/Arweave and re-run,
+ * never to bridge a URL that points back at the dying host.
+ */
+export interface RepinResult {
+    /** hash → new durable locator, ready to bridge to the destination. */
+    repinned: Record<string, string>;
+    /** Re-pinned token ids (for reporting). */
+    repinnedTokens: string[];
+    /** Bytes fetched but their hash didn't match the on-chain commitment — NOT trusted, NOT pinned. */
+    mismatched: NodeCustodyImage[];
+    /** Couldn't fetch the bytes from the source (host down, 404). */
+    unreachable: NodeCustodyImage[];
+    /** Skipped because no durable backend is configured — these need IPFS/Arweave + a re-run. */
+    needsDurableBackend: NodeCustodyImage[];
+}
+export declare function repinNodeCustody(images: NodeCustodyImage[], backend: StorageBackend): Promise<RepinResult>;
+//# sourceMappingURL=migrate.d.ts.map

package/dist/migrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate.d.ts","sourceRoot":"","sources":["../src/migrate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAc,KAAK,cAAc,EAAC,MAAM,cAAc,CAAC;AAC9D,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,oBAAoB,CAAC;AAGzD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,WAAW;IAC1B,sEAAsE;IACtE,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,2CAA2C;IAC3C,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,mGAAmG;IACnG,UAAU,EAAE,gBAAgB,EAAE,CAAC;IAC/B,iEAAiE;IACjE,WAAW,EAAE,gBAAgB,EAAE,CAAC;IAChC,6FAA6F;IAC7F,mBAAmB,EAAE,gBAAgB,EAAE,CAAC;CACzC;AAED,wBAAsB,gBAAgB,CAAC,MAAM,EAAE,gBAAgB,EAAE,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,WAAW,CAAC,CAyChH"}

package/dist/migrate.js

@@ -0,0 +1,55 @@
+/**
+ * The storage half of a resolver migration: re-pinning node-custody images to a durable backend.
+ *
+ * The rest of the migration — reconciling a destination resolver's off-chain state against a
+ * source resolver's served JSON (`buildMigrationPlan`/`verifyParity`) — is pure fetch-based
+ * reconciliation with no storage dependency, so it lives in `@artblocks/abx-sdk`'s `migrate.ts`.
+ * This module is the one piece that needs an actual byte-custody backend: turning a
+ * {@link NodeCustodyImage} (bytes that live only on the soon-to-be-decommissioned source host)
+ * into a portable, durable locator.
+ */
+import { hashContent } from './backend.js';
+export async function repinNodeCustody(images, backend) {
+    const result = { repinned: {}, repinnedTokens: [], mismatched: [], unreachable: [], needsDurableBackend: [] };
+    if (!images.length)
+        return result;
+    // A backend is "durable" for migration iff it can hand back a node-independent locator.
+    if (!backend.locator) {
+        result.needsDurableBackend = [...images];
+        return result;
+    }
+    for (const img of images) {
+        let bytes;
+        let contentType;
+        try {
+            const resp = await fetch(img.imageUrl);
+            if (!resp.ok) {
+                result.unreachable.push(img);
+                continue;
+            }
+            bytes = new Uint8Array(await resp.arrayBuffer());
+            contentType = resp.headers.get('content-type') ?? 'application/octet-stream';
+        }
+        catch {
+            result.unreachable.push(img);
+            continue;
+        }
+        // Trustless: re-hash the fetched bytes and compare to the ON-CHAIN commitment.
+        if (hashContent(bytes).toLowerCase() !== img.hash.toLowerCase()) {
+            result.mismatched.push(img);
+            continue;
+        }
+        await backend.put(img.hash, { bytes, contentType });
+        const loc = await backend.locator(img.hash);
+        if (loc) {
+            result.repinned[img.hash.toLowerCase()] = loc;
+            result.repinnedTokens.push(img.tokenId);
+        }
+        else {
+            // Stored, but the backend still can't produce a portable locator — treat as not durable.
+            result.needsDurableBackend.push(img);
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=migrate.js.map

package/dist/migrate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrate.js","sourceRoot":"","sources":["../src/migrate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,EAAC,WAAW,EAAsB,MAAM,cAAc,CAAC;AA4B9D,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,MAA0B,EAAE,OAAuB;IACxF,MAAM,MAAM,GAAgB,EAAC,QAAQ,EAAE,EAAE,EAAE,cAAc,EAAE,EAAE,EAAE,UAAU,EAAE,EAAE,EAAE,WAAW,EAAE,EAAE,EAAE,mBAAmB,EAAE,EAAE,EAAC,CAAC;IACzH,IAAI,CAAC,MAAM,CAAC,MAAM;QAAE,OAAO,MAAM,CAAC;IAElC,wFAAwF;IACxF,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;QACrB,MAAM,CAAC,mBAAmB,GAAG,CAAC,GAAG,MAAM,CAAC,CAAC;QACzC,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,KAAK,MAAM,GAAG,IAAI,MAAM,EAAE,CAAC;QACzB,IAAI,KAAiB,CAAC;QACtB,IAAI,WAAmB,CAAC;QACxB,IAAI,CAAC;YACH,MAAM,IAAI,GAAG,MAAM,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;YACvC,IAAI,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC;gBACb,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;gBAC7B,SAAS;YACX,CAAC;YACD,KAAK,GAAG,IAAI,UAAU,CAAC,MAAM,IAAI,CAAC,WAAW,EAAE,CAAC,CAAC;YACjD,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,GAAG,CAAC,cAAc,CAAC,IAAI,0BAA0B,CAAC;QAC/E,CAAC;QAAC,MAAM,CAAC;YACP,MAAM,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAC7B,SAAS;QACX,CAAC;QACD,+EAA+E;QAC/E,IAAI,WAAW,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,KAAK,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,EAAE,CAAC;YAChE,MAAM,CAAC,UAAU,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAC5B,SAAS;QACX,CAAC;QACD,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAW,EAAE,EAAC,KAAK,EAAE,WAAW,EAAC,CAAC,CAAC;QACzD,MAAM,GAAG,GAAG,MAAM,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,IAAW,CAAC,CAAC;QACnD,IAAI,GAAG,EAAE,CAAC;YACR,MAAM,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,GAAG,GAAG,CAAC;YAC9C,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAC1C,CAAC;aAAM,CAAC;YACN,yFAAyF;YACzF,MAAM,CAAC,mBAAmB,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QACvC,CAAC;IACH,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/probe.d.ts

@@ -0,0 +1,66 @@
+import type { StorageBackend } from './backend.js';
+import type { CloudStorageConfig } from './cloud.js';
+import { type ArweaveConfig } from './arweave.js';
+import { type ResolveStorageOptions } from './resolve.js';
+/**
+ * `abx storage show --check` / `abx doctor`'s storage section — go beyond "is this backend
+ * CONFIGURED" (what {@link resolveBackend} plus each backend's own `health()` already answer) to
+ * "does a write actually reach the URL a token would bake on-chain."
+ *
+ * The gap this closes is the R2/S3 endpoint-vs-public-base confusion: a backend's `health()` signs
+ * a request against the API `endpoint` — proving credentials work — but never touches the SEPARATE
+ * `publicBase` a marketplace would actually fetch from. Those can point at different buckets (or one
+ * can simply be wrong) with `health()` reporting green the whole time. A PUT through the API,
+ * fetched back over the PUBLIC base with a plain unsigned GET, is the only check that proves the two
+ * agree.
+ *
+ * `fs` and `ipfs` are NOT reimplemented here — their existing `health()` already does exactly what's
+ * asked (fs: writability; ipfs: gateway/API reachability, no upload) and duplicating that logic is
+ * how the two copies drift. `arweave` layers a balance READ (never a paid upload) on top of its
+ * existing identity check. `cloud` gets the new round trip.
+ */
+export interface StorageCheckResult {
+    backend: string;
+    ok: boolean;
+    detail: string;
+    /** Set on a `cloud` check — the API write target and the public read URL, so a mismatch between
+     *  them (the R2/S3 endpoint-vs-public-base trap) is visible on failure rather than a bare
+     *  "fetch failed". Equal in shape, not necessarily in host — that's exactly what's being checked. */
+    putUrl?: string;
+    publicUrl?: string;
+}
+export interface StorageCheckOptions {
+    /** Bound on each network step. A backend method with no abort hook (cloud's `putObject`/
+     *  `getObject`, arweave's balance read) is raced against this rather than truly cancelled — good
+     *  enough to keep a caller (doctor) from hanging, not a guarantee the underlying request stopped. */
+    timeoutMs?: number;
+    /** Injectable for tests — used for the public-base GET only (the PUT/API side goes through the
+     *  resolved backend, which owns its own signing). */
+    fetchFn?: typeof fetch;
+}
+/** fs + ipfs (and any future backend with nothing more to add): delegate straight to the existing
+ *  `health()` — see the module doc for why this is reuse, not a stand-in pending real logic. */
+export declare function checkViaHealth(backend: StorageBackend, opts?: StorageCheckOptions): Promise<StorageCheckResult>;
+/**
+ * `cloud`: PUT a tiny probe object through the signed API, then GET it back with a plain,
+ * UNSIGNED fetch against `publicBase` — the same request a marketplace/browser would make. Reuses
+ * one well-known key (`abx-probe/check.txt`) rather than minting a new one per run, so repeated
+ * checks don't litter the bucket. `cfg` (when given) names the API write target too — the R2/S3
+ * endpoint-vs-public-base trap is only diagnosable if BOTH URLs are on screen, not just the one
+ * that failed.
+ */
+export declare function checkCloudBackend(backend: StorageBackend, cfg?: CloudStorageConfig, opts?: StorageCheckOptions): Promise<StorageCheckResult>;
+/**
+ * `arweave`: the existing `health()` (gateway reachability + identity presence) plus a Turbo
+ * BALANCE read when an identity already exists — never a paid upload (no identity yet is reported
+ * as-is: it's created free on first real upload, so there's nothing to check).
+ */
+export declare function checkArweaveBackend(backend: StorageBackend, cfg: ArweaveConfig | undefined, opts?: StorageCheckOptions): Promise<StorageCheckResult>;
+/**
+ * The one storage-config probe both `abx storage show --check` and `abx doctor` call — dispatches to
+ * the right per-backend check above. Resolving the backend can throw (missing required config, e.g.
+ * cloud with no endpoint/bucket) — same as every other `resolveBackend` call site, and the caller's
+ * existing try/catch around it is the right place to handle that, not this function.
+ */
+export declare function probeStorageBackend(opts: ResolveStorageOptions, checkOpts?: StorageCheckOptions): Promise<StorageCheckResult>;
+//# sourceMappingURL=probe.d.ts.map

package/dist/probe.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"probe.d.ts","sourceRoot":"","sources":["../src/probe.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,cAAc,CAAC;AACjD,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,YAAY,CAAC;AACnD,OAAO,EAAqE,KAAK,aAAa,EAAC,MAAM,cAAc,CAAC;AACpH,OAAO,EAAiB,KAAK,qBAAqB,EAAC,MAAM,cAAc,CAAC;AAExE;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf;;yGAEqG;IACrG,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,mBAAmB;IAClC;;yGAEqG;IACrG,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;yDACqD;IACrD,OAAO,CAAC,EAAE,OAAO,KAAK,CAAC;CACxB;AAqBD;gGACgG;AAChG,wBAAsB,cAAc,CAAC,OAAO,EAAE,cAAc,EAAE,IAAI,GAAE,mBAAwB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAYzH;AAED;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,cAAc,EAAE,GAAG,CAAC,EAAE,kBAAkB,EAAE,IAAI,GAAE,mBAAwB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CA+DtJ;AAED;;;;GAIG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,cAAc,EAAE,GAAG,EAAE,aAAa,GAAG,SAAS,EAAE,IAAI,GAAE,mBAAwB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CA0B9J;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,qBAAqB,EAAE,SAAS,GAAE,mBAAwB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAKvI"}

package/dist/probe.js

@@ -0,0 +1,155 @@
+import { randomBytes } from 'node:crypto';
+import { arweaveFunding, turboIdentity, turboIdentityAddress, isEthIdentity } from './arweave.js';
+import { resolveBackend } from './resolve.js';
+/** Matches readiness.ts's gateway-probe default — this module's other real-network default. */
+const DEFAULT_CHECK_TIMEOUT_MS = 6000;
+/** Race a call against a `ms` deadline, rejecting with `message` if it wins. Most methods probed
+ *  here have no abort hook of their own, so this stops WAITING for a hung request rather than
+ *  cancelling it — good enough to keep a caller (doctor) from hanging. Always clears its timer, so
+ *  a fast call doesn't leave one pending. */
+async function race(p, ms, message) {
+    let timer;
+    const timeout = new Promise((_, reject) => {
+        timer = setTimeout(() => reject(new Error(message)), ms);
+    });
+    try {
+        return await Promise.race([p, timeout]);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** fs + ipfs (and any future backend with nothing more to add): delegate straight to the existing
+ *  `health()` — see the module doc for why this is reuse, not a stand-in pending real logic. */
+export async function checkViaHealth(backend, opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_CHECK_TIMEOUT_MS;
+    try {
+        const h = await race(backend.health?.() ?? Promise.resolve({ ok: true, detail: 'no check defined for this backend' }), timeoutMs, `timed out after ${timeoutMs}ms`);
+        return { backend: backend.id, ok: h.ok, detail: h.detail ?? '' };
+    }
+    catch (e) {
+        return { backend: backend.id, ok: false, detail: e.message };
+    }
+}
+/**
+ * `cloud`: PUT a tiny probe object through the signed API, then GET it back with a plain,
+ * UNSIGNED fetch against `publicBase` — the same request a marketplace/browser would make. Reuses
+ * one well-known key (`abx-probe/check.txt`) rather than minting a new one per run, so repeated
+ * checks don't litter the bucket. `cfg` (when given) names the API write target too — the R2/S3
+ * endpoint-vs-public-base trap is only diagnosable if BOTH URLs are on screen, not just the one
+ * that failed.
+ */
+export async function checkCloudBackend(backend, cfg, opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_CHECK_TIMEOUT_MS;
+    const key = 'abx-probe/check.txt';
+    const putUrl = cfg ? `${cfg.endpoint.replace(/\/+$/, '')}/${cfg.bucket}/${key}` : undefined;
+    if (!backend.publicBase) {
+        return {
+            backend: 'cloud',
+            ok: false,
+            detail: "no public read base configured — set ABX_S3_PUBLIC_BASE (or --public-base) to the bucket's public URL.",
+            putUrl,
+        };
+    }
+    if (!backend.putObject || !backend.getObject) {
+        return { backend: 'cloud', ok: false, detail: 'this cloud backend has no putObject/getObject — cannot round-trip check it.', putUrl };
+    }
+    const publicUrl = `${backend.publicBase.replace(/\/+$/, '')}/${key}`;
+    const token = randomBytes(8).toString('hex');
+    const body = `abx storage check ${token}`;
+    const bytes = new TextEncoder().encode(body);
+    try {
+        await race(backend.putObject(key, { bytes, contentType: 'text/plain' }), timeoutMs, `PUT timed out after ${timeoutMs}ms`);
+    }
+    catch (e) {
+        return { backend: 'cloud', ok: false, detail: `PUT via the API failed: ${e.message}`, putUrl, publicUrl };
+    }
+    const fetchFn = opts.fetchFn ?? fetch;
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+    try {
+        const res = await fetchFn(publicUrl, { signal: ctrl.signal });
+        if (!res.ok) {
+            return {
+                backend: 'cloud',
+                ok: false,
+                detail: `GET via the public base failed (${res.status}) — the public base may point at a different bucket/endpoint than the write API.`,
+                putUrl,
+                publicUrl,
+            };
+        }
+        const got = new TextDecoder().decode(new Uint8Array(await res.arrayBuffer()));
+        if (got !== body) {
+            return {
+                backend: 'cloud',
+                ok: false,
+                detail: 'GET via the public base returned different bytes than were PUT — check for a caching layer or a public base pointed at a different bucket.',
+                putUrl,
+                publicUrl,
+            };
+        }
+        return { backend: 'cloud', ok: true, detail: `round-trip ok via ${publicUrl}`, putUrl, publicUrl };
+    }
+    catch (e) {
+        const aborted = e.name === 'AbortError';
+        return {
+            backend: 'cloud',
+            ok: false,
+            detail: aborted ? `GET via the public base timed out after ${timeoutMs}ms` : `GET via the public base failed: ${e.message}`,
+            putUrl,
+            publicUrl,
+        };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/**
+ * `arweave`: the existing `health()` (gateway reachability + identity presence) plus a Turbo
+ * BALANCE read when an identity already exists — never a paid upload (no identity yet is reported
+ * as-is: it's created free on first real upload, so there's nothing to check).
+ */
+export async function checkArweaveBackend(backend, cfg, opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_CHECK_TIMEOUT_MS;
+    let base;
+    try {
+        base = await race(backend.health?.() ?? Promise.resolve({ ok: true, detail: '' }), timeoutMs, `timed out after ${timeoutMs}ms`);
+    }
+    catch (e) {
+        base = { ok: false, detail: e.message };
+    }
+    if (!cfg)
+        return { backend: 'arweave', ok: base.ok, detail: base.detail ?? '' };
+    const id = turboIdentity(cfg);
+    if (!id) {
+        return { backend: 'arweave', ok: base.ok, detail: [base.detail, 'no identity yet — created free on first upload (nothing to check)'].filter(Boolean).join(' · ') };
+    }
+    try {
+        const funding = await arweaveFunding(cfg);
+        const { credits } = await race(funding.balance(), timeoutMs, `balance check timed out after ${timeoutMs}ms`);
+        const address = turboIdentityAddress(id);
+        return {
+            backend: 'arweave',
+            ok: base.ok,
+            detail: [base.detail, `${credits} credits (identity ${address}${isEthIdentity(id) ? ', eth' : ''})`].filter(Boolean).join(' · '),
+        };
+    }
+    catch (e) {
+        return { backend: 'arweave', ok: base.ok, detail: [base.detail, `balance check failed: ${e.message}`].filter(Boolean).join(' · ') };
+    }
+}
+/**
+ * The one storage-config probe both `abx storage show --check` and `abx doctor` call — dispatches to
+ * the right per-backend check above. Resolving the backend can throw (missing required config, e.g.
+ * cloud with no endpoint/bucket) — same as every other `resolveBackend` call site, and the caller's
+ * existing try/catch around it is the right place to handle that, not this function.
+ */
+export async function probeStorageBackend(opts, checkOpts = {}) {
+    const backend = resolveBackend(opts);
+    if (backend.id === 'cloud' || backend.id === 's3')
+        return checkCloudBackend(backend, opts.cloud, checkOpts);
+    if (backend.id === 'arweave')
+        return checkArweaveBackend(backend, opts.arweave, checkOpts);
+    return checkViaHealth(backend, checkOpts);
+}
+//# sourceMappingURL=probe.js.map

package/dist/probe.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"probe.js","sourceRoot":"","sources":["../src/probe.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,WAAW,EAAC,MAAM,aAAa,CAAC;AAGxC,OAAO,EAAC,cAAc,EAAE,aAAa,EAAE,oBAAoB,EAAE,aAAa,EAAqB,MAAM,cAAc,CAAC;AACpH,OAAO,EAAC,cAAc,EAA6B,MAAM,cAAc,CAAC;AAwCxE,+FAA+F;AAC/F,MAAM,wBAAwB,GAAG,IAAI,CAAC;AAEtC;;;6CAG6C;AAC7C,KAAK,UAAU,IAAI,CAAI,CAAa,EAAE,EAAU,EAAE,OAAe;IAC/D,IAAI,KAAoC,CAAC;IACzC,MAAM,OAAO,GAAG,IAAI,OAAO,CAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE;QAC/C,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IAC3D,CAAC,CAAC,CAAC;IACH,IAAI,CAAC;QACH,OAAO,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC;IAC1C,CAAC;YAAS,CAAC;QACT,YAAY,CAAC,KAAM,CAAC,CAAC;IACvB,CAAC;AACH,CAAC;AAED;gGACgG;AAChG,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,OAAuB,EAAE,OAA4B,EAAE;IAC1F,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,IAAI,wBAAwB,CAAC;IAC7D,IAAI,CAAC;QACH,MAAM,CAAC,GAAG,MAAM,IAAI,CAClB,OAAO,CAAC,MAAM,EAAE,EAAE,IAAI,OAAO,CAAC,OAAO,CAAC,EAAC,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,mCAAmC,EAAC,CAAC,EAC9F,SAAS,EACT,mBAAmB,SAAS,IAAI,CACjC,CAAC;QACF,OAAO,EAAC,OAAO,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC,MAAM,IAAI,EAAE,EAAC,CAAC;IACjE,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,EAAC,OAAO,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAG,CAAW,CAAC,OAAO,EAAC,CAAC;IACxE,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAAC,OAAuB,EAAE,GAAwB,EAAE,OAA4B,EAAE;IACvH,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,IAAI,wBAAwB,CAAC;IAC7D,MAAM,GAAG,GAAG,qBAAqB,CAAC;IAClC,MAAM,MAAM,GAAG,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,GAAG,CAAC,MAAM,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;IAC5F,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC;QACxB,OAAO;YACL,OAAO,EAAE,OAAO;YAChB,EAAE,EAAE,KAAK;YACT,MAAM,EAAE,wGAAwG;YAChH,MAAM;SACP,CAAC;IACJ,CAAC;IACD,IAAI,CAAC,OAAO,CAAC,SAAS,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC;QAC7C,OAAO,EAAC,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,6EAA6E,EAAE,MAAM,EAAC,CAAC;IACtI,CAAC;IACD,MAAM,SAAS,GAAG,GAAG,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC,IAAI,GAAG,EAAE,CAAC;IACrE,MAAM,KAAK,GAAG,WAAW,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC7C,MAAM,IAAI,GAAG,qBAAqB,KAAK,EAAE,CAAC;IAC1C,MAAM,KAAK,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAE7C,IAAI,CAAC;QACH,MAAM,IAAI,CAAC,OAAO,CAAC,SAAS,CAAC,GAAG,EAAE,EAAC,KAAK,EAAE,WAAW,EAAE,YAAY,EAAC,CAAC,EAAE,SAAS,EAAE,uBAAuB,SAAS,IAAI,CAAC,CAAC;IAC1H,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,EAAC,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,EAAE,2BAA4B,CAAW,CAAC,OAAO,EAAE,EAAE,MAAM,EAAE,SAAS,EAAC,CAAC;IACrH,CAAC;IAED,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,IAAI,KAAK,CAAC;IACtC,MAAM,IAAI,GAAG,IAAI,eAAe,EAAE,CAAC;IACnC,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,SAAS,CAAC,CAAC;IACxD,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,MAAM,OAAO,CAAC,SAAS,EAAE,EAAC,MAAM,EAAE,IAAI,CAAC,MAAM,EAAC,CAAC,CAAC;QAC5D,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC;YACZ,OAAO;gBACL,OAAO,EAAE,OAAO;gBAChB,EAAE,EAAE,KAAK;gBACT,MAAM,EAAE,mCAAmC,GAAG,CAAC,MAAM,kFAAkF;gBACvI,MAAM;gBACN,SAAS;aACV,CAAC;QACJ,CAAC;QACD,MAAM,GAAG,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC;QAC9E,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;YACjB,OAAO;gBACL,OAAO,EAAE,OAAO;gBAChB,EAAE,EAAE,KAAK;gBACT,MAAM,EAAE,4IAA4I;gBACpJ,MAAM;gBACN,SAAS;aACV,CAAC;QACJ,CAAC;QACD,OAAO,EAAC,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,qBAAqB,SAAS,EAAE,EAAE,MAAM,EAAE,SAAS,EAAC,CAAC;IACnG,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,MAAM,OAAO,GAAI,CAAW,CAAC,IAAI,KAAK,YAAY,CAAC;QACnD,OAAO;YACL,OAAO,EAAE,OAAO;YAChB,EAAE,EAAE,KAAK;YACT,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC,2CAA2C,SAAS,IAAI,CAAC,CAAC,CAAC,mCAAoC,CAAW,CAAC,OAAO,EAAE;YACtI,MAAM;YACN,SAAS;SACV,CAAC;IACJ,CAAC;YAAS,CAAC;QACT,YAAY,CAAC,KAAK,CAAC,CAAC;IACtB,CAAC;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CAAC,OAAuB,EAAE,GAA8B,EAAE,OAA4B,EAAE;IAC/H,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,IAAI,wBAAwB,CAAC;IAC7D,IAAI,IAAoC,CAAC;IACzC,IAAI,CAAC;QACH,IAAI,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,IAAI,OAAO,CAAC,OAAO,CAAC,EAAC,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAC,CAAC,EAAE,SAAS,EAAE,mBAAmB,SAAS,IAAI,CAAC,CAAC;IAChI,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,IAAI,GAAG,EAAC,EAAE,EAAE,KAAK,EAAE,MAAM,EAAG,CAAW,CAAC,OAAO,EAAC,CAAC;IACnD,CAAC;IACD,IAAI,CAAC,GAAG;QAAE,OAAO,EAAC,OAAO,EAAE,SAAS,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,MAAM,IAAI,EAAE,EAAC,CAAC;IAE9E,MAAM,EAAE,GAAG,aAAa,CAAC,GAAG,CAAC,CAAC;IAC9B,IAAI,CAAC,EAAE,EAAE,CAAC;QACR,OAAO,EAAC,OAAO,EAAE,SAAS,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,mEAAmE,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,EAAC,CAAC;IACnK,CAAC;IACD,IAAI,CAAC;QACH,MAAM,OAAO,GAAG,MAAM,cAAc,CAAC,GAAG,CAAC,CAAC;QAC1C,MAAM,EAAC,OAAO,EAAC,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,iCAAiC,SAAS,IAAI,CAAC,CAAC;QAC3G,MAAM,OAAO,GAAG,oBAAoB,CAAC,EAAE,CAAC,CAAC;QACzC,OAAO;YACL,OAAO,EAAE,SAAS;YAClB,EAAE,EAAE,IAAI,CAAC,EAAE;YACX,MAAM,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,OAAO,sBAAsB,OAAO,GAAG,aAAa,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC;SACjI,CAAC;IACJ,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,EAAC,OAAO,EAAE,SAAS,EAAE,EAAE,EAAE,IAAI,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,IAAI,CAAC,MAAM,EAAE,yBAA0B,CAAW,CAAC,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,EAAC,CAAC;IAC/I,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CAAC,IAA2B,EAAE,YAAiC,EAAE;IACxG,MAAM,OAAO,GAAG,cAAc,CAAC,IAAI,CAAC,CAAC;IACrC,IAAI,OAAO,CAAC,EAAE,KAAK,OAAO,IAAI,OAAO,CAAC,EAAE,KAAK,IAAI;QAAE,OAAO,iBAAiB,CAAC,OAAO,EAAE,IAAI,CAAC,KAAK,EAAE,SAAS,CAAC,CAAC;IAC5G,IAAI,OAAO,CAAC,EAAE,KAAK,SAAS;QAAE,OAAO,mBAAmB,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;IAC3F,OAAO,cAAc,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;AAC5C,CAAC"}

package/dist/readiness.d.ts

@@ -0,0 +1,158 @@
+import { type LocatorNetwork } from '@artblocks/abx-sdk';
+export { gatewayUrlFor } from '@artblocks/abx-sdk';
+export type { LocatorNetwork } from '@artblocks/abx-sdk';
+/**
+ * Is a locator **retrievable** yet — not just accepted?
+ *
+ * An upload service answers "accepted" the moment it has your bytes; a gateway answers "serving"
+ * only once they have propagated to it, and on Arweave that gap runs to minutes. Nothing in the
+ * upload result distinguishes the two, so the natural implementation — upload during a mint, write
+ * the locator into the token — mints a token that renders broken for the first minutes of its life.
+ *
+ * Two independent integrators hit this eight days apart. The first rebuilt this layer themselves
+ * (ranged GETs, a propagating/ready model, retry ladders lengthened after measuring real times) and
+ * concluded "every serious integrator will rebuild some version of this." The second published 32
+ * renders and found **32/32 404ing on `arweave.net` while 22/32 already served from `permagate.io`
+ * and `vilenarios.com`**, with the uploader reporting `CONFIRMED` throughout. That second
+ * observation is why this probes several gateways rather than one: propagation is per-gateway, so
+ * "your gateway doesn't have it" and "the network doesn't have it" are different answers, and only
+ * one of them means something is wrong.
+ */
+export type Readiness = 
+/** The gateway this toolkit would actually use serves the bytes. Safe to reference. */
+'ready'
+/** Another gateway serves it, so the data provably exists on the network — yours hasn't caught
+ *  up. Waiting is the fix. */
+ | 'propagating'
+/** No probed gateway serves it. Deliberately NOT called "propagating": from outside, a locator
+ *  that is still settling and one that is simply wrong look identical, and claiming the friendlier
+ *  of the two is how a tool teaches someone to ignore it. */
+ | 'unreachable';
+export interface GatewayProbe {
+    /** The exact URL asked. */
+    url: string;
+    /** Host only — what a human recognises. */
+    gateway: string;
+    /** Whether this gateway served the bytes. */
+    serving: boolean;
+    /** HTTP status, or null when the request never completed (timeout, DNS, refused). */
+    status: number | null;
+    contentType: string | null;
+    /** Total size when the gateway reported one, else null. A ranged request is used, so this comes
+     *  from `content-range`'s total rather than `content-length` (which is 1 byte on a 206). */
+    bytes: number | null;
+    ms: number;
+    /** Why the request didn't complete. Absent when it did, whatever the status. */
+    error?: string;
+}
+export interface LocatorStatus {
+    /** The locator as given. */
+    locator: string;
+    network: LocatorNetwork;
+    /** The txid / CID / absolute URL the locator resolves to. */
+    id: string;
+    readiness: Readiness;
+    /** The gateway a baked locator would actually resolve through — the one that decides whether a
+     *  marketplace can render this today. */
+    primary: GatewayProbe;
+    /** Well-known others for the same network. Their whole job is to tell propagation from a bad id. */
+    alternates: GatewayProbe[];
+}
+export interface LocatorStatusOptions {
+    /** The gateway to treat as primary — normally the one the active backend is configured with, so
+     *  the verdict is about the gateway that will really be used. Defaults per network. */
+    gateway?: string;
+    /** Skip the alternates (one request instead of three). The cost is the `propagating` verdict:
+     *  without them, a locator that hasn't reached your gateway is indistinguishable from a bad one. */
+    primaryOnly?: boolean;
+    timeoutMs?: number;
+    fetchFn?: typeof fetch;
+}
+/** Parse any accepted locator form into its network + id. */
+export declare function parseLocator(locator: string): {
+    network: LocatorNetwork;
+    id: string;
+};
+/**
+ * The gateway BASE for a locator network — **override → env → generic public default**
+ * (`ABX_IPFS_GATEWAY`/`ABX_ARWEAVE_GATEWAY`, then `ipfs.io`/`arweave.net`). This is the READ-TIME
+ * default for resolving an arbitrary on-chain locator whose upload backend is unknown to the
+ * resolver — distinct from {@link ipfsConfigFromEnv}/{@link arweaveConfigFromEnv}'s MODE-aware
+ * defaults for a backend this toolkit itself configured to write through (e.g. a `kubo` IPFS
+ * gateway defaults to `127.0.0.1:8080`, a locator resolver has no such context and must default
+ * to something that resolves for anyone). `http` locators carry their own base (they are already
+ * an absolute URL) and never reach here — callers return them verbatim before consulting a gateway.
+ *
+ * A thin compose over the SDK's split: {@link resolveGatewayBase} used to own the
+ * `override ?? env ?? default` line itself (`process.env` read inline); now the pure decision
+ * lives in `@artblocks/abx-sdk`'s `resolveGatewayBase` (src/gateways.ts) and the env read in its
+ * `gatewayConfigFromEnv`, so this function's whole body is just wiring override → (env or
+ * nothing) → the SDK's pure default. Kept here, under this same name and signature, because
+ * every existing caller (this package's own `locatorStatus`, token-api's `resolveLocatorUrl`)
+ * still wants exactly this three-rung precedence with one call.
+ */
+export declare function resolveGatewayBase(network: LocatorNetwork, override?: string): string;
+/**
+ * Ask one gateway whether it serves these bytes, reading **headers only**.
+ *
+ * A ranged request (`Range: bytes=0-0`) is what keeps this cheap: the content in question can be tens of
+ * megabytes and the question is only whether it is there. Gateways that ignore `Range` answer 200
+ * with the whole body, so the body is cancelled rather than read — without that, checking a large
+ * locator would download it.
+ */
+export declare function probeGateway(url: string, opts?: {
+    timeoutMs?: number;
+    fetchFn?: typeof fetch;
+}): Promise<GatewayProbe>;
+/** Accepted-vs-retrievable for one locator, across the gateway that matters and a couple of others. */
+export declare function locatorStatus(locator: string, opts?: LocatorStatusOptions): Promise<LocatorStatus>;
+/** One poll attempt from {@link awaitLocatorReady} — lets a caller narrate progress (a CLI spinner,
+ *  a log line) without this module printing anything itself (the SDK/storage layers never print). */
+export interface AwaitLocatorReadyEvent {
+    /** 1-indexed poll attempt. */
+    attempt: number;
+    /** Milliseconds since {@link awaitLocatorReady} was called. */
+    elapsedMs: number;
+    status: LocatorStatus;
+}
+export interface AwaitLocatorReadyOptions {
+    /** Forwarded to every {@link locatorStatus} probe. */
+    gateway?: string;
+    primaryOnly?: boolean;
+    /** Per-probe network timeout, forwarded as {@link LocatorStatusOptions.timeoutMs} (NOT the
+     *  poll's overall deadline — see `timeoutMs` below). Default 6000ms, same as `locatorStatus`. */
+    probeTimeoutMs?: number;
+    fetchFn?: typeof fetch;
+    /** Give up polling once this much total time has elapsed, returning the last status with
+     *  `ready: false` rather than throwing — a caller decides what "still not ready" means for its
+     *  own flow. Default 5 minutes: long enough for typical Arweave propagation (this module's whole
+     *  reason to exist — see the module doc, "the gap runs to minutes"). */
+    timeoutMs?: number;
+    /** Base delay for the linear backoff between polls (`attempt * pollBaseMs`, via the SDK's
+     *  {@link linearBackoffDelay} — the same primitive `service.ts`'s retry ladder uses). Default
+     *  3000ms, so the very first re-poll is quick and later ones back off. */
+    pollBaseMs?: number;
+    onEvent?: (e: AwaitLocatorReadyEvent) => void;
+}
+export interface AwaitLocatorReadyResult {
+    /** The last status observed — `'ready'` iff {@link ready} is true. */
+    status: LocatorStatus;
+    attempts: number;
+    elapsedMs: number;
+    /** False when the deadline was hit before `status.readiness` reached `'ready'`. */
+    ready: boolean;
+}
+/**
+ * Poll {@link locatorStatus} until it reports `'ready'` or the deadline passes.
+ *
+ * `locatorStatus` alone answers "right now" — the natural next question, for a caller that would
+ * otherwise upload during a mint and write the locator into a token that renders broken for its
+ * first minutes of life (see the module doc), is "wait until it's actually there." This is that,
+ * factored out once so a caller doesn't hand-roll its own poll/backoff loop around a one-shot check.
+ *
+ * `'propagating'` is treated the same as `'unreachable'` here — both mean "not yet what THIS caller
+ * can rely on" — but every intermediate status still reaches `onEvent`, so a caller that wants to
+ * distinguish "provably on the network, just behind" from "no evidence yet" can from the events.
+ */
+export declare function awaitLocatorReady(locator: string, opts?: AwaitLocatorReadyOptions): Promise<AwaitLocatorReadyResult>;
+//# sourceMappingURL=readiness.d.ts.map

package/dist/readiness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readiness.d.ts","sourceRoot":"","sources":["../src/readiness.ts"],"names":[],"mappings":"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"}