Docs & SDK.

NEURONS (NeuralNS) is a namespace protocol on Robinhood Chain that assigns persistent, human-readable identities to AI agents. Each name is a Program Derived Address (PDA) storing its owner, resolver, expiry, verified flag, AgentCard NFT mint and metadata URI on chain.

PDA derivation is [ "name", sha256(name) ]. Forward resolution is simply "derive the PDA and read the account" — no indexer needed. All protocol economics (tier prices, payment token, treasury) live in a config PDA [ "config" ] readable by anyone.

The program is deployed on Robinhood Chain:

One real dependency — everything else lives in the program repo.

npm install @solana/web3.js

Derive the PDA, read the account, decode the fields. This works today against mainnet.

import { Connection, PublicKey } from '@solana/web3.js';
import { createHash } from 'node:crypto';

const PROGRAM_ID = new PublicKey('5dqCWiZvLWD1Nge15UhXyGCGd2rF8uN6nPigdnLRWCv1');
const conn = new Connection('https://api.mainnet-beta.solana.com');

function namePda(name) {
  const hash = createHash('sha256').update(name).digest();
  return PublicKey.findProgramAddressSync(
    [Buffer.from('name'), hash], PROGRAM_ID,
  )[0];
}

const pda = namePda('neuralns.agent');
const acc = await conn.getAccountInfo(pda);
if (!acc) throw new Error('not registered');

const d = acc.data;            // layout below (§ On-chain record)
const owner    = new PublicKey(d.subarray(2, 34));
const resolver = new PublicKey(d.subarray(34, 66));
const expiry   = d.readBigInt64LE(66);     // 0 = permanent
const verified = d[74] === 1;
const cardMint = new PublicKey(d.subarray(75, 107));
const nameLen  = d.readUInt32LE(107);
const name     = d.subarray(111, 111 + nameLen).toString('utf8');
const uriLen   = d.readUInt32LE(111 + nameLen);
const uri      = d.subarray(115 + nameLen, 115 + nameLen + uriLen).toString('utf8');

console.log({ name, owner: owner.toBase58(), verified, expiry, uri });

Build the Register instruction (Borsh) and sign it with the payer / connected wallet. The treasury and prices are read from the config PDA.

// Borsh: variant 0 + name(string) + resolver(pubkey) + years(u32) + metadata_uri(string)
function encodeRegister(name, resolver, years, uri) {
  const s = (str) => {
    const b = Buffer.from(str, 'utf8');
    const len = Buffer.alloc(4); len.writeUInt32LE(b.length);
    return Buffer.concat([len, b]);
  };
  const yr = Buffer.alloc(4); yr.writeUInt32LE(years);
  return Buffer.concat([Buffer.from([0]), s(name), resolver.toBuffer(), yr, s(uri)]);
}

const CONFIG = PublicKey.findProgramAddressSync([Buffer.from('config')], PROGRAM_ID)[0];
// treasury = bytes 34..66 of the config account
const cfg = await conn.getAccountInfo(CONFIG);
const TREASURY = new PublicKey(cfg.data.subarray(34, 66));

const ix = new TransactionInstruction({
  programId: PROGRAM_ID,
  keys: [
    { pubkey: payer.publicKey, isSigner: true,  isWritable: true },  // payer
    { pubkey: namePda(name),   isSigner: false, isWritable: true },  // record PDA
    { pubkey: CONFIG,          isSigner: false, isWritable: false }, // config PDA
    { pubkey: TREASURY,        isSigner: false, isWritable: true },  // fee receiver
    { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
  ],
  data: encodeRegister(name, payer.publicKey, 1, 'https://neuralns.xyz/api/agent/' + name + '/card.json'),
});
await sendAndConfirmTransaction(conn, new Transaction().add(ix), [payer]);

Each name PDA stores exactly these bytes (Borsh):

offset   size field
0        1    version (u8 = 2)
1        1    bump (u8)
2        32   owner (Pubkey)
34       32   resolver (Pubkey)
66       8    expiry (i64, unix seconds; 0 = permanent)
74       1    verified (u8)
75       32   card_mint (Pubkey; zeroes = no AgentCard yet)
107      4+N  name (string: u32 len + utf8 bytes)
111+N    4+M  metadata_uri (string: u32 len + utf8 bytes)

The AgentCard is a Token-2022 NFT minted at PDA [ "card", sha256(name) ] with the token-metadata extension (name, symbol, URI) and an optional non-transferable (soulbound) extension.