test.js

const b4a = require('b4a')
const test = require('brittle')
const { spawn } = require('child_process')
const Corestore = require('corestore')
const fs = require('fs').promises
const path = require('path')
const process = require('process')
const crypto = require('hypercore-crypto')
const idEnc = require('hypercore-id-encoding')
const createTestnet = require('hyperdht/testnet')
const CoreSign = require('hypercore-sign')
const SignRequest = require('hypercore-signing-request')
const Hyperdrive = require('hyperdrive')
const Hyperswarm = require('hyperswarm')
const Multisig = require('hyper-multisig')
const NewlineDecoder = require('newline-decoder')
const sodium = require('sodium-native')
const { isBare } = require('which-runtime')
const z32 = require('z32')

const DEBUG = false
const EXECUTABLE = path.join(__dirname, isBare ? 'bin-bare.js' : 'bin.js')

test('link', async (t) => {
  const tLinkCore = t.test('Link core CLI')
  tLinkCore.plan(2)

  const dir = await t.tmp()

  const cliStorageDir = path.join(dir, 'cli-storage')
  await fs.mkdir(cliStorageDir)
  const configLoc = path.join(dir, 'multisig.json')
  const { namespace, publicKeys } = setupMultisig(undefined, 3)
  const config = {
    type: 'core',
    namespace,
    publicKeys
  }
  await fs.writeFile(configLoc, JSON.stringify(config))

  const linkProc = spawn(process.execPath, [
    EXECUTABLE,
    '--config',
    configLoc,
    '--storage',
    cliStorageDir,
    'link'
  ])

  // To avoid zombie processes in case there's an error
  process.on('exit', () => {
    linkProc.kill('SIGKILL')
  })
  linkProc.stderr.on('data', (d) => {
    console.error(d.toString())
    t.fail('There should be no stderr')
  })

  let coreKey = null
  const stdoutDec = new NewlineDecoder('utf-8')
  linkProc.stdout.on('data', (d) => {
    if (DEBUG) console.log(d.toString())

    for (const line of stdoutDec.push(d)) {
      if (line.includes('pear://')) {
        tLinkCore.pass('link is printed')
        coreKey = line.split('pear://')[1]
      }
    }
  })

  linkProc.on('exit', (status) => {
    tLinkCore.is(status, 0, 'CLI process exited cleanly')
  })

  await tLinkCore

  t.is(coreKey, idEnc.normalize(Multisig.getCoreKey(publicKeys, namespace)), 'core key is correct')
})

test('link with custom quorum', async (t) => {
  const tLinkCore = t.test('Link core CLI with quorum')
  tLinkCore.plan(2)

  const dir = await t.tmp()

  const cliStorageDir = path.join(dir, 'cli-storage')
  await fs.mkdir(cliStorageDir)
  const configLoc = path.join(dir, 'multisig.json')
  const { namespace, publicKeys } = setupMultisig(undefined, 5)
  const quorum = 2
  const config = {
    type: 'core',
    namespace,
    publicKeys,
    quorum
  }
  await fs.writeFile(configLoc, JSON.stringify(config))

  const linkProc = spawn(process.execPath, [
    EXECUTABLE,
    '--config',
    configLoc,
    '--storage',
    cliStorageDir,
    'link'
  ])

  process.on('exit', () => {
    linkProc.kill('SIGKILL')
  })
  linkProc.stderr.on('data', (d) => {
    console.error(d.toString())
    t.fail('There should be no stderr')
  })

  let coreKey = null
  const stdoutDec = new NewlineDecoder('utf-8')
  linkProc.stdout.on('data', (d) => {
    if (DEBUG) console.log(d.toString())

    for (const line of stdoutDec.push(d)) {
      if (line.includes('pear://')) {
        tLinkCore.pass('link is printed')
        coreKey = line.split('pear://')[1]
      }
    }
  })

  linkProc.on('exit', (status) => {
    tLinkCore.is(status, 0, 'CLI process exited cleanly')
  })

  await tLinkCore

  const expectedKey = idEnc.normalize(Multisig.getCoreKey(publicKeys, namespace, { quorum }))
  t.is(coreKey, expectedKey, 'core key with custom quorum is correct')

  const defaultKey = idEnc.normalize(Multisig.getCoreKey(publicKeys, namespace))
  t.not(coreKey, defaultKey, 'custom quorum key differs from default quorum key')
})

