hawk-names 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { base, baseSepolia, withHawk, } from "./chains.js";
+export { HAWK_ADDRESSES, getHawkAddresses, hawkAddressesFrom, type HawkAddresses, } from "./addresses.js";
+export { getHawkName, getHawkAddress, getHawkText, getHawkAvatar, } from "./actions.js";
+export { HAWK_NODE, REVERSE_RECORD_NONE, REVERSE_RECORD_CHAIN, REVERSE_RECORD_DEFAULT, SECONDS_PER_YEAR, MIN_REGISTRATION_DURATION_MAINNET, MAX_REGISTRATION_DURATION, type Registration, makeRegistration, makeCommitment, randomSecret, hawkNode, hawkTokenId, validateLabel, } from "./registration.js";
+export { normalize, namehash, labelhash } from "viem/ens";
+export * from "./generated/abis.js";

package/dist/index.js

@@ -0,0 +1,13 @@
+// hawk-names — resolve and register .hawk names on Base.
+//
+// One-line dapp integration:
+//   import { createPublicClient, http } from "viem";
+//   import { base } from "hawk-names";
+//   const client = createPublicClient({ chain: base, transport: http() });
+//   await client.getEnsName({ address: "0x..." });   // → "trader.hawk"
+export { base, baseSepolia, withHawk, } from "./chains.js";
+export { HAWK_ADDRESSES, getHawkAddresses, hawkAddressesFrom, } from "./addresses.js";
+export { getHawkName, getHawkAddress, getHawkText, getHawkAvatar, } from "./actions.js";
+export { HAWK_NODE, REVERSE_RECORD_NONE, REVERSE_RECORD_CHAIN, REVERSE_RECORD_DEFAULT, SECONDS_PER_YEAR, MIN_REGISTRATION_DURATION_MAINNET, MAX_REGISTRATION_DURATION, makeRegistration, makeCommitment, randomSecret, hawkNode, hawkTokenId, validateLabel, } from "./registration.js";
+export { normalize, namehash, labelhash } from "viem/ens";
+export * from "./generated/abis.js";

package/dist/registration.d.ts

@@ -0,0 +1,49 @@
+import { type Address, type Hex } from "viem";
+/** namehash('hawk') */
+export declare const HAWK_NODE: "0xf431efc1fb1b854a38191ac67de7e1ee70205b40f71cb927c938685e82e05403";
+/** Reverse-record bits for Registration.reverseRecord. */
+export declare const REVERSE_RECORD_NONE = 0;
+export declare const REVERSE_RECORD_CHAIN = 1;
+export declare const REVERSE_RECORD_DEFAULT = 2;
+/** Mirror of HawkRegistrarController's Registration struct. */
+export type Registration = {
+    label: string;
+    owner: Address;
+    duration: bigint;
+    secret: Hex;
+    resolver: Address;
+    data: readonly Hex[];
+    reverseRecord: number;
+    referrer: Hex;
+};
+export declare function makeRegistration(params: {
+    label: string;
+    owner: Address;
+    duration: bigint;
+    secret: Hex;
+    resolver?: Address;
+    data?: readonly Hex[];
+    reverseRecord?: number;
+    referrer?: Hex;
+}): Registration;
+/**
+ * Computes the commit-reveal commitment for a registration —
+ * `keccak256(abi.encode(registration))`, byte-identical to the
+ * controller's `makeCommitment`.
+ */
+export declare function makeCommitment(registration: Registration): Hex;
+/** Random 32-byte commit-reveal secret (browser + node). */
+export declare function randomSecret(): Hex;
+/** The namehash of `<label>.hawk`. */
+export declare function hawkNode(label: string): Hex;
+/** The ERC-721 token id (labelhash) for a .hawk second-level name. */
+export declare function hawkTokenId(label: string): bigint;
+/**
+ * Client-side registrability check, mirroring the controller's `valid` plus
+ * ENSIP-15 normalization (the on-chain check is length-only; apps must
+ * normalize). Returns the normalized label or throws with the reason.
+ */
+export declare function validateLabel(rawLabel: string): string;
+export declare const SECONDS_PER_YEAR = 31536000n;
+export declare const MIN_REGISTRATION_DURATION_MAINNET = 2419200n;
+export declare const MAX_REGISTRATION_DURATION = 315360000n;

package/dist/registration.js

