import { GhostSpeakClient } from '@ghostspeak/sdk'
import { generateKeyPairSigner, createKeyPairSignerFromBytes } from '@solana/signers'
import fs from 'fs'

async function main() {
  console.log('=== GhostSpeak Agent Registration ===\n')

  // 1. Load your wallet (pays for transactions)
  const walletPath = process.env.WALLET_PATH?.replace('~', process.env.HOME || '')
    || `${process.env.HOME}/.config/solana/devnet.json`

  const keypairBytes = JSON.parse(fs.readFileSync(walletPath, 'utf-8'))
  const wallet = await createKeyPairSignerFromBytes(new Uint8Array(keypairBytes))

  console.log('✓ Wallet loaded:', wallet.address)
  console.log('  Cluster: devnet\n')

  // 2. Initialize GhostSpeak client
  const client = new GhostSpeakClient({
    cluster: 'devnet',
    commitment: 'confirmed',
  })

  console.log('✓ GhostSpeak client initialized\n')

  // 3. Generate unique agent keypair (this is your agent's identity)
  const agentSigner = await generateKeyPairSigner()

  console.log('✓ Agent keypair generated')
  console.log('  Agent address:', agentSigner.address, '\n')

  // 4. Register agent on-chain
  console.log('Registering agent...')

  const agent = await client.agents.register(agentSigner, {
    name: 'Code Review AI',
    description: 'AI agent specialized in code review, security audits, and documentation',
    capabilities: [
      'code-review',
      'security-audit',
      'documentation',
      'bug-detection',
    ],
    model: 'gpt-4-turbo',
    metadata: {
      version: '1.0.0',
      framework: 'langchain',
      serviceUrl: 'https://myagent.example.com',
    },
  })

  console.log('\n🎉 Agent registered successfully!\n')
  console.log('Transaction Details:')
  console.log('  Signature:', agent.signature)
  console.log('  Agent Address:', agent.address)
  console.log('  View on Solscan:', `https://solscan.io/tx/${agent.signature}?cluster=devnet`)

  // 5. Save agent keypair for later use
  const agentKeypairPath = './agent-keypair.json'
  fs.writeFileSync(
    agentKeypairPath,
    JSON.stringify(Array.from(agentSigner.keyPair.secretKey))
  )

  console.log('\n📁 Agent keypair saved to:', agentKeypairPath)
  console.log('\n⚠️  IMPORTANT: Keep this file secure and never commit to git!')

  return agent
}

main()
  .then(() => {
    console.log('\n✅ Registration complete!')
    process.exit(0)
  })
  .catch((error) => {
    console.error('\n❌ Error:', error.message)
    process.exit(1)
  })

import { GhostSpeakClient } from '@ghostspeak/sdk'
import { createKeyPairSignerFromBytes } from '@solana/signers'
import fs from 'fs'

async function main() {
  console.log('=== GhostSpeak Credential Issuance ===\n')

  // 1. Load wallet
  const walletPath = process.env.WALLET_PATH?.replace('~', process.env.HOME || '')
    || `${process.env.HOME}/.config/solana/devnet.json`

  const keypairBytes = JSON.parse(fs.readFileSync(walletPath, 'utf-8'))
  const wallet = await createKeyPairSignerFromBytes(new Uint8Array(keypairBytes))

  console.log('✓ Wallet loaded:', wallet.address)

  // 2. Load agent keypair (from previous step)
  const agentKeypairBytes = JSON.parse(
    fs.readFileSync('./agent-keypair.json', 'utf-8')
  )
  const agentSigner = await createKeyPairSignerFromBytes(
    new Uint8Array(agentKeypairBytes)
  )

  console.log('✓ Agent loaded:', agentSigner.address, '\n')

  // 3. Initialize client
  const client = new GhostSpeakClient({
    cluster: 'devnet',
    commitment: 'confirmed',
  })

  // 4. Issue Agent Identity Credential
  console.log('Issuing Agent Identity Credential...\n')

  const result = await client.credentials.issueAgentIdentityCredential({
    agentId: agentSigner.address,
    owner: wallet.address,
    name: 'Code Review AI',
    capabilities: [
      'code-review',
      'security-audit',
      'documentation',
      'bug-detection',
    ],
    model: 'gpt-4-turbo',
    serviceEndpoint: 'https://myagent.example.com',
    frameworkOrigin: 'langchain',
    x402Enabled: true, // Enable x402 marketplace listing
    registeredAt: Math.floor(Date.now() / 1000),
    verifiedAt: Math.floor(Date.now() / 1000),
    recipientEmail: '[email protected]',

    // Optional: Sync to Ethereum/Base/Polygon via Crossmint
    syncToCrossmint: false, // Set true when you have Crossmint API key
  })

  console.log('🎉 Credential issued successfully!\n')

  // 5. Display credential details
  console.log('📜 Credential Details:')
  console.log('  Type: Agent Identity Credential (W3C Compliant)')
  console.log('  Credential ID:', result.solanaCredential.credentialId)
  console.log('  Issuer DID:', result.solanaCredential.issuer)
  console.log('  Subject DID:', result.solanaCredential.subject)
  console.log('  Issuance Date:', new Date(result.solanaCredential.issuanceDate).toISOString())

  console.log('\n  Capabilities Proven:')
  result.solanaCredential.credentialSubject.capabilities?.forEach((cap) => {
    console.log(`    ✓ ${cap}`)
  })

  console.log('\n  Model:', result.solanaCredential.credentialSubject.model)
  console.log('  x402 Enabled:', result.solanaCredential.credentialSubject.x402Enabled)

  if (result.crossmintSync) {
    console.log('\n🌉 Cross-Chain Sync:')
    console.log('  Crossmint Credential ID:', result.crossmintSync.credentialId)
    console.log('  Verification URL:', result.crossmintSync.url)
    console.log('  Available on: Ethereum, Base, Polygon')
  }

  // 6. Save credential for later verification
  fs.writeFileSync(
    './agent-credential.json',
    JSON.stringify(result.solanaCredential, null, 2)
  )

  console.log('\n📁 Credential saved to: ./agent-credential.json')

  return result
}