test('core request and sign CLI flow', async (t) => {
  const { bootstrap, store, swarm, store2, swarm2, store3, swarm3, store4, swarm4 } = await setup(
    t,
    4
  )

  const tRequestCore = t.test('Request core CLI')
  tRequestCore.plan(2)
  const tVerifyCore = t.test('Verify core CLI')
  tVerifyCore.plan(4)
  const tCommitCore = t.test('Commit core CLI')
  tCommitCore.plan(1)

  const tRequestCore2 = t.test('Request core 2 CLI')
  tRequestCore2.plan(2)
  const tVerifyCore2 = t.test('Verify core 2 CLI')
  tVerifyCore2.plan(4)
  const tCommitCore2 = t.test('Commit core 2 CLI')
  tCommitCore2.plan(1)

  const srcCore = await setupCore(t, store, swarm)

  const copy2 = store2.get(srcCore.key)
  await copy2.ready()
  swarm2.join(copy2.discoveryKey)
  await copy2.download({ start: 0, end: srcCore.length }).done()

  const copy3 = store3.get(srcCore.key)
  await copy3.ready()
  swarm3.join(copy3.discoveryKey)
  await copy3.download({ start: 0, end: srcCore.length }).done()

  const dir = await t.tmp()

  const cliStorageDir = path.join(dir, 'cli-storage')
  await fs.mkdir(cliStorageDir)
  const configLoc = path.join(dir, 'multisig.json')
  const { namespace, publicKeys, signers } = setupMultisig(undefined, 3)
  const config = {
    type: 'core',
    namespace,
    publicKeys,
    srcKey: idEnc.normalize(srcCore.key),
    bootstrap
  }
  await fs.writeFile(configLoc, JSON.stringify(config))

  let request = null
  {
    const requestCoreProc = spawn(process.execPath, [
      EXECUTABLE,
      '--config',
      configLoc,
      '--storage',
      cliStorageDir,
      'request',
      srcCore.length
    ])

    // To avoid zombie processes in case there's an error
    process.on('exit', () => {
      requestCoreProc.kill('SIGKILL')
    })
    requestCoreProc.stderr.on('data', (d) => {
      console.error(d.toString())
      t.fail('There should be no stderr')
    })

    {
      const stdoutDec = new NewlineDecoder('utf-8')
      requestCoreProc.stdout.on('data', (d) => {
        if (DEBUG) console.log(d.toString())

        for (const line of stdoutDec.push(d)) {
          if (line.includes('hypercore-sign')) {
            tRequestCore.pass('sign request created')
            request = line.split('hypercore-sign ')[1]
          }
        }
      })
    }

    requestCoreProc.on('exit', (status) => {
      tRequestCore.is(status, 0, 'CLI process exited cleanly')
    })

    await tRequestCore
  }

  t.is(SignRequest.decode(z32.decode(request)).version, 2, 'generates legacy requests') // expected to fail when we move to v3 requests. Make sure to major bump then.
  const responses = signers.slice(0, 2).map((signer) => signResponse(z32.decode(request), signer))

  {
    const verifyCoreProc = spawn(process.execPath, [
      EXECUTABLE,
      '--config',
      configLoc,
      '--storage',
      cliStorageDir,
      'verify',
      '--first-commit',
      request,
      ...responses
    ])

    process.on('exit', () => {
      verifyCoreProc.kill('SIGKILL')
    })
    verifyCoreProc.stderr.on('data', (d) => {
      console.log('the stderr is', d.toString())
      console.error(d.toString())
      t.fail('There should be no stderr')
    })

    let reviewLineStart = null
    const reviewLines = []

    const stdoutDec = new NewlineDecoder('utf-8')
    verifyCoreProc.stdout.on('data', (d) => {
      for (const line of stdoutDec.push(d)) {
        if (line.includes('Quorum')) {
          const quorum = parseInt(line.split('Quorum: ')[1].split(' / ')[0])
          if (quorum === responses.length) {
            tVerifyCore.pass('quorum matches number of responses')
          }
        }
        if (line.includes('Review batch to commit:')) {
          reviewLineStart = true
        }
        if (line.includes('core key:')) {
          reviewLineStart = false
          tVerifyCore.pass('core key is printed')
        }
        if (reviewLineStart) {
          reviewLines.push(line)
        } else if (reviewLineStart === false) {
          reviewLineStart = null
          tVerifyCore.pass('review lines printed')
        }
      }
    })
    verifyCoreProc.on('exit', (status) => {
      tVerifyCore.pass('verify core process shuts down cleanly')
    })

    await tVerifyCore

    reviewLines[0] = reviewLines[0].replace('Review batch to commit: ', '')
    const review = JSON.parse(reviewLines.join('\n'))

    t.is(review.destCore.length, 0, 'dest core has no new content')
    t.is(review.srcCore.length, srcCore.length, 'src core info is correct')
    t.is(review.batch.length, srcCore.length, 'batch has all entries from src core')
  }

  {
    const commitCoreProc = spawn(process.execPath, [
      EXECUTABLE,
      '--config',
      configLoc,
      '--storage',
      cliStorageDir,
      'commit',
      '--first-commit',
      request,
      ...responses
    ])

    process.on('exit', () => {
      commitCoreProc.kill('SIGKILL')
    })
    commitCoreProc.stderr.on('data', (d) => {
      console.log('the stderr is', d.toString())
      console.error(d.toString())
      t.fail('There should be no stderr')
    })

    let coreKey = null
    {
      const stdoutDec = new NewlineDecoder('utf-8')
      commitCoreProc.stdout.on('data', async (d) => {
        if (DEBUG) console.log(d.toString())

        for (const line of stdoutDec.push(d)) {
          if (line.includes('core key:')) {
            tCommitCore.pass('sign request committed')
            coreKey = line.split('core key: ')[1]
          }

          if (line.includes('Committed the core, key')) {
            if (DEBUG) console.log('REMOTED BEGIN DOWNLOADING TARGET')
            const key = idEnc.decode(line.split(', key ')[1].slice(0, 52))
            const tgtCopy = store2.get(key)
            await tgtCopy.ready()
            swarm2.join(tgtCopy.discoveryKey)
            tgtCopy.download({ start: 0, end: -1 })

            const tgtCopy2 = store3.get(key)
            await tgtCopy2.ready()
            swarm3.join(tgtCopy2.discoveryKey)
            await tgtCopy2.download({ start: 0, end: -1 })
          }
        }
      })
    }

    await tCommitCore

    {
      /** @type {import('hypercore')} */
      const core = store4.get(idEnc.decode(coreKey))
      t.teardown(() => core.close())
      await core.ready()
      swarm4.join(core.discoveryKey)

      t.is(b4a.toString(await core.get(2)), 'content 2', 'multisig core is seeded')
    }

    const tShutdown = t.test('Shutdown logic')
    tShutdown.plan(1)
    commitCoreProc.on('exit', (status) => {
      tShutdown.pass('commit core process shuts down cleanly')
    })
    commitCoreProc.kill('SIGINT')
    await tShutdown
  }

  await srcCore.append(b4a.from('content 3'))
  await copy2.download({ start: 0, end: srcCore.length }).done()
  await copy3.download({ start: 0, end: srcCore.length }).done()

  // second request
  let request2 = null
  {
    const requestCoreProc = spawn(process.execPath, [
      EXECUTABLE,
      '--config',
      configLoc,
      '--storage',
      cliStorageDir,
      'request',
      srcCore.length
    ])

    // To avoid zombie processes in case there's an error
    process.on('exit', () => {
      requestCoreProc.kill('SIGKILL')
    })
    requestCoreProc.stderr.on('data', (d) => {
      console.error(d.toString())
      t.fail('There should be no stderr')
    })

    {
      const stdoutDec = new NewlineDecoder('utf-8')
      requestCoreProc.stdout.on('data', (d) => {
        if (DEBUG) console.log(d.toString())

        for (const line of stdoutDec.push(d)) {
          if (line.includes('hypercore-sign')) {
            tRequestCore2.pass('sign request created')
            request2 = line.split('hypercore-sign ')[1]
          }
        }
      })
    }

    requestCoreProc.on('exit', (status) => {
      tRequestCore2.is(status, 0, 'CLI process exited cleanly')
    })

    await tRequestCore2
  }

  const responses2 = signers.slice(0, 2).map((signer) => signResponse(z32.decode(request2), signer))

  // second verify (without --first-commit)
  {
    const verifyCoreProc = spawn(process.execPath, [
      EXECUTABLE,
      '--config',
      configLoc,
      '--storage',
      cliStorageDir,
      'verify',
      request2,
      ...responses2
    ])

    process.on('exit', () => {
      verifyCoreProc.kill('SIGKILL')
    })
    verifyCoreProc.stderr.on('data', (d) => {
      console.log('the stderr is', d.toString())
      console.error(d.toString())
      t.fail('There should be no stderr')
    })

    let reviewLineStart = null
    const reviewLines = []

    const stdoutDec = new NewlineDecoder('utf-8')
    verifyCoreProc.stdout.on('data', (d) => {
      for (const line of stdoutDec.push(d)) {
        if (line.includes('Quorum')) {
          const quorum = parseInt(line.split('Quorum: ')[1].split(' / ')[0])
          if (quorum === responses2.length) {
            tVerifyCore2.pass('quorum matches number of responses')
          }
        }
        if (line.includes('Review batch to commit:')) {
          reviewLineStart = true
        }
        if (line.includes('core key:')) {
          reviewLineStart = false
          tVerifyCore2.pass('core key is printed')
        }
        if (reviewLineStart) {
          reviewLines.push(line)
        } else if (reviewLineStart === false) {
          reviewLineStart = null
          tVerifyCore2.pass('review lines printed')
        }
      }
    })
    verifyCoreProc.on('exit', (status) => {
      tVerifyCore2.pass('verify core process shuts down cleanly')
    })

    await tVerifyCore2

    reviewLines[0] = reviewLines[0].replace('Review batch to commit: ', '')
    const review = JSON.parse(reviewLines.join('\n'))

    t.is(review.destCore.length, 3, 'dest core has new content')
    t.is(review.srcCore.length, srcCore.length, 'src core info is correct')
    t.is(review.batch.length, srcCore.length, 'batch has all entries from src core')
  }

  // second commit
  {
    const commitCoreProc = spawn(process.execPath, [
      EXECUTABLE,
      '--config',
      configLoc,
      '--storage',
      cliStorageDir,
      'commit',
      request2,
      ...responses2
    ])

    process.on('exit', () => {
      commitCoreProc.kill('SIGKILL')
    })
    commitCoreProc.stderr.on('data', (d) => {
      console.log('the stderr is', d.toString())
      console.error(d.toString())
      t.fail('There should be no stderr')
    })

    let coreKey = null
    {
      const stdoutDec = new NewlineDecoder('utf-8')
      commitCoreProc.stdout.on('data', (d) => {
        if (DEBUG) console.log(d.toString())

        for (const line of stdoutDec.push(d)) {
          if (line.includes('core key:')) {
            tCommitCore2.pass('sign request committed')
            coreKey = line.split('core key: ')[1]
          }
        }
      })
    }

    await tCommitCore2

    const tShutdown = t.test('Shutdown logic')
    tShutdown.plan(1)
    commitCoreProc.on('exit', (status) => {
      tShutdown.pass('commit core process shuts down cleanly')
    })
    commitCoreProc.kill('SIGINT')
    await tShutdown
  }
})