@@ -0,0 +1,73 @@
+import { encodeAbiParameters, keccak256, toHex, zeroAddress, zeroHash, } from "viem";
+import { namehash, normalize } from "viem/ens";
+/** namehash('hawk') */
+export const HAWK_NODE = "0xf431efc1fb1b854a38191ac67de7e1ee70205b40f71cb927c938685e82e05403";
+/** Reverse-record bits for Registration.reverseRecord. */
+export const REVERSE_RECORD_NONE = 0;
+export const REVERSE_RECORD_CHAIN = 1; // addr.reverse on Base
+export const REVERSE_RECORD_DEFAULT = 2; // default.reverse (EVM-wide fallback)
+export function makeRegistration(params) {
+    return {
+        label: params.label,
+        owner: params.owner,
+        duration: params.duration,
+        secret: params.secret,
+        resolver: params.resolver ?? zeroAddress,
+        data: params.data ?? [],
+        reverseRecord: params.reverseRecord ?? REVERSE_RECORD_NONE,
+        referrer: params.referrer ?? zeroHash,
+    };
+}
+const REGISTRATION_TUPLE = {
+    type: "tuple",
+    components: [
+        { name: "label", type: "string" },
+        { name: "owner", type: "address" },
+        { name: "duration", type: "uint256" },
+        { name: "secret", type: "bytes32" },
+        { name: "resolver", type: "address" },
+        { name: "data", type: "bytes[]" },
+        { name: "reverseRecord", type: "uint8" },
+        { name: "referrer", type: "bytes32" },
+    ],
+};
+/**
+ * Computes the commit-reveal commitment for a registration —
+ * `keccak256(abi.encode(registration))`, byte-identical to the
+ * controller's `makeCommitment`.
+ */
+export function makeCommitment(registration) {
+    return keccak256(encodeAbiParameters([REGISTRATION_TUPLE], [registration]));
+}
+/** Random 32-byte commit-reveal secret (browser + node). */
+export function randomSecret() {
+    const bytes = new Uint8Array(32);
+    globalThis.crypto.getRandomValues(bytes);
+    return toHex(bytes);
+}
+/** The namehash of `<label>.hawk`. */
+export function hawkNode(label) {
+    return namehash(`${normalize(label)}.hawk`);
+}
+/** The ERC-721 token id (labelhash) for a .hawk second-level name. */
+export function hawkTokenId(label) {
+    return BigInt(keccak256(toHex(normalize(label))));
+}
+/**
+ * Client-side registrability check, mirroring the controller's `valid` plus
+ * ENSIP-15 normalization (the on-chain check is length-only; apps must
+ * normalize). Returns the normalized label or throws with the reason.
+ */
+export function validateLabel(rawLabel) {
+    const label = normalize(rawLabel);
+    if (label.includes(".")) {
+        throw new Error("A label cannot contain dots.");
+    }
+    if ([...label].length < 3) {
+        throw new Error("Names must be at least 3 characters.");
+    }
+    return label;
+}
+export const SECONDS_PER_YEAR = 31536000n; // 365 days, the pricing year
+export const MIN_REGISTRATION_DURATION_MAINNET = 2419200n; // 28 days
+export const MAX_REGISTRATION_DURATION = 315360000n; // 3650 days

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "hawk-names",
+  "version": "0.1.0",
+  "description": "Resolve and register .hawk names on Base — ENS-standard resolution with a one-line viem config.",
+  "license": "MIT",
+  "author": "dothawkxyz",
+  "homepage": "https://docs.dothawk.xyz",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dothawkxyz/hawk.git",
+    "directory": "packages/sdk"
+  },
+  "bugs": {
+    "url": "https://github.com/dothawkxyz/hawk/issues"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "sideEffects": false,
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "sync-artifacts": "node scripts/sync-artifacts.mjs",
+    "test": "node --test test/resolution.test.mjs"
+  },
+  "peerDependencies": {
+    "viem": ">=2.30.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.6.0",
+    "viem": "^2.33.3"
+  },
+  "keywords": [
+    "hawk",
+    "base-chain",
+    "ens",
+    "naming",
+    "viem"
+  ]
+}

package/src/actions.ts