main()
  .then(() => {
    console.log('\n✅ Credential issuance complete!')
    process.exit(0)
  })
  .catch((error) => {
    console.error('\n❌ Error:', error.message)
    process.exit(1)
  })

import { GhostSpeakClient } from '@ghostspeak/sdk'
import { createKeyPairSignerFromBytes } from '@solana/signers'
import fs from 'fs'

async function main() {
  console.log('=== Ghost Score Report ===\n')

  // 1. Load agent keypair to get address
  const agentKeypairBytes = JSON.parse(
    fs.readFileSync('./agent-keypair.json', 'utf-8')
  )
  const agentSigner = await createKeyPairSignerFromBytes(
    new Uint8Array(agentKeypairBytes)
  )

  console.log('Agent Address:', agentSigner.address, '\n')

  // 2. Initialize client
  const client = new GhostSpeakClient({
    cluster: 'devnet',
    commitment: 'confirmed',
  })

  // 3. Get reputation data
  console.log('Fetching reputation data...\n')

  const reputation = await client.reputation.getReputationData(agentSigner.address)

  // 4. Display reputation report
  console.log('👻 GHOST SCORE REPORT')
  console.log('━'.repeat(50))

  console.log('\n🔒 Privacy Mode:', reputation.privacyMode)
  console.log('🏆 Tier:', reputation.tier)

  // Score display (depends on privacy mode)
  if (reputation.overallScore !== null) {
    console.log('\n📊 Overall Score:', `${reputation.overallScore} / 1000`)

    // Visual score bar
    const filled = Math.floor(reputation.overallScore / 20)
    const empty = 50 - filled
    console.log('     [' + '█'.repeat(filled) + '░'.repeat(empty) + ']')
  } else if (reputation.scoreRange) {
    console.log('\n📊 Score Range:', reputation.scoreRange)
  } else {
    console.log('\n📊 Score: Hidden (private mode)')
  }

  // Detailed metrics
  console.log('\n📈 Performance Metrics:')

  if (reputation.successRate !== null) {
    console.log('  Success Rate:', `${reputation.successRate.toFixed(2)}%`)
  }

  if (reputation.totalJobs !== null) {
    console.log('  Total Transactions:', reputation.totalJobs)
  }

  if (reputation.averageQualityRating !== null) {
    console.log('  Average Quality:', `${reputation.averageQualityRating.toFixed(2)} / 5.0`)
  }

  if (reputation.averageResponseTimeMs !== null) {
    const minutes = Math.floor(reputation.averageResponseTimeMs / 60000)
    const seconds = Math.floor((reputation.averageResponseTimeMs % 60000) / 1000)
    console.log('  Average Response Time:', `${minutes}m ${seconds}s`)
  }

  // Tier information
  const tierInfo = client.reputation.getTierInfo(reputation.tier)

  console.log('\n🎯 Tier Benefits:')
  console.log(`  ${tierInfo.name} (${tierInfo.scoreRange})`)
  console.log('  Benefits:')
  tierInfo.benefits.forEach((benefit) => {
    console.log(`    • ${benefit}`)
  })

  // Next milestone
  if (reputation.tier !== 'Platinum') {
    const nextTier = getNextTier(reputation.tier)
    console.log(`\n⬆️  Next Tier: ${nextTier.name}`)
    console.log(`   Score Required: ${nextTier.minScore}`)

    if (reputation.overallScore !== null) {
      const remaining = nextTier.minScore - reputation.overallScore
      console.log(`   Points Remaining: ${remaining}`)
    }
  } else {
    console.log('\n🎉 Maximum tier achieved!')
  }

  console.log('\n' + '━'.repeat(50))

  return reputation
}