test('drive request and sign CLI flow', async (t) => {
  const { bootstrap, store, swarm, store2, swarm2, store3, swarm3, store4, swarm4 } = await setup(
    t,
    4
  )

  const tRequestDrive = t.test('Request drive CLI')
  tRequestDrive.plan(7)
  const tVerifyDrive = t.test('Verify drive CLI')
  tVerifyDrive.plan(4)
  const tCommitDrive = t.test('Commit drive CLI')
  tCommitDrive.plan(1)

  const tRequestDrive2 = t.test('Request drive 2 CLI')
  tRequestDrive2.plan(2)
  const tVerifyDrive2 = t.test('Verify drive 2 CLI')
  tVerifyDrive2.plan(4)
  const tCommitDrive2 = t.test('Commit drive 2 CLI')
  tCommitDrive2.plan(1)

  const srcDrive = await setupDrive(t, store, swarm)

  const copy2 = new Hyperdrive(store2, srcDrive.key)
  await copy2.ready()
  swarm2.join(copy2.discoveryKey)
  await copy2.getBlobs()
  await copy2.db.core.download({ start: 0, end: srcDrive.version })
  await copy2.blobs.core.download({
    start: 0,
    end: await srcDrive.getBlobsLength(srcDrive.version)
  })

  const copy3 = new Hyperdrive(store3, srcDrive.key)
  await copy3.ready()
  swarm3.join(copy3.discoveryKey)
  await copy3.getBlobs()
  await copy3.db.core.download({ start: 0, end: srcDrive.version })
  await copy3.blobs.core.download({
    start: 0,
    end: await srcDrive.getBlobsLength(srcDrive.version)
  })

  const dir = await t.tmp()

  const cliStorageDir = path.join(dir, 'cli-storage')
  await fs.mkdir(cliStorageDir)
  const configLoc = path.join(dir, 'multisig.json')
  const { namespace, publicKeys, signers } = setupMultisig(undefined, 3)
  const config = {
    type: 'drive',
    namespace,
    publicKeys,
    srcKey: idEnc.normalize(srcDrive.key),
    bootstrap
  }
  await fs.writeFile(configLoc, JSON.stringify(config))

  let request = null
  {
    const requestDriveProc = spawn(process.execPath, [
      EXECUTABLE,
      '--config',
      configLoc,
      '--storage',
      cliStorageDir,
      'request',
      srcDrive.core.length
    ])

    // To avoid zombie processes in case there's an error
    process.on('exit', () => {
      requestDriveProc.kill('SIGKILL')
    })
    requestDriveProc.stderr.on('data', (d) => {
      console.error(d.toString())
      t.fail('There should be no stderr')
    })

    {
      const stdoutDec = new NewlineDecoder('utf-8')
      requestDriveProc.stdout.on('data', (d) => {
        if (DEBUG) console.log(d.toString())

        for (const line of stdoutDec.push(d)) {
          if (line.includes('hypercore-sign')) {
            tRequestDrive.pass('sign request created')
            request = line.split('hypercore-sign ')[1]
          }
          if (line.includes('Getting the source blobs')) tRequestDrive.pass('source blobs log')
          if (line.includes('Verifying the db core is requestable')) {
            tRequestDrive.pass('db requestable log')
          }
          if (line.includes('Getting the blobs length')) tRequestDrive.pass('blobs length log')
          if (line.includes('Verifying the blobs core is requestable')) {
            tRequestDrive.pass('blobs requestable log')
          }
          if (line.includes('Creating the drive')) tRequestDrive.pass('creating drive log')
        }
      })
    }

    requestDriveProc.on('exit', (status) => {
      tRequestDrive.is(status, 0, 'CLI process exited cleanly')
    })

    await tRequestDrive
  }

  t.is(SignRequest.decode(z32.decode(request)).version, 2, 'generates legacy requests') // expected to fail when we move to v3 requests. Make sure to major bump then.
  const responses = signers.slice(0, 2).map((signer) => signResponse(z32.decode(request), signer))

  {
    const verifyDriveProc = spawn(process.execPath, [
      EXECUTABLE,
      '--config',
      configLoc,
      '--storage',
      cliStorageDir,
      'verify',
      '--first-commit',
      request,
      ...responses
    ])

    process.on('exit', () => {
      verifyDriveProc.kill('SIGKILL')
    })
    verifyDriveProc.stderr.on('data', (d) => {
      console.log('the stderr is', d.toString())
      console.error(d.toString())
      t.fail('There should be no stderr')
    })

    let reviewLineStart = null
    const reviewLines = []

    const stdoutDec = new NewlineDecoder('utf-8')
    verifyDriveProc.stdout.on('data', (d) => {
      for (const line of stdoutDec.push(d)) {
        if (line.includes('Quorum')) {
          const quorum = parseInt(line.split('Quorum: ')[1].split(' / ')[0])
          if (quorum === responses.length) {
            tVerifyDrive.pass('quorum matches number of responses')
          }
        }
        if (line.includes('Review batch to commit:')) {
          reviewLineStart = true
        }
        if (line.includes('drive key:')) {
          reviewLineStart = false
          tVerifyDrive.pass('drive key is printed')
        }
        if (reviewLineStart) {
          reviewLines.push(line)
        } else if (reviewLineStart === false) {
          reviewLineStart = null
          tVerifyDrive.pass('review lines printed')
        }
      }
    })
    verifyDriveProc.on('exit', (status) => {
      tVerifyDrive.pass('verify drive process shuts down cleanly')
    })

    await tVerifyDrive

    reviewLines[0] = reviewLines[0].replace('Review batch to commit: ', '')
    const review = JSON.parse(reviewLines.join('\n'))

    t.is(review.db.destCore.length, 0, 'dest core has no new content')
    t.is(review.db.srcCore.length, srcDrive.db.core.length, 'src core info is correct')
    t.is(review.db.batch.length, srcDrive.db.core.length, 'batch has all entries from src core')
    t.is(review.blobs.destCore.length, 0, 'dest blobs has no new content')
    t.is(review.blobs.srcCore.length, srcDrive.blobs.core.length, 'src blobs info is correct')
    t.is(
      review.blobs.batch.length,
      srcDrive.blobs.core.length,
      'batch has all entries from src blobs'
    )
  }

  {
    const commitDriveProc = spawn(process.execPath, [
      EXECUTABLE,
      '--config',
      configLoc,
      '--storage',
      cliStorageDir,
      'commit',
      '--first-commit',
      request,
      ...responses
    ])

    process.on('exit', () => {
      commitDriveProc.kill('SIGKILL')
    })
    commitDriveProc.stderr.on('data', (d) => {
      console.log('the stderr is', d.toString())
      console.error(d.toString())
      t.fail('There should be no stderr')
    })

    let driveKey = null
    {
      const stdoutDec = new NewlineDecoder('utf-8')
      commitDriveProc.stdout.on('data', async (d) => {
        if (DEBUG) console.log(d.toString())

        for (const line of stdoutDec.push(d)) {
          if (line.includes('drive key:')) {
            tCommitDrive.pass('sign request committed')
            driveKey = line.split('drive key: ')[1]
          }

          if (line.includes('Committed the drive, key')) {
            if (DEBUG) console.log('REMOTES BEGIN DOWNLOADING TARGET')
            const key = idEnc.decode(line.split(', key ')[1].slice(0, 52))

            const tgtCopy = new Hyperdrive(store2, key)
            await tgtCopy.ready()
            swarm2.join(tgtCopy.discoveryKey)
            await tgtCopy.getBlobs()
            await tgtCopy.db.core.download({ start: 0, end: -1 })
            await tgtCopy.blobs.core.download({
              start: 0,
              end: -1
            })

            const tgtCopy2 = new Hyperdrive(store3, key)
            await tgtCopy2.ready()
            swarm3.join(tgtCopy2.discoveryKey)
            await tgtCopy2.getBlobs()
            await tgtCopy2.db.core.download({ start: 0, end: -1 })
            await tgtCopy2.blobs.core.download({
              start: 0,
              end: -1
            })
          }
        }
      })
    }

    await tCommitDrive

    {
      const drive = new Hyperdrive(store4, idEnc.decode(driveKey))
      t.teardown(() => drive.close())
      await drive.ready()
      swarm4.join(drive.discoveryKey)

      t.is(
        b4a.toString(await drive.checkout(srcDrive.version).get('/file2')),
        'file2 content',
        'multisig drive is seeded'
      )
    }

    const tShutdown = t.test('Shutdown logic')
    tShutdown.plan(1)

    commitDriveProc.on('exit', (status) => {
      tShutdown.pass('commit drive process shuts down cleanly')
    })
    commitDriveProc.kill('SIGINT')
    await tShutdown
  }

  await srcDrive.put('/file4', 'file4 content')
  await copy2.getBlobs()
  await copy2.db.core.download({ start: 0, end: srcDrive.version })
  await copy2.blobs.core.download({
    start: 0,
    end: await srcDrive.getBlobsLength(srcDrive.version)
  })
  await copy3.getBlobs()
  await copy3.db.core.download({ start: 0, end: srcDrive.version })
  await copy3.blobs.core.download({
    start: 0,
    end: await srcDrive.getBlobsLength(srcDrive.version)
  })

  // second request
  let request2 = null
  {
    const requestDriveProc = spawn(process.execPath, [
      EXECUTABLE,
      '--config',
      configLoc,
      '--storage',
      cliStorageDir,
      'request',
      srcDrive.core.length
    ])

    // To avoid zombie processes in case there's an error
    process.on('exit', () => {
      requestDriveProc.kill('SIGKILL')
    })
    requestDriveProc.stderr.on('data', (d) => {
      console.error(d.toString())
      t.fail('There should be no stderr')
    })

    {
      const stdoutDec = new NewlineDecoder('utf-8')
      requestDriveProc.stdout.on('data', (d) => {
        if (DEBUG) console.log(d.toString())

        for (const line of stdoutDec.push(d)) {
          if (line.includes('hypercore-sign')) {
            tRequestDrive2.pass('sign request created')
            request2 = line.split('hypercore-sign ')[1]
          }
        }
      })
    }

    requestDriveProc.on('exit', (status) => {
      tRequestDrive2.is(status, 0, 'CLI process exited cleanly')
    })

    await tRequestDrive2
  }

  const responses2 = signers.slice(0, 2).map((signer) => signResponse(z32.decode(request2), signer))

  // second verify (without --first-commit)
  {
    const verifyDriveProc = spawn(process.execPath, [
      EXECUTABLE,
      '--config',
      configLoc,
      '--storage',
      cliStorageDir,
      'verify',
      request2,
      ...responses2
    ])

    process.on('exit', () => {
      verifyDriveProc.kill('SIGKILL')
    })
    verifyDriveProc.stderr.on('data', (d) => {
      console.log('the stderr is', d.toString())
      console.error(d.toString())
      t.fail('There should be no stderr')
    })

    let reviewLineStart = null
    const reviewLines = []

    const stdoutDec = new NewlineDecoder('utf-8')
    verifyDriveProc.stdout.on('data', (d) => {
      for (const line of stdoutDec.push(d)) {
        if (line.includes('Quorum')) {
          const quorum = parseInt(line.split('Quorum: ')[1].split(' / ')[0])
          if (quorum === responses.length) {
            tVerifyDrive2.pass('quorum matches number of responses')
          }
        }
        if (line.includes('Review batch to commit:')) {
          reviewLineStart = true
        }
        if (line.includes('drive key:')) {
          reviewLineStart = false
          tVerifyDrive2.pass('drive key is printed')
        }
        if (reviewLineStart) {
          reviewLines.push(line)
        } else if (reviewLineStart === false) {
          reviewLineStart = null
          tVerifyDrive2.pass('review lines printed')
        }
      }
    })
    verifyDriveProc.on('exit', (status) => {
      tVerifyDrive2.pass('verify drive process shuts down cleanly')
    })

    await tVerifyDrive2

    reviewLines[0] = reviewLines[0].replace('Review batch to commit: ', '')
    const review = JSON.parse(reviewLines.join('\n'))

    t.is(review.db.destCore.length, 4, 'dest core has no new content')
    t.is(review.db.srcCore.length, srcDrive.db.core.length, 'src core info is correct')
    t.is(review.db.batch.length, srcDrive.db.core.length, 'batch has all entries from src core')
    t.is(review.blobs.destCore.length, 3, 'dest blobs has no new content')
    t.is(review.blobs.srcCore.length, srcDrive.blobs.core.length, 'src blobs info is correct')
    t.is(
      review.blobs.batch.length,
      srcDrive.blobs.core.length,
      'batch has all entries from src blobs'
    )
  }

  // second commit
  {
    const commitDriveProc = spawn(process.execPath, [
      EXECUTABLE,
      '--config',
      configLoc,
      '--storage',
      cliStorageDir,
      'commit',
      request2,
      ...responses2
    ])

    process.on('exit', () => {
      commitDriveProc.kill('SIGKILL')
    })
    commitDriveProc.stderr.on('data', (d) => {
      console.log('the stderr is', d.toString())
      console.error(d.toString())
      t.fail('There should be no stderr')
    })

    let driveKey = null
    {
      const stdoutDec = new NewlineDecoder('utf-8')
      commitDriveProc.stdout.on('data', (d) => {
        if (DEBUG) console.log(d.toString())

        for (const line of stdoutDec.push(d)) {
          if (line.includes('drive key:')) {
            tCommitDrive2.pass('sign request committed')
            driveKey = line.split('drive key: ')[1]
          }
        }
      })
    }

    await tCommitDrive2

    const tShutdown = t.test('Shutdown logic')
    tShutdown.plan(1)

    commitDriveProc.on('exit', (status) => {
      tShutdown.pass('commit drive process shuts down cleanly')
    })
    commitDriveProc.kill('SIGINT')
    await tShutdown
  }
})

