enssdk 0.0.1 → 1.10.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

@@ -1,5 +1,53 @@
 # enssdk
 
-This package name is reserved for the [ENSNode](https://ensnode.io) project by [NameHash Labs](https://namehashlabs.org).
+The foundational ENS developer library. Isomorphic, tree-shakable, with composable modules via subpath exports.
 
-For more information, visit [ensnode.io](https://ensnode.io).
+Learn more about [ENSNode](https://ensnode.io/) from [the ENSNode docs](https://ensnode.io/docs).
+
+## Installation
+
+```bash
+npm install enssdk
+```
+
+## Usage
+
+### Core Client
+
+```typescript
+import { createEnsNodeClient } from "enssdk/core";
+
+const client = createEnsNodeClient({ url: "https://api.alpha.ensnode.io" });
+```
+
+### Omnigraph (Typed GraphQL)
+
+```typescript
+import { createEnsNodeClient } from "enssdk/core";
+import { omnigraph, graphql } from "enssdk/omnigraph";
+
+const client = createEnsNodeClient({ url: "https://api.alpha.ensnode.io" })
+  .extend(omnigraph);
+
+const MyQuery = graphql(`
+  query MyQuery($name: Name!) {
+    domain(by: { name: $name }) {
+      name
+      registration { expiry }
+    }
+  }
+`);
+
+const result = await client.omnigraph.query({
+  query: MyQuery,
+  variables: { name: "nick.eth" },
+});
+```
+
+Modules are composable via `extend()` — only import what you use.
+
+## License
+
+Licensed under the MIT License, Copyright © 2025-present [NameHash Labs](https://namehashlabs.org).
+
+See [LICENSE](./LICENSE) for more information.

package/dist/core/index.d.ts

@@ -0,0 +1,20 @@
+interface EnsNodeClientConfig {
+    /**
+     * ENSNode instance URL (e.g. "https://api.alpha.ensnode.io")
+     */
+    url: string;
+    /**
+     * Optional fetch implementation (for Node/edge runtimes)
+     */
+    fetch?: typeof globalThis.fetch;
+}
+type EnsNodeClient<TExtended extends object = {}> = TExtended & {
+    readonly config: Readonly<EnsNodeClientConfig>;
+    extend<const T extends object & {
+        config?: never;
+        extend?: never;
+    }>(fn: (client: EnsNodeClient<TExtended>) => T): EnsNodeClient<TExtended & T>;
+};
+declare function createEnsNodeClient(config: EnsNodeClientConfig): EnsNodeClient;
+
+export { type EnsNodeClient, type EnsNodeClientConfig, createEnsNodeClient };

package/dist/core/index.js

@@ -0,0 +1,23 @@
+// src/core/index.ts
+function createEnsNodeClient(config) {
+  const frozenConfig = Object.freeze({ ...config });
+  function makeClient(base) {
+    const client = {
+      ...base,
+      config: frozenConfig,
+      extend(fn) {
+        const extension = fn(client);
+        return makeClient({
+          ...base,
+          ...extension
+        });
+      }
+    };
+    return client;
+  }
+  return makeClient({});
+}
+export {
+  createEnsNodeClient
+};
+//# sourceMappingURL=index.js.map

package/dist/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/core/index.ts"],"sourcesContent":["export interface EnsNodeClientConfig {\n  /**\n   * ENSNode instance URL (e.g. \"https://api.alpha.ensnode.io\")\n   */\n  url: string;\n\n  /**\n   * Optional fetch implementation (for Node/edge runtimes)\n   */\n  fetch?: typeof globalThis.fetch;\n}\n\nexport type EnsNodeClient<TExtended extends object = {}> = TExtended & {\n  readonly config: Readonly<EnsNodeClientConfig>;\n  extend<const T extends object & { config?: never; extend?: never }>(\n    fn: (client: EnsNodeClient<TExtended>) => T,\n  ): EnsNodeClient<TExtended & T>;\n};\n\nexport function createEnsNodeClient(config: EnsNodeClientConfig): EnsNodeClient {\n  const frozenConfig = Object.freeze({ ...config });\n\n  function makeClient(base: Record<string, unknown>): EnsNodeClient<Record<string, unknown>> {\n    const client = {\n      ...base,\n      config: frozenConfig,\n      extend(fn: (client: any) => object) {\n        const extension = fn(client);\n        return makeClient({\n          ...base,\n          ...(extension as Record<string, unknown>),\n        });\n      },\n    };\n    return client as EnsNodeClient<Record<string, unknown>>;\n  }\n\n  return makeClient({}) as EnsNodeClient;\n}\n"],"mappings":";AAmBO,SAAS,oBAAoB,QAA4C;AAC9E,QAAM,eAAe,OAAO,OAAO,EAAE,GAAG,OAAO,CAAC;AAEhD,WAAS,WAAW,MAAuE;AACzF,UAAM,SAAS;AAAA,MACb,GAAG;AAAA,MACH,QAAQ;AAAA,MACR,OAAO,IAA6B;AAClC,cAAM,YAAY,GAAG,MAAM;AAC3B,eAAO,WAAW;AAAA,UAChB,GAAG;AAAA,UACH,GAAI;AAAA,QACN,CAAC;AAAA,MACH;AAAA,IACF;AACA,WAAO;AAAA,EACT;AAEA,SAAO,WAAW,CAAC,CAAC;AACtB;","names":[]}

package/dist/evm-2UZlELOe.d.ts

@@ -0,0 +1,474 @@
+import { Hex as Hex$1, Address as Address$1 } from 'viem';
+
+/**
+ * A hash value that uniquely identifies a single ENS name.
+ * Result of `namehash` function as specified in ENSIP-1.
+ *
+ * @example
+ * ```
+ * namehash("vitalik.eth") === "0xee6c4522aab0003e8d14cd40a6af439055fd2577951148c14b6cea9a53475835"
+ * ```
+ * @see https://docs.ens.domains/ensip/1#namehash-algorithm
+ * @see https://ensnode.io/docs/reference/terminology#name-node-namehash
+ */
+type Node = Hex$1;
+/**
+ * An ENS Name that may or may not be normalized.
+ *
+ * @example vitalik.eth
+ * @see https://ensnode.io/docs/reference/terminology#name-node-namehash
+ * @see https://docs.ens.domains/ensip/15
+ */
+type Name = string;
+/**
+ * A LabelHash is the result of the labelhash function (which is just keccak256) on a Label.
+ *
+ * @example
+ * ```
+ * labelhash('vitalik') === '0xaf2caa1c2ca1d027f1ac823b529d0a67cd144264b2789fa2ea4d63a67c7103cc'
+ * ```
+ *
+ * @see https://docs.ens.domains/terminology#labelhash
+ * @see https://ensnode.io/docs/reference/terminology#labels-labelhashes-labelhash-function
+ * @see https://ensnode.io/ensrainbow/concepts/glossary#labelhash
+ */
+type LabelHash = Hex$1;
+/**
+ * A LabelHashPath is an ordered list of LabelHashes that uniquely identify an ENS Name.
+ * It is ordered in namegraph TRAVERSAL order (i.e. the opposite order of an ENS Name's labels).
+ *
+ * ex: example.eth's LabelHashPath is
+ * [
+ *   '0x4f5b812789fc606be1b3b16908db13fc7a9adf7ca72641f84d75b47069d3d7f0', // 'eth'
+ *   '0x6fd43e7cffc31bb581d7421c8698e29aa2bd8e7186a394b85299908b4eb9b175', // 'example'
+ * ]
+ */
+type LabelHashPath = LabelHash[];
+/**
+ * A Label is a single part of an ENS Name.
+ *
+ * @example vitalik
+ *
+ * @see https://docs.ens.domains/terminology#label
+ * @see https://ensnode.io/docs/reference/terminology#labels-labelhashes-labelhash-function
+ */
+type Label = string;
+/**
+ * An EncodedLabelHash is a specially formatted (unnormalized) Label formatted
+ * as a non-0x prefixed 32-byte hex string enclosed in square brackets.
+ *
+ * Care should be taken to distinguish Label values formatted as an
+ * EncodedLabelHash as either a LiteralLabel or an InterpretedLabel:
+ * - If a LiteralLabel is formatted as an EncodedLabelHash it does NOT
+ *   symbolically represent the encoding of a LabelHash literal.
+ * - If an InterpretedLabel is formatted as an EncodedLabelHash it should be
+ *   interpreted as encoding a LabelHash literal.
+ *
+ * An InterpretedLabel may be formatted as an EncodedLabelHash if the related
+ * LiteralLabel is:
+ * - not a normalized label
+ * - is an unknown value that could not be healed.
+ * - is too long for DNS-Encoding in contexts where DNS-Encoding was required.
+ *
+ * @example [af2caa1c2ca1d027f1ac823b529d0a67cd144264b2789fa2ea4d63a67c7103cc]
+ *
+ * @see https://ensnode.io/docs/reference/terminology#encoded-labelhash
+ */
+type EncodedLabelHash = `[${string}]`;
+/**
+ * A Literal Label is a Label as it literally appears onchain, without any interpretation
+ * or normalization processing. It may be an unnormalized label for reasons including:
+ * - being an empty label,
+ * - containing '.' characters,
+ * - being formatted as an EncodedLabelHash (which are not normalizable). Note that
+ *   when LiteralLabel are formatted as an EncodedLabelHash they do NOT symbolically
+ *   represent the encoding of a LabelHash literal, or
+ * - containing other unnormalized characters such as null bytes or other characters
+ *   not suitable for display.
+ *
+ * @see https://ensnode.io/docs/reference/terminology#literal-label
+ * @dev nominally typed to enforce usage & enhance codebase clarity
+ */
+type LiteralLabel = Label & {
+    __brand: "LiteralLabel";
+};
+/**
+ * An Interpreted Label is a Label that is either:
+ * a) a Normalized Label, or
+ * b) an Unnormalizable Label exclusively for the reason that it is formatted
+ *    as an Encoded LabelHash that should be interpreted as encoding a
+ *    LabelHash literal, where the encoded LabelHash literal is the `labelhash`
+ *    of the related LiteralLabel.
+ *
+ * @see https://ensnode.io/docs/reference/terminology#interpreted-label
+ * @dev nominally typed to enforce usage & enhance codebase clarity
+ */
+type InterpretedLabel = Label & {
+    __brand: "InterpretedLabel";
+};
+/**
+ * A Literal Name is a Name as it literally appears onchain, composed of 0 or more Literal Labels
+ * joined by dots. It may be an unnormalized name for reasons including:
+ * - containing empty labels,
+ * - containing LiteralLabel values formatted as an EncodedLabelHash (which are
+ *   not normalizable)). Note that when LiteralLabel values are formatted as an
+ *   EncodedLabelHash they do NOT symbolically represent the encoding of a
+ *   LabelHash literal, or
+ * - containing other unnormalized characters such as null bytes or other characters
+ *   not suitable for display.
+ *
+ * @see https://ensnode.io/docs/reference/terminology#literal-name
+ * @dev nominally typed to enforce usage & enhance codebase clarity
+ */
+type LiteralName = Name & {
+    __brand: "LiteralName";
+};
+/**
+ * An Interpreted Name is a Name that is entirely composed of 0 or more Interpreted Labels.
+ *
+ * That is, it is either:
+ * a) a Normalized Name, or
+ * b) an Unnormalizable Name exclusively for the reason that it contains 1 or
+ *    more labels formatted as Encoded LabelHashes that should be interpreted
+ *    as encoding a LabelHash literal, where the encoded LabelHash literal is
+ *    the `labelhash` of the related LiteralLabel.
+ *
+ * @see https://ensnode.io/docs/reference/terminology#interpreted-name
+ * @dev nominally typed to enforce usage & enhance codebase clarity
+ */
+type InterpretedName = Name & {
+    __brand: "InterpretedName";
+};
+/**
+ * A Subgraph Interpreted Label is a Literal Label that is either:
+ * a) (if subgraph-indexable): a Literal Label, of unknown normalization status, guaranteed to not
+ *   contain any of the subgraph-unindexable UTF-8 characters (and therefore guaranteed not to be
+ *   an Encoded LabelHash), or
+ * b) (if subgraph-unindexable): an Encoded LabelHash.
+ *
+ * @see https://ensnode.io/docs/reference/terminology#subgraph-interpreted-label
+ * @dev nominally typed to enforce usage & enhance codebase clarity
+ */
+type SubgraphInterpretedLabel = Label & {
+    __brand: "SubgraphInterpretedLabel";
+};
+/**
+ * A Subgraph Interpreted Name is a name exclusively composed of 0 or more Subgraph Interpreted Labels.
+ *
+ * @see https://ensnode.io/docs/reference/terminology#subgraph-interpreted-name
+ * @dev nominally typed to enforce usage & enhance codebase clarity
+ */
+type SubgraphInterpretedName = Name & {
+    __brand: "SubgraphInterpretedName";
+};
+/**
+ * A DNS-Encoded Name as a hex string, representing the binary DNS wire format encoding
+ * of a domain name. Used in ENS contracts for efficient name storage and transmission.
+ * Each label is prefixed with a length byte, and the entire sequence is null-terminated.
+ *
+ * @example "0x076578616d706c650365746800" represents "example.eth"
+ *
+ * @see https://docs.ens.domains/resolution/names/#dns-encoding
+ * @see https://github.com/ensdomains/ens-contracts/blob/staging/contracts/utils/NameCoder.sol
+ *
+ * DNS Packet Format for Domain Names:
+ * - Domain names are encoded as a sequence of 0 or more labels
+ * - Each label begins with a length byte (1 byte) indicating how many bytes follow for that label
+ *   Note how this constrains each label in DNS encoded names to a max byte length of 255 bytes.
+ * - The bytes after the length byte represent the label, as a UTF-8 byte array
+ * - Labels are concatenated with no separators
+ * - The sequence ends with a null byte (0x00)
+ *
+ * Example: "example.eth" is encoded as:
+ * [0x07, 'e', 'x', 'a', 'm', 'p', 'l', 'e', 0x03, 'e', 't', 'h', 0x00]
+ * Where 0x07 is the length of "example", 0x03 is the length of "eth", and 0x00 marks the end
+ *
+ * Example: "" (empty string, i.e. root node) is encoded as:
+ * [0x00]
+ *
+ * Example: "👩🏼‍❤‍💋‍👨🏼.eth" (multi-byte unicode character) is encoded as:
+ * [0x20, 240, 159, 145, 169, 240, 159, 143, 188, 226, 128, 141, 226, 157, 164, 226,
+ * 128, 141, 240, 159, 146, 139, 226, 128, 141, 240, 159, 145, 168, 240, 159, 143,
+ * 188, 3, 'e', 't', 'h', 0x00]
+ *
+ * A DNS-Encoded Name Packet may be malformed if it does not exactly follow that specification.
+ * Possible reasons a DNS-Encoded Name may be malfomed include:
+ * - 'empty' packet
+ *   - e.g. []
+ *           ^-- that's empty!
+ * - 'length' byte overflowing packet byte length
+ *   - e.g. [0x06, 'e', 't', 'h', 0x00]
+ *            ^-- length overflows available bytes!
+ * - 'junk' at the end of the dns-encoded
+ *   - e.g. [0x03, 'e', 't', 'h', 0x00, 0x01]
+ *                                       ^-- junk!
+ *
+ * @dev This type is _structurally_ typed to aid Event Argument Typing — consumers should further
+ * cast the type of the event argument to a _nominally_ typed DNSEncodedName like {@link DNSEncodedLiteralName}
+ * or {@link DNSEncodedPartiallyInterpretedName} depending on the context.
+ */
+type DNSEncodedName = Hex$1;
+/**
+ * A DNSEncodedName that encodes a name containing 0 or more {@link LiteralLabel}s.
+ *
+ * In a DNSEncodedLiteralName, all labels are Literal Labels, including any Encoded-LabelHash-looking
+ * labels. Any Encoded-LabelHash-looking Literal Label values, when interpreted, will be formatted as
+ * the `labelhash` of the Literal Label value.
+ *
+ * The NameWrapper contract emits DNSEncodedLiteralNames:
+ * @see https://github.com/ensdomains/ens-contracts/blob/staging/contracts/utils/BytesUtils_LEGACY.sol
+ *
+ * The ThreeDNSToken contract emits DNSEncodedLiteralNames:
+ * @see https://github.com/3dns-xyz/contracts/blob/44937318ae26cc036982e8c6a496cd82ebdc2b12/src/regcontrol/libraries/BytesUtils.sol
+ *
+ * @dev nominally typed to enforce usage & enhance codebase clarity
+ */
+type DNSEncodedLiteralName = DNSEncodedName & {
+    __brand: "DNSEncodedLiteralName";
+};
+/**
+ * A DNSEncodedName that encodes a name consisting of 0 or more labels that are either:
+ * a) Literal Labels, or
+ * b) Encoded LabelHashes, which are already an Interpreted Label.
+ *
+ * In a DNSEncodedPartiallyInterpretedName, any Encoded-LabelHash-looking decoded Labels (i.e. ones
+ * that match the regex /^\[[\da-f]{64}\]$/) represent an Encoded LabelHash. When decoding a
+ * DNSEncodedPartiallyInterpretedName, these labels are already considered Interpreted.
+ *
+ * NOTE: This type is unused in ENSv1, but its usage is anticipated in ENSv2 due to Encoded
+ * LabelHash support in the ENSv2 implementation of the NameCoder contract.
+ *
+ * @see https://github.com/ensdomains/ens-contracts/blob/staging/contracts/utils/NameCoder.sol
+ *
+ * @dev nominally typed to enforce usage & enhance codebase clarity
+ */
+type DNSEncodedPartiallyInterpretedName = DNSEncodedName & {
+    __brand: "DNSEncodedPartiallyInterpretedName";
+};
+
+/**
+ * Unix timestamp value
+ *
+ * Represents the number of seconds that have elapsed
+ * since January 1, 1970 (midnight UTC/GMT).
+ *
+ * Guaranteed to be an integer. May be zero or negative to represent a time at or
+ * before Jan 1, 1970.
+ */
+type UnixTimestamp = number;
+/**
+ * Duration
+ *
+ * Representing a duration in seconds.
+ *
+ * Guaranteed to be a non-negative integer.
+ */
+type Duration = number;
+/**
+ * Serialized representation of {@link ChainId}.
+ **/
+type ChainIdString = string;
+/**
+ * Datetime value following the ISO 8601 standard.
+ *
+ * @see https://www.iso.org/iso-8601-date-and-time-format.html
+ */
+type DatetimeISO8601 = string;
+/**
+ * Serialized representation of a {@link URL}.
+ */
+type UrlString = string;
+/**
+ * String representation of {@link AccountId}.
+ *
+ * Formatted as a fully lowercase CAIP-10 AccountId.
+ *
+ * @see https://chainagnostic.org/CAIPs/caip-10
+ */
+type AccountIdString = string;
+/**
+ * String representation of {@link AssetId}.
+ *
+ * Formatted as a fully lowercase CAIP-19 AssetId.
+ *
+ * @see https://chainagnostic.org/CAIPs/caip-19
+ * @example "eip155:1/erc721:0x57f1887a8bf19b14fc0df6fd9b2acc9af147ea85/0xaf2caa1c2ca1d027f1ac823b529d0a67cd144264b2789fa2ea4d63a67c7103cc"
+ *          for vitalik.eth in the eth base registrar on mainnet.
+ */
+type AssetIdString = string;
+
+/**
+ * Serialized CAIP-10 Asset ID that uniquely identifies a Registry contract.
+ */
+type RegistryId = string & {
+    __brand: "RegistryContractId";
+};
+/**
+ * A Label's Storage Id is uint256(labelHash) with lower (right-most) 32 bits zero'd.
+ *
+ * In ENSv2, the rightmost 32 bits of a TokenId is used for version management, and it is the leftmost
+ * 224 bits that are a stable identifier for a Label within a Registry.
+ */
+type StorageId = bigint & {
+    __brand: "StorageId";
+};
+/**
+ * The node that uniquely identifies an ENSv1 name.
+ */
+type ENSv1DomainId = Node & {
+    __brand: "ENSv1DomainId";
+};
+/**
+ * The Serialized CAIP-19 Asset ID (using Storage Id instead of TokenId) that uniquely identifies
+ * an ENSv2 name.
+ */
+type ENSv2DomainId = string & {
+    __brand: "ENSv2DomainId";
+};
+/**
+ * A DomainId is one of ENSv1DomainId or ENSv2DomainId.
+ */
+type DomainId = ENSv1DomainId | ENSv2DomainId;
+/**
+ * Uniquely identifies a Permissions entity.
+ */
+type PermissionsId = AccountIdString & {
+    __brand: "PermissionsId";
+};
+/**
+ * Uniquely identifies a PermissionsResource entity.
+ */
+type PermissionsResourceId = string & {
+    __brand: "PermissionsResourceId";
+};
+/**
+ * Uniquely identifies a PermissionsUser entity.
+ */
+type PermissionsUserId = string & {
+    __brand: "PermissionsUserId";
+};
+/**
+ * Uniquely identifies a Resolver entity.
+ */
+type ResolverId = AccountIdString & {
+    __brand: "ResolverId";
+};
+/**
+ * Uniquely identifies a ResolverRecords entity.
+ */
+type ResolverRecordsId = string & {
+    __brand: "ResolverRecordsId";
+};
+/**
+ * Uniquely identifies a Registration entity.
+ */
+type RegistrationId = string & {
+    __brand: "RegistrationId";
+};
+/**
+ * Uniquely identifies a Renewal entity.
+ */
+type RenewalId = string & {
+    __brand: "RenewalId";
+};
+/**
+ * CanonicalPath is an ordered list of DomainIds describing the canonical path to a Domain.
+ * It is ordered in namegraph TRAVERSAL order (i.e. the opposite order of an ENS Name's labels).
+ */
+type CanonicalPath = DomainId[];
+
+/**
+ * Represents a Hex string, in the format `0x{string}`.
+ */
+type Hex = Hex$1;
+/**
+ * Represents an EVM Address, in the format `0x{string}`, which may or may not be checksummed.
+ */
+type Address = Address$1;
+/**
+ * Represents a normalized (non-checksummed) EVM Address, in the format `0x{string}`, where all
+ * characters are lowercase and length is exactly 42.
+ *
+ * @dev because the Address type is so widely used, nominally typing it would involve a _ton_ of
+ *      asNormalizedAddress() casts across the codebase. By avoiding the __brand, we can easily use
+ *      EventWithArgs<{ address: NormalizedAddress }> in all of the Ponder event handler args to
+ *      declare that the incoming event.args.address is a NormalizedAddress.
+ */
+type NormalizedAddress = Address;
+/**
+ * Unix timestamp value as bigint.
+ *
+ * Represents the number of seconds that have elapsed
+ * since January 1, 1970 (midnight UTC/GMT).
+ *
+ * Guaranteed to be an integer. May be zero or negative to represent a time at or
+ * before Jan 1, 1970.
+ */
+type UnixTimestampBigInt = bigint;
+/**
+ * Duration value as bigint.
+ *
+ * Representing a duration in seconds.
+ *
+ * Guaranteed to be a non-negative integer.
+ */
+type DurationBigInt = bigint;
+/**
+ * A value denominated in wei, the smallest unit of Ether (1 ETH = 10^18 wei).
+ */
+type Wei = bigint;
+/**
+ * Chain ID
+ *
+ * Represents a unique identifier for a chain.
+ * Guaranteed to be a positive integer.
+ *
+ * Chain id standards are organized by the Ethereum Community @ https://github.com/ethereum-lists/chains
+ **/
+type ChainId = number;
+/**
+ * Defaultable Chain ID
+ *
+ * Represents a unique identifier for a chain, or
+ * the default chain as defined by ENSIP-19.
+ *
+ * @see https://docs.ens.domains/ensip/19/#annex-supported-chains
+ *
+ * Guaranteed to be a non-negative integer.
+ **/
+type DefaultableChainId = 0 | ChainId;
+/**
+ * Represents an account (contract or EOA) at `address` on chain `chainId`.
+ *
+ * @see https://chainagnostic.org/CAIPs/caip-10
+ */
+interface AccountId {
+    chainId: ChainId;
+    address: NormalizedAddress;
+}
+/**
+ * An enum representing the possible CAIP-19 Asset Namespace values.
+ *
+ * @see https://chainagnostic.org/CAIPs/caip-19
+ */
+declare const AssetNamespaces: {
+    readonly ERC721: "erc721";
+    readonly ERC1155: "erc1155";
+};
+type AssetNamespace = (typeof AssetNamespaces)[keyof typeof AssetNamespaces];
+/**
+ * A uint256 value that identifies a specific NFT within a NFT contract.
+ */
+type TokenId = bigint;
+/**
+ * Represents an Asset in `assetNamespace` by `tokenId` in `contract`.
+ *
+ * @see https://chainagnostic.org/CAIPs/caip-19
+ */
+interface AssetId {
+    assetNamespace: AssetNamespace;
+    contract: AccountId;
+    tokenId: TokenId;
+}
+
+export { type Address as A, type DatetimeISO8601 as B, type ChainId as C, type DNSEncodedLiteralName as D, type ENSv1DomainId as E, type DefaultableChainId as F, type Duration as G, type Hex as H, type InterpretedName as I, type DurationBigInt as J, type SubgraphInterpretedLabel as K, type LiteralLabel as L, type SubgraphInterpretedName as M, type NormalizedAddress as N, type UnixTimestampBigInt as O, type PermissionsId as P, type UrlString as Q, type RegistrationId as R, type StorageId as S, type TokenId as T, type UnixTimestamp as U, type Wei as W, type AccountId as a, type AccountIdString as b, type AssetId as c, type AssetIdString as d, type Node as e, type DNSEncodedName as f, type ENSv2DomainId as g, type PermissionsResourceId as h, type PermissionsUserId as i, type DomainId as j, type RegistryId as k, type RenewalId as l, type ResolverId as m, type ResolverRecordsId as n, type LabelHash as o, type Label as p, type InterpretedLabel as q, type Name as r, type LiteralName as s, type LabelHashPath as t, type EncodedLabelHash as u, type AssetNamespace as v, AssetNamespaces as w, type CanonicalPath as x, type ChainIdString as y, type DNSEncodedPartiallyInterpretedName as z };