@ensnode/ensnode-sdk 0.0.0-next-20260217194807 → 0.0.0-next-20260217213247

package/dist/index.cjs

@@ -55,6 +55,8 @@ __export(index_exports, {
   EXPECTED_ENCODED_REFERRER_PADDING: () => EXPECTED_ENCODED_REFERRER_PADDING,
   EnsApiClient: () => EnsApiClient,
   EnsApiIndexingStatusResponseCodes: () => EnsApiIndexingStatusResponseCodes,
+  EnsIndexerClient: () => EnsIndexerClient,
+  EnsIndexerIndexingStatusResponseCodes: () => EnsIndexerIndexingStatusResponseCodes,
   ForwardResolutionProtocolStep: () => ForwardResolutionProtocolStep,
   IndexingStatusResponseCodes: () => IndexingStatusResponseCodes,
   LINEANAMES_NODE: () => LINEANAMES_NODE,
@@ -130,6 +132,8 @@ __export(index_exports, {
   deserializeEnsApiConfigResponse: () => deserializeEnsApiConfigResponse,
   deserializeEnsApiIndexingStatusResponse: () => deserializeEnsApiIndexingStatusResponse,
   deserializeEnsApiPublicConfig: () => deserializeEnsApiPublicConfig,
+  deserializeEnsIndexerConfigResponse: () => deserializeEnsIndexerConfigResponse,
+  deserializeEnsIndexerIndexingStatusResponse: () => deserializeEnsIndexerIndexingStatusResponse,
   deserializeEnsIndexerPublicConfig: () => deserializeEnsIndexerPublicConfig,
   deserializeErrorResponse: () => deserializeErrorResponse,
   deserializeIndexingStatusResponse: () => deserializeIndexingStatusResponse,
@@ -259,6 +263,8 @@ __export(index_exports, {
   serializeEnsApiConfigResponse: () => serializeEnsApiConfigResponse,
   serializeEnsApiIndexingStatusResponse: () => serializeEnsApiIndexingStatusResponse,
   serializeEnsApiPublicConfig: () => serializeEnsApiPublicConfig,
+  serializeEnsIndexerConfigResponse: () => serializeEnsIndexerConfigResponse,
+  serializeEnsIndexerIndexingStatusResponse: () => serializeEnsIndexerIndexingStatusResponse,
   serializeEnsIndexerPublicConfig: () => serializeEnsIndexerPublicConfig,
   serializeIndexedChainIds: () => serializeIndexedChainIds,
   serializeIndexingStatusResponse: () => serializeIndexingStatusResponse,
@@ -3363,7 +3369,7 @@ var EnsApiClient = class _EnsApiClient {
    * @returns {EnsApiConfigResponse}
    *
    * @throws if the ENSApi request fails
-   * @throws if the ENSApi returns an error response
+   * @throws if the ENSApi returns a non-ok response
    * @throws if the ENSApi response breaks required invariants
    */
   async config() {
@@ -3387,7 +3393,7 @@ var EnsApiClient = class _EnsApiClient {
    * @returns {EnsApiIndexingStatusResponse}
    *
    * @throws if the ENSApi request fails
-   * @throws if the ENSApi returns an error response
+   * @throws if the ENSApi returns a non-ok response
    * @throws if the ENSApi response breaks required invariants
    */
   async indexingStatus() {
@@ -3404,7 +3410,6 @@ var EnsApiClient = class _EnsApiClient {
       try {
         errorResponse = deserializeErrorResponse(responseData);
       } catch {
-        console.log("Indexing Status API: handling a known indexing status server error.");
       }
       if (typeof errorResponse !== "undefined") {
         throw new Error(`Fetching ENSApi Indexing Status Failed: ${errorResponse.message}`);
@@ -3648,6 +3653,183 @@ var EnsApiClient = class _EnsApiClient {
 var ENSNodeClient = class extends EnsApiClient {
 };
 
+// src/ensindexer/api/config/deserialize.ts
+function deserializeEnsIndexerConfigResponse(maybeResponse) {
+  return deserializeEnsIndexerPublicConfig(maybeResponse, "EnsIndexerConfigResponse");
+}
+
+// src/ensindexer/api/config/serialize.ts
+function serializeEnsIndexerConfigResponse(response) {
+  return serializeEnsIndexerPublicConfig(response);
+}
+
+// src/ensindexer/api/indexing-status/deserialize.ts
+var import_v427 = require("zod/v4");
+
+// src/ensindexer/api/indexing-status/response.ts
+var EnsIndexerIndexingStatusResponseCodes = {
+  /**
+   * Represents that the indexing status is available.
+   */
+  Ok: "ok",
+  /**
+   * Represents that the indexing status is unavailable.
+   */
+  Error: "error"
+};
+
+// src/ensindexer/api/indexing-status/zod-schemas.ts
+var import_v426 = require("zod/v4");
+var makeEnsIndexerIndexingStatusResponseOkSchema = (valueLabel = "Indexing Status Response OK") => import_v426.z.strictObject({
+  responseCode: import_v426.z.literal(EnsIndexerIndexingStatusResponseCodes.Ok),
+  realtimeProjection: makeRealtimeIndexingStatusProjectionSchema(valueLabel)
+});
+var makeEnsIndexerIndexingStatusResponseErrorSchema = (_valueLabel = "Indexing Status Response Error") => import_v426.z.strictObject({
+  responseCode: import_v426.z.literal(EnsIndexerIndexingStatusResponseCodes.Error)
+});
+var makeEnsIndexerIndexingStatusResponseSchema = (valueLabel = "Indexing Status Response") => import_v426.z.discriminatedUnion("responseCode", [
+  makeEnsIndexerIndexingStatusResponseOkSchema(valueLabel),
+  makeEnsIndexerIndexingStatusResponseErrorSchema(valueLabel)
+]);
+var makeSerializedEnsIndexerIndexingStatusResponseOkSchema = (valueLabel = "Serialized Indexing Status Response OK") => import_v426.z.strictObject({
+  responseCode: import_v426.z.literal(EnsIndexerIndexingStatusResponseCodes.Ok),
+  realtimeProjection: makeSerializedRealtimeIndexingStatusProjectionSchema(valueLabel)
+});
+var makeSerializedEnsIndexerIndexingStatusResponseSchema = (valueLabel = "Serialized Indexing Status Response") => import_v426.z.discriminatedUnion("responseCode", [
+  makeSerializedEnsIndexerIndexingStatusResponseOkSchema(valueLabel),
+  makeEnsIndexerIndexingStatusResponseErrorSchema(valueLabel)
+]);
+
+// src/ensindexer/api/indexing-status/deserialize.ts
+function buildUnvalidatedEnsIndexerIndexingStatusResponse(serializedResponse) {
+  if (serializedResponse.responseCode !== EnsIndexerIndexingStatusResponseCodes.Ok) {
+    return serializedResponse;
+  }
+  return {
+    ...serializedResponse,
+    realtimeProjection: buildUnvalidatedRealtimeIndexingStatusProjection(
+      serializedResponse.realtimeProjection
+    )
+  };
+}
+function deserializeEnsIndexerIndexingStatusResponse(maybeResponse) {
+  const parsed = makeSerializedEnsIndexerIndexingStatusResponseSchema().transform(buildUnvalidatedEnsIndexerIndexingStatusResponse).pipe(makeEnsIndexerIndexingStatusResponseSchema()).safeParse(maybeResponse);
+  if (parsed.error) {
+    throw new Error(
+      `Cannot deserialize EnsIndexerIndexingStatusResponse:
+${(0, import_v427.prettifyError)(parsed.error)}
+`
+    );
+  }
+  return parsed.data;
+}
+
+// src/ensindexer/api/indexing-status/serialize.ts
+function serializeEnsIndexerIndexingStatusResponse(response) {
+  switch (response.responseCode) {
+    case EnsIndexerIndexingStatusResponseCodes.Ok:
+      return {
+        responseCode: response.responseCode,
+        realtimeProjection: serializeRealtimeIndexingStatusProjection(response.realtimeProjection)
+      };
+    case EnsIndexerIndexingStatusResponseCodes.Error:
+      return response;
+  }
+}
+
+// src/ensindexer/api/shared/errors/deserialize.ts
+var import_v429 = require("zod/v4");
+
+// src/ensindexer/api/shared/errors/zod-schemas.ts
+var import_v428 = require("zod/v4");
+var ErrorResponseSchema2 = import_v428.z.object({
+  message: import_v428.z.string(),
+  details: import_v428.z.optional(import_v428.z.unknown())
+});
+
+// src/ensindexer/api/shared/errors/deserialize.ts
+function deserializeErrorResponse2(maybeErrorResponse) {
+  const parsed = ErrorResponseSchema2.safeParse(maybeErrorResponse);
+  if (parsed.error) {
+    throw new Error(`Cannot deserialize ErrorResponse:
+${(0, import_v429.prettifyError)(parsed.error)}
+`);
+  }
+  return parsed.data;
+}
+
+// src/ensindexer/client.ts
+var EnsIndexerClient = class {
+  constructor(options) {
+    this.options = options;
+  }
+  getOptions() {
+    return Object.freeze({
+      url: new URL(this.options.url.href)
+    });
+  }
+  /**
+   * Fetch ENSIndexer Config
+   *
+   * Fetch the ENSIndexer's configuration.
+   *
+   * @returns {EnsIndexerConfigResponse}
+   *
+   * @throws if the ENSIndexer request fails
+   * @throws if the ENSIndexer returns a non-ok response
+   * @throws if the ENSIndexer response breaks required invariants
+   */
+  async config() {
+    const url = new URL(`/api/config`, this.options.url);
+    const response = await fetch(url);
+    let responseData;
+    try {
+      responseData = await response.json();
+    } catch {
+      throw new Error("Malformed response data: invalid JSON");
+    }
+    if (!response.ok) {
+      const errorResponse = deserializeErrorResponse2(responseData);
+      throw new Error(`Fetching ENSIndexer Config Failed: ${errorResponse.message}`);
+    }
+    return deserializeEnsIndexerConfigResponse(
+      responseData
+    );
+  }
+  /**
+   * Fetch ENSIndexer Indexing Status
+   *
+   * @returns {EnsIndexerIndexingStatusResponse}
+   *
+   * @throws if the ENSIndexer request fails
+   * @throws if the ENSIndexer returns a non-ok response
+   * @throws if the ENSIndexer response breaks required invariants
+   */
+  async indexingStatus() {
+    const url = new URL(`/api/indexing-status`, this.options.url);
+    const response = await fetch(url);
+    let responseData;
+    try {
+      responseData = await response.json();
+    } catch {
+      throw new Error("Malformed response data: invalid JSON");
+    }
+    if (!response.ok) {
+      let errorResponse;
+      try {
+        errorResponse = deserializeErrorResponse2(responseData);
+      } catch {
+      }
+      if (typeof errorResponse !== "undefined") {
+        throw new Error(`Fetching ENSIndexer Indexing Status Failed: ${errorResponse.message}`);
+      }
+    }
+    return deserializeEnsIndexerIndexingStatusResponse(
+      responseData
+    );
+  }
+};
+
 // src/ensindexer/config/label-utils.ts
 var import_viem15 = require("viem");
 function labelHashToBytes(labelHash) {
@@ -3789,14 +3971,14 @@ function isResolvedIdentity(identity) {
 }
 
 // src/indexing-status/deserialize/chain-indexing-status-snapshot.ts
-var import_v426 = require("zod/v4");
+var import_v430 = require("zod/v4");
 function deserializeChainIndexingStatusSnapshot(maybeSnapshot, valueLabel) {
   const schema = makeChainIndexingStatusSnapshotSchema(valueLabel);
   const parsed = schema.safeParse(maybeSnapshot);
   if (parsed.error) {
     throw new Error(
       `Cannot deserialize into ChainIndexingStatusSnapshot:
-${(0, import_v426.prettifyError)(parsed.error)}
+${(0, import_v430.prettifyError)(parsed.error)}
 `
     );
   }
@@ -3814,52 +3996,52 @@ function createRealtimeIndexingStatusProjection(snapshot, now) {
 }
 
 // src/indexing-status/validate/chain-indexing-status-snapshot.ts
-var import_v427 = require("zod/v4");
+var import_v431 = require("zod/v4");
 function validateChainIndexingStatusSnapshot(unvalidatedSnapshot, valueLabel) {
   const schema = makeChainIndexingStatusSnapshotSchema(valueLabel);
   const parsed = schema.safeParse(unvalidatedSnapshot);
   if (parsed.error) {
     throw new Error(`Invalid ChainIndexingStatusSnapshot:
-${(0, import_v427.prettifyError)(parsed.error)}
+${(0, import_v431.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
 }
 
 // src/indexing-status/validate/cross-chain-indexing-status-snapshot.ts
-var import_v428 = require("zod/v4");
+var import_v432 = require("zod/v4");
 function validateCrossChainIndexingStatusSnapshot(unvalidatedSnapshot, valueLabel) {
   const schema = makeCrossChainIndexingStatusSnapshotSchema(valueLabel);
   const parsed = schema.safeParse(unvalidatedSnapshot);
   if (parsed.error) {
     throw new Error(`Invalid CrossChainIndexingStatusSnapshot:
-${(0, import_v428.prettifyError)(parsed.error)}
+${(0, import_v432.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
 }
 
 // src/indexing-status/validate/omnichain-indexing-status-snapshot.ts
-var import_v429 = require("zod/v4");
+var import_v433 = require("zod/v4");
 function validateOmnichainIndexingStatusSnapshot(unvalidatedSnapshot, valueLabel) {
   const schema = makeOmnichainIndexingStatusSnapshotSchema(valueLabel);
   const parsed = schema.safeParse(unvalidatedSnapshot);
   if (parsed.error) {
     throw new Error(`Invalid OmnichainIndexingStatusSnapshot:
-${(0, import_v429.prettifyError)(parsed.error)}
+${(0, import_v433.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
 }
 
 // src/indexing-status/validate/realtime-indexing-status-projection.ts
-var import_v430 = require("zod/v4");
+var import_v434 = require("zod/v4");
 function validateRealtimeIndexingStatusProjection(unvalidatedProjection, valueLabel) {
   const schema = makeRealtimeIndexingStatusProjectionSchema(valueLabel);
   const parsed = schema.safeParse(unvalidatedProjection);
   if (parsed.error) {
     throw new Error(`Invalid RealtimeIndexingStatusProjection:
-${(0, import_v430.prettifyError)(parsed.error)}
+${(0, import_v434.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4037,13 +4219,13 @@ var import_getUnixTime2 = require("date-fns/getUnixTime");
 var import_getUnixTime = require("date-fns/getUnixTime");
 
 // src/shared/deserialize.ts
-var import_v431 = __toESM(require("zod/v4"), 1);
+var import_v435 = __toESM(require("zod/v4"), 1);
 function deserializeChainId(maybeChainId, valueLabel) {
   const schema = makeChainIdStringSchema(valueLabel);
   const parsed = schema.safeParse(maybeChainId);
   if (parsed.error) {
     throw new Error(`Cannot deserialize ChainId:
-${(0, import_v431.prettifyError)(parsed.error)}
+${(0, import_v435.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4053,7 +4235,7 @@ function deserializeDatetime(maybeDatetime, valueLabel) {
   const parsed = schema.safeParse(maybeDatetime);
   if (parsed.error) {
     throw new Error(`Cannot deserialize Datetime:
-${(0, import_v431.prettifyError)(parsed.error)}
+${(0, import_v435.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4063,7 +4245,7 @@ function deserializeUnixTimestamp(maybeTimestamp, valueLabel) {
   const parsed = schema.safeParse(maybeTimestamp);
   if (parsed.error) {
     throw new Error(`Cannot deserialize Unix Timestamp:
-${(0, import_v431.prettifyError)(parsed.error)}
+${(0, import_v435.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4073,7 +4255,7 @@ function deserializeUrl(maybeUrl, valueLabel) {
   const parsed = schema.safeParse(maybeUrl);
   if (parsed.error) {
     throw new Error(`Cannot deserialize URL:
-${(0, import_v431.prettifyError)(parsed.error)}
+${(0, import_v435.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4083,7 +4265,7 @@ function deserializeBlockNumber(maybeBlockNumber, valueLabel) {
   const parsed = schema.safeParse(maybeBlockNumber);
   if (parsed.error) {
     throw new Error(`Cannot deserialize BlockNumber:
-${(0, import_v431.prettifyError)(parsed.error)}
+${(0, import_v435.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4093,7 +4275,7 @@ function deserializeBlockrange(maybeBlockrange, valueLabel) {
   const parsed = schema.safeParse(maybeBlockrange);
   if (parsed.error) {
     throw new Error(`Cannot deserialize Blockrange:
-${(0, import_v431.prettifyError)(parsed.error)}
+${(0, import_v435.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4103,17 +4285,17 @@ function deserializeBlockRef(maybeBlockRef, valueLabel) {
   const parsed = schema.safeParse(maybeBlockRef);
   if (parsed.error) {
     throw new Error(`Cannot deserialize BlockRef:
-${(0, import_v431.prettifyError)(parsed.error)}
+${(0, import_v435.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
 }
 function deserializeDuration(maybeDuration, valueLabel) {
-  const schema = import_v431.default.coerce.number().pipe(makeDurationSchema(valueLabel));
+  const schema = import_v435.default.coerce.number().pipe(makeDurationSchema(valueLabel));
   const parsed = schema.safeParse(maybeDuration);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize Duration:
-${(0, import_v431.prettifyError)(parsed.error)}
+${(0, import_v435.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4123,7 +4305,7 @@ function parseAccountId(maybeAccountId, valueLabel) {
   const parsed = schema.safeParse(maybeAccountId);
   if (parsed.error) {
     throw new RangeError(`Cannot deserialize AccountId:
-${(0, import_v431.prettifyError)(parsed.error)}
+${(0, import_v435.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4133,7 +4315,7 @@ function deserializePriceEth(maybePrice, valueLabel) {
   const parsed = schema.safeParse(maybePrice);
   if (parsed.error) {
     throw new Error(`Cannot deserialize PriceEth:
-${(0, import_v431.prettifyError)(parsed.error)}
+${(0, import_v435.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4143,7 +4325,7 @@ function deserializePriceUsdc(maybePrice, valueLabel) {
   const parsed = schema.safeParse(maybePrice);
   if (parsed.error) {
     throw new Error(`Cannot deserialize PriceUsdc:
-${(0, import_v431.prettifyError)(parsed.error)}
+${(0, import_v435.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;
@@ -4153,7 +4335,7 @@ function deserializePriceDai(maybePrice, valueLabel) {
   const parsed = schema.safeParse(maybePrice);
   if (parsed.error) {
     throw new Error(`Cannot deserialize PriceDai:
-${(0, import_v431.prettifyError)(parsed.error)}
+${(0, import_v435.prettifyError)(parsed.error)}
 `);
   }
   return parsed.data;