@@ -0,0 +1,50 @@
+import type { Address, Client } from "viem";
+import {
+  getEnsAddress,
+  getEnsAvatar,
+  getEnsName,
+  getEnsText,
+  normalize,
+} from "viem/ens";
+
+/**
+ * Thin, explicit wrappers over viem's ENS actions. If your client's chain
+ * comes from this SDK (`base` / `withHawk`), viem's own
+ * `getEnsName`/`getEnsAddress`/... already resolve .hawk — use whichever
+ * reads better in your codebase.
+ */
+
+/** Primary name for an address (reverse resolution), or null. */
+export async function getHawkName(
+  client: Client,
+  params: { address: Address },
+): Promise<string | null> {
+  return getEnsName(client as never, { address: params.address });
+}
+
+/** Forward-resolves a .hawk name to its address, or null. */
+export async function getHawkAddress(
+  client: Client,
+  params: { name: string },
+): Promise<Address | null> {
+  return getEnsAddress(client as never, { name: normalize(params.name) });
+}
+
+/** Reads a text record (e.g. "com.twitter", "url", "description"). */
+export async function getHawkText(
+  client: Client,
+  params: { name: string; key: string },
+): Promise<string | null> {
+  return getEnsText(client as never, {
+    name: normalize(params.name),
+    key: params.key,
+  });
+}
+
+/** Resolves the avatar record to a usable URI, or null. */
+export async function getHawkAvatar(
+  client: Client,
+  params: { name: string },
+): Promise<string | null> {
+  return getEnsAvatar(client as never, { name: normalize(params.name) });
+}

package/src/addresses.ts

@@ -0,0 +1,101 @@
+import type { Address } from "viem";
+
+/** Every Hawk contract for one deployment. */
+export type HawkAddresses = {
+  registry: Address;
+  baseRegistrar: Address;
+  controller: Address;
+  priceOracle: Address;
+  wrapper: Address;
+  metadata: Address;
+  reservedList: Address;
+  publicResolver: Address;
+  reverseRegistrar: Address;
+  defaultReverseRegistrar: Address;
+  universalResolver: Address;
+  usdc: Address;
+};
+
+const ZERO = "0x0000000000000000000000000000000000000000" as const;
+
+/**
+ * Canonical deployments by chain id.
+ *
+ * - 8453  — Base mainnet (populated at mainnet deploy)
+ * - 84532 — Base Sepolia testnet (populated at testnet deploy)
+ *
+ * For a local/anvil deployment, build your own with `hawkAddressesFrom`
+ * using the deploy script's deployments/hawk-local.json.
+ */
+export const HAWK_ADDRESSES: Record<number, HawkAddresses> = {
+  8453: {
+    registry: "0x5DAF4DF48b022Bf0Fb454DBe9CB2592d3A32b0b2",
+    baseRegistrar: "0x83dcABD50E531325C76b9CB07F4C04Aca187722E",
+    controller: "0x65Acb254B2EF5af1FDFf7B8C77427Ca051Ff4F71",
+    priceOracle: "0x697b2C75652b6895D507b9C8E2Cb3b3C8EfccA29",
+    wrapper: "0x0B922e8B56c778667AbDbBBa522880F98362c6C8",
+    metadata: "0xA972f32580C2DD8eEf379e27B4B91b205BF3437F",
+    reservedList: "0x351c51AA3079e7f7EbeFb5079A92279b22a0AB6c",
+    publicResolver: "0xC7cAB8Af20fF52346F4e93c143Cc8e9d6384e26b",
+    reverseRegistrar: "0x4221F2953294ec98Ddf54964DB293E281db71daB",
+    defaultReverseRegistrar: "0x34acC481E26Ee9566d868F455BecD05353Bae257",
+    universalResolver: "0x1Ebbe68AfA011ADBE561De6215B1AA1Fe0e4bc6C",
+    usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  },
+  84532: {
+    registry: ZERO,
+    baseRegistrar: ZERO,
+    controller: ZERO,
+    priceOracle: ZERO,
+    wrapper: ZERO,
+    metadata: ZERO,
+    reservedList: ZERO,
+    publicResolver: ZERO,
+    reverseRegistrar: ZERO,
+    defaultReverseRegistrar: ZERO,
+    universalResolver: ZERO,
+    usdc: ZERO,
+  },
+};
+
+/** Maps a deployments/hawk-<network>.json record to HawkAddresses. */
+export function hawkAddressesFrom(deployment: {
+  HawkRegistry: Address;
+  HawkBaseRegistrar: Address;
+  HawkRegistrarController: Address;
+  HawkPriceOracle: Address;
+  HawkWrapper: Address;
+  HawkMetadata: Address;
+  HawkReservedList: Address;
+  PublicResolver: Address;
+  ReverseRegistrar: Address;
+  DefaultReverseRegistrar: Address;
+  UniversalResolver: Address;
+  usdc: Address;
+}): HawkAddresses {
+  return {
+    registry: deployment.HawkRegistry,
+    baseRegistrar: deployment.HawkBaseRegistrar,
+    controller: deployment.HawkRegistrarController,
+    priceOracle: deployment.HawkPriceOracle,
+    wrapper: deployment.HawkWrapper,
+    metadata: deployment.HawkMetadata,
+    reservedList: deployment.HawkReservedList,
+    publicResolver: deployment.PublicResolver,
+    reverseRegistrar: deployment.ReverseRegistrar,
+    defaultReverseRegistrar: deployment.DefaultReverseRegistrar,
+    universalResolver: deployment.UniversalResolver,
+    usdc: deployment.usdc,
+  };
+}
+
+export function getHawkAddresses(chainId: number): HawkAddresses {
+  const addresses = HAWK_ADDRESSES[chainId];
+  if (!addresses || addresses.registry === ZERO) {
+    throw new Error(
+      `Hawk is not deployed on chain ${chainId} in this SDK version — ` +
+        `pass addresses explicitly (hawkAddressesFrom) or upgrade hawk-names.`,
+    );
+  }
+  return addresses;
+}

