@hoodag/sdk 0.1.0

package/README.md

@@ -0,0 +1,67 @@
+# @hoodag/sdk
+
+Resolve **.hood** names on [Robinhood Chain](https://hood.ag) (chain id `4663`). ENS-standard,
+so it behaves like ENS resolution — but every read goes through a single contract, the
+**UniversalResolver**, which makes integration a one-liner.
+
+Zero dependencies (uses global `fetch`, works in the browser and Node 18+). Optional
+[viem](https://viem.sh) helpers are exported if your app already uses viem.
+
+## Install
+
+```bash
+npm install @hoodag/sdk
+```
+
+## Usage
+
+```js
+import { resolveHood, reverseHood, resolveTextHood } from '@hoodag/sdk';
+
+// Forward: name -> address
+const addr = await resolveHood('robin.hood');
+// '0x45aa14…'  (or null if unset)
+
+// Reverse: address -> primary name (verified = forward record points back)
+const { name, verified } = await reverseHood(addr);
+// { name: 'robin.hood', verified: true }
+
+// Text records
+const twitter = await resolveTextHood('robin.hood', 'com.twitter');
+```
+
+Every function accepts an optional `rpcUrl` as the last argument if you run your own node:
+
+```js
+await resolveHood('robin.hood', 'https://my-node.example/rpc');
+```
+
+## viem helpers
+
+```js
+import { createPublicClient, http } from 'viem';
+import { HOOD, UNIVERSAL_RESOLVER_ABI } from '@hoodag/sdk';
+
+const client = createPublicClient({ transport: http(HOOD.rpcUrl) });
+const addr = await client.readContract({
+  address: HOOD.contracts.universalResolver,
+  abi: UNIVERSAL_RESOLVER_ABI,
+  functionName: 'resolve',
+  args: ['robin.hood'],
+});
+```
+
+## Contracts (Robinhood Chain, id 4663)
+
+| Contract | Address |
+| --- | --- |
+| Registry (immutable) | `0x3E717dc89AAF4605b607324329EEeB0a8B3C8A1c` |
+| UniversalResolver | `0xa9ed3C73F522875F18DAa631429125da893D8E53` |
+| Registrar (.hood NFT) | `0x9a122C54e15B6287c164b90833bcDA6E16520D50` |
+| Public Resolver | `0x072C7a66a6D52B23274470b86096AFCBF816CA0B` |
+| Registrar Controller | `0x7900b2B8Cc3f0616B18C68AdA7E115A9022Ca04a` |
+| Reverse Registrar | `0x4be6D0379f56404B563afAe17c6b095b1dfcf479` |
+
+## License
+
+MIT

package/hood.js

@@ -0,0 +1,107 @@
+/**
+ * .hood name service SDK — resolve .hood names on Robinhood Chain (4663).
+ *
+ * Drop-in for any app. Two flavors:
+ *   1) Zero-dependency (uses global fetch) — resolveHood / reverseHood / resolveTextHood
+ *   2) viem helpers (if you already use viem) — at the bottom
+ *
+ * All calls hit ONE contract (the HoodUniversalResolver), so integration is a single read.
+ */
+
+export const HOOD = {
+  chainId: 4663,
+  rpcUrl: 'https://rpc.mainnet.chain.robinhood.com',
+  contracts: {
+    registry:          '0x3E717dc89AAF4605b607324329EEeB0a8B3C8A1c', // immutable trust anchor
+    universalResolver: '0xa9ed3C73F522875F18DAa631429125da893D8E53', // <-- call this
+    registrar:         '0x9a122C54e15B6287c164b90833bcDA6E16520D50',
+    resolver:          '0x072C7a66a6D52B23274470b86096AFCBF816CA0B',
+    controller:        '0x7900b2B8Cc3f0616B18C68AdA7E115A9022Ca04a',
+  },
+};
+
+// ---------- zero-dependency implementation (works in browser & node 18+) ----------
+function keccakSelector(sig) {
+  // precomputed 4-byte selectors (verified against the deployed UniversalResolver):
+  const map = {
+    'resolve(string)':            '0x461a4478',
+    'reverse(address)':           '0xe30bd740',
+    'resolveText(string,string)': '0xcb7cef3c',
+  };
+  return map[sig];
+}
+
+function encStringArg(str, extra = '') {
+  // ABI-encode a single dynamic string (+ optional already-encoded trailing words)
+  const bytes = new TextEncoder().encode(str);
+  const hex = [...bytes].map(b => b.toString(16).padStart(2, '0')).join('');
+  const len = bytes.length.toString(16).padStart(64, '0');
+  const padded = hex.padEnd(Math.ceil(hex.length / 64) * 64, '0');
+  // head: offset to string = 0x20 (or 0x40 if there's a second static/dynamic arg — handled by caller)
+  return { len, padded, hexLen: bytes.length };
+}
+
+async function ethCall(to, data, rpcUrl = HOOD.rpcUrl) {
+  const res = await fetch(rpcUrl, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'eth_call', params: [{ to, data }, 'latest'] }),
+  });
+  const j = await res.json();
+  if (j.error) throw new Error(j.error.message);
+  return j.result;
+}
+
+/** resolveHood("robin.hood") -> "0x..." (or null if unset) */
+export async function resolveHood(name, rpcUrl = HOOD.rpcUrl) {
+  const { len, padded } = encStringArg(name);
+  const data = keccakSelector('resolve(string)') +
+    '0000000000000000000000000000000000000000000000000000000000000020' + len + padded;
+  const out = await ethCall(HOOD.contracts.universalResolver, data, rpcUrl);
+  const addr = '0x' + out.slice(-40);
+  return /^0x0{40}$/.test(addr) ? null : addr;
+}
+
+/** reverseHood("0x...") -> { name, verified } */
+export async function reverseHood(address, rpcUrl = HOOD.rpcUrl) {
+  const data = keccakSelector('reverse(address)') + address.toLowerCase().replace('0x', '').padStart(64, '0');
+  const out = await ethCall(HOOD.contracts.universalResolver, data, rpcUrl);
+  const b = out.slice(2);
+  const strOffset = parseInt(b.slice(0, 64), 16) * 2;
+  const verified = parseInt(b.slice(64, 128), 16) === 1;
+  const strLen = parseInt(b.slice(strOffset, strOffset + 64), 16) * 2;
+  const strHex = b.slice(strOffset + 64, strOffset + 64 + strLen);
+  const name = new TextDecoder().decode(Uint8Array.from(strHex.match(/../g)?.map(h => parseInt(h, 16)) ?? []));
+  return { name: name || null, verified };
+}
+
+/** resolveTextHood("robin.hood", "com.twitter") -> "..." */
+export async function resolveTextHood(name, key, rpcUrl = HOOD.rpcUrl) {
+  const n = encStringArg(name), k = encStringArg(key);
+  // two dynamic args: head = [off1=0x40, off2], then arg1, then arg2
+  const head = '0000000000000000000000000000000000000000000000000000000000000040';
+  const arg1 = n.len + n.padded;
+  const off2 = (0x40 + arg1.length / 2).toString(16).padStart(64, '0');
+  const arg2 = k.len + k.padded;
+  const data = keccakSelector('resolveText(string,string)') + head + off2 + arg1 + arg2;
+  const out = await ethCall(HOOD.contracts.universalResolver, data, rpcUrl);
+  const b = out.slice(2);
+  const strLen = parseInt(b.slice(64, 128), 16) * 2;
+  const strHex = b.slice(128, 128 + strLen);
+  return new TextDecoder().decode(Uint8Array.from(strHex.match(/../g)?.map(h => parseInt(h, 16)) ?? []));
+}
+
+// ---------- viem helpers (optional; if your app already uses viem) ----------
+export const UNIVERSAL_RESOLVER_ABI = [
+  { type: 'function', name: 'resolve', stateMutability: 'view', inputs: [{ name: 'name', type: 'string' }], outputs: [{ type: 'address' }] },
+  { type: 'function', name: 'reverse', stateMutability: 'view', inputs: [{ name: 'a', type: 'address' }], outputs: [{ name: 'name', type: 'string' }, { name: 'verified', type: 'bool' }] },
+  { type: 'function', name: 'resolveText', stateMutability: 'view', inputs: [{ name: 'name', type: 'string' }, { name: 'key', type: 'string' }], outputs: [{ type: 'string' }] },
+];
+
+/*  viem usage:
+    import { createPublicClient, http } from 'viem';
+    import { HOOD, UNIVERSAL_RESOLVER_ABI } from './hood.js';
+    const client = createPublicClient({ transport: http(HOOD.rpcUrl) });
+    const addr = await client.readContract({ address: HOOD.contracts.universalResolver, abi: UNIVERSAL_RESOLVER_ABI, functionName: 'resolve', args: ['robin.hood'] });
+    const [name, verified] = await client.readContract({ address: HOOD.contracts.universalResolver, abi: UNIVERSAL_RESOLVER_ABI, functionName: 'reverse', args: [addr] });
+*/

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@hoodag/sdk",
+  "version": "0.1.0",
+  "description": "Resolve .hood names on Robinhood Chain (ENS-standard) — one call, zero dependencies, optional viem helpers.",
+  "type": "module",
+  "main": "./hood.js",
+  "module": "./hood.js",
+  "exports": {
+    ".": "./hood.js"
+  },
+  "files": [
+    "hood.js",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "keywords": [
+    "hood",
+    "ens",
+    "robinhood-chain",
+    "name-service",
+    "resolver",
+    "web3",
+    "viem",
+    "ethereum"
+  ],
+  "homepage": "https://hood.ag",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}