@ensnode/ensnode-sdk 0.28.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 NameHash
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+# ENSNode SDK
+
+This package is a set of libraries enabling smooth interaction with ENSNode services and data, including data processing (such as validating data and enforcing invariants), and ENS-oriented helper functions.
+
+Learn more about [ENSNode](https://ensnode.io/) from [the ENSNode docs](https://ensnode.io/docs/).
+
+## Package overview
+
+- [`utils`](utils) A utility library for interacting with ENS (Ethereum Name Service) data. It contains various helper functions and tools to facilitate interactions with ENS and ENSNode instances.

package/dist/index.d.ts

@@ -0,0 +1,161 @@
+import { Hex, Address } from 'viem';
+
+/**
+ * A PluginName is a unique id for a 'plugin': we use the notion of 'plugins' to describe bundles
+ * of indexing logic.
+ */
+declare enum PluginName {
+    Subgraph = "subgraph",
+    Basenames = "basenames",
+    Lineanames = "lineanames",
+    ThreeDNS = "threedns"
+}
+/**
+ * A hash value that uniquely identifies a single ENS name.
+ * Result of `namehash` function as specified in ENSIP-1.
+ *
+ * @example
+ * ```
+ * namehash("vitalik.eth") === "0xee6c4522aab0003e8d14cd40a6af439055fd2577951148c14b6cea9a53475835"
+ * ```
+ * @link https://docs.ens.domains/ensip/1#namehash-algorithm
+ */
+type Node = Hex;
+/**
+ * A LabelHash is the result of the labelhash function (which is just keccak256) on a Label.
+ *
+ * @link https://docs.ens.domains/terminology#labelhash
+ */
+type LabelHash = Hex;
+/**
+ * A Label is a single part of an ENS Name.
+ *
+ * @link https://docs.ens.domains/terminology#label
+ */
+type Label = string;
+/**
+ * An EncodedLabelHash is a specially formatted unnormalized Label that should be interpreted as a
+ * LabelHash literal, particularly for use within an ENS Name.
+ *
+ * @example [abcd]
+ * @example [abcd].example.eth
+ */
+type EncodedLabelHash = `[${string}]`;
+/**
+ * A Name represents a human-readable ENS name.
+ *
+ * ex: vitalik.eth
+ */
+type Name = string;
+
+declare const ROOT_NODE: Node;
+/**
+ * A set of nodes whose children are used for reverse resolution.
+ *
+ * Useful for identifying if a domain is used for reverse resolution.
+ * See apps/ensindexer/src/handlers/Registry.ts for context.
+ */
+declare const REVERSE_ROOT_NODES: Set<Node>;
+/**
+ * The ETH coinType.
+ *
+ * @see https://docs.ens.domains/ensip/9
+ */
+declare const ETH_COIN_TYPE = 60n;
+
+/**
+ * Cache that maps from string -> ValueType.
+ */
+interface Cache<KeyType extends string, ValueType> {
+    /**
+     * Store a value in the cache with the given key.
+     *
+     * @param key Cache key
+     * @param value Value to store
+     */
+    set(key: KeyType, value: ValueType): void;
+    /**
+     * Retrieve a value from the cache with the given key.
+     *
+     * @param key Cache key
+     * @returns The cached value if it exists, otherwise undefined
+     */
+    get(key: KeyType): ValueType | undefined;
+    /**
+     * Clear the cache.
+     */
+    clear(): void;
+    /**
+     * The current number of items in the cache. Always a non-negative integer.
+     */
+    get size(): number;
+    /**
+     * The maximum number of items in the cache. Always a non-negative integer that is >= size().
+     */
+    get capacity(): number;
+}
+/**
+ * Cache that maps from string -> ValueType with a LRU (least recently used) eviction policy.
+ *
+ * `get` and `set` are O(1) operations.
+ *
+ * @link https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU
+ */
+declare class LruCache<KeyType extends string, ValueType> implements Cache<KeyType, ValueType> {
+    private readonly _cache;
+    private readonly _capacity;
+    /**
+     * Create a new LRU cache with the given capacity.
+     *
+     * @param capacity The maximum number of items in the cache. If set to 0, the cache is effectively disabled.
+     * @throws Error if capacity is not a non-negative integer.
+     */
+    constructor(capacity: number);
+    set(key: string, value: ValueType): void;
+    get(key: string): ValueType | undefined;
+    clear(): void;
+    get size(): number;
+    get capacity(): number;
+}
+
+/**
+ * Implements one step of the namehash algorithm, combining `labelHash` with `node` to produce
+ * the `node` of a given subdomain. Note that the order of the arguments is 'reversed' (as compared to
+ * the actual concatenation) in order to improve readability (i.e. read as [labelHash].[node]).
+ */
+declare const makeSubdomainNode: (labelHash: LabelHash, node: Node) => Node;
+/**
+ * Attempt to heal the labelHash of an addr.reverse subname using an address that might be related to the subname.
+ *
+ * @throws if maybeReverseAddress is not a valid Address
+ * @throws if labelHash is not a valid Labelhash
+ *
+ * @returns the original label if healed, otherwise null
+ */
+declare const maybeHealLabelByReverseAddress: ({ maybeReverseAddress, labelHash, }: {
+    /** The address that is possibly associated with the addr.reverse subname */
+    maybeReverseAddress: Address;
+    /** The labelhash of the addr.reverse subname */
+    labelHash: LabelHash;
+}) => string | null;
+/**
+ * Encodes a uint256 bigint as hex string sized to 32 bytes.
+ * Uses include, in the context of ENS, decoding the uint256-encoded tokenId of NFT-issuing contracts
+ * into Node or LabelHash, which is a common behavior in the ENS ecosystem.
+ * (see NameWrapper, ETHRegistrarController)
+ */
+declare const uint256ToHex32: (num: bigint) => `0x${string}`;
+/**
+ * Check if any characters in `label` are "unindexable".
+ *
+ * Related logic in ENS Subgraph:
+ * https://github.com/ensdomains/ens-subgraph/blob/c844791/src/utils.ts#L68
+ *
+ * @param label - The label to check. Note:
+ * A `null` value for `label` represents an unhealable labelhash.
+ *
+ * @returns `true` if the label is indexable, `false` otherwise.
+ */
+declare const isLabelIndexable: (label: Label | null) => label is Label;
+
+export { type Cache, ETH_COIN_TYPE, type EncodedLabelHash, type Label, type LabelHash, LruCache, type Name, type Node, PluginName, REVERSE_ROOT_NODES, ROOT_NODE, isLabelIndexable, makeSubdomainNode, maybeHealLabelByReverseAddress, uint256ToHex32 };

package/dist/index.js

@@ -0,0 +1,120 @@
+// src/utils/constants.ts
+import { namehash } from "viem";
+var ROOT_NODE = namehash("");
+var REVERSE_ROOT_NODES = /* @__PURE__ */ new Set([namehash("addr.reverse")]);
+var ETH_COIN_TYPE = 60n;
+
+// src/utils/types.ts
+var PluginName = /* @__PURE__ */ ((PluginName2) => {
+  PluginName2["Subgraph"] = "subgraph";
+  PluginName2["Basenames"] = "basenames";
+  PluginName2["Lineanames"] = "lineanames";
+  PluginName2["ThreeDNS"] = "threedns";
+  return PluginName2;
+})(PluginName || {});
+
+// src/utils/cache.ts
+var LruCache = class {
+  _cache = /* @__PURE__ */ new Map();
+  _capacity;
+  /**
+   * Create a new LRU cache with the given capacity.
+   *
+   * @param capacity The maximum number of items in the cache. If set to 0, the cache is effectively disabled.
+   * @throws Error if capacity is not a non-negative integer.
+   */
+  constructor(capacity) {
+    if (!Number.isInteger(capacity)) {
+      throw new Error(
+        `LruCache requires capacity to be an integer but a capacity of ${capacity} was requested.`
+      );
+    }
+    if (capacity < 0) {
+      throw new Error(
+        `LruCache requires a non-negative capacity but a capacity of ${capacity} was requested.`
+      );
+    }
+    this._capacity = capacity;
+  }
+  set(key, value) {
+    this._cache.set(key, value);
+    if (this._cache.size > this._capacity) {
+      const oldestKey = this._cache.keys().next().value;
+      this._cache.delete(oldestKey);
+    }
+  }
+  get(key) {
+    const value = this._cache.get(key);
+    if (value) {
+      this._cache.delete(key);
+      this._cache.set(key, value);
+    }
+    return value;
+  }
+  clear() {
+    this._cache.clear();
+  }
+  get size() {
+    return this._cache.size;
+  }
+  get capacity() {
+    return this._capacity;
+  }
+};
+
+// src/utils/subname-helpers.ts
+import { concat, isAddress, isHash, keccak256, toHex } from "viem";
+import { labelhash } from "viem/ens";
+var makeSubdomainNode = (labelHash, node) => keccak256(concat([node, labelHash]));
+var addrReverseLabel = (address) => address.slice(2).toLowerCase();
+var maybeHealLabelByReverseAddress = ({
+  maybeReverseAddress,
+  labelHash
+}) => {
+  if (!isAddress(maybeReverseAddress)) {
+    throw new Error(
+      `Invalid reverse address: '${maybeReverseAddress}'. Must be a valid EVM Address.`
+    );
+  }
+  if (!isHash(labelHash)) {
+    throw new Error(
+      `Invalid labelHash: '${labelHash}'. Must start with '0x' and represent 32 bytes.`
+    );
+  }
+  const assumedLabel = addrReverseLabel(maybeReverseAddress);
+  if (labelhash(assumedLabel) === labelHash) return assumedLabel;
+  return null;
+};
+var uint256ToHex32 = (num) => toHex(num, { size: 32 });
+var UNINDEXABLE_LABEL_CHARACTERS = [
+  "\0",
+  // null byte: PostgreSQL does not allow storing this character in text fields.
+  ".",
+  // conflicts with ENS label separator logic.
+  "[",
+  // conflicts with "unknown label" representations.
+  "]"
+  // conflicts with "unknown label" representations.
+];
+var UNINDEXABLE_LABEL_CHARACTER_CODES = new Set(
+  UNINDEXABLE_LABEL_CHARACTERS.map((char) => char.charCodeAt(0))
+);
+var isLabelIndexable = (label) => {
+  if (!label) return false;
+  for (let i = 0; i < label.length; i++) {
+    if (UNINDEXABLE_LABEL_CHARACTER_CODES.has(label.charCodeAt(i))) return false;
+  }
+  return true;
+};
+export {
+  ETH_COIN_TYPE,
+  LruCache,
+  PluginName,
+  REVERSE_ROOT_NODES,
+  ROOT_NODE,
+  isLabelIndexable,
+  makeSubdomainNode,
+  maybeHealLabelByReverseAddress,
+  uint256ToHex32
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/constants.ts","../src/utils/types.ts","../src/utils/cache.ts","../src/utils/subname-helpers.ts"],"sourcesContent":["import { namehash } from \"viem\";\nimport { Node } from \"./types\";\n\nexport const ROOT_NODE: Node = namehash(\"\");\n\n/**\n * A set of nodes whose children are used for reverse resolution.\n *\n * Useful for identifying if a domain is used for reverse resolution.\n * See apps/ensindexer/src/handlers/Registry.ts for context.\n */\nexport const REVERSE_ROOT_NODES: Set<Node> = new Set([namehash(\"addr.reverse\")]);\n\n/**\n * The ETH coinType.\n *\n * @see https://docs.ens.domains/ensip/9\n */\nexport const ETH_COIN_TYPE = 60n;\n","import type { Hex } from \"viem\";\n\n/**\n * A PluginName is a unique id for a 'plugin': we use the notion of 'plugins' to describe bundles\n * of indexing logic.\n */\nexport enum PluginName {\n  Subgraph = \"subgraph\",\n  Basenames = \"basenames\",\n  Lineanames = \"lineanames\",\n  ThreeDNS = \"threedns\",\n}\n\n/**\n * A hash value that uniquely identifies a single ENS name.\n * Result of `namehash` function as specified in ENSIP-1.\n *\n * @example\n * ```\n * namehash(\"vitalik.eth\") === \"0xee6c4522aab0003e8d14cd40a6af439055fd2577951148c14b6cea9a53475835\"\n * ```\n * @link https://docs.ens.domains/ensip/1#namehash-algorithm\n */\nexport type Node = Hex;\n\n/**\n * A LabelHash is the result of the labelhash function (which is just keccak256) on a Label.\n *\n * @link https://docs.ens.domains/terminology#labelhash\n */\nexport type LabelHash = Hex;\n\n/**\n * A Label is a single part of an ENS Name.\n *\n * @link https://docs.ens.domains/terminology#label\n */\nexport type Label = string;\n\n/**\n * An EncodedLabelHash is a specially formatted unnormalized Label that should be interpreted as a\n * LabelHash literal, particularly for use within an ENS Name.\n *\n * @example [abcd]\n * @example [abcd].example.eth\n */\nexport type EncodedLabelHash = `[${string}]`;\n\n/**\n * A Name represents a human-readable ENS name.\n *\n * ex: vitalik.eth\n */\nexport type Name = string;\n","/**\n * Cache that maps from string -> ValueType.\n */\nexport interface Cache<KeyType extends string, ValueType> {\n  /**\n   * Store a value in the cache with the given key.\n   *\n   * @param key Cache key\n   * @param value Value to store\n   */\n  set(key: KeyType, value: ValueType): void;\n\n  /**\n   * Retrieve a value from the cache with the given key.\n   *\n   * @param key Cache key\n   * @returns The cached value if it exists, otherwise undefined\n   */\n  get(key: KeyType): ValueType | undefined;\n\n  /**\n   * Clear the cache.\n   */\n  clear(): void;\n\n  /**\n   * The current number of items in the cache. Always a non-negative integer.\n   */\n  get size(): number;\n\n  /**\n   * The maximum number of items in the cache. Always a non-negative integer that is >= size().\n   */\n  get capacity(): number;\n}\n\n/**\n * Cache that maps from string -> ValueType with a LRU (least recently used) eviction policy.\n *\n * `get` and `set` are O(1) operations.\n *\n * @link https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU\n */\nexport class LruCache<KeyType extends string, ValueType> implements Cache<KeyType, ValueType> {\n  private readonly _cache = new Map<string, ValueType>();\n  private readonly _capacity: number;\n\n  /**\n   * Create a new LRU cache with the given capacity.\n   *\n   * @param capacity The maximum number of items in the cache. If set to 0, the cache is effectively disabled.\n   * @throws Error if capacity is not a non-negative integer.\n   */\n  public constructor(capacity: number) {\n    if (!Number.isInteger(capacity)) {\n      throw new Error(\n        `LruCache requires capacity to be an integer but a capacity of ${capacity} was requested.`,\n      );\n    }\n\n    if (capacity < 0) {\n      throw new Error(\n        `LruCache requires a non-negative capacity but a capacity of ${capacity} was requested.`,\n      );\n    }\n\n    this._capacity = capacity;\n  }\n\n  public set(key: string, value: ValueType) {\n    this._cache.set(key, value);\n\n    if (this._cache.size > this._capacity) {\n      // oldestKey is guaranteed to be defined\n      const oldestKey = this._cache.keys().next().value as string;\n      this._cache.delete(oldestKey);\n    }\n  }\n\n  public get(key: string) {\n    const value = this._cache.get(key);\n    if (value) {\n      // The key is already in the cache, move it to the end (most recent)\n      this._cache.delete(key);\n      this._cache.set(key, value);\n    }\n    return value;\n  }\n\n  public clear() {\n    this._cache.clear();\n  }\n\n  public get size() {\n    return this._cache.size;\n  }\n\n  public get capacity() {\n    return this._capacity;\n  }\n}\n","import { Address, concat, isAddress, isHash, keccak256, toHex } from \"viem\";\n\nimport { labelhash } from \"viem/ens\";\nimport type { Label, LabelHash, Node } from \"./types\";\n\n/**\n * Implements one step of the namehash algorithm, combining `labelHash` with `node` to produce\n * the `node` of a given subdomain. Note that the order of the arguments is 'reversed' (as compared to\n * the actual concatenation) in order to improve readability (i.e. read as [labelHash].[node]).\n */\nexport const makeSubdomainNode = (labelHash: LabelHash, node: Node): Node =>\n  keccak256(concat([node, labelHash]));\n\n/**\n * Gets the Label used for subnames of \"addr.reverse\" used for reverse lookups of `address` as per\n * https://docs.ens.domains/resolution/names#reverse-nodes\n */\nconst addrReverseLabel = (address: Address): Label => address.slice(2).toLowerCase();\n\n/**\n * Attempt to heal the labelHash of an addr.reverse subname using an address that might be related to the subname.\n *\n * @throws if maybeReverseAddress is not a valid Address\n * @throws if labelHash is not a valid Labelhash\n *\n * @returns the original label if healed, otherwise null\n */\nexport const maybeHealLabelByReverseAddress = ({\n  maybeReverseAddress,\n  labelHash,\n}: {\n  /** The address that is possibly associated with the addr.reverse subname */\n  maybeReverseAddress: Address;\n\n  /** The labelhash of the addr.reverse subname */\n  labelHash: LabelHash;\n}): string | null => {\n  // check if required arguments are valid\n  if (!isAddress(maybeReverseAddress)) {\n    throw new Error(\n      `Invalid reverse address: '${maybeReverseAddress}'. Must be a valid EVM Address.`,\n    );\n  }\n\n  if (!isHash(labelHash)) {\n    throw new Error(\n      `Invalid labelHash: '${labelHash}'. Must start with '0x' and represent 32 bytes.`,\n    );\n  }\n\n  // derive the assumed label from the normalized address\n  const assumedLabel = addrReverseLabel(maybeReverseAddress);\n\n  // if labelHash of the assumed label matches the provided labelHash, heal\n  if (labelhash(assumedLabel) === labelHash) return assumedLabel;\n\n  // otherwise, healing did not succeed\n  // TODO: log the event args for analysis and debugging\n  return null;\n};\n\n/**\n * Encodes a uint256 bigint as hex string sized to 32 bytes.\n * Uses include, in the context of ENS, decoding the uint256-encoded tokenId of NFT-issuing contracts\n * into Node or LabelHash, which is a common behavior in the ENS ecosystem.\n * (see NameWrapper, ETHRegistrarController)\n */\nexport const uint256ToHex32 = (num: bigint) => toHex(num, { size: 32 });\n\n/**\n * These characters are prohibited in normalized ENS names per the ENSIP-15\n * standard (https://docs.ens.domains/ensip/15). Names containing labels with\n * one or more of these characters are unusable by any app implementing\n * ENSIP-15 (e.g., via https://github.com/adraffy/ens-normalize.js\n * or https://github.com/namehash/ens-normalize-python).\n *\n * While many other characters (beyond these 4) are not supported by\n * ENSIP-15, only the following 4 characters are classified as \"unindexable\" due\n * to specific indexing concerns.\n *\n * Onchain ENS contracts do not enforce ENSIP-15 normalization for reasons\n * including the gas costs of enforcement. This allows unnormalized labels\n * containing these characters to exist onchain. Such labels must be handled\n * carefully by indexers to avoid conflicts.\n *\n * Some indexed labels are \"unknown\" (or \"unindexable\") but still require a\n * representation within indexed data. For this purpose, a special \"unknown\n * label\" format is defined (an EncodedLabelHash) that represents these labels in the format of\n * \"[{labelHash}]\" where {labelHash} is the labelHash of the unknown label.\n * When an indexed label is in this format it is necessary to distinguish an\n * \"unknown\" label containing a labelHash, from an unnormalized label literal\n * that is formatted to appear like an \"unknown\" label. For example, if the\n * unnormalized label literal\n * \"[24695ee963d29f0f52edfdea1e830d2fcfc9052d5ba70b194bddd0afbbc89765]\"\n * is indexed, it will be considered \"unindexable\" (due to the square bracket\n * characters) and therefore be represented as the following \"unknown\" label instead\n * \"[80968d00b78a91f47b233eaa213576293d16dadcbbdceb257bca94b08451ba7f]\"\n * which encodes the labelHash of the unnormalized label literal in\n * square brackets.\n */\nconst UNINDEXABLE_LABEL_CHARACTERS = [\n  \"\\0\", // null byte: PostgreSQL does not allow storing this character in text fields.\n  \".\", // conflicts with ENS label separator logic.\n  \"[\", // conflicts with \"unknown label\" representations.\n  \"]\", // conflicts with \"unknown label\" representations.\n];\n\nconst UNINDEXABLE_LABEL_CHARACTER_CODES = new Set(\n  UNINDEXABLE_LABEL_CHARACTERS.map((char) => char.charCodeAt(0)),\n);\n\n/**\n * Check if any characters in `label` are \"unindexable\".\n *\n * Related logic in ENS Subgraph:\n * https://github.com/ensdomains/ens-subgraph/blob/c844791/src/utils.ts#L68\n *\n * @param label - The label to check. Note:\n * A `null` value for `label` represents an unhealable labelhash.\n *\n * @returns `true` if the label is indexable, `false` otherwise.\n */\nexport const isLabelIndexable = (label: Label | null): label is Label => {\n  if (!label) return false;\n\n  for (let i = 0; i < label.length; i++) {\n    if (UNINDEXABLE_LABEL_CHARACTER_CODES.has(label.charCodeAt(i))) return false;\n  }\n\n  return true;\n};\n"],"mappings":";AAAA,SAAS,gBAAgB;AAGlB,IAAM,YAAkB,SAAS,EAAE;AAQnC,IAAM,qBAAgC,oBAAI,IAAI,CAAC,SAAS,cAAc,CAAC,CAAC;AAOxE,IAAM,gBAAgB;;;ACZtB,IAAK,aAAL,kBAAKA,gBAAL;AACL,EAAAA,YAAA,cAAW;AACX,EAAAA,YAAA,eAAY;AACZ,EAAAA,YAAA,gBAAa;AACb,EAAAA,YAAA,cAAW;AAJD,SAAAA;AAAA,GAAA;;;ACqCL,IAAM,WAAN,MAAuF;AAAA,EAC3E,SAAS,oBAAI,IAAuB;AAAA,EACpC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAQV,YAAY,UAAkB;AACnC,QAAI,CAAC,OAAO,UAAU,QAAQ,GAAG;AAC/B,YAAM,IAAI;AAAA,QACR,iEAAiE,QAAQ;AAAA,MAC3E;AAAA,IACF;AAEA,QAAI,WAAW,GAAG;AAChB,YAAM,IAAI;AAAA,QACR,+DAA+D,QAAQ;AAAA,MACzE;AAAA,IACF;AAEA,SAAK,YAAY;AAAA,EACnB;AAAA,EAEO,IAAI,KAAa,OAAkB;AACxC,SAAK,OAAO,IAAI,KAAK,KAAK;AAE1B,QAAI,KAAK,OAAO,OAAO,KAAK,WAAW;AAErC,YAAM,YAAY,KAAK,OAAO,KAAK,EAAE,KAAK,EAAE;AAC5C,WAAK,OAAO,OAAO,SAAS;AAAA,IAC9B;AAAA,EACF;AAAA,EAEO,IAAI,KAAa;AACtB,UAAM,QAAQ,KAAK,OAAO,IAAI,GAAG;AACjC,QAAI,OAAO;AAET,WAAK,OAAO,OAAO,GAAG;AACtB,WAAK,OAAO,IAAI,KAAK,KAAK;AAAA,IAC5B;AACA,WAAO;AAAA,EACT;AAAA,EAEO,QAAQ;AACb,SAAK,OAAO,MAAM;AAAA,EACpB;AAAA,EAEA,IAAW,OAAO;AAChB,WAAO,KAAK,OAAO;AAAA,EACrB;AAAA,EAEA,IAAW,WAAW;AACpB,WAAO,KAAK;AAAA,EACd;AACF;;;ACpGA,SAAkB,QAAQ,WAAW,QAAQ,WAAW,aAAa;AAErE,SAAS,iBAAiB;AAQnB,IAAM,oBAAoB,CAAC,WAAsB,SACtD,UAAU,OAAO,CAAC,MAAM,SAAS,CAAC,CAAC;AAMrC,IAAM,mBAAmB,CAAC,YAA4B,QAAQ,MAAM,CAAC,EAAE,YAAY;AAU5E,IAAM,iCAAiC,CAAC;AAAA,EAC7C;AAAA,EACA;AACF,MAMqB;AAEnB,MAAI,CAAC,UAAU,mBAAmB,GAAG;AACnC,UAAM,IAAI;AAAA,MACR,6BAA6B,mBAAmB;AAAA,IAClD;AAAA,EACF;AAEA,MAAI,CAAC,OAAO,SAAS,GAAG;AACtB,UAAM,IAAI;AAAA,MACR,uBAAuB,SAAS;AAAA,IAClC;AAAA,EACF;AAGA,QAAM,eAAe,iBAAiB,mBAAmB;AAGzD,MAAI,UAAU,YAAY,MAAM,UAAW,QAAO;AAIlD,SAAO;AACT;AAQO,IAAM,iBAAiB,CAAC,QAAgB,MAAM,KAAK,EAAE,MAAM,GAAG,CAAC;AAiCtE,IAAM,+BAA+B;AAAA,EACnC;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AAAA,EACA;AAAA;AACF;AAEA,IAAM,oCAAoC,IAAI;AAAA,EAC5C,6BAA6B,IAAI,CAAC,SAAS,KAAK,WAAW,CAAC,CAAC;AAC/D;AAaO,IAAM,mBAAmB,CAAC,UAAwC;AACvE,MAAI,CAAC,MAAO,QAAO;AAEnB,WAAS,IAAI,GAAG,IAAI,MAAM,QAAQ,KAAK;AACrC,QAAI,kCAAkC,IAAI,MAAM,WAAW,CAAC,CAAC,EAAG,QAAO;AAAA,EACzE;AAEA,SAAO;AACT;","names":["PluginName"]}

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@ensnode/ensnode-sdk",
+  "version": "0.28.0",
+  "type": "module",
+  "description": "A utility library for interacting with ENSNode and ENS data",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/namehash/ensnode.git",
+    "directory": "packages/ensnode-sdk"
+  },
+  "homepage": "https://github.com/namehash/ensnode/tree/main/packages/ensnode-sdk",
+  "keywords": [
+    "ENS",
+    "ENSNode"
+  ],
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "default": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "viem": "^2.22.13"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@types/node": "^22.14.0",
+    "tsup": "^8.3.6",
+    "typescript": "^5.7.3",
+    "viem": "^2.22.13",
+    "vitest": "^3.1.1",
+    "@ensnode/shared-configs": "0.28.0"
+  },
+  "scripts": {
+    "prepublish": "tsup",
+    "lint": "biome check --write .",
+    "lint:ci": "biome ci",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts"
+}