Integrate .robin names.

Robin is the ENS-standard naming layer for Robinhood Chain. It 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. Integration is a config line, not an SDK adoption project.

The highest-leverage integration is reverse resolution: wherever your UI renders 0x71C7…9F2b, render trader.robin instead.

viem / wagmi — one line.

import { createPublicClient, http } from "viem";
import { robinhoodChainTestnet } from "robin-names"; // ← the one line

const client = createPublicClient({ chain: robinhoodChainTestnet, transport: http() });

// reverse: address → name (do this in your UI)
await client.getEnsName({ address: "0x71C7656EC7ab88b098defB751B7401B5f6d8976F" });
// → "trader.robin"

// forward: name → address (payments, transfers, search)
await client.getEnsAddress({ name: "trader.robin" });

// profile records
await client.getEnsText({ name: "trader.robin", key: "com.twitter" });
await client.getEnsAvatar({ name: "trader.robin" });

With wagmi, pass the chain into your config and use the stock hooks — useEnsName, useEnsAddress, useEnsText, useEnsAvatar. Nothing else changes. Already have your own chain object? Wrap it: withRobin(myChainConfig).

The robin-names SDK lives at packages/sdk in the repo.

Without the SDK.

The SDK is convenience, not dependency. Point any ENS-aware library at Robin's registry and UniversalResolver — addresses below, verified on Blockscout:

import { defineChain } from "viem";

const robinhoodTestnet = defineChain({
  id: 46630,
  name: "Robinhood Chain Testnet",
  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
  rpcUrls: { default: { http: ["https://rpc.testnet.chain.robinhood.com"] } },
  contracts: {
    ensRegistry: { address: "0x8705DEC51223E119C5C9f03121626d086A8eF753" },
    ensUniversalResolver: { address: "0x7112730612e4253Ba2e418A86580615A2c3CDB1D" },
    multicall3: { address: "0xcA11bde05977b3631167028862bE2a173976CA11" },
  },
});

ethers v6: new JsonRpcProvider(rpc, { chainId: 46630, name: "robinhood-testnet", ensAddress: "0x8705…F753" }).

Solidity — resolve on-chain.

// Forward-resolve in a contract via the registry (ERC-137):
ENS registry = ENS(0x8705DEC51223E119C5C9f03121626d086A8eF753);
address resolver = registry.resolver(node);
address target = Resolver(resolver).addr(node);

Or call UniversalResolver.resolve(dnsEncodedName, calldata) for one-call resolution including wildcard support.

UX rules — match ENS behaviour so users trust the result.

1. Always forward-check the reverse. After getEnsName(address), confirm getEnsAddress(thatName) returns the same address before displaying it (viem does this for you).
2. Normalize before hashing. Use ENSIP-15 (normalize from robin-names or viem/ens) on any user-typed name.
3. Names expire. A resolved name is valid now; don't cache it beyond your normal UI cache windows.

Indexed data.

For lists and search — names by owner, expiries, activity, auctions — the public GraphQL endpoint serves the chain's naming state:

api.dotrobin.xyz/graphql

curl -s https://api.dotrobin.xyz/graphql \
  -H "content-type: application/json" \
  -d '{"query":"{ names(orderBy: \"expiresAt\", orderDirection: \"desc\", limit: 20) { items { label owner expiresAt wrapped } totalCount } }"}'

CORS is open — call it straight from your dapp. Schema: indexer/ponder.schema.ts. Self-hosting is one command (ponder start) against any Robinhood Chain RPC.

Name your agents.

Robinhood Chain is built for agentic trading. Agents transact, hold funds, and talk to each other — they need what every actor on a chain needs: an addressable, verifiable identity. One parent name per operator; one subname per agent:

bot1.goldfinch.robin → the agent's smart account

1. Register and wrap your operator name. goldfinch.robin → wrap it (one click in the app, or RobinWrapper.wrapETH2LD). Wrapping turns your name into a parent that can issue subname tokens.
2. Issue a subname per agent. Subnames are real ERC-1155 tokens — transferable, sellable, revocable like any asset.

   RobinWrapper.setSubnodeOwner(
     namehash("goldfinch.robin"),
     "bot1",
     agentAccount,  // the agent's ERC-4337 smart account
     0,             // fuses — or PARENT_CANNOT_CONTROL to emancipate
     0
   )

   Then point it at the agent: PublicResolver.setAddr(node, agentAccount).
3. Give the agent a capability card — text records. Machine-readable profile, readable by any counterparty with one call:

   key	value
   url	the agent's API / A2A endpoint
   description	what this agent does
   agent.capabilities	comma-separated verbs: swap,lend,rebalance
   agent.model	model / runtime identifier
   agent.operator	goldfinch.robin — walk up to the human
   avatar	image URI

4. Set the agent's primary name. The agent's account calls ReverseRegistrar.setName("bot1.goldfinch.robin") (or use setNameForAddr while you control it). Every explorer and dapp that renders reverse resolution now shows the agent's name.

Verify a counterparty agent.

import { createPublicClient, http } from "viem";
import { robinhoodChainTestnet, namehash } from "robin-names";

const client = createPublicClient({ chain: robinhoodChainTestnet, transport: http() });

async function verifyAgent(claimedName, senderAddress) {
  const resolved = await client.getEnsAddress({ name: claimedName });
  if (resolved?.toLowerCase() !== senderAddress.toLowerCase()) return null;
  const operator = claimedName.split(".").slice(1).join(".");
  const endpoint = await client.getEnsText({ name: claimedName, key: "url" });
  const capabilities = await client.getEnsText({ name: claimedName, key: "agent.capabilities" });
  return { operator, endpoint, capabilities };
}

Addresses.

Robinhood Chain testnet, chainId 46630 — live now, verified on Blockscout. Free testnet ETH: faucet.testnet.chain.robinhood.com.

Robin on mainnet (chainId 4663) is not yet deployed. Addresses land in contracts/deployments/ — the deploy script's own record, so published addresses can never drift from what's on chain.