package/src/chains.ts

@@ -0,0 +1,91 @@
+import { defineChain, type Chain } from "viem";
+import { HAWK_ADDRESSES, type HawkAddresses } from "./addresses.js";
+
+const ZERO = "0x0000000000000000000000000000000000000000";
+
+function ensContracts(addresses: HawkAddresses | undefined) {
+  if (!addresses || addresses.registry === ZERO) return {};
+  return {
+    ensRegistry: { address: addresses.registry },
+    ensUniversalResolver: { address: addresses.universalResolver },
+  };
+}
+
+/**
+ * Base mainnet (8453), with Hawk wired in as the chain's ENS —
+ * `getEnsName`, `getEnsAddress`, `getEnsText`, `getEnsAvatar` and every
+ * other viem/wagmi ENS action work out of the box against .hawk names.
+ */
+export const base: Chain = defineChain({
+  id: 8453,
+  name: "Base",
+  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+  rpcUrls: {
+    default: { http: ["https://mainnet.base.org"] },
+  },
+  blockExplorers: {
+    default: {
+      name: "Basescan",
+      url: "https://basescan.org",
+    },
+  },
+  contracts: {
+    multicall3: {
+      address: "0xcA11bde05977b3631167028862bE2a173976CA11",
+    },
+    ...ensContracts(HAWK_ADDRESSES[8453]),
+  },
+});
+
+/** Base Sepolia testnet (84532), Hawk wired in. */
+export const baseSepolia: Chain = defineChain({
+  id: 84532,
+  name: "Base Sepolia",
+  testnet: true,
+  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
+  rpcUrls: {
+    default: { http: ["https://sepolia.base.org"] },
+  },
+  blockExplorers: {
+    default: {
+      name: "Basescan",
+      url: "https://sepolia.basescan.org",
+    },
+  },
+  contracts: {
+    multicall3: {
+      address: "0xcA11bde05977b3631167028862bE2a173976CA11",
+    },
+    ...ensContracts(HAWK_ADDRESSES[84532]),
+  },
+});
+
+/**
+ * Wires Hawk resolution into any viem Chain object — the one-line
+ * integration for dapps that already have their own chain config:
+ *
+ * ```ts
+ * import { withHawk } from "hawk-names";
+ * const chain = withHawk(myBaseChainConfig);
+ * // viem's getEnsName / getEnsAddress now resolve .hawk
+ * ```
+ */
+export function withHawk(
+  chain: Chain,
+  addresses?: HawkAddresses,
+): Chain {
+  const hawk = addresses ?? HAWK_ADDRESSES[chain.id];
+  if (!hawk || hawk.registry === ZERO) {
+    throw new Error(
+      `No Hawk deployment known for chain ${chain.id} — pass addresses explicitly.`,
+    );
+  }
+  return {
+    ...chain,
+    contracts: {
+      ...chain.contracts,
+      ensRegistry: { address: hawk.registry },
+      ensUniversalResolver: { address: hawk.universalResolver },
+    },
+  };
+}