client.js

const process = require('process')
const Hyperswarm = require('hyperswarm')
const RPC = require('@hyperswarm/rpc')
const Corestore = require('corestore')
const Hyperbee = require('hyperbee')
const IdEnc = require('hypercore-id-encoding')
const HyperDHT = require('hyperdht')
const minimist = require('minimist')

const args = minimist(process.argv.slice(2))
const bootstrap = [{ host: '127.0.0.1', port: 30001 }]

class UsernameRegistryClient {
  constructor(serverPublicKey, coreKey, storagePath = null) {
    this.serverPublicKey = serverPublicKey
    this.coreKey = coreKey
    // Use unique storage path to avoid conflicts
    this.storagePath = storagePath || `client-corestore-${Date.now()}`
    this.store = new Corestore(this.storagePath)
    this.bee = null
    this.swarm = null
    this.dht = null
    this.rpc = null
    this.client = null
  }

  async initialize() {
    // Create consistent key pairs
    const dhtKeyPair = await this.store.createKeyPair('dht')
    const swarmKeyPair = await this.store.createKeyPair('swarm')

    // Set up DHT and swarm
    this.dht = new HyperDHT({ keyPair: dhtKeyPair, bootstrap })
    this.swarm = new Hyperswarm({ dht: this.dht, keyPair: swarmKeyPair })

    // Set up corestore replication
    this.swarm.on('connection', async (conn) => {
      console.log('Hyperswarm connection opened')
      this.store.replicate(conn)
    })

    // Get the hypercore and initialize hyperbee
    const core = this.store.get({ key: this.coreKey })
    await core.ready()

    this.bee = new Hyperbee(core, {
      keyEncoding: 'utf8',
      valueEncoding: 'utf8'
    })
    await this.bee.ready()

    // Join the discovery key
    this.swarm.join(core.discoveryKey)

    // Set up RPC client
    this.rpc = new RPC({ dht: this.dht })

    // Wait a bit for the connection to be fully established
    await new Promise(resolve => setTimeout(resolve, 2000))

    console.log(`DHT public key: ${IdEnc.normalize(this.dht.defaultKeyPair.publicKey)}`)
    console.log(`Swarm public key: ${IdEnc.normalize(this.swarm.keyPair.publicKey)}`)

    return this
  }

  async registerUsername(username, publicKey) {
    try {
      if (!this.rpc) {
        throw new Error('RPC client not initialized')
      }
      const response = await this.rpc.request(this.serverPublicKey, 'register-username',
        Buffer.from(JSON.stringify({ username, publicKey }))
      )
      return JSON.parse(response.toString())
    } catch (error) {
      console.error('Error registering username:', error)
      return { success: false, error: error.message }
    }
  }

  async deleteUsername(username, publicKey) {
    try {
      if (!this.rpc) {
        throw new Error('RPC client not initialized')
      }
      const response = await this.rpc.request(this.serverPublicKey, 'delete-username',
        Buffer.from(JSON.stringify({ username, publicKey }))
      )
      return JSON.parse(response.toString())
    } catch (error) {
      console.error('Error deleting username:', error)
      return { success: false, error: error.message }
    }
  }

  async lookupUsername(username) {
    try {
      const result = await this.bee.get(username)
      if (result) {
        return {
          username: username,
          publicKey: result.value.toString()
        }
      }
      return null
    } catch (error) {
      console.error('Error looking up username:', error)
      return null
    }
  }

  async listUsernames() {
    try {
      const usernames = []
      for await (const { key, value } of this.bee.createReadStream()) {
        usernames.push({
          username: key.toString(),
          publicKey: value.toString()
        })
      }
      return usernames
    } catch (error) {
      console.error('Error listing usernames:', error)
      return []
    }
  }

  async destroy() {
    if (this.swarm) {
      await this.swarm.destroy()
    }
    if (this.store) {
      await this.store.close()
    }
  }
}

async function main() {
  if (args.help) {
    console.log(`
Usage: node client.js <command> [options]

Commands:
  register <username> <publicKey>  - Register a username
  delete <username> <publicKey>   - Delete a username
  lookup <username>               - Look up a username
  list                           - List all usernames
  server-info                    - Get server information

Options:
  --server-key <key>             - Server public key (required)
  --core-key <key>               - Core key (required)
  --help                         - Show this help
    `)
    return
  }

  if (!args['server-key'] || !args['core-key']) {
    console.error('Error: --server-key and --core-key are required')
    console.log('Use --help for usage information')
    process.exit(1)
  }

  const serverPublicKey = IdEnc.decode(args['server-key'])
  const coreKey = IdEnc.decode(args['core-key'])

  console.log(`Using server pub key ${IdEnc.normalize(serverPublicKey)} and core key ${IdEnc.normalize(coreKey)}`)

  const client = new UsernameRegistryClient(serverPublicKey, coreKey)

  try {
    await client.initialize()

    const command = args._[0]

    switch (command) {
      case 'register':
        if (args._.length < 3) {
          console.error('Usage: register <username> <publicKey>')
          break
        }
        const registerResult = await client.registerUsername(args._[1], args._[2])
        console.log(JSON.stringify(registerResult, null, 2))
        break

      case 'delete':
        if (args._.length < 3) {
          console.error('Usage: delete <username> <publicKey>')
          break
        }
        const deleteResult = await client.deleteUsername(args._[1], args._[2])
        console.log(JSON.stringify(deleteResult, null, 2))
        break

      case 'lookup':
        if (args._.length < 2) {
          console.error('Usage: lookup <username>')
          break
        }
        const lookupResult = await client.lookupUsername(args._[1])
        if (lookupResult) {
          console.log(JSON.stringify(lookupResult, null, 2))
        } else {
          console.log('Username not found')
        }
        break

      case 'list':
        const listResult = await client.listUsernames()
        console.log(JSON.stringify(listResult, null, 2))
        break

      case 'server-info':
        console.log(`Server public key: ${IdEnc.normalize(serverPublicKey)}`)
        console.log(`Core key: ${IdEnc.normalize(coreKey)}`)
        break

      default:
        console.error(`Unknown command: ${command}`)
        console.log('Use --help for usage information')
        break
    }

  } catch (error) {
    console.error('Client error:', error)
  } finally {
    await client.destroy()
  }
}

if (require.main === module) {
  main()
}

module.exports = UsernameRegistryClient