nara-sdk 1.0.87 → 1.0.89

package/index.ts

@@ -124,7 +124,9 @@ export {
   getAgentMemory,
   getConfig as getAgentRegistryConfig,
   setBio,
+  makeSetBioIx,
   setMetadata,
+  makeSetMetadataIx,
   uploadMemory,
   closeBuffer as closeAgentBuffer,
   transferAgentAuthority,
@@ -134,6 +136,14 @@ export {
   makeLogActivityIx,
   makeLogActivityWithReferralIx,
   setReferral,
+  // Agent index
+  getAgentIndex,
+  listIndexesByAgent,
+  registerAgentIndex,
+  unregisterAgentIndex,
+  makeRegisterAgentIndexIx,
+  makeUnregisterAgentIndexIx,
+  computeIndexHash,
   // Twitter verification
   getAgentTwitter,
   getTweetVerify,
@@ -163,6 +173,8 @@ export {
   withdrawTwitterVerifyFees,
   type AgentRecord,
   type AgentInfo,
+  type AgentIndexInfo,
+  type ReverseIndexInfo,
   type AgentTwitterInfo,
   type TweetVerifyInfo,
   type TweetRecordInfo,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nara-sdk",
-  "version": "1.0.87",
+  "version": "1.0.89",
   "description": "SDK for the Nara chain (Solana-compatible)",
   "module": "index.ts",
   "main": "index.ts",

package/src/agent_registry.ts

@@ -14,6 +14,7 @@ import * as anchor from "@coral-xyz/anchor";
 import { Program, AnchorProvider, Wallet } from "@coral-xyz/anchor";
 import BN from "bn.js";
 import { getAssociatedTokenAddressSync, TOKEN_2022_PROGRAM_ID } from "@solana/spl-token";
+import { createHash } from "node:crypto";
 import bs58 from "bs58";
 import type { NaraAgentRegistry } from "./idls/nara_agent_registry";
 import { DEFAULT_AGENT_REGISTRY_PROGRAM_ID } from "./constants";
@@ -56,6 +57,22 @@ export interface AgentInfo {
   metadata: string | null;
 }
 
+export interface AgentIndexInfo {
+  /** Agent PDA that owns this index entry */
+  agent: PublicKey;
+  /** agent_id of the owning agent */
+  agentId: string;
+  createdAt: number;
+}
+
+export interface ReverseIndexInfo {
+  /** Agent PDA that owns this reverse-index entry */
+  agent: PublicKey;
+  /** Index string registered for the agent (UTF-8, up to 128 bytes) */
+  index: string;
+  createdAt: number;
+}
+
 export interface AgentTwitterInfo {
   agentId: string;
   status: number;
@@ -181,6 +198,35 @@ function getTreasuryPda(programId: PublicKey): PublicKey {
   return pda;
 }
 
+/**
+ * SHA-256 of an index string. The chain uses this 32-byte hash both as a PDA
+ * seed (lifting the 32-byte raw-seed limit) and as an integrity check against
+ * the supplied `index_str` (errors with `AgentIndexHashMismatch` on mismatch).
+ */
+export function computeIndexHash(indexStr: string): Buffer {
+  return createHash("sha256").update(indexStr, "utf8").digest();
+}
+
+function getAgentIndexPda(programId: PublicKey, indexHash: Buffer | Uint8Array): PublicKey {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [Buffer.from("agent_index"), Buffer.from(indexHash)],
+    programId
+  );
+  return pda;
+}
+
+function getReverseIndexPda(
+  programId: PublicKey,
+  agentPda: PublicKey,
+  indexHash: Buffer | Uint8Array
+): PublicKey {
+  const [pda] = PublicKey.findProgramAddressSync(
+    [Buffer.from("reverse_index"), agentPda.toBytes(), Buffer.from(indexHash)],
+    programId
+  );
+  return pda;
+}
+
 function getTwitterPda(programId: PublicKey, agentPda: PublicKey): PublicKey {
   const [pda] = PublicKey.findProgramAddressSync(
     [Buffer.from("twitter"), agentPda.toBuffer()],
@@ -713,6 +759,23 @@ export async function deleteAgent(
 
 // ─── Bio & Metadata ─────────────────────────────────────────────
 
+/**
+ * Build a setBio instruction without sending it.
+ */
+export async function makeSetBioIx(
+  connection: Connection,
+  authority: PublicKey,
+  agentId: string,
+  bio: string,
+  options?: AgentRegistryOptions
+): Promise<TransactionInstruction> {
+  const program = createProgram(connection, Keypair.generate(), options?.programId);
+  return program.methods
+    .setBio(agentId, bio)
+    .accounts({ authority } as any)
+    .instruction();
+}
+
 /**
  * Set or update the agent's bio.
  */
@@ -723,14 +786,27 @@ export async function setBio(
   bio: string,
   options?: AgentRegistryOptions
 ): Promise<string> {
-  const program = createProgram(connection, wallet, options?.programId);
-  const ix = await program.methods
-    .setBio(agentId, bio)
-    .accounts({ authority: wallet.publicKey } as any)
-    .instruction();
+  const ix = await makeSetBioIx(connection, wallet.publicKey, agentId, bio, options);
   return sendTx(connection, wallet, [ix]);
 }
 
+/**
+ * Build a setMetadata instruction without sending it.
+ */
+export async function makeSetMetadataIx(
+  connection: Connection,
+  authority: PublicKey,
+  agentId: string,
+  data: string,
+  options?: AgentRegistryOptions
+): Promise<TransactionInstruction> {
+  const program = createProgram(connection, Keypair.generate(), options?.programId);
+  return program.methods
+    .setMetadata(agentId, data)
+    .accounts({ authority } as any)
+    .instruction();
+}
+
 /**
  * Set or update the agent's metadata (typically JSON).
  */
@@ -741,11 +817,7 @@ export async function setMetadata(
   data: string,
   options?: AgentRegistryOptions
 ): Promise<string> {
-  const program = createProgram(connection, wallet, options?.programId);
-  const ix = await program.methods
-    .setMetadata(agentId, data)
-    .accounts({ authority: wallet.publicKey } as any)
-    .instruction();
+  const ix = await makeSetMetadataIx(connection, wallet.publicKey, agentId, data, options);
   return sendTx(connection, wallet, [ix]);
 }
 
@@ -1087,6 +1159,186 @@ export async function setReferral(
   return sendTx(connection, wallet, [ix]);
 }
 
+// ─── Agent Index ────────────────────────────────────────────────
+
+/**
+ * Parse AgentIndex account data (bytemuck zero-copy layout).
+ * Layout (after 8-byte discriminator):
+ *   32 agent | 8 created_at | 4 agent_id_len | 4 _padding |
+ *   32 agent_id | 32 _reserved
+ */
+function parseAgentIndexData(data: Buffer | Uint8Array): AgentIndexInfo {
+  const buf = Buffer.from(data);
+  let offset = 8;
+  const agent = new PublicKey(buf.subarray(offset, offset + 32)); offset += 32;
+  const createdAt = Number(buf.readBigInt64LE(offset)); offset += 8;
+  const agentIdLen = buf.readUInt32LE(offset); offset += 4;
+  offset += 4; // _padding
+  const agentId = buf.subarray(offset, offset + agentIdLen).toString("utf-8");
+  return { agent, agentId, createdAt };
+}
+
+/**
+ * Parse ReverseIndex account data (bytemuck zero-copy layout).
+ * Layout (after 8-byte discriminator):
+ *   32 agent | 8 created_at | 4 index_len | 4 _padding |
+ *   128 index | 32 _reserved
+ */
+function parseReverseIndexData(data: Buffer | Uint8Array): ReverseIndexInfo {
+  const buf = Buffer.from(data);
+  let offset = 8;
+  const agent = new PublicKey(buf.subarray(offset, offset + 32)); offset += 32;
+  const createdAt = Number(buf.readBigInt64LE(offset)); offset += 8;
+  const indexLen = buf.readUInt32LE(offset); offset += 4;
+  offset += 4; // _padding
+  const index = buf.subarray(offset, offset + indexLen).toString("utf-8");
+  return { agent, index, createdAt };
+}
+
+/**
+ * Look up an agent_index entry by index string.
+ * Returns null if no agent has claimed this index.
+ */
+export async function getAgentIndex(
+  connection: Connection,
+  indexStr: string,
+  options?: AgentRegistryOptions
+): Promise<AgentIndexInfo | null> {
+  const pid = new PublicKey(options?.programId ?? DEFAULT_AGENT_REGISTRY_PROGRAM_ID);
+  const pda = getAgentIndexPda(pid, computeIndexHash(indexStr));
+  const accountInfo = await connection.getAccountInfo(pda);
+  if (!accountInfo) return null;
+  return parseAgentIndexData(accountInfo.data);
+}
+
+/** ReverseIndex account discriminator (from IDL). */
+const REVERSE_INDEX_DISCRIMINATOR = Buffer.from([130, 180, 241, 155, 193, 32, 173, 207]);
+
+/**
+ * List all index strings registered for a given agent.
+ * Scans the program via `getProgramAccounts` with memcmp filters on the
+ * ReverseIndex discriminator and the `agent` field (offset 8).
+ */
+export async function listIndexesByAgent(
+  connection: Connection,
+  agentId: string,
+  options?: AgentRegistryOptions
+): Promise<ReverseIndexInfo[]> {
+  const pid = new PublicKey(options?.programId ?? DEFAULT_AGENT_REGISTRY_PROGRAM_ID);
+  const agentPda = getAgentPda(pid, agentId);
+
+  const accounts = await connection.getProgramAccounts(pid, {
+    commitment: "confirmed",
+    filters: [
+      { memcmp: { offset: 0, bytes: bs58.encode(REVERSE_INDEX_DISCRIMINATOR) } },
+      { memcmp: { offset: 8, bytes: agentPda.toBase58() } },
+    ],
+  });
+
+  return accounts.map(({ account }) => parseReverseIndexData(account.data));
+}
+
+/**
+ * Build a registerAgentIndex instruction without sending it.
+ */
+export async function makeRegisterAgentIndexIx(
+  connection: Connection,
+  payer: PublicKey,
+  authority: PublicKey,
+  agentId: string,
+  indexStr: string,
+  options?: AgentRegistryOptions
+): Promise<TransactionInstruction> {
+  const program = createProgram(connection, Keypair.generate(), options?.programId);
+  const agent = getAgentPda(program.programId, agentId);
+  const indexHash = computeIndexHash(indexStr);
+  return program.methods
+    .registerAgentIndex(indexStr, Array.from(indexHash))
+    .accounts({ payer, authority, agent } as any)
+    .instruction();
+}
+
+/**
+ * Register a custom index string that points to the given agent.
+ * The (index_str → agent_id) mapping can be looked up via getAgentIndex;
+ * the reverse (agent → all index_strs) via listIndexesByAgent.
+ */
+export async function registerAgentIndex(
+  connection: Connection,
+  wallet: Keypair,
+  agentId: string,
+  indexStr: string,
+  options?: AgentRegistryOptions,
+  payer?: Keypair
+): Promise<{ signature: string; agentIndexPda: PublicKey; reverseIndexPda: PublicKey }> {
+  const payerKp = payer ?? wallet;
+  const program = createProgram(connection, payerKp, options?.programId);
+  const agent = getAgentPda(program.programId, agentId);
+  const indexHash = computeIndexHash(indexStr);
+  const ix = await program.methods
+    .registerAgentIndex(indexStr, Array.from(indexHash))
+    .accounts({
+      payer: payerKp.publicKey,
+      authority: wallet.publicKey,
+      agent,
+    } as any)
+    .instruction();
+  const signers = payer && !payer.publicKey.equals(wallet.publicKey) ? [wallet] : [];
+  const signature = await sendTx(connection, payerKp, [ix], signers);
+  return {
+    signature,
+    agentIndexPda: getAgentIndexPda(program.programId, indexHash),
+    reverseIndexPda: getReverseIndexPda(program.programId, agent, indexHash),
+  };
+}
+
+/**
+ * Build an unregisterAgentIndex instruction without sending it.
+ */
+export async function makeUnregisterAgentIndexIx(
+  connection: Connection,
+  rentDestination: PublicKey,
+  authority: PublicKey,
+  agentId: string,
+  indexStr: string,
+  options?: AgentRegistryOptions
+): Promise<TransactionInstruction> {
+  const program = createProgram(connection, Keypair.generate(), options?.programId);
+  const agent = getAgentPda(program.programId, agentId);
+  const indexHash = computeIndexHash(indexStr);
+  return program.methods
+    .unregisterAgentIndex(Array.from(indexHash))
+    .accounts({ rentDestination, authority, agent } as any)
+    .instruction();
+}
+
+/**
+ * Unregister a custom index string and reclaim rent.
+ * The signing wallet must be the agent's authority.
+ * @param rentDestination - Account to receive reclaimed rent (defaults to wallet pubkey).
+ */
+export async function unregisterAgentIndex(
+  connection: Connection,
+  wallet: Keypair,
+  agentId: string,
+  indexStr: string,
+  options?: AgentRegistryOptions,
+  rentDestination?: PublicKey
+): Promise<string> {
+  const program = createProgram(connection, wallet, options?.programId);
+  const agent = getAgentPda(program.programId, agentId);
+  const indexHash = computeIndexHash(indexStr);
+  const ix = await program.methods
+    .unregisterAgentIndex(Array.from(indexHash))
+    .accounts({
+      rentDestination: rentDestination ?? wallet.publicKey,
+      authority: wallet.publicKey,
+      agent,
+    } as any)
+    .instruction();
+  return sendTx(connection, wallet, [ix]);
+}
+
 // ─── Admin functions ────────────────────────────────────────────
 
 /**

package/src/idls/nara_agent_registry.json

@@ -1959,6 +1959,123 @@
         }
       ]
     },
+    {
+      "name": "register_agent_index",
+      "discriminator": [
+        193,
+        207,
+        223,
+        226,
+        130,
+        228,
+        161,
+        207
+      ],
+      "accounts": [
+        {
+          "name": "payer",
+          "writable": true,
+          "signer": true
+        },
+        {
+          "name": "authority",
+          "signer": true,
+          "relations": [
+            "agent"
+          ]
+        },
+        {
+          "name": "agent"
+        },
+        {
+          "name": "agent_index",
+          "docs": [
+            "Forward-lookup PDA: keyed by hash(index_str). Globally unique per index_str."
+          ],
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  97,
+                  103,
+                  101,
+                  110,
+                  116,
+                  95,
+                  105,
+                  110,
+                  100,
+                  101,
+                  120
+                ]
+              },
+              {
+                "kind": "arg",
+                "path": "index_hash"
+              }
+            ]
+          }
+        },
+        {
+          "name": "reverse_index",
+          "docs": [
+            "Reverse-lookup PDA: keyed by (agent, hash(index_str)). One per agent per index."
+          ],
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  114,
+                  101,
+                  118,
+                  101,
+                  114,
+                  115,
+                  101,
+                  95,
+                  105,
+                  110,
+                  100,
+                  101,
+                  120
+                ]
+              },
+              {
+                "kind": "account",
+                "path": "agent"
+              },
+              {
+                "kind": "arg",
+                "path": "index_hash"
+              }
+            ]
+          }
+        },
+        {
+          "name": "system_program",
+          "address": "11111111111111111111111111111111"
+        }
+      ],
+      "args": [
+        {
+          "name": "index_str",
+          "type": "string"
+        },
+        {
+          "name": "index_hash",
+          "type": {
+            "array": [
+              "u8",
+              32
+            ]
+          }
+        }
+      ]
+    },
     {
       "name": "register_agent_with_referral",
       "discriminator": [
@@ -3540,6 +3657,115 @@
         }
       ]
     },
+    {
+      "name": "unregister_agent_index",
+      "discriminator": [
+        245,
+        18,
+        46,
+        12,
+        147,
+        155,
+        203,
+        169
+      ],
+      "accounts": [
+        {
+          "name": "rent_destination",
+          "writable": true
+        },
+        {
+          "name": "authority",
+          "signer": true,
+          "relations": [
+            "agent"
+          ]
+        },
+        {
+          "name": "agent"
+        },
+        {
+          "name": "agent_index",
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  97,
+                  103,
+                  101,
+                  110,
+                  116,
+                  95,
+                  105,
+                  110,
+                  100,
+                  101,
+                  120
+                ]
+              },
+              {
+                "kind": "arg",
+                "path": "index_hash"
+              }
+            ]
+          }
+        },
+        {
+          "name": "reverse_index",
+          "docs": [
+            "Reverse-lookup PDA, closed alongside the main index entry."
+          ],
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  114,
+                  101,
+                  118,
+                  101,
+                  114,
+                  115,
+                  101,
+                  95,
+                  105,
+                  110,
+                  100,
+                  101,
+                  120
+                ]
+              },
+              {
+                "kind": "account",
+                "path": "agent"
+              },
+              {
+                "kind": "arg",
+                "path": "index_hash"
+              }
+            ]
+          }
+        },
+        {
+          "name": "system_program",
+          "address": "11111111111111111111111111111111"
+        }
+      ],
+      "args": [
+        {
+          "name": "index_hash",
+          "type": {
+            "array": [
+              "u8",
+              32
+            ]
+          }
+        }
+      ]
+    },
     {
       "name": "update_activity_config",
       "discriminator": [
@@ -4502,6 +4728,19 @@
     }
   ],
   "accounts": [
+    {
+      "name": "AgentIndex",
+      "discriminator": [
+        241,
+        154,
+        35,
+        103,
+        180,
+        141,
+        49,
+        179
+      ]
+    },
     {
       "name": "AgentState",
       "discriminator": [
@@ -4554,6 +4793,19 @@
         63
       ]
     },
+    {
+      "name": "ReverseIndex",
+      "discriminator": [
+        130,
+        180,
+        241,
+        155,
+        193,
+        32,
+        173,
+        207
+      ]
+    },
     {
       "name": "TweetRecord",
       "discriminator": [
@@ -4875,6 +5127,26 @@
       "code": 6047,
       "name": "TwitterNotRejected",
       "msg": "Twitter binding is not in rejected status"
+    },
+    {
+      "code": 6048,
+      "name": "AgentIndexEmpty",
+      "msg": "Agent index string is empty"
+    },
+    {
+      "code": 6049,
+      "name": "AgentIndexTooLong",
+      "msg": "Agent index string too long"
+    },
+    {
+      "code": 6050,
+      "name": "AgentIndexMismatch",
+      "msg": "Agent index does not belong to the given agent"
+    },
+    {
+      "code": 6051,
+      "name": "AgentIndexHashMismatch",
+      "msg": "Agent index hash does not match the provided index string"
     }
   ],
   "types": [
@@ -4922,6 +5194,69 @@
         ]
       }
     },
+    {
+      "name": "AgentIndex",
+      "docs": [
+        "Per-agent custom index entry. Lets an agent claim arbitrary index strings",
+        "that point back to its agent_id.",
+        "Seeds: [SEED_AGENT_INDEX, index_str.as_bytes()]"
+      ],
+      "serialization": "bytemuck",
+      "repr": {
+        "kind": "c"
+      },
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "agent",
+            "docs": [
+              "The AgentState PDA that owns this index entry"
+            ],
+            "type": "pubkey"
+          },
+          {
+            "name": "created_at",
+            "docs": [
+              "Unix timestamp when this index was registered"
+            ],
+            "type": "i64"
+          },
+          {
+            "name": "agent_id_len",
+            "docs": [
+              "Length of the agent_id stored below"
+            ],
+            "type": "u32"
+          },
+          {
+            "name": "_padding",
+            "type": "u32"
+          },
+          {
+            "name": "agent_id",
+            "docs": [
+              "agent_id of the owning agent (zero-padded)"
+            ],
+            "type": {
+              "array": [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            "name": "_reserved",
+            "type": {
+              "array": [
+                "u8",
+                32
+              ]
+            }
+          }
+        ]
+      }
+    },
     {
       "name": "AgentState",
       "docs": [
@@ -5253,6 +5588,71 @@
         ]
       }
     },
+    {
+      "name": "ReverseIndex",
+      "docs": [
+        "Reverse-lookup record: given an agent, list all index strings registered for it.",
+        "Seeds: [SEED_REVERSE_INDEX, agent_pda.as_ref(), index_str.as_bytes()]",
+        "",
+        "Clients can fetch all reverse_index entries for a given agent via",
+        "`getProgramAccounts` with a memcmp filter on the `agent` field."
+      ],
+      "serialization": "bytemuck",
+      "repr": {
+        "kind": "c"
+      },
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "agent",
+            "docs": [
+              "The AgentState PDA that owns this reverse-index entry"
+            ],
+            "type": "pubkey"
+          },
+          {
+            "name": "created_at",
+            "docs": [
+              "Unix timestamp when this entry was created"
+            ],
+            "type": "i64"
+          },
+          {
+            "name": "index_len",
+            "docs": [
+              "Length of the index string stored below"
+            ],
+            "type": "u32"
+          },
+          {
+            "name": "_padding",
+            "type": "u32"
+          },
+          {
+            "name": "index",
+            "docs": [
+              "Index string (zero-padded), up to 128 bytes"
+            ],
+            "type": {
+              "array": [
+                "u8",
+                128
+              ]
+            }
+          },
+          {
+            "name": "_reserved",
+            "type": {
+              "array": [
+                "u8",
+                32
+              ]
+            }
+          }
+        ]
+      }
+    },
     {
       "name": "TweetRecord",
       "docs": [

package/src/idls/nara_agent_registry.ts

@@ -1965,6 +1965,123 @@ export type NaraAgentRegistry = {
         }
       ]
     },
+    {
+      "name": "registerAgentIndex",
+      "discriminator": [
+        193,
+        207,
+        223,
+        226,
+        130,
+        228,
+        161,
+        207
+      ],
+      "accounts": [
+        {
+          "name": "payer",
+          "writable": true,
+          "signer": true
+        },
+        {
+          "name": "authority",
+          "signer": true,
+          "relations": [
+            "agent"
+          ]
+        },
+        {
+          "name": "agent"
+        },
+        {
+          "name": "agentIndex",
+          "docs": [
+            "Forward-lookup PDA: keyed by hash(index_str). Globally unique per index_str."
+          ],
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  97,
+                  103,
+                  101,
+                  110,
+                  116,
+                  95,
+                  105,
+                  110,
+                  100,
+                  101,
+                  120
+                ]
+              },
+              {
+                "kind": "arg",
+                "path": "indexHash"
+              }
+            ]
+          }
+        },
+        {
+          "name": "reverseIndex",
+          "docs": [
+            "Reverse-lookup PDA: keyed by (agent, hash(index_str)). One per agent per index."
+          ],
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  114,
+                  101,
+                  118,
+                  101,
+                  114,
+                  115,
+                  101,
+                  95,
+                  105,
+                  110,
+                  100,
+                  101,
+                  120
+                ]
+              },
+              {
+                "kind": "account",
+                "path": "agent"
+              },
+              {
+                "kind": "arg",
+                "path": "indexHash"
+              }
+            ]
+          }
+        },
+        {
+          "name": "systemProgram",
+          "address": "11111111111111111111111111111111"
+        }
+      ],
+      "args": [
+        {
+          "name": "indexStr",
+          "type": "string"
+        },
+        {
+          "name": "indexHash",
+          "type": {
+            "array": [
+              "u8",
+              32
+            ]
+          }
+        }
+      ]
+    },
     {
       "name": "registerAgentWithReferral",
       "discriminator": [
@@ -3546,6 +3663,115 @@ export type NaraAgentRegistry = {
         }
       ]
     },
+    {
+      "name": "unregisterAgentIndex",
+      "discriminator": [
+        245,
+        18,
+        46,
+        12,
+        147,
+        155,
+        203,
+        169
+      ],
+      "accounts": [
+        {
+          "name": "rentDestination",
+          "writable": true
+        },
+        {
+          "name": "authority",
+          "signer": true,
+          "relations": [
+            "agent"
+          ]
+        },
+        {
+          "name": "agent"
+        },
+        {
+          "name": "agentIndex",
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  97,
+                  103,
+                  101,
+                  110,
+                  116,
+                  95,
+                  105,
+                  110,
+                  100,
+                  101,
+                  120
+                ]
+              },
+              {
+                "kind": "arg",
+                "path": "indexHash"
+              }
+            ]
+          }
+        },
+        {
+          "name": "reverseIndex",
+          "docs": [
+            "Reverse-lookup PDA, closed alongside the main index entry."
+          ],
+          "writable": true,
+          "pda": {
+            "seeds": [
+              {
+                "kind": "const",
+                "value": [
+                  114,
+                  101,
+                  118,
+                  101,
+                  114,
+                  115,
+                  101,
+                  95,
+                  105,
+                  110,
+                  100,
+                  101,
+                  120
+                ]
+              },
+              {
+                "kind": "account",
+                "path": "agent"
+              },
+              {
+                "kind": "arg",
+                "path": "indexHash"
+              }
+            ]
+          }
+        },
+        {
+          "name": "systemProgram",
+          "address": "11111111111111111111111111111111"
+        }
+      ],
+      "args": [
+        {
+          "name": "indexHash",
+          "type": {
+            "array": [
+              "u8",
+              32
+            ]
+          }
+        }
+      ]
+    },
     {
       "name": "updateActivityConfig",
       "discriminator": [
@@ -4508,6 +4734,19 @@ export type NaraAgentRegistry = {
     }
   ],
   "accounts": [
+    {
+      "name": "agentIndex",
+      "discriminator": [
+        241,
+        154,
+        35,
+        103,
+        180,
+        141,
+        49,
+        179
+      ]
+    },
     {
       "name": "agentState",
       "discriminator": [
@@ -4560,6 +4799,19 @@ export type NaraAgentRegistry = {
         63
       ]
     },
+    {
+      "name": "reverseIndex",
+      "discriminator": [
+        130,
+        180,
+        241,
+        155,
+        193,
+        32,
+        173,
+        207
+      ]
+    },
     {
       "name": "tweetRecord",
       "discriminator": [
@@ -4881,6 +5133,26 @@ export type NaraAgentRegistry = {
       "code": 6047,
       "name": "twitterNotRejected",
       "msg": "Twitter binding is not in rejected status"
+    },
+    {
+      "code": 6048,
+      "name": "agentIndexEmpty",
+      "msg": "Agent index string is empty"
+    },
+    {
+      "code": 6049,
+      "name": "agentIndexTooLong",
+      "msg": "Agent index string too long"
+    },
+    {
+      "code": 6050,
+      "name": "agentIndexMismatch",
+      "msg": "Agent index does not belong to the given agent"
+    },
+    {
+      "code": 6051,
+      "name": "agentIndexHashMismatch",
+      "msg": "Agent index hash does not match the provided index string"
     }
   ],
   "types": [
@@ -4928,6 +5200,69 @@ export type NaraAgentRegistry = {
         ]
       }
     },
+    {
+      "name": "agentIndex",
+      "docs": [
+        "Per-agent custom index entry. Lets an agent claim arbitrary index strings",
+        "that point back to its agent_id.",
+        "Seeds: [SEED_AGENT_INDEX, index_str.as_bytes()]"
+      ],
+      "serialization": "bytemuck",
+      "repr": {
+        "kind": "c"
+      },
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "agent",
+            "docs": [
+              "The AgentState PDA that owns this index entry"
+            ],
+            "type": "pubkey"
+          },
+          {
+            "name": "createdAt",
+            "docs": [
+              "Unix timestamp when this index was registered"
+            ],
+            "type": "i64"
+          },
+          {
+            "name": "agentIdLen",
+            "docs": [
+              "Length of the agent_id stored below"
+            ],
+            "type": "u32"
+          },
+          {
+            "name": "padding",
+            "type": "u32"
+          },
+          {
+            "name": "agentId",
+            "docs": [
+              "agent_id of the owning agent (zero-padded)"
+            ],
+            "type": {
+              "array": [
+                "u8",
+                32
+              ]
+            }
+          },
+          {
+            "name": "reserved",
+            "type": {
+              "array": [
+                "u8",
+                32
+              ]
+            }
+          }
+        ]
+      }
+    },
     {
       "name": "agentState",
       "docs": [
@@ -5259,6 +5594,71 @@ export type NaraAgentRegistry = {
         ]
       }
     },
+    {
+      "name": "reverseIndex",
+      "docs": [
+        "Reverse-lookup record: given an agent, list all index strings registered for it.",
+        "Seeds: [SEED_REVERSE_INDEX, agent_pda.as_ref(), index_str.as_bytes()]",
+        "",
+        "Clients can fetch all reverse_index entries for a given agent via",
+        "`getProgramAccounts` with a memcmp filter on the `agent` field."
+      ],
+      "serialization": "bytemuck",
+      "repr": {
+        "kind": "c"
+      },
+      "type": {
+        "kind": "struct",
+        "fields": [
+          {
+            "name": "agent",
+            "docs": [
+              "The AgentState PDA that owns this reverse-index entry"
+            ],
+            "type": "pubkey"
+          },
+          {
+            "name": "createdAt",
+            "docs": [
+              "Unix timestamp when this entry was created"
+            ],
+            "type": "i64"
+          },
+          {
+            "name": "indexLen",
+            "docs": [
+              "Length of the index string stored below"
+            ],
+            "type": "u32"
+          },
+          {
+            "name": "padding",
+            "type": "u32"
+          },
+          {
+            "name": "index",
+            "docs": [
+              "Index string (zero-padded), up to 128 bytes"
+            ],
+            "type": {
+              "array": [
+                "u8",
+                128
+              ]
+            }
+          },
+          {
+            "name": "reserved",
+            "type": {
+              "array": [
+                "u8",
+                32
+              ]
+            }
+          }
+        ]
+      }
+    },
     {
       "name": "tweetRecord",
       "docs": [