@ensnode/ensnode-sdk 0.0.0-next-20260227185030 → 0.0.0-next-20260228175526

package/dist/index.cjs

@@ -36,7 +36,6 @@ __export(index_exports, {
   ATTR_PROTOCOL_STEP_RESULT: () => ATTR_PROTOCOL_STEP_RESULT,
   AssetNamespaces: () => AssetNamespaces,
   BASENAMES_NODE: () => BASENAMES_NODE,
-  BlockRefRangeTypeIds: () => BlockRefRangeTypeIds,
   ChainIndexingStatusIds: () => ChainIndexingStatusIds,
   ClientError: () => ClientError,
   CrossChainIndexingStrategyIds: () => CrossChainIndexingStrategyIds,
@@ -75,6 +74,7 @@ __export(index_exports, {
   RECORDS_PER_PAGE_MAX: () => RECORDS_PER_PAGE_MAX,
   ROOT_NODE: () => ROOT_NODE,
   ROOT_RESOURCE: () => ROOT_RESOURCE,
+  RangeTypeIds: () => RangeTypeIds,
   RegistrarActionTypes: () => RegistrarActionTypes,
   RegistrarActionsFilterTypes: () => RegistrarActionsFilterTypes,
   RegistrarActionsOrders: () => RegistrarActionsOrders,
@@ -96,6 +96,8 @@ __export(index_exports, {
   bigIntToNumber: () => bigIntToNumber,
   bigintToCoinType: () => bigintToCoinType,
   buildAssetId: () => buildAssetId,
+  buildBlockNumberRange: () => buildBlockNumberRange,
+  buildBlockRefRange: () => buildBlockRefRange,
   buildEncodedReferrer: () => buildEncodedReferrer,
   buildEnsRainbowClientLabelSet: () => buildEnsRainbowClientLabelSet,
   buildLabelSetId: () => buildLabelSetId,
@@ -113,7 +115,6 @@ __export(index_exports, {
   coinTypeReverseLabel: () => coinTypeReverseLabel,
   coinTypeToEvmChainId: () => coinTypeToEvmChainId,
   constructSubInterpretedName: () => constructSubInterpretedName,
-  createIndexingConfig: () => createIndexingConfig,
   createRealtimeIndexingStatusProjection: () => createRealtimeIndexingStatusProjection,
   decodeDNSEncodedLiteralName: () => decodeDNSEncodedLiteralName,
   decodeDNSEncodedName: () => decodeDNSEncodedName,
@@ -121,7 +122,6 @@ __export(index_exports, {
   deserializeAssetId: () => deserializeAssetId,
   deserializeBlockNumber: () => deserializeBlockNumber,
   deserializeBlockRef: () => deserializeBlockRef,
-  deserializeBlockrange: () => deserializeBlockrange,
   deserializeChainId: () => deserializeChainId,
   deserializeChainIndexingStatusSnapshot: () => deserializeChainIndexingStatusSnapshot,
   deserializeConfigResponse: () => deserializeConfigResponse,
@@ -237,7 +237,10 @@ __export(index_exports, {
   parseAccountId: () => parseAccountId,
   parseAssetId: () => parseAssetId,
   parseDai: () => parseDai,
+  parseEncodedLabelHash: () => parseEncodedLabelHash,
   parseEth: () => parseEth,
+  parseLabelHash: () => parseLabelHash,
+  parseLabelHashOrEncodedLabelHash: () => parseLabelHashOrEncodedLabelHash,
   parseNonNegativeInteger: () => parseNonNegativeInteger,
   parsePartialInterpretedName: () => parsePartialInterpretedName,
   parseReverseName: () => parseReverseName,
@@ -425,8 +428,38 @@ var beautifyName = (name) => {
   return beautifiedLabels.join(".");
 };
 
-// src/ens/parse-reverse-name.ts
+// src/ens/parse-labelhash.ts
 var import_viem4 = require("viem");
+function parseLabelHash(maybeLabelHash) {
+  const hexPart = maybeLabelHash.startsWith("0x") ? maybeLabelHash.slice(2) : maybeLabelHash;
+  if (!(0, import_viem4.isHex)(`0x${hexPart}`, { strict: true })) {
+    throw new Error(`Invalid labelHash: contains non-hex characters: ${maybeLabelHash}`);
+  }
+  const normalizedHexPart = hexPart.length % 2 === 1 ? `0${hexPart}` : hexPart;
+  if (normalizedHexPart.length !== 64) {
+    throw new Error(
+      `Invalid labelHash length: expected 32 bytes (64 hex chars), got ${normalizedHexPart.length / 2} bytes: ${maybeLabelHash}`
+    );
+  }
+  return `0x${normalizedHexPart.toLowerCase()}`;
+}
+function parseEncodedLabelHash(maybeEncodedLabelHash) {
+  if (!maybeEncodedLabelHash.startsWith("[") || !maybeEncodedLabelHash.endsWith("]")) {
+    throw new Error(
+      `Invalid encoded labelHash: must be enclosed in square brackets: ${maybeEncodedLabelHash}`
+    );
+  }
+  return parseLabelHash(maybeEncodedLabelHash.slice(1, -1));
+}
+function parseLabelHashOrEncodedLabelHash(maybeLabelHash) {
+  if (maybeLabelHash.startsWith("[") && maybeLabelHash.endsWith("]")) {
+    return parseEncodedLabelHash(maybeLabelHash);
+  }
+  return parseLabelHash(maybeLabelHash);
+}
+
+// src/ens/parse-reverse-name.ts
+var import_viem5 = require("viem");
 
 // src/shared/address.ts
 function asLowerCaseAddress(address) {
@@ -437,7 +470,7 @@ function asLowerCaseAddress(address) {
 var REVERSE_NAME_REGEX = /^([0-9a-fA-F]+)\.([0-9a-f]{1,64}|addr|default)\.reverse$/;
 var parseAddressLabel = (addressLabel) => {
   const maybeAddress = `0x${addressLabel}`;
-  if (!(0, import_viem4.isAddress)(maybeAddress)) {
+  if (!(0, import_viem5.isAddress)(maybeAddress)) {
     throw new Error(`Invalid EVM address "${maybeAddress}"`);
   }
   return asLowerCaseAddress(maybeAddress);
@@ -445,7 +478,7 @@ var parseAddressLabel = (addressLabel) => {
 var parseCoinTypeLabel = (coinTypeLabel) => {
   if (coinTypeLabel === "default") return DEFAULT_EVM_COIN_TYPE;
   if (coinTypeLabel === "addr") return ETH_COIN_TYPE;
-  return bigintToCoinType((0, import_viem4.hexToBigInt)(`0x${coinTypeLabel}`));
+  return bigintToCoinType((0, import_viem5.hexToBigInt)(`0x${coinTypeLabel}`));
 };
 function parseReverseName(name) {
   const match = name.match(REVERSE_NAME_REGEX);
@@ -482,9 +515,9 @@ function reverseName(address, coinType) {
 }
 
 // src/ens/subname-helpers.ts
-var import_viem5 = require("viem");
-var makeSubdomainNode = (labelHash, node) => (0, import_viem5.keccak256)((0, import_viem5.concat)([node, labelHash]));
-var uint256ToHex32 = (num) => (0, import_viem5.toHex)(num, { size: 32 });
+var import_viem6 = require("viem");
+var makeSubdomainNode = (labelHash, node) => (0, import_viem6.keccak256)((0, import_viem6.concat)([node, labelHash]));
+var uint256ToHex32 = (num) => (0, import_viem6.toHex)(num, { size: 32 });
 
 // src/ens/types.ts
 var import_datasources = require("@ensnode/datasources");
@@ -503,11 +536,11 @@ var uniq = (arr) => [...new Set(arr)];
 
 // src/shared/zod-schemas.ts
 var import_caip = require("caip");
-var import_viem8 = require("viem");
+var import_viem9 = require("viem");
 var import_v4 = require("zod/v4");
 
 // src/shared/currencies.ts
-var import_viem6 = require("viem");
+var import_viem7 = require("viem");
 
 // src/shared/numbers.ts
 function bigIntToNumber(n) {
@@ -642,24 +675,24 @@ function validateAmountToParse(value) {
 function parseEth(value) {
   validateAmountToParse(value);
   const currencyInfo2 = getCurrencyInfo(CurrencyIds.ETH);
-  const amount = (0, import_viem6.parseUnits)(value, currencyInfo2.decimals);
+  const amount = (0, import_viem7.parseUnits)(value, currencyInfo2.decimals);
   return priceEth(amount);
 }
 function parseUsdc(value) {
   validateAmountToParse(value);
   const currencyInfo2 = getCurrencyInfo(CurrencyIds.USDC);
-  const amount = (0, import_viem6.parseUnits)(value, currencyInfo2.decimals);
+  const amount = (0, import_viem7.parseUnits)(value, currencyInfo2.decimals);
   return priceUsdc(amount);
 }
 function parseDai(value) {
   validateAmountToParse(value);
   const currencyInfo2 = getCurrencyInfo(CurrencyIds.DAI);
-  const amount = (0, import_viem6.parseUnits)(value, currencyInfo2.decimals);
+  const amount = (0, import_viem7.parseUnits)(value, currencyInfo2.decimals);
   return priceDai(amount);
 }
 
 // src/shared/interpretation/reinterpretation.ts
-var import_viem7 = require("viem");
+var import_viem8 = require("viem");
 function reinterpretLabel(label) {
   if (label === "") {
     throw new Error(
@@ -668,7 +701,7 @@ function reinterpretLabel(label) {
   }
   if (isEncodedLabelHash(label)) return label;
   if (isNormalizedLabel(label)) return label;
-  return encodeLabelHash((0, import_viem7.labelhash)(label));
+  return encodeLabelHash((0, import_viem8.labelhash)(label));
 }
 function reinterpretName(name) {
   if (name === "") return name;
@@ -694,7 +727,7 @@ var makeDurationSchema = (valueLabel = "Value") => import_v4.z.number({
 var makeChainIdSchema = (valueLabel = "Chain ID") => makePositiveIntegerSchema(valueLabel).transform((val) => val);
 var makeChainIdStringSchema = (valueLabel = "Chain ID String") => import_v4.z.string({ error: `${valueLabel} must be a string representing a chain ID.` }).pipe(import_v4.z.coerce.number({ error: `${valueLabel} must represent a positive integer (>0).` })).pipe(makeChainIdSchema(`The numeric value represented by ${valueLabel}`));
 var makeLowercaseAddressSchema = (valueLabel = "EVM address") => import_v4.z.string().check((ctx) => {
-  if (!(0, import_viem8.isAddress)(ctx.value)) {
+  if (!(0, import_viem9.isAddress)(ctx.value)) {
     ctx.issues.push({
       code: "custom",
       message: `${valueLabel} must be a valid EVM address`,
@@ -709,23 +742,6 @@ var makeUrlSchema = (valueLabel = "Value") => import_v4.z.url({
   abort: true
 }).transform((v) => new URL(v));
 var makeBlockNumberSchema = (valueLabel = "Block number") => makeNonNegativeIntegerSchema(valueLabel);
-var makeBlockrangeSchema = (valueLabel = "Value") => import_v4.z.strictObject(
-  {
-    startBlock: makeBlockNumberSchema(`${valueLabel}.startBlock`).optional(),
-    endBlock: makeBlockNumberSchema(`${valueLabel}.endBlock`).optional()
-  },
-  {
-    error: `${valueLabel} must be a valid Blockrange object.`
-  }
-).refine(
-  (v) => {
-    if (v.startBlock && v.endBlock) {
-      return v.startBlock <= v.endBlock;
-    }
-    return true;
-  },
-  { error: `${valueLabel}: startBlock must be before or equal to endBlock` }
-);
 var makeBlockRefSchema = (valueLabel = "Value") => import_v4.z.strictObject(
   {
     timestamp: makeUnixTimestampSchema(`${valueLabel}.timestamp`),
@@ -766,7 +782,7 @@ var makeAccountIdStringSchema = (valueLabel = "Account ID String") => import_v4.
   };
 }).pipe(makeAccountIdSchema(valueLabel));
 var makeHexStringSchema = (options, valueLabel = "String representation of bytes array") => import_v4.z.string().check(function invariant_isHexEncoded(ctx) {
-  if (!(0, import_viem8.isHex)(ctx.value)) {
+  if (!(0, import_viem9.isHex)(ctx.value)) {
     ctx.issues.push({
       code: "custom",
       input: ctx.value,
@@ -775,7 +791,7 @@ var makeHexStringSchema = (options, valueLabel = "String representation of bytes
   }
 }).transform((v) => v).check(function invariant_encodesRequiredBytesCount(ctx) {
   const expectedBytesCount = options.bytesCount;
-  const actualBytesCount = (0, import_viem8.size)(ctx.value);
+  const actualBytesCount = (0, import_viem9.size)(ctx.value);
   if (actualBytesCount !== expectedBytesCount) {
     ctx.issues.push({
       code: "custom",
@@ -1067,17 +1083,88 @@ var import_v410 = require("zod/v4");
 // src/indexing-status/zod-schema/cross-chain-indexing-status-snapshot.ts
 var import_v49 = require("zod/v4");
 
-// src/indexing-status/chain-indexing-status-snapshot.ts
-var BlockRefRangeTypeIds = {
-  /**
-   * Represents that indexing of the chain should be performed for an indefinite range.
-   */
-  Indefinite: "indefinite",
-  /**
-   * Represents that indexing of the chain should be performed for a definite range.
-   */
-  Definite: "definite"
+// src/shared/block-ref.ts
+function isBefore(blockA, blockB) {
+  return blockA.number < blockB.number && blockA.timestamp < blockB.timestamp;
+}
+function isEqualTo(blockA, blockB) {
+  return blockA.number === blockB.number && blockA.timestamp === blockB.timestamp;
+}
+function isBeforeOrEqualTo(blockA, blockB) {
+  return isBefore(blockA, blockB) || isEqualTo(blockA, blockB);
+}
+
+// src/shared/blockrange.ts
+var RangeTypeIds = {
+  Unbounded: "unbounded",
+  LeftBounded: "left-bounded",
+  RightBounded: "right-bounded",
+  Bounded: "bounded"
 };
+function buildBlockNumberRange(startBlock, endBlock) {
+  if (startBlock === void 0 && endBlock === void 0) {
+    return {
+      rangeType: RangeTypeIds.Unbounded
+    };
+  }
+  if (startBlock !== void 0 && endBlock === void 0) {
+    return {
+      rangeType: RangeTypeIds.LeftBounded,
+      startBlock
+    };
+  }
+  if (startBlock === void 0 && endBlock !== void 0) {
+    return {
+      rangeType: RangeTypeIds.RightBounded,
+      endBlock
+    };
+  }
+  if (startBlock !== void 0 && endBlock !== void 0) {
+    if (startBlock > endBlock) {
+      throw new Error(
+        `For a block number range startBlock must be lower than or equal to endBlock.`
+      );
+    }
+    return {
+      rangeType: RangeTypeIds.Bounded,
+      startBlock,
+      endBlock
+    };
+  }
+  throw new Error("Invalid block number range. This should be unreachable.");
+}
+function buildBlockRefRange(startBlock, endBlock) {
+  if (startBlock === void 0 && endBlock === void 0) {
+    return {
+      rangeType: RangeTypeIds.Unbounded
+    };
+  }
+  if (startBlock !== void 0 && endBlock === void 0) {
+    return {
+      rangeType: RangeTypeIds.LeftBounded,
+      startBlock
+    };
+  }
+  if (startBlock === void 0 && endBlock !== void 0) {
+    return {
+      rangeType: RangeTypeIds.RightBounded,
+      endBlock
+    };
+  }
+  if (startBlock !== void 0 && endBlock !== void 0) {
+    if (isBeforeOrEqualTo(startBlock, endBlock) === false) {
+      throw new Error(`For a block ref range startBlock must be before or equal to endBlock.`);
+    }
+    return {
+      rangeType: RangeTypeIds.Bounded,
+      startBlock,
+      endBlock
+    };
+  }
+  throw new Error("Invalid block ref range. This should be unreachable.");
+}
+
+// src/indexing-status/chain-indexing-status-snapshot.ts
 var ChainIndexingStatusIds = {
   /**
    * Represents that indexing of the chain is not ready to begin yet because:
@@ -1109,19 +1196,6 @@ var ChainIndexingStatusIds = {
    */
   Completed: "chain-completed"
 };
-function createIndexingConfig(startBlock, endBlock) {
-  if (endBlock) {
-    return {
-      blockRangeType: BlockRefRangeTypeIds.Definite,
-      startBlock,
-      endBlock
-    };
-  }
-  return {
-    blockRangeType: BlockRefRangeTypeIds.Indefinite,
-    startBlock
-  };
-}
 function getTimestampForLowestOmnichainStartBlock(chains) {
   const earliestKnownBlockTimestamps = chains.map(
     (chain) => chain.config.startBlock.timestamp
@@ -1138,7 +1212,7 @@ function getTimestampForHighestOmnichainKnownBlock(chains) {
   for (const chain of chains) {
     switch (chain.chainStatus) {
       case ChainIndexingStatusIds.Queued:
-        if (chain.config.blockRangeType === BlockRefRangeTypeIds.Definite) {
+        if (chain.config.rangeType === RangeTypeIds.Bounded) {
           latestKnownBlockTimestamps.push(chain.config.endBlock.timestamp);
         }
         break;
@@ -1281,22 +1355,9 @@ function getOmnichainIndexingCursor(chains) {
 
 // src/indexing-status/zod-schema/chain-indexing-status-snapshot.ts
 var import_v47 = require("zod/v4");
-
-// src/shared/block-ref.ts
-function isBefore(blockA, blockB) {
-  return blockA.number < blockB.number && blockA.timestamp < blockB.timestamp;
-}
-function isEqualTo(blockA, blockB) {
-  return blockA.number === blockB.number && blockA.timestamp === blockB.timestamp;
-}
-function isBeforeOrEqualTo(blockA, blockB) {
-  return isBefore(blockA, blockB) || isEqualTo(blockA, blockB);
-}
-
-// src/indexing-status/zod-schema/chain-indexing-status-snapshot.ts
 function invariant_chainSnapshotQueuedBlocks(ctx) {
   const { config } = ctx.value;
-  if (config.blockRangeType === BlockRefRangeTypeIds.Indefinite) {
+  if (config.rangeType === RangeTypeIds.LeftBounded) {
     return;
   }
   if (isBeforeOrEqualTo(config.startBlock, config.endBlock) === false) {
@@ -1323,7 +1384,7 @@ function invariant_chainSnapshotBackfillBlocks(ctx) {
       message: "`latestIndexedBlock` must be before or same as `backfillEndBlock`."
     });
   }
-  if (config.blockRangeType === BlockRefRangeTypeIds.Indefinite) {
+  if (config.rangeType === RangeTypeIds.LeftBounded) {
     return;
   }
   if (isEqualTo(backfillEndBlock, config.endBlock) === false) {
@@ -1368,31 +1429,40 @@ function invariant_chainSnapshotFollowingBlocks(ctx) {
     });
   }
 }
-var makeBlockRefRangeSchema = (valueLabel = "Value") => import_v47.z.discriminatedUnion("blockRangeType", [
-  import_v47.z.object({
-    blockRangeType: import_v47.z.literal(BlockRefRangeTypeIds.Indefinite),
-    startBlock: makeBlockRefSchema(valueLabel)
-  }),
-  import_v47.z.object({
-    blockRangeType: import_v47.z.literal(BlockRefRangeTypeIds.Definite),
-    startBlock: makeBlockRefSchema(valueLabel),
-    endBlock: makeBlockRefSchema(valueLabel)
-  })
-]);
 var makeChainIndexingStatusSnapshotQueuedSchema = (valueLabel = "Value") => import_v47.z.object({
   chainStatus: import_v47.z.literal(ChainIndexingStatusIds.Queued),
-  config: makeBlockRefRangeSchema(valueLabel)
+  config: import_v47.z.discriminatedUnion("rangeType", [
+    import_v47.z.object({
+      rangeType: import_v47.z.literal(RangeTypeIds.LeftBounded),
+      startBlock: makeBlockRefSchema(valueLabel)
+    }),
+    import_v47.z.object({
+      rangeType: import_v47.z.literal(RangeTypeIds.Bounded),
+      startBlock: makeBlockRefSchema(valueLabel),
+      endBlock: makeBlockRefSchema(valueLabel)
+    })
+  ])
 }).check(invariant_chainSnapshotQueuedBlocks);
 var makeChainIndexingStatusSnapshotBackfillSchema = (valueLabel = "Value") => import_v47.z.object({
   chainStatus: import_v47.z.literal(ChainIndexingStatusIds.Backfill),
-  config: makeBlockRefRangeSchema(valueLabel),
+  config: import_v47.z.discriminatedUnion("rangeType", [
+    import_v47.z.object({
+      rangeType: import_v47.z.literal(RangeTypeIds.LeftBounded),
+      startBlock: makeBlockRefSchema(valueLabel)
+    }),
+    import_v47.z.object({
+      rangeType: import_v47.z.literal(RangeTypeIds.Bounded),
+      startBlock: makeBlockRefSchema(valueLabel),
+      endBlock: makeBlockRefSchema(valueLabel)
+    })
+  ]),
   latestIndexedBlock: makeBlockRefSchema(valueLabel),
   backfillEndBlock: makeBlockRefSchema(valueLabel)
 }).check(invariant_chainSnapshotBackfillBlocks);
 var makeChainIndexingStatusSnapshotCompletedSchema = (valueLabel = "Value") => import_v47.z.object({
   chainStatus: import_v47.z.literal(ChainIndexingStatusIds.Completed),
   config: import_v47.z.object({
-    blockRangeType: import_v47.z.literal(BlockRefRangeTypeIds.Definite),
+    rangeType: import_v47.z.literal(RangeTypeIds.Bounded),
     startBlock: makeBlockRefSchema(valueLabel),
     endBlock: makeBlockRefSchema(valueLabel)
   }),
@@ -1401,7 +1471,7 @@ var makeChainIndexingStatusSnapshotCompletedSchema = (valueLabel = "Value") => i
 var makeChainIndexingStatusSnapshotFollowingSchema = (valueLabel = "Value") => import_v47.z.object({
   chainStatus: import_v47.z.literal(ChainIndexingStatusIds.Following),
   config: import_v47.z.object({
-    blockRangeType: import_v47.z.literal(BlockRefRangeTypeIds.Indefinite),
+    rangeType: import_v47.z.literal(RangeTypeIds.LeftBounded),
     startBlock: makeBlockRefSchema(valueLabel)
   }),
   latestIndexedBlock: makeBlockRefSchema(valueLabel),
@@ -1669,7 +1739,7 @@ function invariant_snapshotTimeIsTheHighestKnownBlockTimestamp(ctx) {
   const { snapshotTime, omnichainSnapshot } = ctx.value;
   const chains = Array.from(omnichainSnapshot.chains.values());
   const startBlockTimestamps = chains.map((chain) => chain.config.startBlock.timestamp);
-  const endBlockTimestamps = chains.map((chain) => chain.config).filter((chainConfig) => chainConfig.blockRangeType === BlockRefRangeTypeIds.Definite).map((chainConfig) => chainConfig.endBlock.timestamp);
+  const endBlockTimestamps = chains.map((chain) => chain.config).filter((chainConfig) => chainConfig.rangeType === RangeTypeIds.Bounded).map((chainConfig) => chainConfig.endBlock.timestamp);
   const backfillEndBlockTimestamps = chains.filter((chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill).map((chain) => chain.backfillEndBlock.timestamp);
   const latestKnownBlockTimestamps = chains.filter((chain) => chain.chainStatus === ChainIndexingStatusIds.Following).map((chain) => chain.latestKnownBlock.timestamp);
   const highestKnownBlockTimestamp = Math.max(
@@ -2003,17 +2073,17 @@ var serializeIndexingStatusResponse = serializeEnsApiIndexingStatusResponse;
 var import_v420 = require("zod/v4");
 
 // src/ensapi/api/name-tokens/zod-schemas.ts
-var import_viem13 = require("viem");
+var import_viem14 = require("viem");
 var import_v419 = require("zod/v4");
 
 // src/tokenscope/name-token.ts
-var import_viem12 = require("viem");
+var import_viem13 = require("viem");
 var import_datasources5 = require("@ensnode/datasources");
 
 // src/shared/account-id.ts
-var import_viem9 = require("viem");
+var import_viem10 = require("viem");
 var accountIdEqual = (a, b) => {
-  return a.chainId === b.chainId && (0, import_viem9.isAddressEqual)(a.address, b.address);
+  return a.chainId === b.chainId && (0, import_viem10.isAddressEqual)(a.address, b.address);
 };
 
 // src/shared/datasource-contract.ts
@@ -2043,12 +2113,12 @@ var makeContractMatcher = (namespace, b) => (datasourceName, contractName) => {
 };
 
 // src/tokenscope/assets.ts
-var import_viem11 = require("viem");
+var import_viem12 = require("viem");
 var import_v417 = require("zod/v4");
 
 // src/tokenscope/zod-schemas.ts
 var import_caip3 = require("caip");
-var import_viem10 = require("viem");
+var import_viem11 = require("viem");
 var import_v416 = require("zod/v4");
 
 // src/shared/types.ts
@@ -2093,7 +2163,7 @@ var makeAssetIdStringSchema = (valueLabel = "Asset ID String Schema") => import_
 }, makeAssetIdSchema(valueLabel));
 function invariant_nameTokenOwnershipHasNonZeroAddressOwner(ctx) {
   const ownership = ctx.value;
-  if (ctx.value.owner.address === import_viem10.zeroAddress) {
+  if (ctx.value.owner.address === import_viem11.zeroAddress) {
     ctx.issues.push({
       code: "custom",
       input: ctx.value,
@@ -2119,7 +2189,7 @@ var makeNameTokenOwnershipUnknownSchema = (valueLabel = "Name Token Ownership Un
 }).check(invariant_nameTokenOwnershipHasNonZeroAddressOwner);
 function invariant_nameTokenOwnershipHasZeroAddressOwner(ctx) {
   const ownership = ctx.value;
-  if (ctx.value.owner.address !== import_viem10.zeroAddress) {
+  if (ctx.value.owner.address !== import_viem11.zeroAddress) {
     ctx.issues.push({
       code: "custom",
       input: ctx.value,
@@ -2297,11 +2367,11 @@ var NFTTransferTypes = {
 };
 var getNFTTransferType = (from, to, allowMintedRemint, metadata, currentlyIndexedOwner) => {
   const isIndexed = currentlyIndexedOwner !== void 0;
-  const isIndexedAsMinted = isIndexed && !(0, import_viem11.isAddressEqual)(currentlyIndexedOwner, import_viem11.zeroAddress);
-  const isMint = (0, import_viem11.isAddressEqual)(from, import_viem11.zeroAddress);
-  const isBurn = (0, import_viem11.isAddressEqual)(to, import_viem11.zeroAddress);
-  const isSelfTransfer = (0, import_viem11.isAddressEqual)(from, to);
-  if (isIndexed && !(0, import_viem11.isAddressEqual)(currentlyIndexedOwner, from)) {
+  const isIndexedAsMinted = isIndexed && !(0, import_viem12.isAddressEqual)(currentlyIndexedOwner, import_viem12.zeroAddress);
+  const isMint = (0, import_viem12.isAddressEqual)(from, import_viem12.zeroAddress);
+  const isBurn = (0, import_viem12.isAddressEqual)(to, import_viem12.zeroAddress);
+  const isSelfTransfer = (0, import_viem12.isAddressEqual)(from, to);
+  if (isIndexed && !(0, import_viem12.isAddressEqual)(currentlyIndexedOwner, from)) {
     if (isMint && allowMintedRemint) {
     } else {
       throw new Error(
@@ -2442,7 +2512,7 @@ function getNameTokenOwnership(namespaceId, name, owner) {
       owner
     };
   }
-  if ((0, import_viem12.isAddressEqual)(owner.address, import_viem12.zeroAddress)) {
+  if ((0, import_viem13.isAddressEqual)(owner.address, import_viem13.zeroAddress)) {
     return {
       ownershipType: NameTokenOwnershipTypes.Burned,
       owner
@@ -2512,7 +2582,7 @@ var makeRegisteredNameTokenSchema = (valueLabel = "Registered Name Token", seria
   accurateAsOf: makeUnixTimestampSchema(`${valueLabel}.accurateAsOf`)
 }).check(function invariant_nameIsAssociatedWithDomainId(ctx) {
   const { name, domainId } = ctx.value;
-  if ((0, import_viem13.namehash)(name) !== domainId) {
+  if ((0, import_viem14.namehash)(name) !== domainId) {
     ctx.issues.push({
       code: "custom",
       input: ctx.value,
@@ -2671,34 +2741,34 @@ var import_v423 = require("zod/v4");
 var import_v421 = require("zod/v4");
 
 // src/registrars/encoded-referrer.ts
-var import_viem14 = require("viem");
+var import_viem15 = require("viem");
 var ENCODED_REFERRER_BYTE_OFFSET = 12;
 var ENCODED_REFERRER_BYTE_LENGTH = 32;
-var EXPECTED_ENCODED_REFERRER_PADDING = (0, import_viem14.pad)("0x", {
+var EXPECTED_ENCODED_REFERRER_PADDING = (0, import_viem15.pad)("0x", {
   size: ENCODED_REFERRER_BYTE_OFFSET,
   dir: "left"
 });
-var ZERO_ENCODED_REFERRER = (0, import_viem14.pad)("0x", {
+var ZERO_ENCODED_REFERRER = (0, import_viem15.pad)("0x", {
   size: ENCODED_REFERRER_BYTE_LENGTH,
   dir: "left"
 });
 function buildEncodedReferrer(address) {
   const lowercaseAddress = address.toLowerCase();
-  return (0, import_viem14.pad)(lowercaseAddress, { size: ENCODED_REFERRER_BYTE_LENGTH, dir: "left" });
+  return (0, import_viem15.pad)(lowercaseAddress, { size: ENCODED_REFERRER_BYTE_LENGTH, dir: "left" });
 }
 function decodeEncodedReferrer(encodedReferrer) {
-  if ((0, import_viem14.size)(encodedReferrer) !== ENCODED_REFERRER_BYTE_LENGTH) {
+  if ((0, import_viem15.size)(encodedReferrer) !== ENCODED_REFERRER_BYTE_LENGTH) {
     throw new Error(
       `Encoded referrer value must be represented by ${ENCODED_REFERRER_BYTE_LENGTH} bytes.`
     );
   }
-  const padding = (0, import_viem14.slice)(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
+  const padding = (0, import_viem15.slice)(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
   if (padding !== EXPECTED_ENCODED_REFERRER_PADDING) {
-    return import_viem14.zeroAddress;
+    return import_viem15.zeroAddress;
   }
-  const decodedReferrer = (0, import_viem14.slice)(encodedReferrer, ENCODED_REFERRER_BYTE_OFFSET);
+  const decodedReferrer = (0, import_viem15.slice)(encodedReferrer, ENCODED_REFERRER_BYTE_OFFSET);
   try {
-    return (0, import_viem14.getAddress)(decodedReferrer);
+    return (0, import_viem15.getAddress)(decodedReferrer);
   } catch {
     throw new Error(`Decoded referrer value must be a valid EVM address.`);
   }
@@ -3906,7 +3976,7 @@ function validateEnsIndexerPublicConfigCompatibility(configA, configB) {
 }
 
 // src/ensindexer/config/label-utils.ts
-var import_viem15 = require("viem");
+var import_viem16 = require("viem");
 function labelHashToBytes(labelHash) {
   try {
     if (labelHash.length !== 66) {
@@ -3918,7 +3988,7 @@ function labelHashToBytes(labelHash) {
     if (!labelHash.startsWith("0x")) {
       throw new Error("Labelhash must be 0x-prefixed");
     }
-    const bytes = (0, import_viem15.hexToBytes)(labelHash);
+    const bytes = (0, import_viem16.hexToBytes)(labelHash);
     if (bytes.length !== 32) {
       throw new Error(`Invalid labelHash length ${bytes.length} bytes (expected 32)`);
     }
@@ -3986,7 +4056,7 @@ function parseNonNegativeInteger(maybeNumber) {
 }
 
 // src/ensv2/ids-lib.ts
-var import_viem16 = require("viem");
+var import_viem17 = require("viem");
 var makeRegistryId = (accountId) => formatAccountId(accountId);
 var makeENSv1DomainId = (node) => node;
 var makeENSv2DomainId = (registry, canonicalId) => formatAssetId({
@@ -3997,7 +4067,7 @@ var makeENSv2DomainId = (registry, canonicalId) => formatAssetId({
 var maskLower32Bits = (num) => num ^ num & 0xffffffffn;
 var getCanonicalId = (input) => {
   if (typeof input === "bigint") return maskLower32Bits(input);
-  return getCanonicalId((0, import_viem16.hexToBigInt)(input));
+  return getCanonicalId((0, import_viem17.hexToBigInt)(input));
 };
 var makePermissionsId = (contract) => formatAccountId(contract);
 var makePermissionsResourceId = (contract, resource) => `${makePermissionsId(contract)}/${resource}`;
@@ -4343,16 +4413,6 @@ ${(0, import_v435.prettifyError)(parsed.error)}
   }
   return parsed.data;
 }
-function deserializeBlockrange(maybeBlockrange, valueLabel) {
-  const schema = makeBlockrangeSchema(valueLabel);
-  const parsed = schema.safeParse(maybeBlockrange);
-  if (parsed.error) {
-    throw new Error(`Cannot deserialize Blockrange:
-${(0, import_v435.prettifyError)(parsed.error)}
-`);
-  }
-  return parsed.data;
-}
 function deserializeBlockRef(maybeBlockRef, valueLabel) {
   const schema = makeBlockRefSchema(valueLabel);
   const parsed = schema.safeParse(maybeBlockRef);
@@ -4560,11 +4620,11 @@ var TtlCache = class {
 };
 
 // src/shared/interpretation/interpret-address.ts
-var import_viem17 = require("viem");
-var interpretAddress = (owner) => (0, import_viem17.isAddressEqual)(import_viem17.zeroAddress, owner) ? null : owner;
+var import_viem18 = require("viem");
+var interpretAddress = (owner) => (0, import_viem18.isAddressEqual)(import_viem18.zeroAddress, owner) ? null : owner;
 
 // src/shared/interpretation/interpret-record-values.ts
-var import_viem18 = require("viem");
+var import_viem19 = require("viem");
 
 // src/shared/null-bytes.ts
 var hasNullByte = (value) => value.indexOf("\0") !== -1;
@@ -4580,8 +4640,8 @@ function interpretAddressRecordValue(value) {
   if (hasNullByte(value)) return null;
   if (value === "") return null;
   if (value === "0x") return null;
-  if (!(0, import_viem18.isAddress)(value)) return value;
-  if ((0, import_viem18.isAddressEqual)(value, import_viem18.zeroAddress)) return null;
+  if (!(0, import_viem19.isAddress)(value)) return value;
+  if ((0, import_viem19.isAddressEqual)(value, import_viem19.zeroAddress)) return null;
   return asLowerCaseAddress(value);
 }
 function interpretTextRecordKey(key) {
@@ -4600,12 +4660,12 @@ var interpretTokenIdAsLabelHash = (tokenId) => uint256ToHex32(tokenId);
 var interpretTokenIdAsNode = (tokenId) => uint256ToHex32(tokenId);
 
 // src/shared/interpretation/interpreted-names-and-labels.ts
-var import_viem20 = require("viem");
+var import_viem21 = require("viem");
 var import_ens10 = require("viem/ens");
 
 // src/shared/labelhash.ts
-var import_viem19 = require("viem");
-var labelhashLiteralLabel = (label) => (0, import_viem19.keccak256)((0, import_viem19.stringToBytes)(label));
+var import_viem20 = require("viem");
+var labelhashLiteralLabel = (label) => (0, import_viem20.keccak256)((0, import_viem20.stringToBytes)(label));
 
 // src/shared/interpretation/interpreted-names-and-labels.ts
 function literalLabelToInterpretedLabel(label) {
@@ -4629,7 +4689,7 @@ function encodedLabelToLabelhash(label) {
   if (label.indexOf("[") !== 0) return null;
   if (label.indexOf("]") !== 65) return null;
   const hash = `0x${label.slice(1, 65)}`;
-  if (!(0, import_viem20.isHex)(hash)) return null;
+  if (!(0, import_viem21.isHex)(hash)) return null;
   return hash;
 }
 function isInterpetedLabel(label) {