@ensnode/ensnode-sdk 1.15.1 → 1.16.0

package/dist/internal.js

@@ -102,6 +102,7 @@ var makeDefaultableChainIdSchema = (valueLabel = "Defaultable Chain ID") => make
 var makeDefaultableChainIdStringSchema = (valueLabel = "Defaultable Chain ID String") => z.string({ error: `${valueLabel} must be a string representing a chain ID.` }).pipe(z.coerce.number({ error: `${valueLabel} must represent a non-negative integer (>=0).` })).pipe(makeDefaultableChainIdSchema(`The numeric value represented by ${valueLabel}`));
 var makeCoinTypeSchema = (valueLabel = "Coin Type") => z.number({ error: `${valueLabel} must be a number.` }).int({ error: `${valueLabel} must be an integer.` }).nonnegative({ error: `${valueLabel} must be a non-negative integer (>=0).` }).transform((val) => val);
 var makeCoinTypeStringSchema = (valueLabel = "Coin Type String") => z.string({ error: `${valueLabel} must be a string representing a coin type.` }).pipe(z.coerce.number({ error: `${valueLabel} must represent a non-negative integer (>=0).` })).pipe(makeCoinTypeSchema(`The numeric value represented by ${valueLabel}`));
+var makeEmailSchema = (valueLabel = "Email") => z.string({ error: `${valueLabel} must be a string.` }).trim().pipe(z.email({ error: `${valueLabel} must be a valid email address.` })).transform((value) => value);
 var makeNormalizedAddressSchema = (valueLabel = "EVM address") => z.string().check((ctx) => {
   if (!isAddress(ctx.value, { strict: false })) {
     ctx.issues.push({
@@ -508,10 +509,10 @@ function getHighestKnownBlockTimestamp(chains) {
       "Invariant violation: at least one chain is required to determine the highest known block timestamp"
     );
   }
-  const startBlockTimestamps = chains.map((chain) => chain.config.startBlock.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 startBlockTimestamps = chains.map((chain2) => chain2.config.startBlock.timestamp);
+  const endBlockTimestamps = chains.map((chain2) => chain2.config).filter((chainConfig) => chainConfig.rangeType === RangeTypeIds.Bounded).map((chainConfig) => chainConfig.endBlock.timestamp);
+  const backfillEndBlockTimestamps = chains.filter((chain2) => chain2.chainStatus === ChainIndexingStatusIds.Backfill).map((chain2) => chain2.backfillEndBlock.timestamp);
+  const latestKnownBlockTimestamps = chains.filter((chain2) => chain2.chainStatus === ChainIndexingStatusIds.Following).map((chain2) => chain2.latestKnownBlock.timestamp);
   return Math.max(
     ...startBlockTimestamps,
     ...endBlockTimestamps,
@@ -551,26 +552,26 @@ var OmnichainIndexingStatusIds = {
   Completed: "omnichain-completed"
 };
 function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotUnstarted(chains) {
-  return chains.every((chain) => chain.chainStatus === ChainIndexingStatusIds.Queued);
+  return chains.every((chain2) => chain2.chainStatus === ChainIndexingStatusIds.Queued);
 }
 function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotBackfill(chains) {
   const atLeastOneChainInTargetStatus = chains.some(
-    (chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill
+    (chain2) => chain2.chainStatus === ChainIndexingStatusIds.Backfill
   );
   const otherChainsHaveValidStatuses = chains.every(
-    (chain) => chain.chainStatus === ChainIndexingStatusIds.Queued || chain.chainStatus === ChainIndexingStatusIds.Backfill || chain.chainStatus === ChainIndexingStatusIds.Completed
+    (chain2) => chain2.chainStatus === ChainIndexingStatusIds.Queued || chain2.chainStatus === ChainIndexingStatusIds.Backfill || chain2.chainStatus === ChainIndexingStatusIds.Completed
   );
   return atLeastOneChainInTargetStatus && otherChainsHaveValidStatuses;
 }
 function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotCompleted(chains) {
   const allChainsHaveValidStatuses = chains.every(
-    (chain) => chain.chainStatus === ChainIndexingStatusIds.Completed
+    (chain2) => chain2.chainStatus === ChainIndexingStatusIds.Completed
   );
   return allChainsHaveValidStatuses;
 }
 function checkChainIndexingStatusSnapshotsForOmnichainStatusSnapshotFollowing(chains) {
   const allChainsHaveValidStatuses = chains.some(
-    (chain) => chain.chainStatus === ChainIndexingStatusIds.Following
+    (chain2) => chain2.chainStatus === ChainIndexingStatusIds.Following
   );
   return allChainsHaveValidStatuses;
 }
@@ -732,12 +733,12 @@ function invariant_omnichainSnapshotStatusIsConsistentWithChainSnapshot(ctx) {
 function invariant_omnichainIndexingCursorLowerThanEarliestStartBlockAcrossQueuedChains(ctx) {
   const snapshot = ctx.value;
   const queuedChains = Array.from(snapshot.chains.values()).filter(
-    (chain) => chain.chainStatus === ChainIndexingStatusIds.Queued
+    (chain2) => chain2.chainStatus === ChainIndexingStatusIds.Queued
   );
   if (queuedChains.length === 0) {
     return;
   }
-  const queuedChainStartBlocks = queuedChains.map((chain) => chain.config.startBlock.timestamp);
+  const queuedChainStartBlocks = queuedChains.map((chain2) => chain2.config.startBlock.timestamp);
   const queuedChainEarliestStartBlock = Math.min(...queuedChainStartBlocks);
   if (snapshot.omnichainIndexingCursor >= queuedChainEarliestStartBlock) {
     ctx.issues.push({
@@ -750,12 +751,12 @@ function invariant_omnichainIndexingCursorLowerThanEarliestStartBlockAcrossQueue
 function invariant_omnichainIndexingCursorLowerThanOrEqualToLatestBackfillEndBlockAcrossBackfillChains(ctx) {
   const snapshot = ctx.value;
   const backfillChains = Array.from(snapshot.chains.values()).filter(
-    (chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill
+    (chain2) => chain2.chainStatus === ChainIndexingStatusIds.Backfill
   );
   if (backfillChains.length === 0) {
     return;
   }
-  const backfillEndBlocks = backfillChains.map((chain) => chain.backfillEndBlock.timestamp);
+  const backfillEndBlocks = backfillChains.map((chain2) => chain2.backfillEndBlock.timestamp);
   const highestBackfillEndBlock = Math.max(...backfillEndBlocks);
   if (snapshot.omnichainIndexingCursor > highestBackfillEndBlock) {
     ctx.issues.push({
@@ -768,13 +769,13 @@ function invariant_omnichainIndexingCursorLowerThanOrEqualToLatestBackfillEndBlo
 function invariant_omnichainIndexingCursorIsEqualToHighestLatestIndexedBlockAcrossIndexedChain(ctx) {
   const snapshot = ctx.value;
   const indexedChains = Array.from(snapshot.chains.values()).filter(
-    (chain) => chain.chainStatus === ChainIndexingStatusIds.Backfill || chain.chainStatus === ChainIndexingStatusIds.Completed || chain.chainStatus === ChainIndexingStatusIds.Following
+    (chain2) => chain2.chainStatus === ChainIndexingStatusIds.Backfill || chain2.chainStatus === ChainIndexingStatusIds.Completed || chain2.chainStatus === ChainIndexingStatusIds.Following
   );
   if (indexedChains.length === 0) {
     return;
   }
   const indexedChainLatestIndexedBlocks = indexedChains.map(
-    (chain) => chain.latestIndexedBlock.timestamp
+    (chain2) => chain2.latestIndexedBlock.timestamp
   );
   const indexedChainHighestLatestIndexedBlock = Math.max(...indexedChainLatestIndexedBlocks);
   if (snapshot.omnichainIndexingCursor !== indexedChainHighestLatestIndexedBlock) {
@@ -1602,8 +1603,8 @@ function decodeEncodedReferrer(encodedReferrer) {
       `Encoded referrer value must be represented by ${ENCODED_REFERRER_BYTE_LENGTH} bytes.`
     );
   }
-  const padding = slice(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
-  if (padding !== EXPECTED_ENCODED_REFERRER_PADDING) return zeroAddress4;
+  const padding2 = slice(encodedReferrer, 0, ENCODED_REFERRER_BYTE_OFFSET);
+  if (padding2 !== EXPECTED_ENCODED_REFERRER_PADDING) return zeroAddress4;
   const decodedReferrer = slice(encodedReferrer, ENCODED_REFERRER_BYTE_OFFSET);
   try {
     return toNormalizedAddress2(decodedReferrer);
@@ -1964,9 +1965,1095 @@ var errorResponseInternalServerErrorExample = {
 };
 
 // src/omnigraph-api/example-queries.ts
-import { asInterpretedName, toNormalizedAddress as toNormalizedAddress3 } from "enssdk";
+import { asInterpretedName, toNormalizedAddress as toNormalizedAddress4 } from "enssdk";
 import { DatasourceNames as DatasourceNames2, ENSNamespaceIds as ENSNamespaceIds3 } from "@ensnode/datasources";
-import { accounts } from "@ensnode/datasources/devnet";
+
+// ../integration-test-env/src/devnet/fixtures.ts
+import { getCoderByCoinName } from "@ensdomains/address-encoder";
+import { bytesToHex as bytesToHex2 } from "@ensdomains/address-encoder/utils";
+
+// ../../node_modules/.pnpm/@ensdomains+content-hash@3.1.0-rc.1/node_modules/@ensdomains/content-hash/dist/esm/utils/coders.js
+import { decodeArAddress, encodeArAddress } from "@ensdomains/address-encoder/coders";
+
+// ../../node_modules/.pnpm/@scure+base@1.2.6/node_modules/@scure/base/lib/esm/index.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function isArrayOf(isString, arr) {
+  if (!Array.isArray(arr))
+    return false;
+  if (arr.length === 0)
+    return true;
+  if (isString) {
+    return arr.every((item) => typeof item === "string");
+  } else {
+    return arr.every((item) => Number.isSafeInteger(item));
+  }
+}
+function afn(input) {
+  if (typeof input !== "function")
+    throw new Error("function expected");
+  return true;
+}
+function astr(label, input) {
+  if (typeof input !== "string")
+    throw new Error(`${label}: string expected`);
+  return true;
+}
+function anumber(n) {
+  if (!Number.isSafeInteger(n))
+    throw new Error(`invalid integer: ${n}`);
+}
+function aArr(input) {
+  if (!Array.isArray(input))
+    throw new Error("array expected");
+}
+function astrArr(label, input) {
+  if (!isArrayOf(true, input))
+    throw new Error(`${label}: array of strings expected`);
+}
+function anumArr(label, input) {
+  if (!isArrayOf(false, input))
+    throw new Error(`${label}: array of numbers expected`);
+}
+// @__NO_SIDE_EFFECTS__
+function chain(...args) {
+  const id = (a) => a;
+  const wrap = (a, b) => (c) => a(b(c));
+  const encode2 = args.map((x) => x.encode).reduceRight(wrap, id);
+  const decode2 = args.map((x) => x.decode).reduce(wrap, id);
+  return { encode: encode2, decode: decode2 };
+}
+// @__NO_SIDE_EFFECTS__
+function alphabet(letters) {
+  const lettersA = typeof letters === "string" ? letters.split("") : letters;
+  const len = lettersA.length;
+  astrArr("alphabet", lettersA);
+  const indexes = new Map(lettersA.map((l, i) => [l, i]));
+  return {
+    encode: (digits) => {
+      aArr(digits);
+      return digits.map((i) => {
+        if (!Number.isSafeInteger(i) || i < 0 || i >= len)
+          throw new Error(`alphabet.encode: digit index outside alphabet "${i}". Allowed: ${letters}`);
+        return lettersA[i];
+      });
+    },
+    decode: (input) => {
+      aArr(input);
+      return input.map((letter) => {
+        astr("alphabet.decode", letter);
+        const i = indexes.get(letter);
+        if (i === void 0)
+          throw new Error(`Unknown letter: "${letter}". Allowed: ${letters}`);
+        return i;
+      });
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function join(separator = "") {
+  astr("join", separator);
+  return {
+    encode: (from) => {
+      astrArr("join.decode", from);
+      return from.join(separator);
+    },
+    decode: (to) => {
+      astr("join.decode", to);
+      return to.split(separator);
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function padding(bits, chr = "=") {
+  anumber(bits);
+  astr("padding", chr);
+  return {
+    encode(data) {
+      astrArr("padding.encode", data);
+      while (data.length * bits % 8)
+        data.push(chr);
+      return data;
+    },
+    decode(input) {
+      astrArr("padding.decode", input);
+      let end = input.length;
+      if (end * bits % 8)
+        throw new Error("padding: invalid, string should have whole number of bytes");
+      for (; end > 0 && input[end - 1] === chr; end--) {
+        const last = end - 1;
+        const byte = last * bits;
+        if (byte % 8 === 0)
+          throw new Error("padding: invalid, string has too much padding");
+      }
+      return input.slice(0, end);
+    }
+  };
+}
+function convertRadix(data, from, to) {
+  if (from < 2)
+    throw new Error(`convertRadix: invalid from=${from}, base cannot be less than 2`);
+  if (to < 2)
+    throw new Error(`convertRadix: invalid to=${to}, base cannot be less than 2`);
+  aArr(data);
+  if (!data.length)
+    return [];
+  let pos = 0;
+  const res = [];
+  const digits = Array.from(data, (d) => {
+    anumber(d);
+    if (d < 0 || d >= from)
+      throw new Error(`invalid integer: ${d}`);
+    return d;
+  });
+  const dlen = digits.length;
+  while (true) {
+    let carry = 0;
+    let done = true;
+    for (let i = pos; i < dlen; i++) {
+      const digit = digits[i];
+      const fromCarry = from * carry;
+      const digitBase = fromCarry + digit;
+      if (!Number.isSafeInteger(digitBase) || fromCarry / from !== carry || digitBase - digit !== fromCarry) {
+        throw new Error("convertRadix: carry overflow");
+      }
+      const div = digitBase / to;
+      carry = digitBase % to;
+      const rounded = Math.floor(div);
+      digits[i] = rounded;
+      if (!Number.isSafeInteger(rounded) || rounded * to + carry !== digitBase)
+        throw new Error("convertRadix: carry overflow");
+      if (!done)
+        continue;
+      else if (!rounded)
+        pos = i;
+      else
+        done = false;
+    }
+    res.push(carry);
+    if (done)
+      break;
+  }
+  for (let i = 0; i < data.length - 1 && data[i] === 0; i++)
+    res.push(0);
+  return res.reverse();
+}
+var gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
+var radix2carry = /* @__NO_SIDE_EFFECTS__ */ (from, to) => from + (to - gcd(from, to));
+var powers = /* @__PURE__ */ (() => {
+  let res = [];
+  for (let i = 0; i < 40; i++)
+    res.push(2 ** i);
+  return res;
+})();
+function convertRadix2(data, from, to, padding2) {
+  aArr(data);
+  if (from <= 0 || from > 32)
+    throw new Error(`convertRadix2: wrong from=${from}`);
+  if (to <= 0 || to > 32)
+    throw new Error(`convertRadix2: wrong to=${to}`);
+  if (/* @__PURE__ */ radix2carry(from, to) > 32) {
+    throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${/* @__PURE__ */ radix2carry(from, to)}`);
+  }
+  let carry = 0;
+  let pos = 0;
+  const max = powers[from];
+  const mask = powers[to] - 1;
+  const res = [];
+  for (const n of data) {
+    anumber(n);
+    if (n >= max)
+      throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);
+    carry = carry << from | n;
+    if (pos + from > 32)
+      throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);
+    pos += from;
+    for (; pos >= to; pos -= to)
+      res.push((carry >> pos - to & mask) >>> 0);
+    const pow = powers[pos];
+    if (pow === void 0)
+      throw new Error("invalid carry");
+    carry &= pow - 1;
+  }
+  carry = carry << to - pos & mask;
+  if (!padding2 && pos >= from)
+    throw new Error("Excess padding");
+  if (!padding2 && carry > 0)
+    throw new Error(`Non-zero padding: ${carry}`);
+  if (padding2 && pos > 0)
+    res.push(carry >>> 0);
+  return res;
+}
+// @__NO_SIDE_EFFECTS__
+function radix(num) {
+  anumber(num);
+  const _256 = 2 ** 8;
+  return {
+    encode: (bytes) => {
+      if (!isBytes(bytes))
+        throw new Error("radix.encode input should be Uint8Array");
+      return convertRadix(Array.from(bytes), _256, num);
+    },
+    decode: (digits) => {
+      anumArr("radix.decode", digits);
+      return Uint8Array.from(convertRadix(digits, num, _256));
+    }
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function radix2(bits, revPadding = false) {
+  anumber(bits);
+  if (bits <= 0 || bits > 32)
+    throw new Error("radix2: bits should be in (0..32]");
+  if (/* @__PURE__ */ radix2carry(8, bits) > 32 || /* @__PURE__ */ radix2carry(bits, 8) > 32)
+    throw new Error("radix2: carry overflow");
+  return {
+    encode: (bytes) => {
+      if (!isBytes(bytes))
+        throw new Error("radix2.encode input should be Uint8Array");
+      return convertRadix2(Array.from(bytes), 8, bits, !revPadding);
+    },
+    decode: (digits) => {
+      anumArr("radix2.decode", digits);
+      return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));
+    }
+  };
+}
+function checksum(len, fn) {
+  anumber(len);
+  afn(fn);
+  return {
+    encode(data) {
+      if (!isBytes(data))
+        throw new Error("checksum.encode: input should be Uint8Array");
+      const sum = fn(data).slice(0, len);
+      const res = new Uint8Array(data.length + len);
+      res.set(data);
+      res.set(sum, data.length);
+      return res;
+    },
+    decode(data) {
+      if (!isBytes(data))
+        throw new Error("checksum.decode: input should be Uint8Array");
+      const payload = data.slice(0, -len);
+      const oldChecksum = data.slice(-len);
+      const newChecksum = fn(payload).slice(0, len);
+      for (let i = 0; i < len; i++)
+        if (newChecksum[i] !== oldChecksum[i])
+          throw new Error("Invalid checksum");
+      return payload;
+    }
+  };
+}
+var utils = {
+  alphabet,
+  chain,
+  checksum,
+  convertRadix,
+  convertRadix2,
+  radix,
+  radix2,
+  join,
+  padding
+};
+var genBase58 = /* @__NO_SIDE_EFFECTS__ */ (abc) => /* @__PURE__ */ chain(/* @__PURE__ */ radix(58), /* @__PURE__ */ alphabet(abc), /* @__PURE__ */ join(""));
+var base58 = /* @__PURE__ */ genBase58("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
+
+// ../../node_modules/.pnpm/@ensdomains+content-hash@3.1.0-rc.1/node_modules/@ensdomains/content-hash/dist/esm/utils/coders.js
+var createMultibaseCoder = ({ name, prefix, encode: encodeWithoutPrefix, decode: decodeWithoutPrefix }) => {
+  const encode2 = (bytes) => `${prefix}${encodeWithoutPrefix(bytes)}`;
+  const decode2 = (multibase) => {
+    if (!multibase.startsWith(prefix)) {
+      throw new Error(`Multibase ${name} must start with ${prefix}`);
+    }
+    return decodeWithoutPrefix(multibase.slice(prefix.length));
+  };
+  return {
+    name,
+    prefix,
+    encode: encode2,
+    decode: decode2
+  };
+};
+var base58btc = createMultibaseCoder({
+  name: "base58btc",
+  prefix: "z",
+  encode: base58.encode,
+  decode: base58.decode
+});
+var customBase32 = utils.chain(utils.radix2(5), utils.alphabet("abcdefghijklmnopqrstuvwxyz234567"), utils.join(""));
+var base32 = createMultibaseCoder({
+  name: "base32",
+  prefix: "b",
+  encode: (bytes) => customBase32.encode(bytes),
+  decode: (multibase) => customBase32.decode(multibase)
+});
+var base36Chain = utils.chain(utils.radix(36), utils.alphabet("0123456789abcdefghijklmnopqrstuvwxyz"), utils.join(""));
+var base36 = createMultibaseCoder({
+  name: "base36",
+  prefix: "k",
+  encode: base36Chain.encode,
+  decode: base36Chain.decode
+});
+var base64url = createMultibaseCoder({
+  name: "base64url",
+  prefix: "u",
+  encode: encodeArAddress,
+  decode: decodeArAddress
+});
+
+// ../../node_modules/.pnpm/@ensdomains+content-hash@3.1.0-rc.1/node_modules/@ensdomains/content-hash/dist/esm/utils/coerce.js
+var coerce = (o) => {
+  if (o instanceof Uint8Array && o.constructor.name === "Uint8Array")
+    return o;
+  if (o instanceof ArrayBuffer)
+    return new Uint8Array(o);
+  if (ArrayBuffer.isView(o)) {
+    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
+  }
+  throw new Error("Unknown type, must be binary type");
+};
+
+// ../../node_modules/.pnpm/@noble+curves@1.9.7/node_modules/@noble/curves/esm/utils.js
+function equalBytes(a, b) {
+  if (a.length !== b.length)
+    return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++)
+    diff |= a[i] ^ b[i];
+  return diff === 0;
+}
+
+// ../../node_modules/.pnpm/@noble+curves@1.9.7/node_modules/@noble/curves/esm/abstract/utils.js
+var equalBytes2 = equalBytes;
+
+// ../../node_modules/.pnpm/@ensdomains+content-hash@3.1.0-rc.1/node_modules/@ensdomains/content-hash/dist/esm/utils/varint.js
+var MSB = 128;
+var REST = 127;
+var MSBALL = ~REST;
+var INT = Math.pow(2, 31);
+var encodeVarint = (num, out, offset = 0) => {
+  out = out || [];
+  offset = offset || 0;
+  while (num >= INT) {
+    out[offset++] = num & 255 | MSB;
+    num /= 128;
+  }
+  while (num & MSBALL) {
+    out[offset++] = num & 255 | MSB;
+    num >>>= 7;
+  }
+  out[offset] = num | 0;
+  return out;
+};
+var MSB$1 = 128;
+var REST$1 = 127;
+var decodeVarint = (buf, offset = 0) => {
+  var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf.length;
+  do {
+    if (counter >= l) {
+      read.bytes = 0;
+      throw new RangeError("Could not decode varint");
+    }
+    b = buf[counter++];
+    res += shift < 28 ? (b & REST$1) << shift : (b & REST$1) * Math.pow(2, shift);
+    shift += 7;
+  } while (b >= MSB$1);
+  return [res, counter - offset];
+};
+var N1 = Math.pow(2, 7);
+var N2 = Math.pow(2, 14);
+var N3 = Math.pow(2, 21);
+var N4 = Math.pow(2, 28);
+var N5 = Math.pow(2, 35);
+var N6 = Math.pow(2, 42);
+var N7 = Math.pow(2, 49);
+var N8 = Math.pow(2, 56);
+var N9 = Math.pow(2, 63);
+var varintEncodingLength = (value) => {
+  return value < N1 ? 1 : value < N2 ? 2 : value < N3 ? 3 : value < N4 ? 4 : value < N5 ? 5 : value < N6 ? 6 : value < N7 ? 7 : value < N8 ? 8 : value < N9 ? 9 : 10;
+};
+
+// ../../node_modules/.pnpm/@ensdomains+content-hash@3.1.0-rc.1/node_modules/@ensdomains/content-hash/dist/esm/utils/digest.js
+var Digest = class {
+  /**
+   * Creates a multihash digest.
+   */
+  constructor(code, size4, digest, bytes) {
+    Object.defineProperty(this, "code", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "size", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "digest", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "bytes", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.code = code;
+    this.size = size4;
+    this.digest = digest;
+    this.bytes = bytes;
+  }
+};
+var createDigest = (code, digest) => {
+  const size4 = digest.byteLength;
+  const sizeOffset = varintEncodingLength(code);
+  const digestOffset = sizeOffset + varintEncodingLength(size4);
+  const bytes = new Uint8Array(digestOffset + size4);
+  encodeVarint(code, bytes, 0);
+  encodeVarint(size4, bytes, sizeOffset);
+  bytes.set(digest, digestOffset);
+  return new Digest(code, size4, digest, bytes);
+};
+var decodeDigest = (multihash) => {
+  const bytes = coerce(multihash);
+  const [code, sizeOffset] = decodeVarint(bytes);
+  const [size4, digestOffset] = decodeVarint(bytes.subarray(sizeOffset));
+  const digest = bytes.subarray(sizeOffset + digestOffset);
+  if (digest.byteLength !== size4) {
+    throw new Error("Incorrect length");
+  }
+  return new Digest(code, size4, digest, bytes);
+};
+var digestEquals = (a, b) => {
+  if (a === b) {
+    return true;
+  } else {
+    const data = b;
+    return a.code === data.code && a.size === data.size && data.bytes instanceof Uint8Array && equalBytes2(a.bytes, data.bytes);
+  }
+};
+
+// ../../node_modules/.pnpm/@ensdomains+content-hash@3.1.0-rc.1/node_modules/@ensdomains/content-hash/dist/esm/utils/cid.js
+function format(link, base2) {
+  const { bytes, version } = link;
+  switch (version) {
+    case 0:
+      return toStringV0(bytes, baseCache(link), base2 ?? base58btc.encode);
+    default:
+      return toStringV1(bytes, baseCache(link), base2 ?? base32.encode);
+  }
+}
+var cache = /* @__PURE__ */ new WeakMap();
+function baseCache(cid) {
+  const baseCache2 = cache.get(cid);
+  if (baseCache2 == null) {
+    const baseCache3 = /* @__PURE__ */ new Map();
+    cache.set(cid, baseCache3);
+    return baseCache3;
+  }
+  return baseCache2;
+}
+var CID = class _CID {
+  /**
+   * @param version - Version of the CID
+   * @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
+   * @param multihash - (Multi)hash of the of the content.
+   */
+  constructor(version, code, multihash, bytes) {
+    Object.defineProperty(this, "code", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "version", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "multihash", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "bytes", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "/", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.code = code;
+    this.version = version;
+    this.multihash = multihash;
+    this.bytes = bytes;
+    this["/"] = bytes;
+  }
+  /**
+   * Signalling `cid.asCID === cid` has been replaced with `cid['/'] === cid.bytes`
+   * please either use `CID.asCID(cid)` or switch to new signalling mechanism
+   *
+   * @deprecated
+   */
+  get asCID() {
+    return this;
+  }
+  // ArrayBufferView
+  get byteOffset() {
+    return this.bytes.byteOffset;
+  }
+  // ArrayBufferView
+  get byteLength() {
+    return this.bytes.byteLength;
+  }
+  toV0() {
+    switch (this.version) {
+      case 0: {
+        return this;
+      }
+      case 1: {
+        const { code, multihash } = this;
+        if (code !== DAG_PB_CODE) {
+          throw new Error("Cannot convert a non dag-pb CID to CIDv0");
+        }
+        if (multihash.code !== SHA_256_CODE) {
+          throw new Error("Cannot convert non sha2-256 multihash CID to CIDv0");
+        }
+        return _CID.createV0(multihash);
+      }
+      default: {
+        throw Error(`Can not convert CID version ${this.version} to version 0. This is a bug please report`);
+      }
+    }
+  }
+  toV1() {
+    switch (this.version) {
+      case 0: {
+        const { code, digest } = this.multihash;
+        const multihash = createDigest(code, digest);
+        return _CID.createV1(this.code, multihash);
+      }
+      case 1: {
+        return this;
+      }
+      default: {
+        throw Error(`Can not convert CID version ${this.version} to version 1. This is a bug please report`);
+      }
+    }
+  }
+  equals(other) {
+    return _CID.equals(this, other);
+  }
+  static equals(self, other) {
+    const unknown = other;
+    return unknown != null && self.code === unknown.code && self.version === unknown.version && digestEquals(self.multihash, unknown.multihash);
+  }
+  toString(base2) {
+    return format(this, base2);
+  }
+  toJSON() {
+    return { "/": format(this) };
+  }
+  link() {
+    return this;
+  }
+  get [Symbol.toStringTag]() {
+    return "CID";
+  }
+  // Legacy
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return `CID(${this.toString()})`;
+  }
+  /**
+   * Takes any input `value` and returns a `CID` instance if it was
+   * a `CID` otherwise returns `null`. If `value` is instanceof `CID`
+   * it will return value back. If `value` is not instance of this CID
+   * class, but is compatible CID it will return new instance of this
+   * `CID` class. Otherwise returns null.
+   *
+   * This allows two different incompatible versions of CID library to
+   * co-exist and interop as long as binary interface is compatible.
+   */
+  static asCID(input) {
+    if (input == null) {
+      return null;
+    }
+    const value = input;
+    if (value instanceof _CID) {
+      return value;
+    } else if (value["/"] != null && value["/"] === value.bytes || value.asCID === value) {
+      const { version, code, multihash, bytes } = value;
+      return new _CID(version, code, multihash, bytes ?? encodeCID(version, code, multihash.bytes));
+    } else if (value[cidSymbol] === true) {
+      const { version, multihash, code } = value;
+      const digest = decodeDigest(multihash);
+      return _CID.create(version, code, digest);
+    } else {
+      return null;
+    }
+  }
+  /**
+   * @param version - Version of the CID
+   * @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
+   * @param digest - (Multi)hash of the of the content.
+   */
+  static create(version, code, digest) {
+    if (typeof code !== "number") {
+      throw new Error("String codecs are no longer supported");
+    }
+    if (!(digest.bytes instanceof Uint8Array)) {
+      throw new Error("Invalid digest");
+    }
+    switch (version) {
+      case 0: {
+        if (code !== DAG_PB_CODE) {
+          throw new Error(`Version 0 CID must use dag-pb (code: ${DAG_PB_CODE}) block encoding`);
+        } else {
+          return new _CID(version, code, digest, digest.bytes);
+        }
+      }
+      case 1: {
+        const bytes = encodeCID(version, code, digest.bytes);
+        return new _CID(version, code, digest, bytes);
+      }
+      default: {
+        throw new Error("Invalid version");
+      }
+    }
+  }
+  /**
+   * Simplified version of `create` for CIDv0.
+   */
+  static createV0(digest) {
+    return _CID.create(0, DAG_PB_CODE, digest);
+  }
+  /**
+   * Simplified version of `create` for CIDv1.
+   *
+   * @param code - Content encoding format code.
+   * @param digest - Multihash of the content.
+   */
+  static createV1(code, digest) {
+    return _CID.create(1, code, digest);
+  }
+  /**
+   * Decoded a CID from its binary representation. The byte array must contain
+   * only the CID with no additional bytes.
+   *
+   * An error will be thrown if the bytes provided do not contain a valid
+   * binary representation of a CID.
+   */
+  static decode(bytes) {
+    let [cid, remainder] = _CID.decodeFirst(bytes);
+    if (remainder.length !== 0) {
+      [cid, remainder] = _CID.decodeFirst(Uint8Array.from([0, DAG_PB_CODE, ...bytes]));
+      if (remainder.length !== 0)
+        throw new Error("Incorrect length");
+    }
+    return cid;
+  }
+  /**
+   * Decoded a CID from its binary representation at the beginning of a byte
+   * array.
+   *
+   * Returns an array with the first element containing the CID and the second
+   * element containing the remainder of the original byte array. The remainder
+   * will be a zero-length byte array if the provided bytes only contained a
+   * binary CID representation.
+   */
+  static decodeFirst(bytes) {
+    const specs = _CID.inspectBytes(bytes);
+    const prefixSize = specs.size - specs.multihashSize;
+    const multihashBytes = coerce(bytes.subarray(prefixSize, prefixSize + specs.multihashSize));
+    if (multihashBytes.byteLength !== specs.multihashSize) {
+      throw new Error("Incorrect length");
+    }
+    const digestBytes = multihashBytes.subarray(specs.multihashSize - specs.digestSize);
+    const digest = new Digest(specs.multihashCode, specs.digestSize, digestBytes, multihashBytes);
+    const cid = specs.version === 0 ? _CID.createV0(digest) : _CID.createV1(specs.codec, digest);
+    return [cid, bytes.subarray(specs.size)];
+  }
+  /**
+   * Inspect the initial bytes of a CID to determine its properties.
+   *
+   * Involves decoding up to 4 varints. Typically this will require only 4 to 6
+   * bytes but for larger multicodec code values and larger multihash digest
+   * lengths these varints can be quite large. It is recommended that at least
+   * 10 bytes be made available in the `initialBytes` argument for a complete
+   * inspection.
+   */
+  static inspectBytes(initialBytes) {
+    let offset = 0;
+    const next = () => {
+      const [i, length] = decodeVarint(initialBytes.subarray(offset));
+      offset += length;
+      return i;
+    };
+    let version = next();
+    let codec = DAG_PB_CODE;
+    if (version === 18) {
+      version = 0;
+      offset = 0;
+    } else {
+      codec = next();
+    }
+    if (version !== 0 && version !== 1) {
+      throw new RangeError(`Invalid CID version ${version}`);
+    }
+    const prefixSize = offset;
+    const multihashCode = next();
+    const digestSize = next();
+    const size4 = offset + digestSize;
+    const multihashSize = size4 - prefixSize;
+    return { version, codec, multihashCode, digestSize, multihashSize, size: size4 };
+  }
+  /**
+   * Takes cid in a string representation and creates an instance. If `base`
+   * decoder is not provided will use a default from the configuration. It will
+   * throw an error if encoding of the CID is not compatible with supplied (or
+   * a default decoder).
+   */
+  static parse(source, base2) {
+    const [prefix, bytes] = parseCIDtoBytes(source, base2);
+    const cid = _CID.decode(bytes);
+    baseCache(cid).set(prefix, source);
+    return cid;
+  }
+};
+function parseCIDtoBytes(source, base2) {
+  switch (source[0]) {
+    // CIDv0 is parsed differently
+    case "Q": {
+      const decoder = base2 ?? base58btc;
+      return [
+        base58btc.prefix,
+        decoder.decode(`${base58btc.prefix}${source}`)
+      ];
+    }
+    case base58btc.prefix: {
+      const decoder = base2 ?? base58btc;
+      return [base58btc.prefix, decoder.decode(source)];
+    }
+    case base32.prefix: {
+      const decoder = base2 ?? base32;
+      return [base32.prefix, decoder.decode(source)];
+    }
+    case base36.prefix: {
+      const decoder = base2 ?? base36;
+      return [base36.prefix, decoder.decode(source)];
+    }
+    default: {
+      source = `z${source}`;
+      return [source[0], base58btc.decode(source)];
+    }
+  }
+}
+function toStringV0(bytes, cache4, base2) {
+  const { prefix } = base2;
+  if (prefix !== base58btc.prefix) {
+    throw Error(`Cannot string encode V0 in ${base2.name} encoding`);
+  }
+  const cid = cache4.get(prefix);
+  if (cid == null) {
+    const cid2 = base2.encode(bytes).slice(1);
+    cache4.set(prefix, cid2);
+    return cid2;
+  } else {
+    return cid;
+  }
+}
+function toStringV1(bytes, cache4, base2) {
+  const { prefix } = base2;
+  const cid = cache4.get(prefix);
+  if (cid == null) {
+    const cid2 = base2.encode(bytes);
+    cache4.set(prefix, cid2);
+    return cid2;
+  } else {
+    return cid;
+  }
+}
+var DAG_PB_CODE = 112;
+var SHA_256_CODE = 18;
+function encodeCID(version, code, multihash) {
+  const codeOffset = varintEncodingLength(version);
+  const hashOffset = codeOffset + varintEncodingLength(code);
+  const bytes = new Uint8Array(hashOffset + multihash.byteLength);
+  encodeVarint(version, bytes, 0);
+  encodeVarint(code, bytes, codeOffset);
+  bytes.set(multihash, hashOffset);
+  return bytes;
+}
+var cidSymbol = /* @__PURE__ */ Symbol.for("@ipld/js-cid/CID");
+
+// ../../node_modules/.pnpm/@ensdomains+content-hash@3.1.0-rc.1/node_modules/@ensdomains/content-hash/dist/esm/helpers.js
+var concatUint8Arrays = (array1, array2) => {
+  let result = new Uint8Array(array1.length + array2.length);
+  result.set(array1, 0);
+  result.set(array2, array1.length);
+  return result;
+};
+
+// ../../node_modules/.pnpm/@ensdomains+content-hash@3.1.0-rc.1/node_modules/@ensdomains/content-hash/dist/esm/map.js
+var codeToName = {
+  227: "ipfs",
+  229: "ipns",
+  228: "swarm",
+  444: "onion",
+  445: "onion3",
+  11639056: "skynet",
+  11704592: "arweave"
+};
+var nameToCode = {
+  ipfs: 227,
+  ipns: 229,
+  swarm: 228,
+  onion: 444,
+  onion3: 445,
+  skynet: 11639056,
+  arweave: 11704592
+};
+
+// ../../node_modules/.pnpm/@ensdomains+content-hash@3.1.0-rc.1/node_modules/@ensdomains/content-hash/dist/esm/profiles.js
+import { decodeArAddress as decodeArAddress2, encodeArAddress as encodeArAddress2 } from "@ensdomains/address-encoder/coders";
+var hexStringToBytes = (hex) => {
+  let value = hex;
+  if (value.startsWith("0x")) {
+    value = value.slice(2);
+  }
+  if (value.length % 2 !== 0) {
+    throw new Error("Invalid hex string");
+  }
+  const bytes = new Uint8Array(value.length / 2);
+  for (let i = 0; i < value.length; i += 2) {
+    bytes[i / 2] = parseInt(value.slice(i, i + 2), 16);
+  }
+  return bytes;
+};
+var bytesToHexString = (bytes) => {
+  let hex = "";
+  for (let i = 0; i < bytes.length; i++) {
+    hex += bytes[i].toString(16).padStart(2, "0");
+  }
+  return hex;
+};
+var isCryptographicIPNS = (cid) => {
+  try {
+    const { multihash } = cid;
+    if (multihash.size < 38) {
+      const mh = decodeDigest(multihash.bytes);
+      if (mh.code === 0 && mh.size < 36) {
+        return false;
+      }
+    }
+    return true;
+  } catch (_) {
+    return false;
+  }
+};
+var base64Decode = (value) => decodeArAddress2(value);
+var encodes = {
+  skynet: (value) => {
+    return base64Decode(value);
+  },
+  swarm: (value) => {
+    const bytes = hexStringToBytes(value);
+    const multihash = createDigest(27, bytes);
+    return CID.create(1, 250, multihash).bytes;
+  },
+  ipfs: (value) => {
+    return CID.parse(value).toV1().bytes;
+  },
+  ipns: (value) => {
+    const cid = CID.parse(value);
+    return CID.create(1, 114, cid.multihash).bytes;
+  },
+  utf8: (value) => {
+    const encoder = new TextEncoder();
+    return encoder.encode(value);
+  },
+  arweave: (value) => {
+    return base64Decode(value);
+  }
+};
+var decodes = {
+  hexMultiHash: (value) => {
+    const cid = CID.decode(value);
+    return bytesToHexString(decodeDigest(cid.multihash.bytes).digest);
+  },
+  ipfs: (value) => {
+    const cid = CID.decode(value).toV1();
+    return cid.toString(cid.code === 114 ? base36 : base32);
+  },
+  ipns: (value) => {
+    const cid = CID.decode(value).toV1();
+    if (!isCryptographicIPNS(cid)) {
+      console.warn("[ensdomains/content-hash] use of non-cryptographic identifiers in ipns-ns is deprecated and will be removed, migrate to ED25519 libp2p-key");
+      return String.fromCodePoint(...CID.decode(value).multihash.digest);
+    }
+    return cid.toString(base36);
+  },
+  utf8: (value) => {
+    const decoder = new TextDecoder();
+    return decoder.decode(value);
+  },
+  base64: (value) => {
+    return encodeArAddress2(value);
+  }
+};
+var profiles = {
+  skynet: {
+    encode: encodes.skynet,
+    decode: decodes.base64
+  },
+  swarm: {
+    encode: encodes.swarm,
+    decode: decodes.hexMultiHash
+  },
+  ipfs: {
+    encode: encodes.ipfs,
+    decode: decodes.ipfs
+  },
+  ipns: {
+    encode: encodes.ipns,
+    decode: decodes.ipns
+  },
+  arweave: {
+    encode: encodes.arweave,
+    decode: decodes.base64
+  },
+  default: {
+    encode: encodes.utf8,
+    decode: decodes.utf8
+  }
+};
+
+// ../../node_modules/.pnpm/@ensdomains+content-hash@3.1.0-rc.1/node_modules/@ensdomains/content-hash/dist/esm/index.js
+var decode = (contentHash) => {
+  const bytes = hexStringToBytes(contentHash);
+  const [code, offset] = decodeVarint(bytes);
+  const value = bytes.slice(offset);
+  const name = codeToName[code];
+  let profile = profiles[name];
+  if (!profile)
+    profile = profiles["default"];
+  return profile.decode(value);
+};
+var encode = (name, value) => {
+  let profile = profiles[name];
+  if (!profile)
+    profile = profiles["default"];
+  const bytes = profile.encode(value);
+  const code = nameToCode[name];
+  const codeBytes = encodeVarint(code, new Uint8Array(varintEncodingLength(code)));
+  return bytesToHexString(concatUint8Arrays(codeBytes, bytes));
+};
+
+// ../integration-test-env/src/devnet/fixtures.ts
+import { asNormalizedAddress, toNormalizedAddress as toNormalizedAddress3 } from "enssdk";
+import { mnemonicToAccount } from "viem/accounts";
+var mnemonic = "test test test test test test test test test test test junk";
+function createAccount(addressIndex, resolver) {
+  const account = mnemonicToAccount(mnemonic, { addressIndex });
+  return {
+    ...account,
+    address: toNormalizedAddress3(account.address),
+    resolver
+  };
+}
+var accounts = {
+  deployer: createAccount(0, asNormalizedAddress("0x9c97ec2d79944fa55aa2eb6385bc8711cacf18d2")),
+  owner: createAccount(1, asNormalizedAddress("0x8550d35164e7f86bb6adf4cedb3f012913c9d563")),
+  user: createAccount(2, asNormalizedAddress("0x98a84b915ffe27241033ac8f29c6b7849a0fb6e4")),
+  user2: createAccount(3, asNormalizedAddress("0xd04f8f3726a417cfadeea604fc94cf66112b9af6"))
+};
+var addresses = {
+  one: asNormalizedAddress(`0x${"1".repeat(40)}`)
+};
+var getRawAddress = (coinName, address) => {
+  const coder = getCoderByCoinName(coinName);
+  return {
+    coinType: coder.coinType,
+    raw: bytesToHex2(coder.decode(address)),
+    address
+  };
+};
+var getRawContenthash = (codec, input) => {
+  const encoded = encode(codec, input);
+  return {
+    raw: `0x${encoded}`,
+    // decode normalizes values (e.g. IPFS CIDv0 input → CIDv1 decoded, IPNS peer id → base36 CID)
+    decoded: decode(encoded)
+  };
+};
+var testEthTextRecords = {
+  avatar: { key: "avatar", value: "https://example.com/avatar.png" },
+  twitter: { key: "com.twitter", value: "ensdomains" },
+  github: { key: "com.github", value: "@ensdomains" },
+  x: { key: "com.x", value: "this_is_real_ensdomains_not_twitter_but_x_haha" },
+  telegram: { key: "org.telegram", value: "t.me/ensdomains" },
+  url: { key: "url", value: "https://ens.domains" },
+  email: { key: "email", value: "test@ens.domains" },
+  description: { key: "description", value: "test.eth" },
+  header: { key: "header", value: "https://example.com/header.png" }
+};
+var rawAddresses = {
+  bitcoin: getRawAddress("btc", "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t4"),
+  litecoin: getRawAddress("ltc", "LaMT348PWRnrqeeWArpwQPbuanpXDZGEUz"),
+  dogecoin: getRawAddress("doge", "DBXu2kgc3xtvCUWFcxFE3r9hEYgmuaaCyD"),
+  monacoin: getRawAddress("mona", "MHxgS2XMXjeJ4if2PRRbWYcdwZPWfdwaDT"),
+  rootstock: getRawAddress("rbtc", "0x5aaEB6053f3e94c9b9a09f33669435E7ef1bEAeD"),
+  binance: getRawAddress("bnb", "bnb1grpf0955h0ykzq3ar5nmum7y6gdfl6lxfn46h2"),
+  solana: getRawAddress("sol", "FncazAs6omJJjtLVzquzT9KoyXn6tFixr9kGjr42ktLj")
+};
+var fixtures = {
+  abiBytes: `0x${"01".repeat(32)}`,
+  fourBytesInterface: "0x11100111",
+  publicKeyX: `0x${"02".repeat(32)}`,
+  publicKeyY: `0x${"03".repeat(32)}`,
+  rawAddresses,
+  textRecords: testEthTextRecords
+};
+var contenthashFixtures = {
+  // CIDv0 input — decodes back to CIDv1
+  ipfs: getRawContenthash("ipfs", "QmRAQB6YaCyidP37UdDnjFY5vQuiBrcqdyoW1CuDgwxkD4"),
+  swarm: getRawContenthash(
+    "swarm",
+    "d1de9994b4d039f6548d191eb26786769f580809256b4685ef316805265ea162"
+  ),
+  ipns: getRawContenthash("ipns", "12D3KooWG4NvqQVczTrWY1H2tvsJmbQf5bbA3xGYXC4FM3wWCfE4"),
+  onion: getRawContenthash("onion", "zqktlwi4fecvo6ri"),
+  onion3: getRawContenthash("onion3", "p53lf57qovyuvwsc6xnrppyply3vtqm7l6pcobkmyqsiofyeznfu5uqd"),
+  skynet: getRawContenthash("skynet", "CABAB_1Dt0FJsxqsu_J4TodNCbCGvtFf1Uys_3EgzOlTcg"),
+  arweave: getRawContenthash("arweave", "ys32Pt8uC7TrVxHdOLByOspfPEq2LO63wREHQIM9SJQ"),
+  empty: { raw: "0x", decoded: null },
+  invalid: { raw: "0xdeadbeef", decoded: null },
+  zero: {
+    raw: "0x0000000000000000000000000000000000000000000000000000000000000000",
+    decoded: null
+  }
+};
+var contenthashSubnames = Object.entries(contenthashFixtures).map(([label, fixture]) => ({
+  label,
+  name: `${label}.contenthash.eth`,
+  records: { contenthash: fixture.raw }
+}));
+
+// src/omnigraph-api/example-queries.ts
 var SEPOLIA_V2_V2_ETH_REGISTRY = getDatasourceContract(
   ENSNamespaceIds3.SepoliaV2,
   DatasourceNames2.ENSv2Root,
@@ -1982,25 +3069,26 @@ var ENS_TEST_ENV_V2_ETH_REGISTRAR = getDatasourceContract(
   DatasourceNames2.ENSv2Root,
   "ETHRegistrar"
 );
-var VITALIK_ADDRESS = toNormalizedAddress3("0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045");
-var SEPOLIA_V2_ADDRESS_WITH_LOT_OF_NAMES = toNormalizedAddress3(
-  "0x69696969c3b3ca102eeb5c53a065a7c3ae4fb6dd"
-);
-var SEPOLIA_V2_ADDRESS_WITH_PERMISSIONS = toNormalizedAddress3(
-  "0x4c65a1c8d330ce1c3f60e00cd55709ba5fe2e090"
+var VITALIK_ADDRESS = toNormalizedAddress4("0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045");
+var SEPOLIA_V2_ACCOUNT = toNormalizedAddress4("0x801d2e48d378f161dba7ad7ad002ad557714c191");
+var SEPOLIA_V2_ACCOUNT_WITH_V1_AND_V2 = toNormalizedAddress4(
+  "0xffffffffff52d316b7bd028358089bc8066b8f80"
 );
 var DEVNET_NAME_WITH_OWNED_RESOLVER = asInterpretedName("example.eth");
-var SEPOLIA_V2_TEST_NAME = asInterpretedName("test-name.eth");
+var SEPOLIA_V2_NAME = asInterpretedName("roppp.eth");
+var VITALIK_NAME = asInterpretedName("vitalik.eth");
+var GREG_NAME = asInterpretedName("gregskril.eth");
+var GREG_ADDRESS = toNormalizedAddress4("0x179a862703a4adfb29896552df9e307980d19285");
+var OFFCHAIN_NAME = asInterpretedName("patricio.onpoap.eth");
 var MAINNET_PUBLIC_RESOLVER = getDatasourceContract(
   ENSNamespaceIds3.Mainnet,
   DatasourceNames2.ReverseResolverRoot,
   "DefaultPublicResolver5"
 );
-var SEPOLIA_V2_PUBLIC_RESOLVER = getDatasourceContract(
-  ENSNamespaceIds3.SepoliaV2,
-  DatasourceNames2.ReverseResolverRoot,
-  "DefaultPublicResolver5"
-);
+var SEPOLIA_V2_RESOLVER_WITH_RECORDS = {
+  chainId: 11155111,
+  address: toNormalizedAddress4("0x8fade66b79cc9f707ab26799354482eb93a5b7dd")
+};
 function getGraphqlApiExampleQueryById(id) {
   const found = graphqlApiExampleQueryById.get(id);
   if (!found) {
@@ -2014,18 +3102,44 @@ var GRAPHQL_API_EXAMPLE_QUERIES = [
   ////////////////
   {
     id: "hello-world",
-    query: `#
-# Welcome to this interactive playground for
-# ENSNode's GraphQL API!
-#
-# You can get started by typing your query here or by using
-# the Explorer on the left to select the data you want to query.
-#
-# There are also example queries in the tabs above \u261D\uFE0F
-query HelloWorld {
-  domain(by: { name: "eth" }) { canonical { name { interpreted beautified } } owner { address } }
+    query: `query HelloWorld($address: Address!) {
+  # Lookup an Account by address.
+  account(by: { address: $address }) {
+    resolve {
+      # Reverse resolve the ENS primary name of the account
+      # using a convenient ETHEREUM alias for mainnet.
+      primaryName(by: { chainName: ETHEREUM }) {
+        # Get the regular interpreted variant of the primary name
+        # and also the special beautified variant that optimizes names
+        # containing special characters such as emojis for proper display in interfaces.
+        name { interpreted beautified }
+        resolve {
+          # If the account has a primary name on Ethereum (mainnet),
+          # forward resolve the interpreted ENS profile of that name in the same query!
+          profile {
+            description
+            avatar { httpUrl }
+            addresses { ethereum bitcoin }
+            socials {
+              twitter { handle httpUrl }
+              github { handle httpUrl }
+            }
+          }
+        }
+      }
+    }
+
+    # Also load the count of ENSv1 and ENSv2 domains owned by the account
+    # to see if they have domains they should upgrade to ENSv2
+    v1DomainsCount: domains(where: { version: ENSv1 }) { totalCount }
+    v2DomainsCount: domains(where: { version: ENSv2 }) { totalCount }
+  }
 }`,
-    variables: { default: {} }
+    variables: {
+      default: { address: VITALIK_ADDRESS },
+      [ENSNamespaceIds3.EnsTestEnv]: { address: accounts.owner.address },
+      [ENSNamespaceIds3.SepoliaV2]: { address: SEPOLIA_V2_ACCOUNT_WITH_V1_AND_V2 }
+    }
   },
   /////////////////
   // Find Domains
@@ -2061,17 +3175,40 @@ query FindDomains(
         order: { by: "NAME", dir: "DESC" }
       },
       [ENSNamespaceIds3.SepoliaV2]: {
-        name: { starts_with: "test-na" },
+        name: { starts_with: "sf" },
         order: { by: "NAME", dir: "DESC" }
       }
     }
   },
-  ///////////////////
-  // Domain By Name
-  ///////////////////
   {
     id: "domain-by-name",
     query: `
+query DomainByName($name: InterpretedName!) {
+  domain(by: { name: $name }) {
+    canonical { name { beautified } }
+    owner { address }
+    resolve {
+      profile {
+        description
+        addresses {
+          ethereum
+        }
+      }
+    }
+  }
+}`,
+    variables: {
+      default: { name: "eth" },
+      [ENSNamespaceIds3.SepoliaV2]: { name: SEPOLIA_V2_NAME },
+      [ENSNamespaceIds3.Mainnet]: { name: VITALIK_NAME }
+    }
+  },
+  ////////////////////////////////
+  // Domain By Name Type Condition
+  ////////////////////////////////
+  {
+    id: "domain-by-name-type-condition",
+    query: `
 query DomainByName($name: InterpretedName!) {
   domain(by: {name: $name}) {
     __typename
@@ -2088,7 +3225,7 @@ query DomainByName($name: InterpretedName!) {
 }`,
     variables: {
       default: { name: "eth" },
-      [ENSNamespaceIds3.SepoliaV2]: { name: SEPOLIA_V2_TEST_NAME }
+      [ENSNamespaceIds3.SepoliaV2]: { name: SEPOLIA_V2_NAME }
     }
   },
   ///////////////////////
@@ -2132,10 +3269,160 @@ query DomainRegistration($name: InterpretedName!) {
   }
 }`,
     variables: {
-      default: { name: "vitalik.eth" },
-      [ENSNamespaceIds3.SepoliaV2]: { name: SEPOLIA_V2_TEST_NAME }
+      default: { name: VITALIK_NAME },
+      [ENSNamespaceIds3.SepoliaV2]: { name: SEPOLIA_V2_NAME }
     }
   },
+  ////////////////////
+  // Domain Records
+  ////////////////////
+  {
+    id: "domain-records",
+    query: `
+query DomainRecords($name: InterpretedName!) {
+  domain(by: {name: $name}) {
+    canonical {
+      name {
+        interpreted
+      }
+    }
+    resolve {
+      records {
+        addresses(coinTypes: [60, 2147483658, 501]) {
+          coinType
+          address
+        }
+        texts(keys: ["description", "avatar", "url", "com.github", "com.twitter"]) {
+          key
+          value
+        }
+        contenthash
+      }
+    }
+  }
+}`,
+    variables: {
+      default: { name: GREG_NAME },
+      [ENSNamespaceIds3.EnsTestEnv]: {
+        name: DEVNET_NAME_WITH_OWNED_RESOLVER
+      },
+      [ENSNamespaceIds3.SepoliaV2]: {
+        name: SEPOLIA_V2_NAME
+      }
+    }
+  },
+  {
+    id: "domain-profile",
+    query: `
+query DomainProfile($name: InterpretedName!) {
+  domain(by: {name: $name}) {
+    resolve {
+      profile {
+        description
+        avatar {
+          httpUrl
+        }
+        addresses {
+          ethereum
+          base
+          solana
+          bitcoin
+          rootstock
+        }
+        socials {
+          github {
+            handle
+            httpUrl
+          }
+          twitter {
+            handle
+            httpUrl
+          }
+        }
+        website {
+          httpUrl
+        }
+        header {
+          httpUrl
+        }
+      }
+    }
+  }
+}`,
+    variables: { default: { name: GREG_NAME } }
+  },
+  {
+    id: "domain-profile-and-records",
+    query: `
+query DomainProfileAndRecords($name: InterpretedName!) {
+  domain(by: { name: $name }) {
+    resolve {
+      profile {
+        avatar {
+          httpUrl
+        }
+        addresses {
+          ethereum
+          solana
+        }
+        socials {
+          github {
+            handle
+            httpUrl
+          }
+          twitter {
+            handle
+            httpUrl
+          }
+        }
+        website {
+          httpUrl
+        }
+      }
+      records {
+        addresses(coinTypes: [60, 501]) {
+          coinType
+          address
+        }
+        texts(keys: ["avatar", "com.twitter", "com.github", "url"]) {
+          key
+          value
+        }
+      }
+    }
+  }
+}`,
+    variables: { default: { name: GREG_NAME } }
+  },
+  ////////////////////////////////////
+  // Offchain Name (UnindexedDomain)
+  ////////////////////////////////////
+  {
+    id: "offchain-name",
+    query: `
+query OffchainName($name: InterpretedName!) {
+  domain(by: { name: $name }) {
+    # Resolvable-but-unindexed names (offchain / CCIP-Read) surface as UnindexedDomain
+    __typename
+    id
+    canonical { name { interpreted } }
+    resolver {
+      # the wildcard Resolver that ENS Forward Resolution (ENSIP-10) lands on
+      effective {
+        extended
+        contract { chainId address }
+      }
+    }
+    resolve {
+      records {
+        addresses(coinTypes: [60]) { coinType address }
+        texts(keys: ["avatar", "com.twitter", "description"]) { key value }
+      }
+    }
+  }
+}`,
+    variables: { default: { name: OFFCHAIN_NAME } }
+  },
   //////////////////////
   // Domain Subdomains
   //////////////////////
@@ -2145,7 +3432,34 @@ query DomainRegistration($name: InterpretedName!) {
 query DomainSubdomains($name: InterpretedName!) {
   domain(by: {name: $name}) {
     canonical { name { interpreted beautified } }
-    subdomains(first: 10) {
+    subdomains(first: 10, order: {
+       by: NAME,
+       dir: ASC
+    }) {
+      edges {
+        node {
+          canonical { name { interpreted beautified } }
+        }
+      }
+    }
+  }
+}`,
+    variables: {
+      default: { name: "eth" },
+      // in mainnet there is too many subdomains of eth
+      [ENSNamespaceIds3.Mainnet]: { name: "base.eth" }
+    }
+  },
+  ////////////////////////////////////
+  // Most Recently Registered Subdomains
+  ////////////////////////////////////
+  {
+    id: "domain-subdomains-recently-registered",
+    query: `
+query RecentlyRegisteredSubdomains($name: InterpretedName!) {
+  domain(by: {name: $name}) {
+    canonical { name { interpreted beautified } }
+    subdomains(first: 10, order: {by: REGISTRATION_TIMESTAMP, dir: DESC}) {
       edges {
         node {
           canonical { name { interpreted beautified } }
@@ -2206,7 +3520,7 @@ query DomainEvents($name: InterpretedName!) {
 }`,
     variables: {
       default: { name: "newowner.eth" },
-      [ENSNamespaceIds3.SepoliaV2]: { name: SEPOLIA_V2_TEST_NAME }
+      [ENSNamespaceIds3.SepoliaV2]: { name: SEPOLIA_V2_NAME }
     }
   },
   ////////////////////
@@ -2232,7 +3546,64 @@ query AccountDomains(
     variables: {
       default: { address: VITALIK_ADDRESS },
       [ENSNamespaceIds3.EnsTestEnv]: { address: accounts.owner.address },
-      [ENSNamespaceIds3.SepoliaV2]: { address: SEPOLIA_V2_ADDRESS_WITH_LOT_OF_NAMES }
+      [ENSNamespaceIds3.SepoliaV2]: { address: SEPOLIA_V2_ACCOUNT }
+    }
+  },
+  /////////////////////////
+  // Account Primary Names
+  /////////////////////////
+  {
+    id: "account-primary-names",
+    query: `
+query AccountPrimaryNames($address: Address!) {
+  account(by: { address: $address }) {
+    address
+    resolve {
+      onePrimaryName: primaryName(by: { chainName: OPTIMISM }) {
+        chainName
+        name { interpreted beautified }
+      }
+
+      twoPrimaryNames: primaryNames(where: { chainNames: [ETHEREUM, BASE] }) {
+        chainName
+        name { interpreted beautified }
+      }
+    }
+  }
+}`,
+    variables: {
+      default: { address: GREG_ADDRESS },
+      [ENSNamespaceIds3.EnsTestEnv]: { address: accounts.owner.address },
+      [ENSNamespaceIds3.SepoliaV2]: { address: SEPOLIA_V2_ACCOUNT }
+    }
+  },
+  {
+    id: "account-primary-name-records",
+    query: `
+query AccountPrimaryNameRecords($address: Address!) {
+  account(by: { address: $address }) {
+    address
+    resolve {
+      primaryName(by: { chainName: ETHEREUM }) {
+        name { interpreted beautified }
+        resolve {
+          profile {
+            description
+            socials {
+              twitter {
+                httpUrl
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}`,
+    variables: {
+      default: { address: VITALIK_ADDRESS },
+      [ENSNamespaceIds3.EnsTestEnv]: { address: accounts.owner.address },
+      [ENSNamespaceIds3.SepoliaV2]: { address: SEPOLIA_V2_ACCOUNT }
     }
   },
   ////////////////////
@@ -2251,7 +3622,7 @@ query AccountEvents(
     variables: {
       default: { address: VITALIK_ADDRESS },
       [ENSNamespaceIds3.EnsTestEnv]: { address: accounts.deployer.address },
-      [ENSNamespaceIds3.SepoliaV2]: { address: SEPOLIA_V2_ADDRESS_WITH_LOT_OF_NAMES }
+      [ENSNamespaceIds3.SepoliaV2]: { address: SEPOLIA_V2_ACCOUNT }
     }
   },
   /////////////////////
@@ -2336,7 +3707,7 @@ query PermissionsByUser($address: Address!) {
 }`,
     variables: {
       default: { address: accounts.deployer.address },
-      [ENSNamespaceIds3.SepoliaV2]: { address: SEPOLIA_V2_ADDRESS_WITH_PERMISSIONS }
+      [ENSNamespaceIds3.SepoliaV2]: { address: SEPOLIA_V2_ACCOUNT }
     }
   },
   //////////////////////////////////
@@ -2362,7 +3733,7 @@ query AccountResolverPermissions($address: Address!) {
 }`,
     variables: {
       default: { address: accounts.deployer.address },
-      [ENSNamespaceIds3.SepoliaV2]: { address: SEPOLIA_V2_ADDRESS_WITH_LOT_OF_NAMES }
+      [ENSNamespaceIds3.SepoliaV2]: { address: SEPOLIA_V2_ACCOUNT }
     }
   },
   //////////////////////////////
@@ -2375,17 +3746,20 @@ query DomainResolver($name: InterpretedName!) {
   domain(by: { name: $name }) {
     resolver {
       assigned {
-        records { edges { node { node keys coinTypes } } }
-        permissions { resources { edges { node { resource users { edges { node { user { address } roles } } } } } } }
-        events { totalCount edges { node { topics data timestamp } } }
+        contract {
+          address
+        }
+        events(first: 5) {
+          edges { node { topics data timestamp } }
+        }
       }
     }
   }
 }`,
     variables: {
-      default: { name: "vitalik.eth" },
+      default: { name: VITALIK_NAME },
       [ENSNamespaceIds3.EnsTestEnv]: { name: DEVNET_NAME_WITH_OWNED_RESOLVER },
-      [ENSNamespaceIds3.SepoliaV2]: { name: SEPOLIA_V2_TEST_NAME }
+      [ENSNamespaceIds3.SepoliaV2]: { name: SEPOLIA_V2_NAME }
     }
   },
   ////////////////////////
@@ -2417,7 +3791,7 @@ query ResolverByAddress($contract: AccountIdInput!) {
 }`,
     variables: {
       default: { contract: MAINNET_PUBLIC_RESOLVER },
-      [ENSNamespaceIds3.SepoliaV2]: { contract: SEPOLIA_V2_PUBLIC_RESOLVER }
+      [ENSNamespaceIds3.SepoliaV2]: { contract: SEPOLIA_V2_RESOLVER_WITH_RECORDS }
     }
   },
   //////////////
@@ -2427,31 +3801,19 @@ query ResolverByAddress($contract: AccountIdInput!) {
     id: "namegraph",
     query: `
 query Namegraph {
-  root {
-    id
-    domains {
-      edges {
-        node {
-          canonical { name { interpreted beautified } }
-
-          subdomains {
-            edges {
-              node {
-                canonical { name { interpreted beautified } }
-
-                subdomains {
-                  edges {
-                    node {
-                      canonical { name { interpreted beautified } }
-                    }
-                  }
-                }
-              }
-            }
+  domain(by: { name: "eth" }) {
+    registry { id contract { chainId address } }
+    parent { id }
+    subregistry {
+      domains {
+        edges {
+          node {
+            canonical { name { beautified } }
           }
         }
       }
     }
+    subdomains { edges { node { canonical { name { beautified } } } } }
   }
 }`,
     variables: { default: {} }
@@ -2470,7 +3832,7 @@ query AccountMigratedNames($address: Address!) {
 }`,
     variables: {
       default: { address: VITALIK_ADDRESS },
-      [ENSNamespaceIds3.SepoliaV2]: { address: SEPOLIA_V2_ADDRESS_WITH_LOT_OF_NAMES }
+      [ENSNamespaceIds3.SepoliaV2]: { address: SEPOLIA_V2_ACCOUNT_WITH_V1_AND_V2 }
     }
   },
   {
@@ -2487,6 +3849,31 @@ query GetEthDomains {
   }
 }`,
     variables: { default: {} }
+  },
+  {
+    id: "accelerate-resolve",
+    query: `
+query AccelerateResolve($address: Address!) {
+  account(by: { address: $address }) {
+    address
+    # resolve is automatically accelerated. To disable, resolve(accelerate: false)
+    resolve {
+      acceleration { requested attempted }
+      primaryName(by: { chainName: ETHEREUM }) {
+        name { interpreted beautified }
+        resolve {
+          acceleration { requested attempted }
+          profile { description }
+        }
+      }
+    }
+  }
+}`,
+    variables: {
+      default: { address: VITALIK_ADDRESS },
+      [ENSNamespaceIds3.EnsTestEnv]: { address: accounts.owner.address },
+      [ENSNamespaceIds3.SepoliaV2]: { address: SEPOLIA_V2_ACCOUNT_WITH_V1_AND_V2 }
+    }
   }
 ];
 var graphqlApiExampleQueryById = new Map(
@@ -2525,7 +3912,8 @@ async function supportsInterface({
       abi: EIP_165_ABI,
       functionName: "supportsInterface",
       address,
-      args: [selector]
+      args: [selector],
+      retryEmptyResponse: false
     });
   } catch {
     return false;
@@ -2734,29 +4122,29 @@ function buildRpcConfigsFromEnv(env, namespace) {
   );
   const rpcAutoGenMode = buildRpcAutoGenMode(env);
   const rpcConfigs = {};
-  for (const chain of chainsInNamespace) {
-    const specificValue = env[`RPC_URL_${chain.id}`];
+  for (const chain2 of chainsInNamespace) {
+    const specificValue = env[`RPC_URL_${chain2.id}`];
     if (specificValue) {
-      rpcConfigs[serializeChainId(chain.id)] = specificValue;
+      rpcConfigs[serializeChainId(chain2.id)] = specificValue;
       continue;
     }
-    if (chain.id === ensTestEnvChain.id) {
+    if (chain2.id === ensTestEnvChain.id) {
       rpcConfigs[serializeChainId(ensTestEnvChain.id)] = ensTestEnvChain.rpcUrls.default.http[0];
       continue;
     }
     const httpUrls = [
       // alchemy, if specified and available
-      alchemyApiKey && alchemySupportsChain(chain.id) && `https://${buildAlchemyBaseUrl(chain.id, alchemyApiKey)}`,
+      alchemyApiKey && alchemySupportsChain(chain2.id) && `https://${buildAlchemyBaseUrl(chain2.id, alchemyApiKey)}`,
       // QuickNode, if specified and available
-      quickNodeApiKey && quickNodeEndpointName && quickNodeSupportsChain(chain.id) && `https://${buildQuickNodeURL(chain.id, quickNodeApiKey, quickNodeEndpointName)}`,
+      quickNodeApiKey && quickNodeEndpointName && quickNodeSupportsChain(chain2.id) && `https://${buildQuickNodeURL(chain2.id, quickNodeApiKey, quickNodeEndpointName)}`,
       // dRPC, if specified and available
-      dRPCKey && dRPCSupportsChain(chain.id) && buildDRPCUrl(chain.id, dRPCKey)
+      dRPCKey && dRPCSupportsChain(chain2.id) && buildDRPCUrl(chain2.id, dRPCKey)
     ];
-    const wsUrl = rpcAutoGenMode === RpcAutoGenModes.HttpAndWs && alchemyApiKey && alchemySupportsChain(chain.id) && //
-    `wss://${buildAlchemyBaseUrl(chain.id, alchemyApiKey)}`;
+    const wsUrl = rpcAutoGenMode === RpcAutoGenModes.HttpAndWs && alchemyApiKey && alchemySupportsChain(chain2.id) && //
+    `wss://${buildAlchemyBaseUrl(chain2.id, alchemyApiKey)}`;
     const urls = [...httpUrls, wsUrl].filter(Boolean);
     if (urls.length > 0) {
-      rpcConfigs[serializeChainId(chain.id)] = urls.join(
+      rpcConfigs[serializeChainId(chain2.id)] = urls.join(
         ","
       );
     }
@@ -2934,8 +4322,8 @@ import { isAddressEqual as isAddressEqual4, zeroAddress as zeroAddress5 } from "
 var interpretAddress = (owner) => isAddressEqual4(zeroAddress5, owner) ? null : owner;
 
 // src/shared/interpretation/interpret-record-values.ts
-import { isInterpretedName, toNormalizedAddress as toNormalizedAddress4 } from "enssdk";
-import { isAddress as isAddress2, isAddressEqual as isAddressEqual5, zeroAddress as zeroAddress6 } from "viem";
+import { isInterpretedName } from "enssdk";
+import { isHex as isHex2, zeroAddress as zeroAddress6 } from "viem";
 
 // src/shared/null-bytes.ts
 var hasNullByte = (value) => value.indexOf("\0") !== -1;
@@ -2947,12 +4335,11 @@ function interpretNameRecordValue(value) {
   return value;
 }
 function interpretAddressRecordValue(value) {
-  if (hasNullByte(value)) return null;
-  if (value === "") return null;
   if (value === "0x") return null;
-  if (!isAddress2(value, { strict: false })) return value;
-  if (isAddressEqual5(value, zeroAddress6)) return null;
-  return toNormalizedAddress4(value);
+  if (!isHex2(value, { strict: true })) return null;
+  const normalized = value.toLowerCase();
+  if (normalized === zeroAddress6) return null;
+  return normalized;
 }
 function interpretTextRecordKey(key) {
   if (hasNullByte(key)) return null;
@@ -3120,10 +4507,10 @@ var getContractsByManagedName = (namespace) => {
     }
   };
 };
-var cache = /* @__PURE__ */ new Map();
+var cache2 = /* @__PURE__ */ new Map();
 var getManagedName = (namespace, contract) => {
   const cacheKey = `${namespace}:${stringifyAccountId(contract)}`;
-  const cached = cache.get(cacheKey);
+  const cached = cache2.get(cacheKey);
   if (cached !== void 0) return cached;
   for (const [managedName, group] of Object.entries(getContractsByManagedName(namespace))) {
     const isAnyOfTheContracts = group.contracts.some(
@@ -3134,7 +4521,7 @@ var getManagedName = (namespace, contract) => {
       const name = asInterpretedName2(namespaceSpecific ?? managedName);
       const node = namehashInterpretedName3(name);
       const result = { name, node, registry: group.registry };
-      cache.set(cacheKey, result);
+      cache2.set(cacheKey, result);
       return result;
     }
   }
@@ -3144,14 +4531,18 @@ var getManagedName = (namespace, contract) => {
 };
 
 // src/shared/root-registry.ts
-import { makeENSv1RegistryId, makeENSv2RegistryId } from "enssdk";
+import {
+  makeConcreteRegistryId,
+  makeENSv1RegistryId,
+  makeENSv2RegistryId
+} from "enssdk";
 import { DatasourceNames as DatasourceNames6 } from "@ensnode/datasources";
 var getENSv1RootRegistry = (namespace) => getDatasourceContract(namespace, DatasourceNames6.ENSRoot, "ENSv1Registry");
 
 // src/shared/protocol-acceleration/is-bridged-resolver.ts
-var cache2 = /* @__PURE__ */ new Map();
+var cache3 = /* @__PURE__ */ new Map();
 var getBridgedResolverConfigs = (namespace) => {
-  const cached = cache2.get(namespace);
+  const cached = cache3.get(namespace);
   if (cached) return cached;
   const configs = [];
   const basenames = maybeGetDatasource4(namespace, DatasourceNames7.Basenames);
@@ -3186,7 +4577,7 @@ var getBridgedResolverConfigs = (namespace) => {
       targetRegistryId: makeENSv1VirtualRegistryId(registry, node)
     });
   }
-  cache2.set(namespace, configs);
+  cache3.set(namespace, configs);
   return configs;
 };
 function isBridgedResolver(namespace, resolver) {
@@ -3348,6 +4739,7 @@ export {
   makeENSIndexerPublicConfigSchema,
   makeENSIndexerVersionInfoSchema,
   makeENSNamespaceIdSchema,
+  makeEmailSchema,
   makeEnsApiIndexingStatusResponseErrorSchema,
   makeEnsApiIndexingStatusResponseOkSchema,
   makeEnsApiIndexingStatusResponseSchema,
@@ -3434,4 +4826,12 @@ export {
   staticResolverImplementsAddressRecordDefaulting,
   stringifyConfig
 };
+/*! Bundled license information:
+
+@scure/base/lib/esm/index.js:
+  (*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/curves/esm/utils.js:
+  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/
 //# sourceMappingURL=internal.js.map