# Welcome! ### What is dotHYPE? dotHYPE transforms names into modular, programmable identity containers built for the HyperEVM era. Whether you’re here to claim your first `.hype` name, integrate identity into your dApp, or explore the architecture behind it all, we’ve designed dotHYPE to meet you where you are clear, composable, and future-ready. It starts with naming, then becomes identity infrastructure. ## Begin your dotHYPE journey based on your intent: **🔰**New to dotHYPE? → [Quickstart Guide](/quickstart/introduction-to-dothype) 🔧Building or integrating? → [Builder Toolkit](/integrating-.hype/build-with-dothype) 🤿Curious about how it works? → [Explore the Architecture](/architecture/how-it-all-works) 🔧 Inside our first-principles thinking → [Explore the philosophy behind dotHYPE ](/foundations/principles) ## 📚Explore Our Guides Navigate our system based on what you want to do - whether you're just getting started or building something new\..
How to use HyperEVMNew to the ecosystem? Start here./pages/2ZjbRPxFZyzN7KPRvanZ
Get Your NameStep-by-step tutorials for claiming, renewing, and customizing your .hype name./pages/4WIMpDzFb3YkAuStdIFK
Customize Your IdentityPersonalize your .hype name with avatars, social links, and metadata./pages/oZdK7PzOZUx62Tlovcx0
Build with dotHYPEEverything builders need: SDKs, resolvers, integration guides, and smart contract docs./pages/O1EG3PZ8CGvHlByRSKLy
Explore the ArchitectureUnderstand the architecture, minting mechanics, and roadmap behind dotHYPE./pages/vcUJefBogfy45F7yiiWK
Official LinksTwitter, Discord, Website/pages/uBphrlclX9J6iYNor0Fp
# Introduction to dotHYPE Welcome to the future of modular on-chain identity for HyperEVM. In Web3, we’ve built protocols for speed, liquidity, and composability - but identity is still stuck in the past. Wallets remain anonymous strings. Roles are implied, not declared. And on-chain coordination still lacks a shared, human-readable interface. dotHYPE changes that.\ It’s starts with the naming service and evolves into a foundational infrastructure for how users, protocols, and agents identify and interact on HyperEVM. Every `.hype` name is a container: structured to evolve, personalize, and coordinate. This isn’t strictly just about making addresses human-readable. It’s about making systems **human-comprehensible**. **dotHYPE gives you a `.hype` name that is:** * ✅ Human-readable (like `you.hype`) * ✅ Fully on-chain and ENS-compatible * ✅ Permissionless to mint * ✅ Modular and programmable for expansion **Designed for today and tomorrow.** * In a modular blockchain like HyperEVM, coordination happens across many contracts, dashboards, and UIs. * dotHYPE helps tie these elements together into one readable identity. **This quickstart will help you:** 1. [Claim your name](/quickstart/introduction-to-dothype/get-your-name) 2. [Use it in real ways](/quickstart/introduction-to-dothype/what-you-can-do-today) 3. [Understand where the product is heading](/quickstart/introduction-to-dothype/whats-coming-next) Let’s get started. # HyperEVM Basics HyperEVM is the EVM-compatible layer of the Hyperliquid blockchain. If this is your first time exploring HyperEVM, here’s everything you need to get started. ### Add HyperEVM to Your Wallet To interact with apps and assets on HyperEVM, you’ll first need to add it to your wallet (e.g. MetaMask). **Easiest Option:**\ Use [Chainlist](https://chainlist.org/chain/999) - one click, and you’re in. **Manual Setup:**\ Go to your wallet > “Add Network” or “Custom RPC” and enter: * **Network Name:** Hyperliquid * **Chain ID:** 999; any other number will land to testnet * **RPC URL:** * **Currency Symbol:** HYPE * **Block Explorers (optional):** * (preferred) * *
# Get Your Name Step-by-step guide to minting your .hype identity. This guide walks you through every step of the whitelist minting process on dotHYPE. ## What you'll Need Before you begin, make sure you’ve got: * **A wallet** (like MetaMask, Rabby, or Frame) * **Some $HYPE** on HyperEVM\ (You'll use $HYPE to pay for your name based on USD-pegged pricing) * **A name in mind**\ (Availability will be checked during the process) ## Step-by-Step: How to Mint a Name {% stepper %} {% step %} ### Step 1: Connect Your Wallet Click the “Connect Wallet” button on the minting page.\ You’ll see your wallet address appear once connected. This is the wallet that will own the name. {% endstep %} {% step %} ### 🔍 Step 2: Search for a Name Type your desired name into the search bar (e.g., `yourname.hype`).\ The system will check real-time availability and show the corresponding price. | Name Length | Price (USD in $HYPE) | | ------------- | -------------------- | | 3 characters | $40 | | 4 characters | $24 | | 5+ characters | $12 | | {% endstep %} | | {% step %} ### ✍️ Step 3: Confirm Your Name If available, click **“Mint Name”**. This prepares a transaction to mint the name directly to your wallet.\ You’re not sending a transaction yet just signing a message that locks your intent to mint. {% endstep %} {% step %} ### 💸 Step 4: Complete the Mint Once signed, you’ll see a “Confirm Mint” button. This triggers the onchain mint, and you’ll pay in $HYPE. Make sure your wallet has enough $HYPE to cover the mint price + gas. Any additional $HYPE not used will be refunded. {% endstep %} {% step %} ### 🎉 Step 5: Success Congrats! You now own a `.hype` name, fully on-chain! You’ll see: * Your name in the UI * A confirmation banner with a link to view on block explorer * Option to personalize your name (avatar, bio, records) {% endstep %} {% endstepper %} Now that you have your .hype name, see [what you can do today](/quickstart/introduction-to-dothype/what-you-can-do-today) # What You Can Do Today Your .hype name is usable the moment it’s minted. ### 🔍 Reverse Resolution At launch, `.hype` lets you choose how much (or how little) you want to share. Whether you're privacy-focused and just want a human-readable name for receiving funds, or you're building a full public identity with links, metadata, and delegation - **you control what’s visible, meaningful, and connected.** Each feature you use becomes part of a larger identity graph over time to **enhance discoverability, coordination, and trust -** when you choose to lean into it. ### ✅ Replace Your 0x Address with a Name Long wallet addresses are unreadable and impersonal. Sharing them feels cold—and checking them is error-prone. With `.hype`, your wallet becomes human: * Instead of `0x1f7a…e4A9`, you send and receive using `.hype` * You can reference people by name in leaderboards and dashboards if the dApp has integrated `.hype` resolution **“Where does this work?”**\ If a HyperEVM dApp supports `.hype` resolution, your `.hype` name resolves **automatically.** 🔍 Example: A HyperEVM explorer or DeFistaking dashboard that uses `.hype` resolution will display your `.hype` name natively instead of your wallet address. ### 🎨 **Customize Your Identity Metadata** **“Why would I care about metadata?”**\ Think of it like filling in your profile on LinkedIn or GitHub. Except this profile is **onchain -** portable, provable, and composable: * Add a **Twitter handle**, **GitHub link**, or **bio** * Set an **avatar image** that becomes your identity across apps * Attach a **website** or project link that makes it easier to find or trust you **“Why does this matter now?”**\ Even if there aren’t rich profile pages at launch, you’re creating a discoverable surface for integrations and tools down the line. It’s your identity seed. ### 🔗 **Delegate Control Across Wallets** **“Why split name and wallet?”**\ Most people use different wallets for different things - cold storage, trading, DAO voting, etc. dotHYPE lets you: * Assign your `.hype` name to a **secondary wallet** for safety * Represent a DAO, multi-sig, or protocol with one name, while operations happen from different addresses **“What does that unlock?”**\ This is key for teams, devs, and pseudonymous users. You stay consistent without tying everything to one key. ### **Coming Soon in Phase 2:** * .hype-aware partner dApps * Enhanced Metadata Custimization * Community leaderboard for early holders * Embedded `.hype` lookups in HyperEVM dashboards # Customizing Your Identity Make your name more than a label - make it a reflection of who you are. Once you've minted your `.hype` name, you can personalize it with metadata, visual assets, and text fields. This not only makes your identity expressive - it also makes it legible to other dApps and dashboards. ### 🎭 Set an Avatar * Choose from a selection of backgrounds (initial options: first 1,000 get a special version) * Upload an image or select a preset (if/when offchain avatar hosting is enabled) ### 📝 Add Text Records * Twitter handle, website, GitHub profile * Any other metadata you want publicly associated with your name * Compatible with ENS-style `text()` records ### 🪪 Claim Your Primary Name * Set your `.hype` name as your default reverse record so it shows up in wallet UIs and supported apps ### 🔗 Visibility in Ecosystem * When integrations go live, your name + metadata will display directly in partner protocols (e.g. Hyperswap trading profile) * Text records can be queried by bots, dashboards, or other apps for identity display > Every personalization adds structure and visibility to your onchain identity. # What's Coming Next dotHYPE isn’t just a naming service. It’s modular identity infrastructure. As we grow, we’re focused on building **structured identity,** where your name is not only an address, but also reflection of your role, reputation, and connections across the ecosystem. These are all things you can choose to opt-into as we develop the identity focused infrastructure to make your HyperEVM more seamless and secure. We’re ultimately expanding `.hype` into powerful tools for coordination and identity: ### 🧩 Composable Identity Layers We're designing identity primitives that allow protocols to define and delegate structure: team namespaces, DAO roles, multi-vault operations wrapped into readable, queryable sub-identities. ### 🧠 Interoperable Metadata Future phases will introduce contextual, role-aware metadata. Think of `.hype` names as smart containers that express what a user or entity *does*, not just who they are, that will unlock new levels of interaction, incentives, and UX focused usability across the ecosystem. ### 🔎 Legibility Across Ecosystems We're exploring ways to surface name-linked behavior and alignment, so `.hype` becomes a trusted signal of activity, contribution, or governance standing across dashboards, bots, and smart contracts. ### 🔐 Access & Permissions Made Simple We’re researching flexible tools that let protocols use `.hype` names to manage access, delegate permissions, and trigger actions without needing complex smart contracts. > The future of dotHYPE is intentionally modular and composable. Our roadmap is guided by ecosystem need from the voice of the end user. ### :trophy: Leaderboard system More details to come soon ;) Want to help shape what’s next? Join our community → [Discord](/official-links) # Principles Learn what dotHYPE is, why identity matters, and how modular naming unlocks reputation, clarity, and composability. Naming in Web3 has been reduced to vanity. We believe it should be about legibility, structure, and coordination. At dotHYPE, we returned to first principles: what does identity infrastructure require in a modular, high-performance ecosystem like HyperEVM? Our conclusions shaped every layer of our stack: * **Modularity**: Registry, controller, and resolver are isolated components - independently upgradeable and designed to avoid monolithic bloat. * **Composability > Coupling**: We respect ENS where it enhances interoperability, but discard legacy router patterns and static assumptions. * **Permissionless by Default**: Access is fair, cryptographically verifiable, and free from gatekeeping. * **Community-Aligned**: Roadmap is shaped in partnership with builders. Feedback is and keeping a close pulse to the voice of the user is paramount. Names in dotHYPE aims to transcend its familiar limitations. They are containers for metadata, anchors of reputation, and primitives for coordination. We believe defaults encode values. That’s why our architecture reflects a moral stance as much as a technical one: sustainability over speculation, openness over opacity, structure over chaos. Most systems retrofitted identity into rigid models. We started clean: modular, interoperable, and extensible from day one. # Team Vision We are builders, but also stewards. Community at the core, product and execution focused. We understand that building naming infrastructure is a long-term commitment to the clarity, agency, and composability of an entire ecosystem. Mistakes are inevitable. But accountability, transparency, and principled iteration are how we navigate tradeoffs. At dotHYPE, we’ve paced our rollout in conversation with the ecosystem - not to engineer momentum, but to deepen alignment. From DeFi vault architects to middleware builders, we’ve gathered insights not from retrospectives, but from the road itself. We believe identity is an enabling surface, a protocol primitive. We believe names can be used to encode purpose, designate function, and streamline interactions between agents, humans, and protocols alike. Rather than chasing early attention, we focused on credibility. That meant engineering for clarity. Listening before declaring. Designing with others, not just for them. We are a team that values precision. Not in pursuit of perfection, but to avoid the silent drift that erodes systems over time. The result is infrastructure shaped by stewardship. We’re not here to build fast. We’re here to build what lasts. # Product Philosophy “If you’re going to build it, build it right.” Infrastructure should do more than serve today’s needs. It should shape tomorrow’s possibilities. dotHYPE is built with modularity at its core. We chose to reimagine, in particular respecting what worked well and forgoing what didn't with more modern approaches. ENS set a strong precedent, but its router-based model strains under evolving demands. We retained the essentials such as its resolution standards, ERC-721 NFT-based ownership and left behind the baggage that hindered progress. Our starting point is dialogue that's deeply immersed with builders in the ecosystem. We met with protocol founders, infra architects, and dApp developers to understand the real bottlenecks they faced. The signal was clear: the ecosystem didn’t need another vanity layer. It needed structure, legibility, and durable trust to build a user experience worthy in the Hyperliquid ecosystem aiming to be the "Future of Finance". # Roadmap An honest look at what comes next. How we’re extending dotHYPE beyond names to unlock deeper identity, richer integrations, and a modular ecosystem that grows through deliberate iteration. The future of identity isn't something we expect to achieve in a single release. It’s a long-term, purpose-driven journey. What launches today is the foundational layer of a much broader vision: a modular identity protocol that can evolve alongside the HyperEVM ecosystem. We’ve intentionally focused on doing the basics right: clean architecture, standard resolution, principled minting so that future layers can be built with confidence and without compromise. Real identity infrastructure is iterative. It needs to be tested, stressed, and informed by how people actually use it. That’s why post-launch, our priorities shift toward listening, integrating, and extending. **Here’s what comes next:** * **Integration Support for HyperEVM Protocols**\ We’re working closely with our launch and post-launch partners to embed `.hype` resolution across their respective applications. This means leaderboard visibility, dashboard presence, user filtering, and other ways to give names real semantic weight. Every integration brings us closer to making identity actionable and legible by default. * **Infrastructural and Metadata Refinement**\ Our next major technical layer involves subgraph indexing and schema standardization. This unlocks structured metadata for names, enabling things like role tagging, reputation, and credential-based coordination. Think of this as the second foundation: not just who you are, but what you represent, fully onchain. * **UX and Design Optimization**\ Identity should be intuitive and we recognize that needs to be developed with an active userbase. We’ll be refining our mint flows, profile displays, and SDK integration points so that `.hype` names are functional, frictionless, and expressive in every interface that supports it. * **Deeper Integration with Strategic Partners**\ Our beta-phase R\&D begins here. We’ll work hand-in-hand with key partners to explore advanced identity use cases such as delegation flows, vault-level trust, and even digital passports that evolve over time. These partnerships will shape how identity in HyperEVM moves from static label to living credential. By building modularly and deploying iteratively, we’re ensuring that dotHYPE launches with a product first focus that is informed by true UX necessity. The next chapter is about layering meaning, trust, and utility into every name. # Build with dotHYPE Integrate Identity. Resolve with Confidence. #### **Whether you're building a wallet, dashboard, or on-chain application, integrating .hype domains helps your users move from raw addresses to structured, readable identity.** Our resolver is fully on-chain, ENS-compatible, and designed without centralized gatekeepers so you can plug-in with confidence. Everything is modular and upgrade-ready, giving us a stable foundation today and flexibility for tomorrow. ### What You Can Do * **Resolve Names to Addresses** * **Read On-chain Text Records** (e.g. Twitter, avatar) * **Support Reverse Resolution** * **Query Ownership via ERC721** ### Start Integrating **→ Resolver Reference**\ Includes ABI, contract address, and example calls (`addr()`, `text()`, `name()`). **→ Integration Examples (Coming Soon)**\ Code snippets for Ethers.js / Web3.js / React environments. ### SDK (Coming Soon) Our JS/TS SDK will simplify: * Name availability + resolution * Minting hooks * React-ready UI components Ready to build with dotHYPE? → [Get Started with the Resolver](/integrating-.hype/build-with-dothype/how-to-get-.hype-integrated-in-your-dapp) # How to get .hype integrated in your dApp This guide will help you integrate resolution into your HyperEVM application using our contract, with a real-world example for customizing your wallet connect UI. ### **Use `.hype` Names in Your App** The dotHYPE resolver is fully ENS-compatible, making integration simple for developers already familiar with Ethereum naming systems. You can use standard `addr()`, `getName()`, and `text()` calls to resolve identity information from `.hype` domains. No proprietary logic required. ### Basic Usage To resolve `.hype` names, use the d**otHYPEResolver** contract and the following standard functions: | Function | Purpose | | -------------------------------- | ------------------------------------------------ | | `addr(bytes32 node)` | Returns the address for a `.hype` name | | `getName(address)` | Returns the primary `.hype` name for a wallet | | `text(bytes32 node, string key)` | Returns a text record (e.g. `twitter`, `avatar`) | > Note: The `node` refers to the ENS-compatible **namehash** of the `.hype` domain. # Custom Connect Button Display .hype Names Instead of Wallet Addresses This component enhances your RainbowKit wallet connection UX by displaying the user's primary `.hype` name (if set) instead of a truncated address. It works seamlessly across HyperEVM mainnet and testnet, supports loading states, and falls back to address when no name is set. ### Step 1. Overview & Purpose This custom component: * Replaces wallet addresses with `.hype` domains * Uses the `DotHypeResolver.name(address)` function * Falls back to the address if no primary name is set * Detects network automatically via chain ID * Supports full styling customization > **⚠️ Important:**\ > **Replace the placeholder contract addresses in the code with your actual deployed resolver addresses (see `/info` page for details).** ### **Step 2.** CustomConnectButton.tsx
Full Code ```tsx import { useState, useEffect, useCallback } from "react"; import { ConnectButton } from "@rainbow-me/rainbowkit"; import { usePublicClient } from "wagmi"; import { Address } from "viem"; import { getCurrentNetworkAddresses } from "@/contracts/addresses"; import { DOT_HYPE_RESOLVER_ABI } from "@/contracts/abis"; /** * Custom ConnectButton that shows primary domain name instead of truncated address * when a primary domain is set for the connected wallet */ export function CustomConnectButton() { return ( {({ account, chain, openAccountModal, openChainModal, openConnectModal, authenticationStatus, mounted, }) => { // Note: If your app doesn't use authentication, you // can remove all 'authenticationStatus' checks const ready = mounted && authenticationStatus !== "loading"; const connected = ready && account && chain && (!authenticationStatus || authenticationStatus === "authenticated"); return (
{(() => { if (!connected) { return ( ); } if (chain.unsupported) { return ( ); } return (
); })()}
); }} ); } /** * Account button component that shows primary domain or truncated address */ interface AccountButtonProps { account: { address: string; displayBalance?: string; }; openAccountModal: () => void; } function AccountButton({ account, openAccountModal }: AccountButtonProps) { const { primaryDomain, isLoading: primaryDomainLoading } = usePrimaryDomain( account?.address as Address ); const { avatar, isLoading: avatarLoading } = useUserAvatar( account?.address as Address ); const displayText = primaryDomain || `${account.address.slice(0, 6)}...${account.address.slice(-4)}`; const showBalance = account.displayBalance ? ` (${account.displayBalance})` : ""; const isLoading = primaryDomainLoading || avatarLoading; return ( ); } /** * Avatar image component with fallback */ interface AvatarImageProps { src: string; } function AvatarImage({ src }: AvatarImageProps) { const [hasError, setHasError] = useState(false); if (hasError) { return (
); } return ( User avatar setHasError(true)} /> ); } // Hook implementations used in the CustomConnectButton above /** * Hook to fetch the primary domain name for an address using the getName function * @param address - The Hyperliquid address to get the primary domain for */ export function usePrimaryDomain(address?: Address): { primaryDomain: string | null; isLoading: boolean; error: string | null; refetch: () => Promise; } { const [primaryDomain, setPrimaryDomain] = useState(null); const [isLoading, setIsLoading] = useState(false); const [error, setError] = useState(null); const publicClient = usePublicClient(); const addresses = getCurrentNetworkAddresses(); const resolverAddress = addresses.DOT_HYPE_RESOLVER as Address; const fetchPrimaryDomain = useCallback(async () => { if (!publicClient || !address) { setPrimaryDomain(null); setIsLoading(false); setError(null); return; } setIsLoading(true); setError(null); try { // Call getName function on the resolver const domainName = await publicClient.readContract({ address: resolverAddress, abi: DOT_HYPE_RESOLVER_ABI, functionName: "getName", args: [address], }); // Check if we got a valid domain name if ( domainName && typeof domainName === "string" && domainName.trim() !== "" ) { setPrimaryDomain(domainName); } else { setPrimaryDomain(null); } } catch (err) { console.error("Error fetching primary domain:", err); // Handle specific error cases let errorMessage = "Failed to fetch primary domain"; if (err instanceof Error) { if (err.message.includes("execution reverted")) { errorMessage = "No primary domain set for this address"; } else if (err.message.includes("OpcodeNotFound")) { errorMessage = "Resolver contract does not support getName function"; } else { errorMessage = err.message; } } setError(errorMessage); setPrimaryDomain(null); } finally { setIsLoading(false); } }, [address, publicClient, resolverAddress]); useEffect(() => { fetchPrimaryDomain(); }, [fetchPrimaryDomain]); return { primaryDomain, isLoading, error, refetch: fetchPrimaryDomain, }; } /** * Hook to fetch the user's avatar from their primary domain's text records * Uses the resolver's getValue function to get the avatar directly by address */ export function useUserAvatar(address?: Address): { avatar: string | null; isLoading: boolean; error: string | null; } { const [avatar, setAvatar] = useState(null); const [isLoading, setIsLoading] = useState(false); const [error, setError] = useState(null); const publicClient = usePublicClient(); useEffect(() => { if (!address || !publicClient) { setAvatar(null); setIsLoading(false); setError(null); return; } const fetchAvatar = async () => { setIsLoading(true); setError(null); try { const { DOT_HYPE_RESOLVER } = getCurrentNetworkAddresses(); // Use getValue to get the avatar text record directly by address const avatarValue = (await publicClient.readContract({ address: DOT_HYPE_RESOLVER as `0x${string}`, abi: DOT_HYPE_RESOLVER_ABI, functionName: "getValue", args: [address, "avatar"], })) as string; // Only set avatar if it's a valid non-empty string if (avatarValue && avatarValue.trim() !== "") { setAvatar(avatarValue.trim()); } else { setAvatar(null); } } catch (err) { console.warn("Error fetching user avatar:", err); setAvatar(null); setError(err instanceof Error ? err.message : "Failed to fetch avatar"); } finally { setIsLoading(false); } }; fetchAvatar(); }, [address, publicClient]); return { avatar, isLoading, error, }; } ```
### Step 3. CSS Styles
Styles.css ```css /* CSS Styles for Components */ /* Connect Button Styles */ .connect-button { background: linear-gradient(135deg, #6366f1, #8b5cf6); color: white; padding: 8px 24px; border-radius: 8px; font-weight: 500; border: none; cursor: pointer; transition: all 0.2s ease; box-shadow: 0 4px 6px rgba(0, 0, 0, 0.1); } .connect-button:hover { background: linear-gradient(135deg, #8b5cf6, #6366f1); box-shadow: 0 6px 12px rgba(0, 0, 0, 0.15); } .wrong-network-button { background: #ef4444; color: white; padding: 8px 16px; border-radius: 8px; font-weight: 500; border: none; cursor: pointer; transition: background-color 0.2s ease; } .wrong-network-button:hover { background: #dc2626; } .connected-container { display: flex; align-items: center; gap: 12px; } .chain-button { display: flex; align-items: center; gap: 8px; background: rgba(156, 163, 175, 0.1); padding: 8px 12px; border-radius: 8px; border: none; cursor: pointer; transition: background-color 0.2s ease; font-size: 14px; } .chain-button:hover { background: rgba(156, 163, 175, 0.2); } .chain-icon { width: 20px; height: 20px; border-radius: 50%; } .account-button { display: flex; align-items: center; gap: 8px; background: white; border: 1px solid #d1d5db; padding: 8px 16px; border-radius: 8px; cursor: pointer; transition: all 0.2s ease; box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1); } .account-button:hover { background: #f9fafb; } .account-info { display: flex; align-items: center; gap: 8px; } .status-indicator { width: 8px; height: 8px; background: #10b981; border-radius: 50%; } .loading-spinner { width: 16px; height: 16px; border: 2px solid #e5e7eb; border-top: 2px solid #6366f1; border-radius: 50%; animation: spin 1s linear infinite; } @keyframes spin { to { transform: rotate(360deg); } } /* Address Input Styles */ .address-input-container { width: 100%; } .input-label { display: block; font-size: 14px; font-weight: 500; color: #374151; margin-bottom: 8px; } .input-wrapper { position: relative; } .address-input { width: 100%; padding: 12px 40px 12px 12px; border: 1px solid #d1d5db; border-radius: 8px; font-size: 14px; transition: all 0.2s ease; background: white; } .address-input:focus { outline: none; border-color: #6366f1; box-shadow: 0 0 0 3px rgba(99, 102, 241, 0.1); } .address-input.loading { border-color: #3b82f6; } .address-input.valid { border-color: #10b981; } .address-input.error { border-color: #ef4444; } .input-status-icon { position: absolute; right: 12px; top: 50%; transform: translateY(-50%); font-size: 16px; } .status-message { margin-top: 4px; font-size: 14px; display: flex; align-items: center; gap: 4px; } .status-message.loading { color: #3b82f6; } .status-message.success { color: #10b981; } .status-message.error { color: #ef4444; } .resolution-display { margin-top: 8px; padding: 12px; border-radius: 6px; font-size: 14px; } .resolution-display.domain { background: rgba(59, 130, 246, 0.1); border: 1px solid rgba(59, 130, 246, 0.2); } .resolution-display.address { background: rgba(16, 185, 129, 0.1); border: 1px solid rgba(16, 185, 129, 0.2); } .resolution-content { display: flex; align-items: center; gap: 8px; } .avatar-thumbnail { width: 24px; height: 24px; border-radius: 4px; border: 1px solid rgba(0, 0, 0, 0.1); object-fit: cover; flex-shrink: 0; } .resolution-value { font-family: monospace; word-break: break-all; color: #1f2937; flex: 1; } .help-text { margin-top: 4px; font-size: 12px; color: #6b7280; } /* Dark mode styles */ :global(.dark) .chain-button { background: rgba(75, 85, 99, 0.5); color: #f3f4f6; } :global(.dark) .account-button { background: #1f2937; border-color: #374151; color: white; } :global(.dark) .account-button:hover { background: #111827; } :global(.dark) .address-input { background: #1f2937; border-color: #374151; color: white; } :global(.dark) .input-label { color: #d1d5db; } :global(.dark) .help-text { color: #9ca3af; } :global(.dark) .resolution-value { color: #f3f4f6; } ```
### Step 4. Usage Example
TSX ```tsx import { CustomConnectButton } from './CustomConnectButton'; import { useChainId } from 'wagmi'; function App() { const chainId = useChainId(); return (
); } ```
### :warning:Pro Tip > The component automatically detects the network based on the chain Id prop. **Chain ID 999** is used for HyperEVM mainnet, while **any other value** defaults to testnet. # Tools & Community Ask questions, explore terminology, or get involved with the dotHYPE community. * FAQ & glossary * Community links (Telegram, Twitter, Discord) * Governance principles * Audit and bounty transparency # Official Links Only use the official links below for accurate and up-to-date information about dotHYPE. Be cautious of scams, impersonators, or unofficial sources. Always verify you’re on a trusted domain before int * 🌐 Website: [https://dothype.io](https://dothype.io/) * 💬 Discord: * 🐦 X (Twitter): [https://x.com/d0thype](https://x.com/d0tHYPE) # Terms & Conditions Version 1.01 Effective Date: 2025-07-11 ; Last Updated: 2025-07-16 ### 1. Introduction Welcome to dotHYPE, a decentralized naming and identity protocol purpose-built for the Hyperliquid and HyperEVM ecosystems. dotHYPE allows users to register human-readable names (e.g., yourname.hype) that resolve to wallet addresses, metadata, and smart contract interactions. These names serve as onchain identifiers for individuals, DAOs, vaults, strategies, and other decentralized entities. The Service includes: * Immutable name registration via blockchain smart contracts, * ENS-compatible resolution for wallets, websites, and metadata, * Structured identity tools for decentralized applications and frontends, * Tiered pricing for name registration based on character length. dotHYPE is non-custodial, permissionless, and modular by design. It does not moderate or verify submitted names, nor does it arbitrate disputes. Once a name is registered and finalized on-chain, it becomes a permanent and public record. The Service is operated by dotHYPE LLC, a Delaware-registered limited liability company. By accessing or using any part of the Service including searching, connecting a wallet, or registering a name, you agree to be bound by these Terms & Conditions. If you do not agree to be bound by these Terms and Conditions, you are prohibited from accessing, registering for, or otherwise using the Services in any manner. For information on how we collect, use, or retain any off-chain metadata or wallet interaction logs, please refer to our Privacy Policy. This document will govern all data-related matters not addressed in these Terms. ### 2. Nature of the Protocol dotHYPE is a non-custodial, decentralized, and permissionless protocol. It allows users to register human-readable identifiers (.hype names) that resolve to blockchain addresses, metadata, and other information. These identifiers are publicly visible, on-chain, and immutable. While the protocol is permissionless in its public phases, dotHYPE may pre-reserve a limited subset of names for strategic purposes such as partnership allocations, community rewards, or technical bootstrapping. These reservations are finite, transparently managed, and do not affect the integrity or decentralization of the broader protocol. dotHYPE does not pre-moderate user-submitted names in open minting phases. User registrations are immutable once finalized on-chain, and dotHYPE LLC does not act as a content moderator or arbitrator of naming disputes. ### 3. User Responsibilities By using the Service, you agree that: * You are solely responsible for any name, metadata, or content you submit or register. * You will not register names that: * Infringe any copyright, trademark, or intellectual property rights; * Impersonate any person or entity; * Are misleading, defamatory, abusive, hateful, threatening, or otherwise unlawful. * You acknowledge that: * All registrations are public and permanent; * dotHYPE does not remove or alter names post-registration; * You are solely liable for any legal claims that arise from your name usage. You agree to use the Service in compliance with all applicable laws and regulations in your jurisdiction. ### 4. Intellectual Property and Disputes dotHYPE LLC: * Does not adjudicate or resolve intellectual property disputes; * Does not verify ownership of trademarks or brands; * Does not endorse or approve any registered name. * May publish a public list of reserved names for transparency. However, we reserve the right (but not the obligation) to: * Comply with a valid legal order by a U.S. court or government authority; * Limit visibility or functionality of a name in cases of: * Proven legal infringement; * Fraud, impersonation, or systemic abuse. These actions do not constitute name censorship or moderation and are implemented only in rare, clearly documented legal cases. ### 5. Indemnification You agree to indemnify, defend, and hold harmless dotHYPE LLC, its developers, officers, affiliates, and agents from and against all third-party claims, damages, liabilities, losses, costs, or expenses (including reasonable legal fees) arising out of or relating to: * Your use of the Service; * Any name or metadata you submit or register; * Any violation of these Terms or applicable law; * Any claim that a name you register infringes a third party’s rights. The provisions of this clause shall survive any termination or expiration of these Terms and shall remain in full force and effect. ### 6. Disclaimers In addition to all other disclaimers provided in this document, dotHYPE disclaims responsibility for the outcomes of any interactions users may have with third-party tools or services that interface with the protocol. Users are solely responsible for ensuring the integrity of their on-chain actions and off-chain integrations. THE SERVICE IS PROVIDED “AS IS” AND “AS AVAILABLE,” WITHOUT WARRANTIES OF ANY KIND - EXPRESS, IMPLIED, OR STATUTORY. WE DISCLAIM ALL WARRANTIES, INCLUDING BUT NOT LIMITED TO: * MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE, * NON-INFRINGEMENT, * ACCURACY, * SECURITY, * AVAILABILITY, * OR THAT THE SERVICE WILL BE ERROR-FREE OR UNINTERRUPTED. You acknowledge and agree that your use of the Service is at your sole risk. The Service is provided on an 'as is' and 'as available' basis without warranties of any kind. You further understand and accept that blockchain protocols and related technologies may be subject to vulnerabilities, including but not limited to software bugs, security breaches, hacks, hard or soft forks, network downtime, or other systemic failures that are beyond the control of dotHYPE. dotHYPE shall not be held liable for any losses or damages arising from such events. ### 7. Limitation of Liability To the fullest extent permitted by law: dotHYPE LLC and its affiliates will not be liable for any indirect, incidental, special, consequential, punitive, or exemplary damages arising from: * Your use or inability to use the Service; * Any errors or delays in smart contract operation; * Loss of funds, names, or digital assets; * Third-party actions, legal claims, or service incompatibilities. Total liability shall not exceed the amount paid by you (if any) directly to dotHYPE LLC in connection with the Service. ### 8. Payments and Fees * All payments are processed in supported digital assets (e.g., $HYPE, USDTo). * No fiat payments are accepted. * All transactions are final. No refunds will be issued except where explicitly outlined in promotional campaigns or special programs. * Prices and fees may fluctuate based on token price, auction mechanics, or market conditions. ### 9. Technical Risks & Service Availability * dotHYPE provides no guarantees about: * Availability of any name; * Uptime or performance of the Service; * Compatibility with wallets, browsers, or external applications. You acknowledge and accept the risks associated with using blockchain-based applications, including: * Failed transactions, * Congestion or downtime, * Incompatibility with third-party tools, * On-chain slippage in pricing or renewals. ### 10. Prohibited Conduct You may not: * Use bots or automated scripts to mass-register names unless explicitly authorized; * Exploit contract vulnerabilities or front-running opportunities; * Attempt to interfere with or harm the protocol; * Violate applicable laws, regulations, or third-party rights. We reserve the right to restrict access for users engaging in prohibited conduct, in accordance with applicable laws. ### 11. No Endorsement dotHYPE LLC does not endorse, sponsor, or certify any user, project, or entity based on their name registration. The presence of a name in the protocol does not imply legitimacy, affiliation, or quality. ### 12. Governing Law & Dispute Resolution These Terms are governed by the laws of the State of Delaware, USA, without regard to its conflict-of-law principles. Binding Arbitration: Any dispute or claim shall be resolved exclusively through binding arbitration administered in Delaware.\ No Class Actions: You waive the right to participate in any class action or class-wide arbitration. ### 13. Changes to the Terms dotHYPE may revise these Terms at any time. Updates will be posted with a new “Last Updated” date. Where material changes are made, we will post a notice on our website and maintain a version history log for reference. Continued use of the Service after such changes constitutes your acceptance of the revised Terms. ### 14. Age Restrictions The Service is intended for individuals 18 years of age or older. We do not knowingly collect data from individuals under 18. If such data is discovered, it will be deleted promptly. ### 15. Entire Agreement These Terms constitute the entire agreement between you and dotHYPE LLC concerning the use of the Service. If any provision is deemed unenforceable, the remaining terms shall remain in effect. This agreement does not create any agency, partnership, or joint venture relationship. Any failure by dotHYPE LLC to enforce any provision shall not constitute a waiver of that provision. ### 16. Force Majeure dotHYPE LLC shall not be held liable for any failure or delay in performance under these Terms due to causes beyond its reasonable control, including but not limited to: acts of God, natural disasters, war, terrorism, civil unrest, labor shortages, governmental actions, regulatory changes, blockchain network failures, smart contract exploits, or widespread internet outages. In such events, dotHYPE reserves the right to suspend or modify parts of the Service without liability or notice until normal operations can resume. ### 17. Contact For legal inquiries, including those related to trademarks, intellectual property, or arbitration notices, please contact:
# Privacy Policy Version: 1.01 Effective Date: 2025-07-11 ; Last Updated: 2025-07-16 ### 1. Introduction This Privacy Policy explains how dotHYPE LLC, a Delaware-registered limited liability company ("dotHYPE," "we," "our," or "us"), collects, uses, shares, and protects personal and pseudonymous data in connection with your use of the dotHYPE protocol, website, and smart contracts (collectively, the "Service"). This policy is designed to comply with: * The General Data Protection Regulation (GDPR), * The California Consumer Privacy Act (CCPA) and California Privacy Rights Act (CPRA), * Emerging Web3 privacy expectations for decentralized and wallet-based applications. By connecting a wallet, interacting with the protocol, or otherwise using the Service, you consent to the practices outlined herein. This Privacy Policy should be read in conjunction with our Terms & Conditions, which govern your use of the Service and include additional disclaimers and limitations relevant to your data and identity interactions. ### 2. Information We Collect #### a. On-Chain Data (Public) The following data is stored permanently and publicly on blockchain networks: * Wallet addresses * Name registrations and metadata * Smart contract interactions (e.g., mints, renewals, transfers) This data is immutable and accessible to anyone. dotHYPE does not control how third parties access or interpret this data. #### b. Off-Chain Data (Controlled by dotHYPE) We may collect or process limited off-chain data: For clarity, we do not collect any directly identifiable personal information (PII) such as names, emails, physical addresses, government IDs, or account logins. All interactions occur via self-custodied wallets and are pseudonymous by design. | Data Type | Purpose | | -------------------------------------- | ------------------------------------------------------------------------------- | | Wallet snapshots | To verify allowlist eligibility during pre-mint phases | | Wallet metadata (timestamp, signature) | To confirm mint eligibility or prevent abuse | | IP address, browser, device type | For fraud detection, security, and rate limiting (via services like Cloudflare) | | Anonymized analytics | To improve protocol performance and UX (via privacy-first tools like Plausible) | We do not collect names, emails, or other directly identifying information. ### 3. Legal Basis for Processing In accordance with GDPR Article 6, we process personal and pseudonymous data under the following legal bases: * Legitimate interest: to secure the protocol and prevent abuse. * Performance of a contract: to fulfill services tied to allowlist eligibility, minting access, or smart contract execution. ### 4. How We Use the Data We use collected data to: * Verify mint eligibility during allowlist and snapshot phases. * Enable fair access and prevent sybil attacks or wallet manipulation. * Improve protocol security, UX, and performance. * Comply with legal obligations or requests. We do not use collected data for profiling, behavioral advertising, or selling. ### 5. Sharing & Third-Party Processors We do not sell or rent your data. We may share limited data under these conditions: * With ecosystem partners who submit allowlists (e.g., wallet addresses only). * With infrastructure vendors (e.g., snapshot services, analytics providers) who act as data processors under formal Data Processing Agreements (DPAs). * With legal authorities if required by court order or valid legal process. All third-party service providers are contractually bound to uphold this policy. ### 6. Cross-Border Data Transfers If you are located in the European Economic Area (EEA), United Kingdom, or another jurisdiction with data transfer restrictions, please note: Your data may be transferred to and processed in the United States or other jurisdictions where we or our processors operate. Where required, we implement appropriate safeguards such as Standard Contractual Clauses (SCCs) to ensure adequate protection of your data. ### 7. Data Retention We retain off-chain data only as long as needed for the purpose for which it was collected. * Snapshot data is retained for no more than 60 days after a mint phase concludes. * Analytics and logs are periodically anonymized or purged. You may request deletion of any off-chain data by contacting . We cannot delete data that is stored immutably on a public blockchain. ### 8. Your Rights #### Under GDPR (EU/UK Residents): You may request: * Access to off-chain data we hold about your wallet * Rectification or deletion of off-chain data * Restriction of processing * Data portability (where applicable) #### Under CCPA/CPRA (California Residents): You have the right to: * Know what personal information we have collected * Request deletion of your data * Opt-out of data sharing (note: we do not share or sell user data) To exercise any of these rights, contact with the subject line “Privacy Request – \[Your Wallet Address]”. ### 9. Cookies and Analytics Our website may use: * Essential cookies for load balancing and wallet verification * Anonymized usage analytics via privacy-respecting tools like Plausible We do not use tracking pixels, fingerprinting tools, or behavioral ads. ### 10. Web3 User Considerations dotHYPE aligns with self-sovereign identity (SSI) principles by enabling users to participate without disclosing off-chain identities. As the Web3 privacy ecosystem matures, we may explore integrations with zero-knowledge credential frameworks that enhance selective disclosure and data minimization. While we encourage wallet hygiene, you should be aware that: * Wallet addresses are pseudonymous but traceable * Name registrations and smart contract interactions are public * Use of ENS-compatible resolvers may expose text records or avatars you configure We recommend avoiding storing personal identifiers in on-chain metadata. Should users choose to add personal data via ENS-compatible records or resolver metadata, they do so voluntarily and at their own risk. We cannot control or remove such data once written to the blockchain. ### 11. Updates to This Policy We may update this Privacy Policy as laws evolve or our Service changes. Each revision will include a new version number and updated "Last Updated" date. If updates are material, we will: * Update the “Last Updated” date * Notify users via the website or other appropriate channels ### 12. Contact Us For privacy-related concerns or to exercise your data rights, contact our Data Protection Officer (DPO) or authorized privacy representative at: You may also reach us at: dotHYPE LLC\ 8 The Green Suite B Dover, DE, US 19901\

# Logos {% file src="/files/by7NXzTQvr9AwwVypTNA" %} {% file src="/files/GiN8FbhHeh5zS7tjJ9QA" %} {% file src="/files/7TDr9BeEzEef0IsT9jBE" %} {% file src="/files/JqZIRETAVYvEMcUYAgbp" %}