Docs

{
  "ok": true,
  "data": { ... },
  "meta": { "chain": "Robinhood", "chainId": 4663, "timestamp": "2024-01-01T00:00:00Z" }
}

// Errors:
{ "ok": false, "error": "Domain not found or not yet minted", "code": 404 }

// GET /api/resolve/alice
{
  "ok": true,
  "data": {
    "domain": "alice",
    "owner": "0xAbCd...1234",
    "tokenId": "42",
    "fullDomain": "alice.rob"
  },
  "meta": { "chain": "Robinhood", "chainId": 4663, "timestamp": "..." }
}

// GET /api/profile/alice
{
  "ok": true,
  "data": {
    "domain": "alice",
    "owner": "0xAbCd...1234",
    "tokenId": "42",
    "fullDomain": "alice.rob",
    "profile": {
      "bio": "Building on Robinhood Chain",
      "profilePicture": "https://...",
      "socialLinks": [{ "platform": "twitter", "url": "https://twitter.com/alice", "icon": "twitter" }],
      "customLinks": [{ "title": "My Website", "url": "https://alice.xyz" }]
    }
  }
}

// GET /api/owner/0xAbCd...1234
{
  "ok": true,
  "data": {
    "wallet": "0xAbCd...1234",
    "count": 3,
    "domains": [
      { "tokenId": "42", "domain": "alice", "fullDomain": "alice.rob" },
      { "tokenId": "57", "domain": "alicedev", "fullDomain": "alicedev.rob" }
    ]
  }
}

// GET /agent/status
{
  "ok": true,
  "status": "operational",
  "chain": "Robinhood",
  "chainId": 4663,
  "contracts": {
    "domainNFT": "0x37F7ba486afE8Be3C3C70A4FC3eCacC6DD51c6C8",
    "marketplace": "0xAefec6e65ADE8D95c0Cf69D20e9254556f6cC637"
  },
  "timestamp": "2026-07-21T00:00:00Z"
}

// POST /agent/tx/mint  { "domain": "alice" }
{
  "ok": true,
  "transaction": {
    "to": "0x37F7ba486afE8Be3C3C70A4FC3eCacC6DD51c6C8",
    "data": "0x...",
    "value": "500000000000000",
    "chainId": 4663
  },
  "domain": "alice",
  "fullDomain": "alice.rob",
  "mintFee": "0.0005 ETH"
}

npm install ethers viem @rainbow-me/rainbowkit wagmi

import { ethers } from "ethers";

const DOMAIN_NFT = "0x37F7ba486afE8Be3C3C70A4FC3eCacC6DD51c6C8";
const RPC        = "https://rpc.mainnet.chain.robinhood.com";

const DOMAIN_NFT_ABI = [
  "function getTokenIdByName(string) view returns (uint256)",
  "function ownerOf(uint256) view returns (address)",
  "function getFullDomainName(uint256) view returns (string)",
];

async function resolve(domain: string) {
  const provider = new ethers.JsonRpcProvider(RPC);
  const nft = new ethers.Contract(DOMAIN_NFT, DOMAIN_NFT_ABI, provider);

  const tokenId = await nft.getTokenIdByName(domain.replace(/\.rob$/, ""));
  if (tokenId === 0n) return null;

  const owner      = await nft.ownerOf(tokenId);
  const fullDomain = await nft.getFullDomainName(tokenId);
  return { owner, tokenId: tokenId.toString(), fullDomain };
}

const result = await resolve("alice");
console.log(result);
// → { owner: "0xAbCd…", tokenId: "42", fullDomain: "alice.rob" }

const RESOLVER_ABI = [
  "function reverseResolve(address) view returns (uint256, string, string)",
  "function hasPrimaryDomain(address) view returns (bool)",
];

async function reverseResolve(wallet: string) {
  const provider = new ethers.JsonRpcProvider(RPC);
  const resolver = new ethers.Contract(RESOLVER_ADDRESS, RESOLVER_ABI, provider);

  const has = await resolver.hasPrimaryDomain(wallet);
  if (!has) return null;

  const [tokenId, domainName, fullDomain] = await resolver.reverseResolve(wallet);
  return { tokenId: tokenId.toString(), domainName, fullDomain };
}

import { createPublicClient, http, defineChain } from "viem";

const robinhoodChain = defineChain({
  id: 4663,
  name: "Robinhood",
  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
  rpcUrls: { default: { http: ["https://rpc.mainnet.chain.robinhood.com"] } },
  blockExplorers: { default: { name: "Blockscout", url: "https://robinhoodchain.blockscout.com" } },
});

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

const tokenId = await client.readContract({
  address: "0x37F7ba486afE8Be3C3C70A4FC3eCacC6DD51c6C8",
  abi: [{ name: "getTokenIdByName", type: "function",
    inputs: [{ name: "domainName", type: "string" }],
    outputs: [{ name: "", type: "uint256" }], stateMutability: "view" }],
  functionName: "getTokenIdByName",
  args: ["alice"],
});

// Forward resolve
const res = await fetch("/api/resolve/alice");
const { data } = await res.json();
console.log(data.owner, data.tokenId);

// Reverse resolve
const r2 = await fetch("/api/reverse/0xAbCd...1234");
const { data: d2 } = await r2.json();
console.log(d2.fullDomain); // "alice.rob"

// Full profile
const r3 = await fetch("/api/profile/alice");
const { data: d3 } = await r3.json();
console.log(d3.profile.bio, d3.profile.socialLinks);

// All domains for a wallet
const r4 = await fetch("/api/owner/0xAbCd...1234");
const { data: d4 } = await r4.json();
console.log(d4.count, d4.domains);

const RESOLVER_ABI = [
  "function setPrimaryDomain(uint256 tokenId) external",
  "function clearPrimaryDomain() external",
];

// Connect a signer (user wallet)
const provider = new ethers.BrowserProvider(window.ethereum);
const signer   = await provider.getSigner();
const resolver = new ethers.Contract(RESOLVER_ADDRESS, RESOLVER_ABI, signer);

// Set token #42 as primary
const tx = await resolver.setPrimaryDomain(42);
await tx.wait();
console.log("Primary domain set on-chain");

// Clear primary domain
const tx2 = await resolver.clearPrimaryDomain();
await tx2.wait();

openapi: "3.1.0"
info:
  title: Rob Domains Resolution API
  version: "1.0.0"
  description: HTTP API for resolving .rob domain names on Robinhood Chain

servers:
  - url: https://robdn.com
    description: Production

paths:
  /api/resolve/{domain}:
    get:
      summary: Forward resolution
      parameters:
        - name: domain
          in: path
          required: true
          schema: { type: string, example: "alice" }
      responses:
        "200":
          description: Resolved domain
          content:
            application/json:
              schema:
                $ref: "#/components/schemas/ResolveResponse"
        "404":
          description: Domain not found

  /api/reverse/{wallet}:
    get:
      summary: Reverse resolution
      parameters:
        - name: wallet
          in: path
          required: true
          schema: { type: string, example: "0xAbCd...1234" }
      responses:
        "200":
          description: Primary domain for wallet

components:
  schemas:
    ResolveResponse:
      type: object
      properties:
        ok: { type: boolean }
        data:
          type: object
          properties:
            domain: { type: string }
            owner:  { type: string }
            tokenId: { type: string }
            fullDomain: { type: string }
        meta:
          type: object
          properties:
            chain:    { type: string }
            chainId:  { type: integer }
            timestamp: { type: string, format: date-time }