Add Keet identity to a chat app

npm install keet-identity-key hypercore-crypto

  let mnemonic = cmd.flags.mnemonic
  const mnemonicPath = path.join(appStorage, 'identity-mnemonic.txt')
  if (!mnemonic) {
    mnemonic = await fs.promises.readFile(mnemonicPath, 'utf-8').catch((err) => {
      if (err.code !== 'ENOENT') throw err
    })
    mnemonic = mnemonic || Identity.generateMnemonic()
  }
  await fs.promises.writeFile(mnemonicPath, mnemonic)

const Corestore = require('corestore')
const debounce = require('debounceify')
const crypto = require('hypercore-crypto')
const Hyperswarm = require('hyperswarm')
const Identity = require('keet-identity-key')
const ReadyResource = require('ready-resource')

const ChatRoomIdentity = require('./chat-room-identity')

class WorkerTask extends ReadyResource {
  constructor (pipe, storage, mnemonic, opts = {}) {
    super()

    this.pipe = pipe
    this.storage = storage
    this.mnemonic = mnemonic
    this.invite = opts.invite
    this.name = opts.name || `User ${Date.now()}`

    this.store = new Corestore(storage)
    this.swarm = new Hyperswarm()
    this.swarm.on('connection', (conn) => this.store.replicate(conn))

    this.room = new ChatRoomIdentity(this.store, this.swarm, this.invite)
    this.debounceMessages = debounce(() => this._messages())
    this.room.on('update', () => this.debounceMessages())

    this.identity = null
    this.deviceKeyPair = null
    this.deviceProof = null
  }

  async _open () {
    this.identity = await Identity.from({ mnemonic: this.mnemonic })
    this.deviceKeyPair = crypto.keyPair()
    this.deviceProof = await this.identity.bootstrap(this.deviceKeyPair.publicKey)

    await this.store.ready()
    await this.room.ready()

    this.pipe.on('data', async (data) => {
      let message
      try {
        message = JSON.parse(data)
      } catch {
        return
      }
      if (message.type === 'add-message') {
        const proof = Identity.attestData(Buffer.from(message.text), this.deviceKeyPair, this.deviceProof)
        await this.room.addMessage(message.text, proof, { name: this.name, at: Date.now() })
      }
    })
    await this.debounceMessages()

    this.pipe.write(JSON.stringify({ type: 'invite', invite: await this.room.getInvite() }))
  }

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

  async _messages () {
    const messages = await this.room.getMessages()
    messages.sort((a, b) => a.info.at - b.info.at)
    for (const msg of messages) {
      const res = Identity.verify(msg.proof, Buffer.from(msg.text), {
        expectedIdentity: this.identity.identityPublicKey
      })
      msg.info.verified = !!res
    }
    this.pipe.write(JSON.stringify({ type: 'messages', messages }))
  }
}

module.exports = WorkerTask

const Autobase = require('autobase')
const b4a = require('b4a')
const BlindPairing = require('blind-pairing')
const HyperDB = require('hyperdb')
const ReadyResource = require('ready-resource')
const z32 = require('z32')

const ChatDispatch = require('../spec/dispatch')
const ChatDb = require('../spec/db')

class ChatRoomIdentity extends ReadyResource {
  constructor (store, swarm, invite) {
    super()

    this.store = store
    this.swarm = swarm
    this.invite = invite

    this.pairing = new BlindPairing(swarm)

    /** @type {{ add: function(string, function(any, { view: HyperDB, base: Autobase })) }} */
    this.router = new ChatDispatch.Router()
    this._setupRouter()

    this.localBase = Autobase.getLocalCore(this.store)
    this.base = null
    this.pairMember = null
  }

