hawk-names 0.1.0

package/LICENSE

@@ -0,0 +1,26 @@
+MIT License
+
+Copyright (c) 2026 dotrobinxyz
+
+The contracts under `contracts/` are a fork of ensdomains/ens-contracts
+(https://github.com/ensdomains/ens-contracts), Copyright (c) ENS Labs Ltd and
+contributors, also licensed under the MIT License. Robin-specific additions
+live under `contracts/contracts/robin/`.
+
+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,66 @@
+# hawk-names
+
+Resolve and register `.hawk` names on Base — ENS-standard resolution with a
+one-line viem config, built for the agent economy.
+
+Hawk implements the exact ENS interfaces (ERC-137 registry, standard
+resolver profiles, ENSIP namehash, reverse records, a UniversalResolver), so
+**the ENS tooling you already use works unchanged** — stock viem, wagmi, and
+ethers resolve `.hawk` once they know where the registry lives.
+
+## Install
+
+```sh
+npm i hawk-names viem
+```
+
+## Use
+
+```ts
+import { createPublicClient, http } from "viem";
+import { base } from "hawk-names"; // ← Base with Hawk wired in as its ENS
+
+const client = createPublicClient({ chain: base, transport: http() });
+
+// reverse: address → name (render this instead of 0x…)
+await client.getEnsName({ address: "0x882220CF716aEF2421b6ab283E63427D81497d8c" });
+// → "genesis.hawk"
+
+// forward: name → address (payments, transfers, search)
+await client.getEnsAddress({ name: "genesis.hawk" });
+
+// profile records
+await client.getEnsText({ name: "genesis.hawk", key: "url" });
+await client.getEnsAvatar({ name: "genesis.hawk" });
+```
+
+With wagmi, pass the chain into your config and use the stock hooks —
+`useEnsName`, `useEnsAddress`, `useEnsText`, `useEnsAvatar`. Nothing else
+changes. Already have your own Base chain object? Wrap it:
+`withHawk(myChainConfig)`.
+
+## Agents
+
+Hawk is agent identity: one parent name per operator, one subname per agent
+— `bot1.bankr.hawk` cryptographically hangs off `bankr.hawk`. Subnames are
+real ERC-1155 tokens (transferable, revocable), and text records are the
+agent's machine-readable capability card (`url`, `agent.capabilities`,
+`agent.operator`, …).
+
+## Also exported
+
+- `HAWK_ADDRESSES`, `getHawkAddresses` — the deployed contract addresses
+- `getHawkName` / `getHawkAddress` / `getHawkText` / `getHawkAvatar` —
+  standalone actions when you don't want to touch your chain object
+- `makeRegistration`, `makeCommitment`, `randomSecret`, `validateLabel` —
+  commit–reveal registration helpers
+- `normalize`, `namehash`, `labelhash` (re-exported from `viem/ens`)
+- Typed ABIs for every deployed contract
+
+## More
+
+- App: <https://dothawk.xyz>
+- Source: [github.com/dotrobinxyz/hawk](https://github.com/dotrobinxyz/hawk) — `packages/sdk`
+- Deployed addresses: `contracts/deployments/hawk-base.json` in the repo
+
+MIT © dotrobinxyz

package/dist/actions.d.ts

@@ -0,0 +1,24 @@
+import type { Address, Client } from "viem";
+/**
+ * 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 declare function getHawkName(client: Client, params: {
+    address: Address;
+}): Promise<string | null>;
+/** Forward-resolves a .hawk name to its address, or null. */
+export declare function getHawkAddress(client: Client, params: {
+    name: string;
+}): Promise<Address | null>;
+/** Reads a text record (e.g. "com.twitter", "url", "description"). */
+export declare function getHawkText(client: Client, params: {
+    name: string;
+    key: string;
+}): Promise<string | null>;
+/** Resolves the avatar record to a usable URI, or null. */
+export declare function getHawkAvatar(client: Client, params: {
+    name: string;
+}): Promise<string | null>;

package/dist/actions.js

@@ -0,0 +1,26 @@
+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, params) {
+    return getEnsName(client, { address: params.address });
+}
+/** Forward-resolves a .hawk name to its address, or null. */
+export async function getHawkAddress(client, params) {
+    return getEnsAddress(client, { name: normalize(params.name) });
+}
+/** Reads a text record (e.g. "com.twitter", "url", "description"). */
+export async function getHawkText(client, params) {
+    return getEnsText(client, {
+        name: normalize(params.name),
+        key: params.key,
+    });
+}
+/** Resolves the avatar record to a usable URI, or null. */
+export async function getHawkAvatar(client, params) {
+    return getEnsAvatar(client, { name: normalize(params.name) });
+}

package/dist/addresses.d.ts

@@ -0,0 +1,42 @@
+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;
+};
+/**
+ * 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 declare const HAWK_ADDRESSES: Record<number, HawkAddresses>;
+/** Maps a deployments/hawk-<network>.json record to HawkAddresses. */
+export declare 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;
+export declare function getHawkAddresses(chainId: number): HawkAddresses;

package/dist/addresses.js

@@ -0,0 +1,65 @@
+const ZERO = "0x0000000000000000000000000000000000000000";
+/**
+ * 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 = {
+    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) {
+    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) {
+    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/dist/chains.d.ts

@@ -0,0 +1,21 @@
+import { type Chain } from "viem";
+import { type HawkAddresses } from "./addresses.js";
+/**
+ * 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 declare const base: Chain;
+/** Base Sepolia testnet (84532), Hawk wired in. */
+export declare const baseSepolia: Chain;
+/**
+ * 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 declare function withHawk(chain: Chain, addresses?: HawkAddresses): Chain;

package/dist/chains.js

@@ -0,0 +1,82 @@
+import { defineChain } from "viem";
+import { HAWK_ADDRESSES } from "./addresses.js";
+const ZERO = "0x0000000000000000000000000000000000000000";
+function ensContracts(addresses) {
+    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 = 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 = 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, addresses) {
+    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 },
+        },
+    };
+}