test('seed cmd - core', async (t) => {
  const {
    bootstrap,
    store,
    swarm,
    store2,
    swarm2,
    store3,
    swarm3,
    store4,
    swarm4,
    store5,
    swarm5
  } = await setup(t, 5)

  const srcCore = await setupCore(t, store, swarm)
  const discoveryKey = srcCore.discoveryKey

  const dir = await t.tmp()
  const cliStorageDir = path.join(dir, 'cli-storage')
  await fs.mkdir(cliStorageDir)
  const configLoc = path.join(dir, 'multisig.json')
  const { namespace, publicKeys, signers } = setupMultisig(undefined, 3)
  const config = {
    type: 'core',
    namespace,
    publicKeys,
    srcKey: idEnc.normalize(srcCore.key),
    bootstrap
  }
  await fs.writeFile(configLoc, JSON.stringify(config))

  let request = null
  {
    const tRequest = t.test('Request')
    tRequest.plan(2)

    const proc = spawn(process.execPath, [
      EXECUTABLE,
      '--config',
      configLoc,
      '--storage',
      cliStorageDir,
      'request',
      '--force',
      srcCore.length
    ])
    process.on('exit', () => proc.kill('SIGKILL'))
    proc.stderr.on('data', (d) => {
      console.error(d.toString())
      t.fail('no stderr expected during request')
    })

    const dec = new NewlineDecoder('utf-8')
    proc.stdout.on('data', (d) => {
      if (DEBUG) console.log(d.toString())
      for (const line of dec.push(d)) {
        if (line.includes('hypercore-sign')) {
          tRequest.pass('sign request created')
          request = line.split('hypercore-sign ')[1]
        }
      }
    })
    proc.on('exit', (status) => tRequest.is(status, 0, 'request process exited cleanly'))
    await tRequest
  }

  const responses = signers.slice(0, 2).map((signer) => signResponse(z32.decode(request), signer))

  let tgtCoreKey = null
  {
    const tCommit = t.test('Commit')
    tCommit.plan(1)

    const proc = spawn(process.execPath, [
      EXECUTABLE,
      '--config',
      configLoc,
      '--storage',
      cliStorageDir,
      'commit',
      '--first-commit',
      '--force-dangerous',
      request,
      ...responses
    ])
    process.on('exit', () => proc.kill('SIGKILL'))
    proc.stderr.on('data', (d) => {
      console.error(d.toString())
      t.fail('no stderr expected during commit')
    })

    const dec = new NewlineDecoder('utf-8')
    proc.stdout.on('data', (d) => {
      if (DEBUG) console.log(d.toString())
      for (const line of dec.push(d)) {
        if (line.includes('core key:')) {
          tCommit.pass('committed')
          tgtCoreKey = line.split('core key: ')[1]
        }
      }
    })

    await tCommit
    proc.kill('SIGINT')
    await new Promise((resolve) => proc.on('exit', resolve))
  }

  const srcCopy2 = store2.get(srcCore.key)
  await srcCopy2.ready()

  const tgtCopy4 = store4.get(idEnc.decode(tgtCoreKey))
  await tgtCopy4.ready()

  {
    const tSeedSrc = t.test('Seed source core')
    tSeedSrc.plan(1)
    const tSeedTgt = t.test('Seed target core')
    tSeedTgt.plan(1)

    const seedProc = spawn(process.execPath, [
      EXECUTABLE,
      '--config',
      configLoc,
      '--storage',
      cliStorageDir,
      'seed',
      '--log-interval',
      '100'
    ])
    process.on('exit', () => seedProc.kill('SIGKILL'))
    seedProc.stderr.on('data', (d) => {
      console.error(d.toString())
      t.fail('no stderr expected during seed')
    })

    let doneSrc = false
    let doneTgt = false
    const dec = new NewlineDecoder('utf-8')
    seedProc.stdout.on('data', (d) => {
      if (DEBUG) console.log(d.toString())
      for (const line of dec.push(d)) {
        if (line.includes(`Source core: 3 peers, 3 fully downloaded, length: 3`) && !doneSrc) {
          tSeedSrc.pass('source core is fully downloaded and seeded')
          doneSrc = true
        }
        if (line.includes(`Multisig core: 2 peers, 2 fully downloaded, length: 3`) && !doneTgt) {
          tSeedTgt.pass('target core is fully downloaded and seeded')
          doneTgt = true
        }
      }
    })

    swarm2.join(discoveryKey)
    srcCopy2.download({ start: 0, end: -1 })

    const srcCopy3 = store3.get(srcCore.key)
    await srcCopy3.ready()
    swarm3.join(discoveryKey)
    srcCopy3.download({ start: 0, end: -1 })

    swarm4.join(discoveryKey)
    tgtCopy4.download({ start: 0, end: -1 })

    const tgtCopy5 = store5.get(idEnc.decode(tgtCoreKey))
    await tgtCopy5.ready()
    swarm5.join(discoveryKey)
    tgtCopy5.download({ start: 0, end: -1 })

    await tSeedSrc
    await tSeedTgt

    const tShutdown = t.test('Shutdown seed')
    tShutdown.plan(1)
    seedProc.on('exit', () => tShutdown.pass('seed process shut down cleanly'))
    seedProc.kill('SIGINT')
    await tShutdown
  }

  {
    const tSeedSrc = t.test('Seed source core')
    tSeedSrc.plan(1)
    const tSeedTgt = t.test('Seed target core')
    tSeedTgt.plan(1)

    const seedProc = spawn(process.execPath, [
      EXECUTABLE,
      '--config',
      configLoc,
      '--storage',
      cliStorageDir,
      'seed',
      '--log-interval',
      '100'
    ])
    process.on('exit', () => seedProc.kill('SIGKILL'))
    seedProc.stderr.on('data', (d) => {
      console.error(d.toString())
      t.fail('no stderr expected during seed')
    })

    let doneSrc = false
    let doneTgt = false
    const dec = new NewlineDecoder('utf-8')
    seedProc.stdout.on('data', (d) => {
      if (DEBUG) console.log(d.toString())
      for (const line of dec.push(d)) {
        if (line.includes(`Source core: 3 peers, 3 fully downloaded, length: 5`) && !doneSrc) {
          tSeedSrc.pass('source core is fully downloaded and seeded')
          doneSrc = true
        }
        if (line.includes(`Multisig core: 2 peers, 2 fully downloaded, length: 3`) && !doneTgt) {
          tSeedTgt.pass('target core is fully downloaded and seeded')
          doneTgt = true
        }
      }
    })

    await srcCore.append(b4a.from('content 3'))
    await srcCore.append(b4a.from('content 4'))

    await tSeedSrc
    await tSeedTgt

    const tShutdown = t.test('Shutdown seed')
    tShutdown.plan(1)
    seedProc.on('exit', () => tShutdown.pass('seed process shut down cleanly'))
    seedProc.kill('SIGINT')
    await tShutdown
  }

  {
    let request2 = null
    {
      const tRequest = t.test('Request')
      tRequest.plan(2)

      const proc = spawn(process.execPath, [
        EXECUTABLE,
        '--config',
        configLoc,
        '--storage',
        cliStorageDir,
        'request',
        srcCore.length
      ])
      process.on('exit', () => proc.kill('SIGKILL'))
      proc.stderr.on('data', (d) => {
        console.error(d.toString())
        t.fail('no stderr expected during request')
      })

      const dec = new NewlineDecoder('utf-8')
      proc.stdout.on('data', (d) => {
        if (DEBUG) console.log(d.toString())
        for (const line of dec.push(d)) {
          if (line.includes('hypercore-sign')) {
            tRequest.pass('sign request created')
            request2 = line.split('hypercore-sign ')[1]
          }
        }
      })
      proc.on('exit', (status) => tRequest.is(status, 0, 'request process exited cleanly'))
      await tRequest
    }

    const responses2 = signers
      .slice(0, 2)
      .map((signer) => signResponse(z32.decode(request2), signer))

    let tgtCoreKey2 = null
    {
      const tCommit = t.test('Commit')
      tCommit.plan(1)

      const proc = spawn(process.execPath, [
        EXECUTABLE,
        '--config',
        configLoc,
        '--storage',
        cliStorageDir,
        'commit',
        request2,
        ...responses2
      ])
      process.on('exit', () => proc.kill('SIGKILL'))
      proc.stderr.on('data', (d) => {
        console.error(d.toString())
        t.fail('no stderr expected during commit')
      })

      const dec = new NewlineDecoder('utf-8')
      proc.stdout.on('data', (d) => {
        if (DEBUG) console.log(d.toString())
        for (const line of dec.push(d)) {
          if (line.includes('core key:')) {
            tCommit.pass('committed')
            tgtCoreKey2 = line.split('core key: ')[1]
          }
        }
      })

      await tCommit
      proc.kill('SIGINT')
      await new Promise((resolve) => proc.on('exit', resolve))
    }

    const tSeedSrc = t.test('Seed source core')
    tSeedSrc.plan(1)
    const tSeedTgt = t.test('Seed target core')
    tSeedTgt.plan(1)

    const seedProc = spawn(process.execPath, [
      EXECUTABLE,
      '--config',
      configLoc,
      '--storage',
      cliStorageDir,
      'seed',
      '--log-interval',
      '100'
    ])
    process.on('exit', () => seedProc.kill('SIGKILL'))
    seedProc.stderr.on('data', (d) => {
      console.error(d.toString())
      t.fail('no stderr expected during seed')
    })

    let doneSrc = false
    let doneTgt = false
    const dec = new NewlineDecoder('utf-8')
    seedProc.stdout.on('data', (d) => {
      if (DEBUG) console.log(d.toString())
      for (const line of dec.push(d)) {
        if (line.includes(`Source core: 3 peers, 3 fully downloaded, length: 5`) && !doneSrc) {
          tSeedSrc.pass('source core is fully downloaded and seeded')
          doneSrc = true
        }
        if (line.includes(`Multisig core: 2 peers, 2 fully downloaded, length: 5`) && !doneTgt) {
          tSeedTgt.pass('target core is fully downloaded and seeded')
          doneTgt = true
        }
      }
    })

    await tSeedSrc
    await tSeedTgt

    const tShutdown = t.test('Shutdown seed')
    tShutdown.plan(1)
    seedProc.on('exit', () => tShutdown.pass('seed process shut down cleanly'))
    seedProc.kill('SIGINT')
    await tShutdown
  }
})

