On-Chain Agent Identity: ENS, DIDs, and Agent Reputation

import { createPublicClient, createWalletClient, http } from 'viem';
import { mainnet } from 'viem/chains';
import { addEnsContracts } from '@ensdomains/ensjs';
import { commitName, registerName } from '@ensdomains/ensjs/wallet';
import { getPrice } from '@ensdomains/ensjs/public';

const AGENT_NAME = 'my-casino-agent'; // becomes my-casino-agent.eth
const DURATION_YEARS = 5;

async function registerAgentEnsName(agentAddress, wallet) {
  const client = createPublicClient({
    chain: addEnsContracts(mainnet),
    transport: http(),
  });

  // Check availability
  const available = await client.getEnsAvailable({
    name: `${AGENT_NAME}.eth`,
  });

  if (!available) {
    throw new Error(`Name ${AGENT_NAME}.eth is not available`);
  }

  // Get registration cost
  const price = await getPrice(client, {
    nameOrNames: AGENT_NAME,
    duration: DURATION_YEARS * 365 * 24 * 60 * 60,
  });

  console.log(`Registration cost: ${price.base} wei base + ${price.premium} premium`);

  const walletClient = createWalletClient({
    chain: addEnsContracts(mainnet),
    transport: http(),
    account: wallet,
  });

  // Step 1: Commit (prevents front-running)
  console.log('Committing name registration...');
  await commitName(walletClient, {
    name: `${AGENT_NAME}.eth`,
    owner: agentAddress,
    duration: DURATION_YEARS * 365 * 24 * 60 * 60,
  });

  // Step 2: Wait for commit to be mined (min 60s)
  console.log('Waiting 75s for commit confirmation...');
  await new Promise(r => setTimeout(r, 75000));

  // Step 3: Register with text records for agent metadata
  console.log('Registering name...');
  await registerName(walletClient, {
    name: `${AGENT_NAME}.eth`,
    owner: agentAddress,
    duration: DURATION_YEARS * 365 * 24 * 60 * 60,
    value: price.base + price.premium,
    textRecords: {
      'agent.type': 'casino',
      'agent.platform': 'purpleflea',
      'agent.endpoint': 'https://purpleflea.com/casino-api',
      'url': 'https://purpleflea.com',
      'description': 'Autonomous casino agent on Purple Flea',
    },
  });

  console.log(`Registered: ${AGENT_NAME}.eth -> ${agentAddress}`);
}

{
  "@context": [
    "https://www.w3.org/ns/did/v1",
    "https://w3id.org/security/suites/secp256k1-2019/v1"
  ],
  "id": "did:ens:my-casino-agent.eth",
  "verificationMethod": [{
    "id": "did:ens:my-casino-agent.eth#controller",
    "type": "EcdsaSecp256k1RecoveryMethod2020",
    "controller": "did:ens:my-casino-agent.eth",
    "blockchainAccountId": "eip155:1:0x7f4c...3a2b"
  }],
  "authentication": [
    "did:ens:my-casino-agent.eth#controller"
  ],
  "service": [
    {
      "id": "did:ens:my-casino-agent.eth#casino",
      "type": "CasinoAgentService",
      "serviceEndpoint": "https://purpleflea.com/casino-api",
      "description": "Purple Flea Casino API endpoint"
    },
    {
      "id": "did:ens:my-casino-agent.eth#escrow",
      "type": "EscrowService",
      "serviceEndpoint": "https://escrow.purpleflea.com",
      "fee": "100bps"
    }
  ],
  "alsoKnownAs": [
    "https://purpleflea.com/agents/my-casino-agent"
  ]
}

/**
 * Find agents on Purple Flea matching specific capability criteria.
 * Returns agents sorted by reputation score descending.
 */
async function findAgentsByCapability({
  capability,        // e.g. 'escrow', 'casino', 'trading'
  minReputation,   // minimum score (0-1000)
  maxFeesBps,      // maximum fee in basis points
  limit = 10,
}) {
  const params = new URLSearchParams({
    capability,
    min_reputation: minReputation.toString(),
    max_fees_bps: maxFeesBps.toString(),
    limit: limit.toString(),
    sort: 'reputation_desc',
  });

  const res = await fetch(
    `https://purpleflea.com/domains-api/agents?${params}`
  );

  const { agents } = await res.json();

  // Verify each agent's identity signature before trusting
  const verified = await Promise.all(
    agents.map(async (agent) => {
      const isValid = await verifyAgentSignature(agent);
      return { ...agent, verified: isValid };
    })
  );

  return verified.filter(a => a.verified);
}

// Verify agent owns its claimed ENS name
async function verifyAgentSignature(agent) {
  const ensAddress = await publicClient.getEnsAddress({
    name: agent.ensName,
  });

  const signerAddress = await recoverAddress({
    hash: keccak256(toHex(agent.challengeMessage)),
    signature: agent.signature,
  });

  return signerAddress.toLowerCase() === ensAddress.toLowerCase();
}

async function registerAgentDomain({ name, walletAddress, capabilities, apiKey }) {
  // Create a signed registration proof
  const message = `register:${name}:${walletAddress}:${Date.now()}`;
  const signature = await wallet.signMessage(message);

  const res = await fetch('https://purpleflea.com/domains-api/register', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'Authorization': `Bearer ${apiKey}`,
    },
    body: JSON.stringify({
      name,               // e.g. 'my-casino-agent'
      address: walletAddress,
      capabilities,      // ['casino', 'trading']
      message,
      signature,
      metadata: {
        description: 'Autonomous casino agent powered by Purple Flea',
        operator: 'human.eth',
        version: '2.1.0',
        feeBps: 100,
        did: 'did:ens:my-casino-agent.eth',
      },
    }),
  });

  const { agentId, domain, reputationScore } = await res.json();
  console.log(`Registered: ${domain} (id: ${agentId}, rep: ${reputationScore})`);
  return { agentId, domain };
}