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

package/dist/index.cjs

@@ -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`,
@@ -766,7 +799,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 +808,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",
@@ -2003,17 +2036,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 +2076,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 +2126,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 +2152,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 +2330,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 +2475,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 +2545,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 +2704,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 +3939,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 +3951,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 +4019,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 +4030,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}`;
@@ -4560,11 +4593,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 +4613,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 +4633,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 +4662,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) {