test('seed cmd - drive', async (t) => {
  const {
    bootstrap,
    store,
    swarm,
    store2,
    swarm2,
    store3,
    swarm3,
    store4,
    swarm4,
    store5,
    swarm5
  } = await setup(t, 5)

  const srcDrive = await setupDrive(t, store, swarm)
  const discoveryKey = srcDrive.discoveryKey
  await srcDrive.getBlobs()

  const dir = await t.tmp()
  const cliStorageDir = path.join(dir, 'cli-storage')
  await fs.mkdir(cliStorageDir)
  const configLoc = path.join(dir, 'multisig.json')
  const { namespace, publicKeys, signers } = setupMultisig(undefined, 3)
  const config = {
    type: 'drive',
    namespace,
    publicKeys,
    srcKey: idEnc.normalize(srcDrive.key),
    bootstrap
  }
  await fs.writeFile(configLoc, JSON.stringify(config))

  const initialSrcDbLength = srcDrive.db.core.length
  const initialSrcBlobsLength = srcDrive.blobs.core.length

  let request = null
  {
    const tRequest = t.test('Request')
    tRequest.plan(2)

    const proc = spawn(process.execPath, [
      EXECUTABLE,
      '--config',
      configLoc,
      '--storage',
      cliStorageDir,
      'request',
      '--force',
      srcDrive.core.length
    ])
    process.on('exit', () => proc.kill('SIGKILL'))
    proc.stderr.on('data', (d) => {
      console.error(d.toString())
      t.fail('no stderr expected during request')
    })

    const dec = new NewlineDecoder('utf-8')
    proc.stdout.on('data', (d) => {
      if (DEBUG) console.log(d.toString())
      for (const line of dec.push(d)) {
        if (line.includes('hypercore-sign')) {
          tRequest.pass('sign request created')
          request = line.split('hypercore-sign ')[1]
        }
      }
    })
    proc.on('exit', (status) => tRequest.is(status, 0, 'request process exited cleanly'))
    await tRequest
  }

  const responses = signers.slice(0, 2).map((signer) => signResponse(z32.decode(request), signer))

  let tgtDriveKey = null
  {
    const tCommit = t.test('Commit')
    tCommit.plan(1)

    const proc = spawn(process.execPath, [
      EXECUTABLE,
      '--config',
      configLoc,
      '--storage',
      cliStorageDir,
      'commit',
      '--first-commit',
      '--force-dangerous',
      request,
      ...responses
    ])
    process.on('exit', () => proc.kill('SIGKILL'))
    proc.stderr.on('data', (d) => {
      console.error(d.toString())
      t.fail('no stderr expected during commit')
    })

    const dec = new NewlineDecoder('utf-8')
    proc.stdout.on('data', (d) => {
      if (DEBUG) console.log(d.toString())
      for (const line of dec.push(d)) {
        if (line.includes('drive key:')) {
          tCommit.pass('committed')
          tgtDriveKey = line.split('drive key: ')[1]
        }
      }
    })

    await tCommit
    proc.kill('SIGINT')
    await new Promise((resolve) => proc.on('exit', resolve))
  }

  let updatedSrcDbLength = initialSrcDbLength
  let updatedSrcBlobsLength = initialSrcBlobsLength

  const srcCopy2 = new Hyperdrive(store2, srcDrive.key)
  await srcCopy2.ready()

  const tgtCopy4 = new Hyperdrive(store4, idEnc.decode(tgtDriveKey))
  await tgtCopy4.ready()

  {
    const tSeedSrcDb = t.test('Seed source db core')
    tSeedSrcDb.plan(1)
    const tSeedSrcBlobs = t.test('Seed source blobs core')
    tSeedSrcBlobs.plan(1)
    const tSeedTgtDb = t.test('Seed target db core')
    tSeedTgtDb.plan(1)
    const tSeedTgtBlobs = t.test('Seed target blobs core')
    tSeedTgtBlobs.plan(1)

    const seedProc = spawn(process.execPath, [
      EXECUTABLE,
      '--config',
      configLoc,
      '--storage',
      cliStorageDir,
      'seed',
      '--log-interval',
      '100'
    ])
    process.on('exit', () => seedProc.kill('SIGKILL'))
    seedProc.stderr.on('data', (d) => {
      console.error(d.toString())
      t.fail('no stderr expected during seed')
    })

    let doneSrcDb = false
    let doneSrcBlobs = false
    let doneTgtDb = false
    let doneTgtBlobs = false
    const dec = new NewlineDecoder('utf-8')
    seedProc.stdout.on('data', (d) => {
      if (DEBUG) console.log(d.toString())
      for (const line of dec.push(d)) {
        if (
          line.includes(
            `Source DB core: 3 peers, 3 fully downloaded, length: ${initialSrcDbLength}`
          ) &&
          !doneSrcDb
        ) {
          tSeedSrcDb.pass('source db core is fully downloaded and seeded')
          doneSrcDb = true
        }
        if (
          line.includes(
            `Source Blobs core: 3 peers, 3 fully downloaded, length: ${initialSrcBlobsLength}`
          ) &&
          !doneSrcBlobs
        ) {
          tSeedSrcBlobs.pass('source blobs core is fully downloaded and seeded')
          doneSrcBlobs = true
        }
        if (
          line.includes(
            `Multisig DB core: 2 peers, 2 fully downloaded, length: ${initialSrcDbLength}`
          ) &&
          !doneTgtDb
        ) {
          tSeedTgtDb.pass('target db core is fully downloaded and seeded')
          doneTgtDb = true
        }
        if (
          line.includes(
            `Multisig Blobs core: 2 peers, 2 fully downloaded, length: ${initialSrcBlobsLength}`
          ) &&
          !doneTgtBlobs
        ) {
          tSeedTgtBlobs.pass('target blobs core is fully downloaded and seeded')
          doneTgtBlobs = true
        }
      }
    })

    swarm2.join(discoveryKey)
    await srcCopy2.getBlobs()
    srcCopy2.db.core.download({ start: 0, end: -1 })
    srcCopy2.blobs.core.download({ start: 0, end: -1 })

    const srcCopy3 = new Hyperdrive(store3, srcDrive.key)
    await srcCopy3.ready()
    swarm3.join(discoveryKey)
    await srcCopy3.getBlobs()
    srcCopy3.db.core.download({ start: 0, end: -1 })
    srcCopy3.blobs.core.download({ start: 0, end: -1 })

    swarm4.join(discoveryKey)
    await tgtCopy4.getBlobs()
    tgtCopy4.db.core.download({ start: 0, end: -1 })
    tgtCopy4.blobs.core.download({ start: 0, end: -1 })

    const tgtCopy5 = new Hyperdrive(store5, idEnc.decode(tgtDriveKey))
    await tgtCopy5.ready()
    swarm5.join(discoveryKey)
    await tgtCopy5.getBlobs()
    tgtCopy5.db.core.download({ start: 0, end: -1 })
    tgtCopy5.blobs.core.download({ start: 0, end: -1 })

    await tSeedSrcDb
    await tSeedSrcBlobs
    await tSeedTgtDb
    await tSeedTgtBlobs

    const tShutdown = t.test('Shutdown seed')
    tShutdown.plan(1)
    seedProc.on('exit', () => tShutdown.pass('seed process shut down cleanly'))
    seedProc.kill('SIGINT')
    await tShutdown
  }

  {
    const tSeedSrcDb = t.test('Seed source db core')
    tSeedSrcDb.plan(1)
    const tSeedSrcBlobs = t.test('Seed source blobs core')
    tSeedSrcBlobs.plan(1)
    const tSeedTgtDb = t.test('Seed target db core')
    tSeedTgtDb.plan(1)
    const tSeedTgtBlobs = t.test('Seed target blobs core')
    tSeedTgtBlobs.plan(1)

    const seedProc = spawn(process.execPath, [
      EXECUTABLE,
      '--config',
      configLoc,
      '--storage',
      cliStorageDir,
      'seed',
      '--log-interval',
      '100'
    ])
    process.on('exit', () => seedProc.kill('SIGKILL'))
    seedProc.stderr.on('data', (d) => {
      console.error(d.toString())
      t.fail('no stderr expected during seed')
    })

    let doneSrcDb = false
    let doneSrcBlobs = false
    let doneTgtDb = false
    let doneTgtBlobs = false
    const dec = new NewlineDecoder('utf-8')
    seedProc.stdout.on('data', (d) => {
      if (DEBUG) console.log(d.toString())
      for (const line of dec.push(d)) {
        if (
          line.includes(
            `Source DB core: 3 peers, 3 fully downloaded, length: ${updatedSrcDbLength}`
          ) &&
          !doneSrcDb
        ) {
          tSeedSrcDb.pass('source db core is fully downloaded and seeded')
          doneSrcDb = true
        }
        if (
          line.includes(
            `Source Blobs core: 3 peers, 3 fully downloaded, length: ${updatedSrcBlobsLength}`
          ) &&
          !doneSrcBlobs
        ) {
          tSeedSrcBlobs.pass('source blobs core is fully downloaded and seeded')
          doneSrcBlobs = true
        }
        if (
          line.includes(
            `Multisig DB core: 2 peers, 2 fully downloaded, length: ${initialSrcDbLength}`
          ) &&
          !doneTgtDb
        ) {
          tSeedTgtDb.pass('target db core is fully downloaded and seeded')
          doneTgtDb = true
        }
        if (
          line.includes(
            `Multisig Blobs core: 2 peers, 2 fully downloaded, length: ${initialSrcBlobsLength}`
          ) &&
          !doneTgtBlobs
        ) {
          tSeedTgtBlobs.pass('target blobs core is fully downloaded and seeded')
          doneTgtBlobs = true
        }
      }
    })

    await srcDrive.put('/file4', 'file4 content')
    updatedSrcDbLength = srcDrive.db.core.length
    updatedSrcBlobsLength = srcDrive.blobs.core.length

    await tSeedSrcDb
    await tSeedSrcBlobs
    await tSeedTgtDb
    await tSeedTgtBlobs

    const tShutdown = t.test('Shutdown seed')
    tShutdown.plan(1)
    seedProc.on('exit', () => tShutdown.pass('seed process shut down cleanly'))
    seedProc.kill('SIGINT')
    await tShutdown
  }

  {
    let request2 = null
    {
      const tRequest = t.test('Request')
      tRequest.plan(2)

      const proc = spawn(process.execPath, [
        EXECUTABLE,
        '--config',
        configLoc,
        '--storage',
        cliStorageDir,
        'request',
        srcDrive.core.length
      ])
      process.on('exit', () => proc.kill('SIGKILL'))
      proc.stderr.on('data', (d) => {
        console.error(d.toString())
        t.fail('no stderr expected during request')
      })

      const dec = new NewlineDecoder('utf-8')
      proc.stdout.on('data', (d) => {
        if (DEBUG) console.log(d.toString())
        for (const line of dec.push(d)) {
          if (line.includes('hypercore-sign')) {
            tRequest.pass('sign request created')
            request2 = line.split('hypercore-sign ')[1]
          }
        }
      })
      proc.on('exit', (status) => tRequest.is(status, 0, 'request process exited cleanly'))
      await tRequest
    }

    const responses2 = signers
      .slice(0, 2)
      .map((signer) => signResponse(z32.decode(request2), signer))

    let tgtDriveKey2 = null
    {
      const tCommit = t.test('Commit')
      tCommit.plan(1)

      const proc = spawn(process.execPath, [
        EXECUTABLE,
        '--config',
        configLoc,
        '--storage',
        cliStorageDir,
        'commit',
        request2,
        ...responses2
      ])
      process.on('exit', () => proc.kill('SIGKILL'))
      proc.stderr.on('data', (d) => {
        console.error(d.toString())
        t.fail('no stderr expected during commit')
      })

      const dec = new NewlineDecoder('utf-8')
      proc.stdout.on('data', (d) => {
        if (DEBUG) console.log(d.toString())
        for (const line of dec.push(d)) {
          if (line.includes('drive key:')) {
            tCommit.pass('committed')
            tgtDriveKey2 = line.split('drive key: ')[1]
          }
        }
      })

      await tCommit
      proc.kill('SIGINT')
      await new Promise((resolve) => proc.on('exit', resolve))
    }

    t.is(tgtDriveKey2, tgtDriveKey, 'second commit keeps the same multisig drive key')

    const tSeedSrcDb = t.test('Seed source db core')
    tSeedSrcDb.plan(1)
    const tSeedSrcBlobs = t.test('Seed source blobs core')
    tSeedSrcBlobs.plan(1)
    const tSeedTgtDb = t.test('Seed target db core')
    tSeedTgtDb.plan(1)
    const tSeedTgtBlobs = t.test('Seed target blobs core')
    tSeedTgtBlobs.plan(1)

    const seedProc = spawn(process.execPath, [
      EXECUTABLE,
      '--config',
      configLoc,
      '--storage',
      cliStorageDir,
      'seed',
      '--log-interval',
      '100'
    ])
    process.on('exit', () => seedProc.kill('SIGKILL'))
    seedProc.stderr.on('data', (d) => {
      console.error(d.toString())
      t.fail('no stderr expected during seed')
    })

    let doneSrcDb = false
    let doneSrcBlobs = false
    let doneTgtDb = false
    let doneTgtBlobs = false
    const dec = new NewlineDecoder('utf-8')
    seedProc.stdout.on('data', (d) => {
      if (DEBUG) console.log(d.toString())
      for (const line of dec.push(d)) {
        if (
          line.includes(
            `Source DB core: 3 peers, 3 fully downloaded, length: ${updatedSrcDbLength}`
          ) &&
          !doneSrcDb
        ) {
          tSeedSrcDb.pass('source db core is fully downloaded and seeded')
          doneSrcDb = true
        }
        if (
          line.includes(
            `Source Blobs core: 3 peers, 3 fully downloaded, length: ${updatedSrcBlobsLength}`
          ) &&
          !doneSrcBlobs
        ) {
          tSeedSrcBlobs.pass('source blobs core is fully downloaded and seeded')
          doneSrcBlobs = true
        }
        if (
          line.includes(
            `Multisig DB core: 2 peers, 2 fully downloaded, length: ${updatedSrcDbLength}`
          ) &&
          !doneTgtDb
        ) {
          tSeedTgtDb.pass('target db core is fully downloaded and seeded')
          doneTgtDb = true
        }
        if (
          line.includes(
            `Multisig Blobs core: 2 peers, 2 fully downloaded, length: ${updatedSrcBlobsLength}`
          ) &&
          !doneTgtBlobs
        ) {
          tSeedTgtBlobs.pass('target blobs core is fully downloaded and seeded')
          doneTgtBlobs = true
        }
      }
    })

    await tSeedSrcDb
    await tSeedSrcBlobs
    await tSeedTgtDb
    await tSeedTgtBlobs

    const tShutdown = t.test('Shutdown seed')
    tShutdown.plan(1)
    seedProc.on('exit', () => tShutdown.pass('seed process shut down cleanly'))
    seedProc.kill('SIGINT')
    await tShutdown
  }
})

