Identity Registry

pub struct MetadataEntry {
    pub key: ByteArray,    // Metadata key (e.g., "agentName")
    pub value: ByteArray,  // Metadata value (e.g., "MyTradingBot")
}

pub struct Registered {
    #[key]
    pub agent_id: u256,           // The new agent's token ID
    pub token_uri: ByteArray,     // Token URI (may be empty)
    pub owner: ContractAddress,   // Owner of the new agent
}

pub struct MetadataSet {
    #[key]
    pub agent_id: u256,          // Agent token ID
    #[key]
    pub indexed_key: ByteArray,  // Key for indexing
    pub key: ByteArray,          // Full metadata key
    pub value: ByteArray,        // New metadata value
}

pub struct URIUpdated {
    #[key]
    pub agent_id: u256,          // Agent token ID
    #[key]
    pub updater: ContractAddress, // Who updated the URI
    pub new_uri: ByteArray,      // New token URI
}

#[starknet::interface]
pub trait IIdentityRegistry<TContractState> {
    // Registration functions
    fn register(ref self: TContractState) -> u256;
    fn register_with_token_uri(ref self: TContractState, token_uri: ByteArray) -> u256;
    fn register_with_metadata(
        ref self: TContractState,
        token_uri: ByteArray,
        metadata: Array<MetadataEntry>
    ) -> u256;

    // Metadata functions
    fn set_metadata(ref self: TContractState, agent_id: u256, key: ByteArray, value: ByteArray);
    fn get_metadata(self: @TContractState, agent_id: u256, key: ByteArray) -> ByteArray;
    fn set_agent_uri(ref self: TContractState, agent_id: u256, new_uri: ByteArray);

    // Wallet binding functions
    fn set_agent_wallet(
        ref self: TContractState,
        agent_id: u256,
        new_wallet: ContractAddress,
        deadline: u64,
        signature: Span<felt252>
    );
    fn unset_agent_wallet(ref self: TContractState, agent_id: u256);
    fn get_agent_wallet(self: @TContractState, agent_id: u256) -> ContractAddress;
    fn get_wallet_set_nonce(self: @TContractState, agent_id: u256) -> u64;

    // Query functions
    fn total_agents(self: @TContractState) -> u256;
    fn agent_exists(self: @TContractState, agent_id: u256) -> bool;
    fn is_authorized_or_owner(self: @TContractState, spender: ContractAddress, agent_id: u256) -> bool;
}

fn register(ref self: TContractState) -> u256

import { Account, RpcProvider, Contract, constants } from "starknet";

const provider = new RpcProvider({ nodeUrl: process.env.STARKNET_RPC_URL });
const account = new Account(
  provider,
  address,
  privateKey,
  undefined,
  constants.TRANSACTION_VERSION.V3
);

const { transaction_hash } = await account.execute({
  contractAddress: identityRegistryAddress,
  entrypoint: "register",
  calldata: [],
});

const receipt = await account.waitForTransaction(transaction_hash);
// Parse agent_id from Registered event

fn register_with_token_uri(ref self: TContractState, token_uri: ByteArray) -> u256

import { CallData } from "starknet";

const tokenUri = "ipfs://QmYourAgentSpecificationHash";

await account.execute({
  contractAddress: identityRegistryAddress,
  entrypoint: "register_with_token_uri",
  calldata: CallData.compile({ token_uri: tokenUri }),
});

fn register_with_metadata(
    ref self: TContractState,
    token_uri: ByteArray,
    metadata: Array<MetadataEntry>
) -> u256

const metadata = [
  { key: "agentName", value: "TradingBot" },
  { key: "agentType", value: "defi-trader" },
  { key: "version", value: "1.0.0" },
  { key: "model", value: "claude-opus-4-5" },
  { key: "status", value: "active" },
];

await account.execute({
  contractAddress: identityRegistryAddress,
  entrypoint: "register_with_metadata",
  calldata: CallData.compile({
    token_uri: "ipfs://QmAgentSpec",
    metadata: metadata,
  }),
});