  async _open () {
    await this.localBase.ready()
    const localKey = this.localBase.key
    const isEmpty = this.localBase.length === 0

    let key
    let encryptionKey
    if (isEmpty && this.invite) {
      const res = await new Promise((resolve) => {
        this.pairing.addCandidate({
          invite: z32.decode(this.invite),
          userData: localKey,
          onadd: resolve
        })
      })
      key = res.key
      encryptionKey = res.encryptionKey
    }

    // if base is not initialized, key and encryptionKey must be provided
    // if base is already initialized in this store namespace, key and encryptionKey can be omitted
    await this.localBase.close()
    this.base = new Autobase(this.store, key, {
      encrypt: true,
      encryptionKey,
      open: this._openBase.bind(this),
      close: this._closeBase.bind(this),
      apply: this._applyBase.bind(this)
    })

    const writablePromise = new Promise((resolve) => {
      this.base.on('update', () => {
        if (this.base.writable) resolve()
        if (!this.base._interrupting) this.emit('update')
      })
    })
    await this.base.ready()
    this.swarm.join(this.base.discoveryKey)
    if (!this.base.writable) await writablePromise

    this.view.core.download({ start: 0, end: -1 })

    this.pairMember = this.pairing.addMember({
      discoveryKey: this.base.discoveryKey,
      /** @type {function(import('blind-pairing-core').MemberRequest)} */
      onadd: async (request) => {
        const inv = await this.view.findOne('@pear-chat-identity/invites', { id: request.inviteId })
        if (!inv) return
        request.open(inv.publicKey)
        await this.addWriter(request.userData)
        request.confirm({
          key: this.base.key,
          encryptionKey: this.base.encryptionKey
        })
      }
    })
  }

  async _close () {
    await this.pairMember?.close()
    await this.base?.close()
    await this.localBase.close()
    await this.pairing.close()
  }

  _openBase (store) {
    return HyperDB.bee(store.get('view'), ChatDb, { extension: false, autoUpdate: true })
  }

  async _closeBase (view) {
    await view.close()
  }

  async _applyBase (nodes, view, base) {
    for (const node of nodes) {
      await this.router.dispatch(node.value, { view, base })
    }
    await view.flush()
  }

  _setupRouter () {
    this.router.add('@pear-chat-identity/add-writer', async (data, context) => {
      await context.base.addWriter(data.key)
    })
    this.router.add('@pear-chat-identity/add-invite', async (data, context) => {
      await context.view.insert('@pear-chat-identity/invites', data)
    })
    this.router.add('@pear-chat-identity/add-message', async (data, context) => {
      await context.view.insert('@pear-chat-identity/messages', data)
    })
  }

  /** @type {HyperDB} */
  get view () {
    return this.base.view
  }

  async getInvite () {
    const existing = await this.view.findOne('@pear-chat-identity/invites', {})
    if (existing) {
      return z32.encode(existing.invite)
    }
    const { id, invite, publicKey, expires } = BlindPairing.createInvite(this.base.key)
    await this.base.append(
      ChatDispatch.encode('@pear-chat-identity/add-invite', { id, invite, publicKey, expires })
    )
    return z32.encode(invite)
  }

  async addWriter (key) {
    await this.base.append(
      ChatDispatch.encode('@pear-chat-identity/add-writer', { key: b4a.isBuffer(key) ? key : b4a.from(key) })
    )
  }

  async getMessages ({ reverse = true, limit = 100 } = {}) {
    return await this.view.find('@pear-chat-identity/messages', { reverse, limit }).toArray()
  }

  async addMessage (text, proof, info) {
    const id = Math.random().toString(16).slice(2)
    await this.base.append(
      ChatDispatch.encode('@pear-chat-identity/add-message', { id, text, proof, info })
    )
  }
}

module.exports = ChatRoomIdentity

rm -rf spec && npm run build:db

    const verified = message.info?.verified
    const badge = document.createElement('span')
    badge.className = `text-[10px] ${verified ? 'text-emerald-400' : 'text-rose-400'}`
    badge.title = verified ? 'Signature verified' : 'Signature invalid'
    badge.textContent = verified ? '● verified' : '○ unverified'

    const time = document.createElement('span')
    time.className = 'ml-auto text-xs text-neutral-500'
    time.textContent = new Date(message.info?.at).toLocaleTimeString()

    meta.append(name, badge, time)