test('clear errors for bad config', async (t) => {
  const dir = await t.tmp()

  const cliStorageDir = path.join(dir, 'cli-storage')
  await fs.mkdir(cliStorageDir)
  const configLoc = path.join(dir, 'multisig.json')
  const goodConfig = {
    type: 'core',
    namespace: 'my-namespace',
    publicKeys: ['a'.repeat(64)]
  }
  await fs.writeFile(configLoc, JSON.stringify(goodConfig))

  {
    const { status } = await runCommand(configLoc, cliStorageDir)
    t.is(status, 0, 'sanity check: good config works')
  }

  {
    const badConfig = {
      ...goodConfig,
      type: 'cor'
    }
    await fs.writeFile(configLoc, JSON.stringify(badConfig))

    const { status, stderr } = await runCommand(configLoc, cliStorageDir)
    t.is(status, 1, 'err status')
    t.ok(stderr.includes("type must be either core or drive. Saw 'cor'"), 'correct type error msg')
  }

  {
    const badConfig = {
      ...goodConfig,
      namespace: undefined
    }
    await fs.writeFile(configLoc, JSON.stringify(badConfig))

    const { status, stderr } = await runCommand(configLoc, cliStorageDir)
    t.is(status, 1, 'err status')
    t.ok(stderr.includes('namespace must be set'), 'correct namespace error msg')
  }

  {
    const badConfig = {
      ...goodConfig,
      publicKeys: []
    }
    await fs.writeFile(configLoc, JSON.stringify(badConfig))

    const { status, stderr } = await runCommand(configLoc, cliStorageDir)
    t.is(status, 1, 'err status')
    t.ok(
      stderr.includes('publicKeys must be set and include at least 1 key'),
      'correct publicKeys error msg'
    )
  }

  {
    const badConfig = {
      ...goodConfig,
      publicKeys: ['b'.repeat(64), 'aaaa']
    }
    await fs.writeFile(configLoc, JSON.stringify(badConfig))

    const { status, stderr } = await runCommand(configLoc, cliStorageDir)
    t.is(status, 1, 'err status')
    t.ok(stderr.includes("invalid publicKey 1: 'aaaa'"), 'correct invalid publicKey error msg')
  }

  {
    const badConfig = {
      ...goodConfig,
      srcKey: undefined
    }
    await fs.writeFile(configLoc, JSON.stringify(badConfig))

    const { status, stderr } = await runCommand(configLoc, cliStorageDir, 'verify', [
      'irrelevantrequestcontent'
    ])
    t.is(status, 1, 'err status')
    t.ok(stderr.includes('srcKey must be set'), 'correct srcKey error msg')
  }

  {
    const badConfig = {
      ...goodConfig,
      srcKey: 'aaaa'
    }
    await fs.writeFile(configLoc, JSON.stringify(badConfig))

    const { status, stderr } = await runCommand(configLoc, cliStorageDir, 'verify', [
      'irrelevantrequestcontent'
    ])
    t.is(status, 1, 'err status')
    t.ok(stderr.includes("invalid srcKey: 'aaaa'"), 'correct srcKey error msg')
  }
})

