// Select revealers from all eligible revealers for a message
 async getRevealersForMessage(reward: BN, numRevealers: number) {
   const eligibleRevealers: Revealer[] = await this.getEligibleRevealers();
   const minReward: BN = reward.div(new BN(numRevealers + 1));
   const filteredAndOrderedRevealers: Revealer[] = eligibleRevealers
     .filter((revealer: Revealer) => minReward.gte(revealer.minReward))
     .sort((a, b) => a.stakePerMessage.sub(b.stakePerMessage).toNumber());
   return filteredAndOrderedRevealers.slice(0, numRevealers);
 }

    it(`should pass ${testName}`, function(done) {
      let incoming = officalTests[testName].in
      // if we are testing a big number
      if (incoming[0] === '#') {
        const bn = new BN(incoming.slice(1))
        incoming = Buffer.from(bn.toArray())
      }

      const encoded = RLP.encode(incoming)
      assert.equal('0x' + encoded.toString('hex'), officalTests[testName].out.toLowerCase())
      done()
    })

export function makeTokenTransferSkeleton(recipientAddress: string, consensusHash: string,
                                          tokenType: string, tokenAmount: BN,
                                          scratchArea: string
) {
  /*
   Format:

    0     2  3              19         38          46                        80
    |-----|--|--------------|----------|-----------|-------------------------|
    magic op  consensus_hash token_type amount (BE) scratch area
                             (ns_id)

    output 0: token transfer code
    output 1: recipient address
  */
  if (scratchArea.length > 34) {
    throw new Error('Invalid scratch area: must be no more than 34 bytes')
  }

  const opReturnBuffer = Buffer.alloc(46 + scratchArea.length)

  const tokenTypeHex = Buffer.from(tokenType).toString('hex')
  const tokenTypeHexPadded = `00000000000000000000000000000000000000${tokenTypeHex}`.slice(-38)

  const tokenValueHex = tokenAmount.toString(16, 2)

  if (tokenValueHex.length > 16) {
    // exceeds 2**64; can't fit
    throw new Error(`Cannot send tokens: cannot fit ${tokenAmount.toString()} into 8 bytes`)
  }

  const tokenValueHexPadded = `0000000000000000${tokenValueHex}`.slice(-16)

  opReturnBuffer.write(opEncode('$'), 0, 3, 'ascii')
  opReturnBuffer.write(consensusHash, 3, consensusHash.length / 2, 'hex')
  opReturnBuffer.write(tokenTypeHexPadded, 19, tokenTypeHexPadded.length / 2, 'hex')
  opReturnBuffer.write(tokenValueHexPadded, 38, tokenValueHexPadded.length / 2, 'hex')
  opReturnBuffer.write(scratchArea, 46, scratchArea.length, 'ascii')

  const nullOutput = bitcoin.payments.embed({ data: [opReturnBuffer] }).output
  const tx = makeTXbuilder()

  tx.addOutput(nullOutput, 0)
  tx.addOutput(recipientAddress, DUST_MINIMUM)

  return tx.buildIncomplete()
}

 // Return all eligible revealers from contract
 async getEligibleRevealers() {
   const eligibleRevealersCount: BN = (await this.kimono.getEligibleRevealersCount())[0];
   const eligibleRevealers: Revealer[] = new Array(
     eligibleRevealersCount.toNumber()
   ).fill(undefined);
   for (let i = 0; i < eligibleRevealersCount.toNumber(); i++) {
     const revealerAddress = (await this.kimono.eligibleRevealers(i))[0];
     const [
       publicKey,
       minReward,
       stakePerMessage
     ] = await this.kimono.revealerTable(revealerAddress);
     eligibleRevealers[i] = {
       address: revealerAddress,
       publicKey,
       minReward,
       stakePerMessage
     };
   }
   return eligibleRevealers;
 }

export function bnToBytes(bn: BN, length: number) {
  return hexToBytes(bn.toString(16, length));
}

 .filter((revealer: Revealer) => minReward.gte(revealer.minReward))