fn set_metadata(ref self: TContractState, agent_id: u256, key: ByteArray, value: ByteArray)

await account.execute({
  contractAddress: identityRegistryAddress,
  entrypoint: "set_metadata",
  calldata: CallData.compile({
    agent_id: agentId,
    key: "status",
    value: "paused",
  }),
});

fn get_metadata(self: @TContractState, agent_id: u256, key: ByteArray) -> ByteArray

const identityRegistry = new Contract(abi, identityRegistryAddress, provider);

const name = await identityRegistry.get_metadata(agentId, "agentName");
const status = await identityRegistry.get_metadata(agentId, "status");

fn total_agents(self: @TContractState) -> u256

fn agent_exists(self: @TContractState, agent_id: u256) -> bool

fn set_agent_uri(ref self: TContractState, agent_id: u256, new_uri: ByteArray)

await account.execute({
  contractAddress: identityRegistryAddress,
  entrypoint: "set_agent_uri",
  calldata: CallData.compile({
    agent_id: agentId,
    new_uri: "ipfs://QmNewAgentSpec",
  }),
});

fn set_agent_wallet(
    ref self: TContractState,
    agent_id: u256,
    new_wallet: ContractAddress,
    deadline: u64,
    signature: Span<felt252>
)

hash = poseidon_hash(agent_id, new_wallet, owner, deadline, nonce)

import { hash, Account, CallData } from "starknet";

// Compute the message hash
const nonce = await identityRegistry.get_wallet_set_nonce(agentId);
const deadline = Math.floor(Date.now() / 1000) + 300; // 5 minutes

const messageHash = hash.computePoseidonHash(
  agentId,
  newWalletAddress,
  ownerAddress,
  deadline,
  nonce
);

// Wallet signs the hash
const signature = await walletAccount.signMessage({ hash: messageHash });

// Owner calls set_agent_wallet
await ownerAccount.execute({
  contractAddress: identityRegistryAddress,
  entrypoint: "set_agent_wallet",
  calldata: CallData.compile({
    agent_id: agentId,
    new_wallet: newWalletAddress,
    deadline: deadline,
    signature: signature,
  }),
});

fn unset_agent_wallet(ref self: TContractState, agent_id: u256)

fn get_agent_wallet(self: @TContractState, agent_id: u256) -> ContractAddress

fn get_wallet_set_nonce(self: @TContractState, agent_id: u256) -> u64

// Internal storage
metadata: Map<(u256, felt252), ByteArray>

// Key hashing
let key_hash: felt252 = poseidon_hash(key_bytes);
let value = self.metadata.read((agent_id, key_hash));

import { Account, RpcProvider, Contract, CallData, constants } from "starknet";

// Setup
const provider = new RpcProvider({ nodeUrl: "https://starknet-sepolia.g.alchemy.com/..." });
const account = new Account(provider, address, privateKey, undefined, constants.TRANSACTION_VERSION.V3);

// Register agent with metadata
const metadata = [
  { key: "agentName", value: "TradingBot" },
  { key: "agentType", value: "defi-trader" },
  { key: "model", value: "claude-opus-4-5" },
  { key: "status", value: "active" },
];

const { transaction_hash } = await account.execute({
  contractAddress: identityRegistryAddress,
  entrypoint: "register_with_metadata",
  calldata: CallData.compile({
    token_uri: "ipfs://QmAgentSpec",
    metadata: metadata,
  }),
});

await account.waitForTransaction(transaction_hash);

// Query the agent
const registry = new Contract(abi, identityRegistryAddress, provider);
const total = await registry.total_agents();
const exists = await registry.agent_exists(1n);
const name = await registry.get_metadata(1n, "agentName");
const owner = await registry.owner_of(1n);

console.log(`Total agents: ${total}`);
console.log(`Agent exists: ${exists}`);
console.log(`Agent name: ${name}`);
console.log(`Owner: ${owner}`);