test('validates multisigKey if set', async (t) => {
  const dir = await t.tmp()

  const cliStorageDir = path.join(dir, 'cli-storage')
  await fs.mkdir(cliStorageDir)
  const configLoc = path.join(dir, 'multisig.json')
  const config = {
    type: 'core',
    namespace: 'my-namespace',
    publicKeys: ['a'.repeat(64)]
  }
  await fs.writeFile(configLoc, JSON.stringify(config))

  let multisigKey = null
  {
    const { status, stdout } = await runCommand(configLoc, cliStorageDir)
    t.is(status, 0, 'sanity check: config works')
    multisigKey = stdout.split('pear://')[1].trim()
  }

  config.multisigKey = 'a'.repeat(64)
  await fs.writeFile(configLoc, JSON.stringify(config))
  {
    const { status, stderr } = await runCommand(configLoc, cliStorageDir)
    t.is(status, 1, 'error status')
    t.ok(
      stderr.includes(
        `multisigKey does not correspond to the key generated from the config, expected ${multisigKey} (hex: ${idEnc.decode(multisigKey).toString('hex')})`
      )
    )
  }

  config.multisigKey = multisigKey
  await fs.writeFile(configLoc, JSON.stringify(config))
  {
    const { status, stderr } = await runCommand(configLoc, cliStorageDir)
    t.is(status, 0, 'correct run with valid multisigKey')
    t.is(stderr, '', 'no stderr (sanity check)')
  }
})

