┌──────────────────────────────────────────────────────────────┐
│  1. Issue on Solana                                          │
│     GhostSpeak creates W3C credential on Solana blockchain   │
│     Cost: ~0.0002 SOL (~$0.03)                               │
├──────────────────────────────────────────────────────────────┤
│  2. Sync to Crossmint                                        │
│     Webhook sent to Crossmint with credential data           │
│     Crossmint indexes and stores credential                  │
├──────────────────────────────────────────────────────────────┤
│  3. Verify on EVM Chains                                     │
│     Any EVM chain can verify via Crossmint API               │
│     Cost: Free (verification-only)                           │
└──────────────────────────────────────────────────────────────┘

// 1. Issue on Solana
const credential = await client.credentials.issueAgentIdentityCredential({
  agentId: agentAddress,
  name: 'My AI Agent',
  capabilities: ['code-review'],
  syncToCrossmint: true, // Enable cross-chain sync
  recipientEmail: '[email protected]' // For Crossmint notifications
})

console.log('Solana Credential ID:', credential.solanaCredential.credentialId)
console.log('Crossmint Credential ID:', credential.crossmintSync.credentialId)
console.log('Crossmint URL:', credential.crossmintSync.url)

// 2. Crossmint automatically receives webhook and indexes credential

// 3. Verify on Ethereum (or any EVM chain)
const ethVerification = await fetch(
  `https://crossmint.com/api/v1/credentials/${credential.crossmintSync.credentialId}/verify`,
  {
    method: 'GET',
    headers: {
      'X-API-Key': CROSSMINT_API_KEY
    }
  }
)

const result = await ethVerification.json()
console.log('Valid on Ethereum:', result.valid)
console.log('Issuer:', result.issuer)
console.log('Claims:', result.claims)

# Staging (for devnet testing)
CROSSMINT_API_KEY=staging_sk_...
CROSSMINT_ENVIRONMENT=staging

# Production (for mainnet)
CROSSMINT_API_KEY=prod_sk_...
CROSSMINT_ENVIRONMENT=production

import { GhostSpeakClient } from '@ghostspeak/sdk'

const client = new GhostSpeakClient({
  cluster: 'devnet',
  commitment: 'confirmed',
  credentials: {
    crossmintApiKey: process.env.CROSSMINT_API_KEY,
    crossmintEnvironment: process.env.CROSSMINT_ENVIRONMENT || 'staging'
  }
})

const credential = await client.credentials.issueAgentIdentityCredential({
  agentId: agentAddress,
  owner: walletAddress,
  name: 'My AI Agent',
  capabilities: ['code-review', 'security-audit'],
  syncToCrossmint: true, // Enable cross-chain
  recipientEmail: '[email protected]' // Optional: email notifications
})

// Credential now exists on:
// - Solana (native)
// - Crossmint (indexed for EVM verification)

// Ethereum smart contract or Node.js backend
const response = await fetch(
  `https://crossmint.com/api/v1/credentials/${credentialId}/verify`,
  {
    method: 'GET',
    headers: {
      'X-API-Key': process.env.CROSSMINT_API_KEY,
      'Content-Type': 'application/json'
    }
  }
)

const result = await response.json()

if (result.valid && !result.revoked) {
  console.log('✅ Credential is valid!')
  console.log('Issuer:', result.issuer) // did:sol:GhostSpeak
  console.log('Subject:', result.subject) // did:sol:agentId
  console.log('Claims:', result.claims)
} else {
  console.log('❌ Credential is invalid or revoked')
}

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

interface ICrossmintVerifier {
    function verifyCredential(
        string calldata credentialId
    ) external view returns (bool valid, bool revoked, string memory issuer);
}

contract AgentGatekeeper {
    ICrossmintVerifier public verifier;

    constructor(address _verifier) {
        verifier = ICrossmintVerifier(_verifier);
    }

    function checkAgentCredential(
        string calldata credentialId,
        string[] calldata requiredCapabilities
    ) public view returns (bool) {
        (bool valid, bool revoked, string memory issuer) = verifier.verifyCredential(credentialId);

        // Only accept GhostSpeak-issued credentials
        require(valid && !revoked, "Invalid credential");
        require(
            keccak256(bytes(issuer)) == keccak256(bytes("did:sol:GhostSpeak")),
            "Not a GhostSpeak credential"
        );

        // Additional capability checks would go here
        return true;
    }
}

import { ethers } from 'ethers'

async function verifyAgentCredential(credentialId: string) {
  const response = await fetch(
    `https://crossmint.com/api/v1/credentials/${credentialId}/verify`,
    {
      headers: { 'X-API-Key': CROSSMINT_API_KEY }
    }
  )

  const result = await response.json()

  if (!result.valid || result.revoked) {
    throw new Error('Invalid or revoked credential')
  }

  // Check if credential has required capability
  const hasCodeReview = result.claims.capabilities?.includes('code-review')

  return {
    valid: true,
    agentId: result.subject,
    capabilities: result.claims.capabilities,
    hasCodeReview
  }
}

// Usage in React/Next.js
function AgentProfile({ credentialId }: { credentialId: string }) {
  const [credential, setCredential] = useState(null)

  useEffect(() => {
    verifyAgentCredential(credentialId).then(setCredential)
  }, [credentialId])

  if (!credential) return <div>Verifying...</div>

  return (
    <div>
      <h2>Agent Verified ✅</h2>
      <p>Agent ID: {credential.agentId}</p>
      <p>Capabilities: {credential.capabilities.join(', ')}</p>
    </div>
  )
}

// Revoke on Solana
await client.credentials.revoke(credentialId, {
  reason: 'Agent capabilities changed'
})

// Crossmint automatically updates revocation status

// Verification on Ethereum now returns revoked: true
const ethVerification = await fetch(
  `https://crossmint.com/api/v1/credentials/${credentialId}/verify`,
  { headers: { 'X-API-Key': CROSSMINT_API_KEY } }
).then(r => r.json())

console.log('Revoked:', ethVerification.revoked) // true
console.log('Reason:', ethVerification.revocationReason)