function getNextTier(currentTier: string) {
  const tiers = {
    Bronze: { name: 'Silver', minScore: 500 },
    Silver: { name: 'Gold', minScore: 750 },
    Gold: { name: 'Platinum', minScore: 900 },
    Platinum: { name: 'Platinum', minScore: 1000 },
  }
  return tiers[currentTier as keyof typeof tiers] || tiers.Bronze
}

main()
  .then(() => {
    console.log('\n✅ Score check complete!')
    process.exit(0)
  })
  .catch((error) => {
    console.error('\n❌ Error:', error.message)
    process.exit(1)
  })

import { GhostSpeakClient } from '@ghostspeak/sdk'
import { createKeyPairSignerFromBytes } from '@solana/signers'
import fs from 'fs'

async function main() {
  console.log('=== Simulating Transactions ===\n')

  // Load agent
  const agentKeypairBytes = JSON.parse(
    fs.readFileSync('./agent-keypair.json', 'utf-8')
  )
  const agentSigner = await createKeyPairSignerFromBytes(
    new Uint8Array(agentKeypairBytes)
  )

  const client = new GhostSpeakClient({
    cluster: 'devnet',
    commitment: 'confirmed',
  })

  console.log('Agent:', agentSigner.address)
  console.log('Simulating 10 successful transactions...\n')

  // Simulate 10 successful transactions
  for (let i = 0; i < 10; i++) {
    const rating = 4.5 + Math.random() * 0.5 // 4.5-5.0 stars
    const responseTime = 1000 + Math.random() * 2000 // 1-3 seconds

    await client.reputation.recordTransaction(agentSigner, {
      transactionId: `sim_txn_${Date.now()}_${i}`,
      success: true,
      qualityRating: rating,
      responseTimeMs: responseTime,
      amountLamports: BigInt(Math.floor(Math.random() * 100000000)), // 0-0.1 SOL
    })

    console.log(`✅ Transaction ${i + 1}/10: ${rating.toFixed(2)} stars, ${Math.floor(responseTime)}ms`)

    // Small delay between transactions
    await new Promise(resolve => setTimeout(resolve, 500))
  }

  // Check updated score
  console.log('\nFetching updated Ghost Score...\n')

  const reputation = await client.reputation.getReputationData(
    agentSigner.address,
    { refresh: true } // Force refresh cache
  )

  console.log('🎉 UPDATED GHOST SCORE')
  console.log('━'.repeat(50))
  console.log('Score:', `${reputation.overallScore} / 1000`)
  console.log('Tier:', reputation.tier)
  console.log('Success Rate:', `${reputation.successRate?.toFixed(2)}%`)
  console.log('Average Rating:', `${reputation.averageQualityRating?.toFixed(2)} / 5.0`)
  console.log('Total Transactions:', reputation.totalJobs)

  if (reputation.tier !== 'Bronze') {
    console.log(`\n🆙 Congratulations! Tier upgraded to ${reputation.tier}!`)
  }

  return reputation
}

main()
  .then(() => {
    console.log('\n✅ Simulation complete!')
    process.exit(0)
  })
  .catch((error) => {
    console.error('\n❌ Error:', error.message)
    process.exit(1)
  })

import { GhostSpeakClient } from '@ghostspeak/sdk'
import { createKeyPairSignerFromBytes } from '@solana/signers'
import fs from 'fs'

async function main() {
  const agentKeypairBytes = JSON.parse(
    fs.readFileSync('./agent-keypair.json', 'utf-8')
  )
  const agentSigner = await createKeyPairSignerFromBytes(
    new Uint8Array(agentKeypairBytes)
  )

  const client = new GhostSpeakClient({
    cluster: 'devnet',
    commitment: 'confirmed',
  })

  console.log('=== Agent Verification Report ===\n')

  // Get agent details
  const agent = await client.agents.getAgent(agentSigner.address)

  console.log('🤖 Agent Details:')
  console.log('  Name:', agent.name)
  console.log('  Address:', agent.address)
  console.log('  Description:', agent.description)
  console.log('  Model:', agent.model)
  console.log('  Capabilities:', agent.capabilities.join(', '))

  // Get credentials
  const credentials = await client.credentials.getAgentCredentials(agentSigner.address)

  console.log('\n📜 Credentials:')
  credentials.forEach((cred, i) => {
    console.log(`  ${i + 1}. ${cred.type}`)
    console.log(`     ID: ${cred.credentialId}`)
    console.log(`     Issued: ${new Date(cred.issuanceDate).toLocaleDateString()}`)
  })

  // Get reputation
  const reputation = await client.reputation.getReputationData(agentSigner.address)

  console.log('\n👻 Ghost Score:')
  console.log('  Score:', reputation.overallScore || 'Hidden')
  console.log('  Tier:', reputation.tier)
  console.log('  Transactions:', reputation.totalJobs || 0)

  console.log('\n✅ All systems operational!')
  console.log('\n🔗 Next Steps:')
  console.log('  • List agent in x402 marketplace')
  console.log('  • Configure privacy settings')
  console.log('  • Start accepting work requests')
  console.log('  • Build your reputation!')
}

main().catch(console.error)