async function runCommand(configLoc, cliStorageDir, command = 'link', args = []) {
  let procResolve = null
  const doneProm = new Promise((resolve) => {
    procResolve = resolve
  })

  const proc = spawn(process.execPath, [
    EXECUTABLE,
    '--config',
    configLoc,
    '--storage',
    cliStorageDir,
    command,
    ...args
  ])
  // To avoid zombie processes in case there's an error
  process.on('exit', () => {
    proc.kill('SIGKILL')
  })
  proc.on('exit', (status) => {
    procResolve(status)
  })

  const stderrDec = new NewlineDecoder('utf-8')
  let stderr = ''
  proc.stderr.on('data', (d) => {
    if (DEBUG) console.log(d.toString())

    for (const line of stderrDec.push(d)) {
      stderr += line + '\n'
    }
  })

  const stdoutDec = new NewlineDecoder('utf-8')
  let stdout = ''
  proc.stdout.on('data', (d) => {
    if (DEBUG) console.log(d.toString())

    for (const line of stdoutDec.push(d)) {
      stdout += line + '\n'
    }
  })

  const status = await doneProm
  return { status, stderr, stdout }
}

async function setupTestnet(t) {
  const testnet = await createTestnet()
  t.teardown(() => testnet.destroy(), { order: 5000 })
  const bootstrap = testnet.bootstrap
  return { testnet, bootstrap }
}

async function setup(t, n = 1, network) {
  const res = network ?? (await setupTestnet(t))
  const { bootstrap } = res

  for (let step = 1; step <= n; step++) {
    const storage = await t.tmp()
    const store = new Corestore(storage)
    t.teardown(() => store.close(), { order: 4000 })
    const swarm = new Hyperswarm({ bootstrap })
    t.teardown(() => swarm.destroy(), { order: 3000 })

    swarm.on('connection', (conn) => store.replicate(conn))

    const nstring = step > 1 ? step : ''
    res[`storage${nstring}`] = storage
    res[`store${nstring}`] = store
    res[`swarm${nstring}`] = swarm
  }

  return res
}

function setupMultisig(namespace = 'holepunchto/my-test', numSigners = 5) {
  const signers = []
  for (let i = 0; i < numSigners; i++) {
    const seed = sodium.sodium_malloc(sodium.randombytes_SEEDBYTES)
    sodium.randombytes_buf(seed)
    const password = sodium.sodium_malloc(8)
    sodium.randombytes_buf_deterministic(password, seed)

    const keys = CoreSign.generateKeys(password)
    signers.push({ ...keys, seed })
  }
  const publicKeys = signers.map((signer) => idEnc.normalize(signer.publicKey))

  return { namespace, signers, publicKeys }
}

function signResponse(request, signer) {
  const { clonedSigner, decodedReq, signatures } = sign(request, signer)
  const res = SignRequest.encodeResponse({
    version: decodedReq.version,
    requestHash: crypto.hash(request),
    publicKey: clonedSigner.publicKey,
    signatures
  })
  return z32.encode(res)
}

function sign(request, signer) {
  // clone to avoid mutation
  const clonedSigner = Object.keys(signer).reduce((acc, key) => {
    acc[key] = b4a.from(signer[key])
    return acc
  }, {})

  const decodedReq = SignRequest.decode(request)

  const password = sodium.sodium_malloc(8)
  sodium.randombytes_buf_deterministic(password, clonedSigner.seed)

  const response = CoreSign.sign(request, clonedSigner.secretKey, password)
  const { signatures } = SignRequest.decodeResponse(response)

  return { clonedSigner, decodedReq, signatures }
}

async function setupCore(t, store, swarm) {
  /** @type {import('hypercore')} */
  const core = store.get({ name: 'test-core' })
  t.teardown(() => core.close())
  await core.ready()
  swarm.join(core.discoveryKey)

  await core.append(b4a.from('content 0'))
  await core.append(b4a.from('content 1'))
  await core.append(b4a.from('content 2'))
  return core
}

async function setupDrive(t, store, swarm) {
  const drive = new Hyperdrive(store)
  t.teardown(() => drive.close())
  await drive.ready()
  swarm.join(drive.discoveryKey)

  await drive.put('/file1', 'file1 content')
  await drive.put('/file2', 'file2 content')
  await drive.put('/file3', 'file3 content')
  return drive
}