@aztec/stdlib 0.0.0-test.1 → 0.0.1-commit.b655e406

package/src/rollup/{base_or_merge_rollup_public_inputs.ts → tx_rollup_public_inputs.ts}

@@ -1,22 +1,17 @@
-import { SpongeBlob } from '@aztec/blob-lib';
+import { SpongeBlob } from '@aztec/blob-lib/types';
 import { Fr } from '@aztec/foundation/fields';
 import { bufferSchemaFor } from '@aztec/foundation/schemas';
 import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 import { PartialStateReference } from '../tx/partial_state_reference.js';
-import { RollupTypes } from '../types/shared.js';
-import { ConstantRollupData } from './constant_rollup_data.js';
+import { BlockConstantData } from './block_constant_data.js';
 
 /**
  * Output of the base and merge rollup circuits.
  */
-export class BaseOrMergeRollupPublicInputs {
+export class TxRollupPublicInputs {
   constructor(
-    /**
-     * Specifies from which type of rollup circuit these inputs are from.
-     */
-    public rollupType: RollupTypes,
     /**
      * Number of txs in this rollup.
      */
@@ -24,15 +19,15 @@ export class BaseOrMergeRollupPublicInputs {
     /**
      * Data which is forwarded through the rollup circuits unchanged.
      */
-    public constants: ConstantRollupData,
+    public constants: BlockConstantData,
     /**
      * Partial state reference at the start of the rollup circuit.
      */
-    public start: PartialStateReference,
+    public startTreeSnapshots: PartialStateReference,
     /**
      * Partial state reference at the end of the rollup circuit.
      */
-    public end: PartialStateReference,
+    public endTreeSnapshots: PartialStateReference,
     /**
      * Sponge state to absorb blob inputs at the start of the rollup circuit.
      */
@@ -42,7 +37,7 @@ export class BaseOrMergeRollupPublicInputs {
      */
     public endSpongeBlob: SpongeBlob,
     /**
-     * SHA256 hash of L2 to L1 messages. Used to make public inputs constant-sized (to then be opened on-chain).
+     * SHA256 hash of L2 to L1 messages. Used to make public inputs constant-sized (to then be opened onchain).
      * Note: Truncated to 31 bytes to fit in Fr.
      */
     public outHash: Fr,
@@ -58,10 +53,9 @@ export class BaseOrMergeRollupPublicInputs {
 
   /** Returns an empty instance. */
   static empty() {
-    return new BaseOrMergeRollupPublicInputs(
-      RollupTypes.Base,
+    return new TxRollupPublicInputs(
       0,
-      ConstantRollupData.empty(),
+      BlockConstantData.empty(),
       PartialStateReference.empty(),
       PartialStateReference.empty(),
       SpongeBlob.empty(),
@@ -78,12 +72,11 @@ export class BaseOrMergeRollupPublicInputs {
    * @param buffer - Buffer or reader to read from.
    * @returns The deserialized public inputs.
    */
-  static fromBuffer(buffer: Buffer | BufferReader): BaseOrMergeRollupPublicInputs {
+  static fromBuffer(buffer: Buffer | BufferReader): TxRollupPublicInputs {
     const reader = BufferReader.asReader(buffer);
-    return new BaseOrMergeRollupPublicInputs(
-      reader.readNumber(),
+    return new TxRollupPublicInputs(
       reader.readNumber(),
-      reader.readObject(ConstantRollupData),
+      reader.readObject(BlockConstantData),
       reader.readObject(PartialStateReference),
       reader.readObject(PartialStateReference),
       reader.readObject(SpongeBlob),
@@ -100,12 +93,11 @@ export class BaseOrMergeRollupPublicInputs {
    */
   toBuffer() {
     return serializeToBuffer(
-      this.rollupType,
       this.numTxs,
       this.constants,
 
-      this.start,
-      this.end,
+      this.startTreeSnapshots,
+      this.endTreeSnapshots,
 
       this.startSpongeBlob,
       this.endSpongeBlob,
@@ -128,10 +120,10 @@ export class BaseOrMergeRollupPublicInputs {
   /**
    * Deserializes from a hex string.
    * @param str - A hex string to deserialize from.
-   * @returns A new BaseOrMergeRollupPublicInputs instance.
+   * @returns A new TxRollupPublicInputs instance.
    */
   static fromString(str: string) {
-    return BaseOrMergeRollupPublicInputs.fromBuffer(hexToBuffer(str));
+    return TxRollupPublicInputs.fromBuffer(hexToBuffer(str));
   }
 
   /** Returns a buffer representation for JSON serialization. */
@@ -141,6 +133,6 @@ export class BaseOrMergeRollupPublicInputs {
 
   /** Creates an instance from a hex string. */
   static get schema() {
-    return bufferSchemaFor(BaseOrMergeRollupPublicInputs);
+    return bufferSchemaFor(TxRollupPublicInputs);
   }
 }

package/src/schemas/schemas.ts

@@ -49,6 +49,9 @@ export const schemas = {
   /** Hex string with an optional 0x prefix which gets removed as part of the parsing. */
   HexString: foundationSchemas.HexString,
 
+  /** Schema for secret config value */
+  SecretValue: foundationSchemas.SecretValue,
+
   /** Accepts a hex string. */
   AztecAddress: AztecAddress.schema,
 

package/src/slashing/empire.ts

@@ -0,0 +1,100 @@
+import { getRoundForSlot, getRoundsForEpoch } from './helpers.js';
+import type { Offense, OffenseIdentifier, SlashPayload, SlashPayloadRound, ValidatorSlash } from './types.js';
+import { OffenseType } from './types.js';
+
+/**
+ * Returns true if the offense is uncontroversial as in it can be verified via L1 data alone,
+ * and does not depend on the local view of the node of the L2 p2p network.
+ * @param offense - The offense type to check
+ */
+export function isOffenseUncontroversial(offense: OffenseType): boolean {
+  return (
+    offense === OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS ||
+    offense === OffenseType.PROPOSED_INCORRECT_ATTESTATIONS ||
+    offense === OffenseType.ATTESTED_DESCENDANT_OF_INVALID
+  );
+}
+
+/** Extracts offense identifiers (validator, epoch, offense type) from an Empire-based SlashPayload */
+export function getOffenseIdentifiersFromPayload(payload: SlashPayload | SlashPayloadRound): OffenseIdentifier[] {
+  return payload.slashes.flatMap((slash: ValidatorSlash) =>
+    slash.offenses.map(o => ({
+      validator: slash.validator,
+      offenseType: o.offenseType,
+      epochOrSlot: o.epochOrSlot,
+    })),
+  );
+}
+
+/** Creates ValidatorSlashes used to create an Empire-based SlashPayload from a set of Offenses */
+export function offensesToValidatorSlash(offenses: Offense[]): ValidatorSlash[] {
+  return offenses.map(offense => ({
+    validator: offense.validator,
+    amount: offense.amount,
+    offenses: [{ epochOrSlot: offense.epochOrSlot, offenseType: offense.offenseType }],
+  }));
+}
+
+/**
+ * Sorts offense data by:
+ * - Uncontroversial offenses first
+ * - Slash amount (descending)
+ * - Epoch or slot (ascending, ie oldest first)
+ * - Validator address (ascending)
+ * - Offense type (descending)
+ */
+export function offenseDataComparator(a: Offense, b: Offense): number {
+  return (
+    Number(isOffenseUncontroversial(b.offenseType)) - Number(isOffenseUncontroversial(a.offenseType)) ||
+    Number(b.amount - a.amount) ||
+    Number(a.epochOrSlot - b.epochOrSlot) ||
+    a.validator.toString().localeCompare(b.validator.toString()) ||
+    Number(b.offenseType) - Number(a.offenseType)
+  );
+}
+
+/**
+ * Returns the first round in which the offense is eligible for being included in an Empire-based slash payload.
+ * Should be equal to to the first round that starts strictly after the offense becomes detectable.
+ */
+export function getFirstEligibleRoundForOffense(
+  offense: OffenseIdentifier,
+  constants: { slashingRoundSize: number; epochDuration: number; proofSubmissionEpochs: number },
+): bigint {
+  // TODO(palla/slash): Check for off-by-ones
+  switch (offense.offenseType) {
+    // Inactivity is detected at the end of the epoch, so we flag it as detected in the first fresh round for the next epoch
+    case OffenseType.INACTIVITY: {
+      const epoch = offense.epochOrSlot;
+      const detectedEpoch = epoch + 1n;
+      return getRoundsForEpoch(detectedEpoch, constants)[0] + 1n;
+    }
+    // These offenses are detected once an epoch is pruned, which happens after the proof submission window
+    case OffenseType.VALID_EPOCH_PRUNED:
+    case OffenseType.DATA_WITHHOLDING: {
+      // TODO(palla/slash): Check for off-by-ones especially here
+      const epoch = offense.epochOrSlot;
+      const detectedEpoch = epoch + BigInt(constants.proofSubmissionEpochs);
+      return getRoundsForEpoch(detectedEpoch, constants)[0] + 1n;
+    }
+    // These offenses are detected immediately in the slot they occur, so we assume they are detected in the first round for the following slot
+    case OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS:
+    case OffenseType.PROPOSED_INCORRECT_ATTESTATIONS:
+    case OffenseType.ATTESTED_DESCENDANT_OF_INVALID:
+    case OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL: {
+      const slot = offense.epochOrSlot;
+      const detectedSlot = slot + 1n;
+      return getRoundForSlot(detectedSlot, constants).round + 1n;
+    }
+    // Assume these are epoch-based offenses, even though we should never have to process these
+    case OffenseType.UNKNOWN: {
+      const epoch = offense.epochOrSlot;
+      const detectedEpoch = epoch + 1n;
+      return getRoundsForEpoch(detectedEpoch, constants)[0] + 1n;
+    }
+    default: {
+      const _: never = offense.offenseType;
+      throw new Error(`Unknown offense type: ${offense.offenseType}`);
+    }
+  }
+}

package/src/slashing/helpers.ts

@@ -0,0 +1,136 @@
+import { type L1RollupConstants, getEpochAtSlot, getSlotRangeForEpoch } from '../epoch-helpers/index.js';
+import type { SlasherConfig } from '../interfaces/slasher.js';
+import { type Offense, OffenseType } from './types.js';
+
+/** Returns the voting round number and voting slot within the round for a given L2 slot. */
+export function getRoundForSlot(
+  slot: bigint,
+  constants: { slashingRoundSize: number },
+): { round: bigint; votingSlot: bigint } {
+  const roundSize = BigInt(constants.slashingRoundSize);
+  const round = slot / roundSize;
+  const votingSlot = slot % roundSize;
+  return { round, votingSlot };
+}
+
+/** Returns the voting round(s) lower and upper bounds (inclusive) covered by the given epoch */
+export function getRoundsForEpoch(
+  epoch: bigint,
+  constants: { slashingRoundSize: number; epochDuration: number },
+): [bigint, bigint] {
+  const [start, end] = getSlotRangeForEpoch(epoch, constants);
+  const startRound = getRoundForSlot(start, constants).round;
+  const endRound = getRoundForSlot(end, constants).round;
+  return [startRound, endRound];
+}
+
+/** Returns the epochs spanned during a given slashing round */
+export function getEpochsForRound(
+  round: bigint,
+  constants: { slashingRoundSize: number; epochDuration: number },
+): bigint[] {
+  const epochs: bigint[] = [];
+  const firstSlot = round * BigInt(constants.slashingRoundSize);
+  const lastSlot = firstSlot + BigInt(constants.slashingRoundSize) - 1n;
+  const startEpoch = getEpochAtSlot(firstSlot, constants);
+  const endEpoch = getEpochAtSlot(lastSlot, constants);
+  for (let epoch = startEpoch; epoch <= endEpoch; epoch++) {
+    epochs.push(epoch);
+  }
+  return epochs;
+}
+
+/** Reads the configured penalty for a given offense type from a slasher config struct */
+export function getPenaltyForOffense(
+  offense: OffenseType,
+  config: Pick<
+    SlasherConfig,
+    | 'slashAttestDescendantOfInvalidPenalty'
+    | 'slashBroadcastedInvalidBlockPenalty'
+    | 'slashPrunePenalty'
+    | 'slashDataWithholdingPenalty'
+    | 'slashUnknownPenalty'
+    | 'slashInactivityPenalty'
+    | 'slashProposeInvalidAttestationsPenalty'
+  >,
+) {
+  switch (offense) {
+    case OffenseType.VALID_EPOCH_PRUNED:
+      return config.slashPrunePenalty;
+    case OffenseType.DATA_WITHHOLDING:
+      return config.slashDataWithholdingPenalty;
+    case OffenseType.INACTIVITY:
+      return config.slashInactivityPenalty;
+    case OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS:
+    case OffenseType.PROPOSED_INCORRECT_ATTESTATIONS:
+      return config.slashProposeInvalidAttestationsPenalty;
+    case OffenseType.ATTESTED_DESCENDANT_OF_INVALID:
+      return config.slashAttestDescendantOfInvalidPenalty;
+    case OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL:
+      return config.slashBroadcastedInvalidBlockPenalty;
+    case OffenseType.UNKNOWN:
+      return config.slashUnknownPenalty;
+    default: {
+      const _exhaustiveCheck: never = offense;
+      throw new Error(`Unknown offense type: ${_exhaustiveCheck}`);
+    }
+  }
+}
+
+/** Returns whether the `epochOrSlot` field for an offense references an epoch or a slot */
+export function getTimeUnitForOffense(offense: OffenseType): 'epoch' | 'slot' {
+  switch (offense) {
+    case OffenseType.ATTESTED_DESCENDANT_OF_INVALID:
+    case OffenseType.BROADCASTED_INVALID_BLOCK_PROPOSAL:
+    case OffenseType.PROPOSED_INCORRECT_ATTESTATIONS:
+    case OffenseType.PROPOSED_INSUFFICIENT_ATTESTATIONS:
+      return 'slot';
+    case OffenseType.INACTIVITY:
+    case OffenseType.DATA_WITHHOLDING:
+    case OffenseType.UNKNOWN:
+    case OffenseType.VALID_EPOCH_PRUNED:
+      return 'epoch';
+    default: {
+      const _exhaustiveCheck: never = offense;
+      throw new Error(`Unknown offense type: ${_exhaustiveCheck}`);
+    }
+  }
+}
+
+/** Returns the slot for a given offense. If the offense references an epoch, returns the first slot of the epoch. */
+export function getSlotForOffense(
+  offense: Pick<Offense, 'epochOrSlot' | 'offenseType'>,
+  constants: Pick<L1RollupConstants, 'epochDuration'>,
+): bigint {
+  const { epochOrSlot, offenseType } = offense;
+  return getTimeUnitForOffense(offenseType) === 'epoch' ? epochOrSlot * BigInt(constants.epochDuration) : epochOrSlot;
+}
+
+/** Returns the epoch for a given offense. If the offense type or epoch is not defined, returns undefined. */
+export function getEpochForOffense(
+  offense: Pick<Offense, 'epochOrSlot' | 'offenseType'>,
+  constants: Pick<L1RollupConstants, 'epochDuration'>,
+): bigint;
+export function getEpochForOffense(
+  offense: Partial<Pick<Offense, 'epochOrSlot' | 'offenseType'>>,
+  constants: Pick<L1RollupConstants, 'epochDuration'>,
+): bigint | undefined;
+export function getEpochForOffense(
+  offense: Partial<Pick<Offense, 'epochOrSlot' | 'offenseType'>>,
+  constants: Pick<L1RollupConstants, 'epochDuration'>,
+): bigint | undefined {
+  const { epochOrSlot, offenseType } = offense;
+  if (epochOrSlot === undefined || offenseType === undefined) {
+    return undefined;
+  }
+  return getTimeUnitForOffense(offenseType) === 'epoch' ? epochOrSlot : epochOrSlot / BigInt(constants.epochDuration);
+}
+
+/** Returns the slashing round in which a given offense occurred. */
+export function getRoundForOffense(
+  offense: Pick<Offense, 'epochOrSlot' | 'offenseType'>,
+  constants: { slashingRoundSize: number; epochDuration: number },
+): bigint {
+  const slot = getSlotForOffense(offense, constants);
+  return getRoundForSlot(slot, constants).round;
+}

package/src/slashing/index.ts

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './interfaces.js';
+export * from './helpers.js';
+export * from './empire.js';
+export * from './tally.js';
+export * from './serialization.js';

package/src/slashing/interfaces.ts

@@ -0,0 +1,11 @@
+import type { ProposerSlashAction } from './types.js';
+
+export interface ProposerSlashActionProvider {
+  /**
+   * Returns the actions to take for the proposer in the current slot.
+   * This can include creating a slash payload or other actions.
+   * @param slotNumber - The current slot number
+   * @returns The actions to take
+   */
+  getProposerActions(slotNumber: bigint): Promise<ProposerSlashAction[]>;
+}

package/src/slashing/serialization.ts

@@ -0,0 +1,103 @@
+import { times } from '@aztec/foundation/collection';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import { BufferReader, bigintToUInt64BE, bigintToUInt128BE, serializeToBuffer } from '@aztec/foundation/serialize';
+
+import type {
+  Offense,
+  OffenseType,
+  SlashPayload,
+  SlashPayloadRound,
+  ValidatorSlash,
+  ValidatorSlashOffense,
+} from './types.js';
+
+export function serializeOffense(offense: Offense): Buffer {
+  return serializeToBuffer(
+    offense.validator,
+    bigintToUInt128BE(offense.amount),
+    offense.offenseType,
+    bigintToUInt64BE(offense.epochOrSlot),
+  );
+}
+
+export function deserializeOffense(buffer: Buffer): Offense {
+  const reader = BufferReader.asReader(buffer);
+  const validator = reader.readObject(EthAddress);
+  const amount = reader.readUInt128();
+  const offense = reader.readNumber() as OffenseType;
+  const epochOrSlot = reader.readUInt64();
+
+  return { validator, amount, offenseType: offense, epochOrSlot };
+}
+
+function serializeValidatorSlashOffense(offense: ValidatorSlashOffense): Buffer {
+  return serializeToBuffer(bigintToUInt64BE(offense.epochOrSlot), offense.offenseType);
+}
+
+function deserializeValidatorSlashOffense(buffer: Buffer | BufferReader): ValidatorSlashOffense {
+  const reader = BufferReader.asReader(buffer);
+  return {
+    epochOrSlot: reader.readUInt64(),
+    offenseType: reader.readNumber() as OffenseType,
+  };
+}
+
+function serializeValidatorSlash(slash: ValidatorSlash): Buffer {
+  return serializeToBuffer(
+    slash.validator,
+    bigintToUInt128BE(slash.amount),
+    slash.offenses.length,
+    slash.offenses.map(serializeValidatorSlashOffense),
+  );
+}
+
+function deserializeValidatorSlash(buffer: Buffer | BufferReader): ValidatorSlash {
+  const reader = BufferReader.asReader(buffer);
+  const validator = reader.readObject(EthAddress);
+  const amount = reader.readUInt128();
+  const offensesCount = reader.readNumber();
+  const offenses = times(offensesCount, () => deserializeValidatorSlashOffense(reader));
+
+  return { validator, amount, offenses };
+}
+
+export function serializeSlashPayload(payload: SlashPayload): Buffer {
+  return serializeToBuffer(
+    payload.address,
+    payload.slashes.length,
+    payload.slashes.map(serializeValidatorSlash),
+    bigintToUInt64BE(payload.timestamp),
+  );
+}
+
+export function deserializeSlashPayload(buffer: Buffer): SlashPayload {
+  const reader = BufferReader.asReader(buffer);
+  const address = reader.readObject(EthAddress);
+  const slashesCount = reader.readNumber();
+  const slashes = times(slashesCount, () => deserializeValidatorSlash(reader));
+  const timestamp = reader.readUInt64();
+  return { address, slashes, timestamp };
+}
+
+export function serializeSlashPayloadRound(payload: SlashPayloadRound): Buffer {
+  return serializeToBuffer(
+    payload.address,
+    payload.slashes.length,
+    payload.slashes.map(serializeValidatorSlash),
+    bigintToUInt64BE(payload.timestamp),
+    Number(payload.votes),
+    bigintToUInt64BE(payload.round),
+  );
+}
+
+export function deserializeSlashPayloadRound(buffer: Buffer): SlashPayloadRound {
+  const reader = BufferReader.asReader(buffer);
+  const address = reader.readObject(EthAddress);
+  const slashesCount = reader.readNumber();
+  const slashes = times(slashesCount, () => deserializeValidatorSlash(reader));
+  const timestamp = reader.readUInt64();
+  const votes = BigInt(reader.readNumber());
+  const round = reader.readUInt64();
+
+  return { address, slashes, timestamp, votes, round };
+}

package/src/slashing/tally.ts

@@ -0,0 +1,87 @@
+import { sumBigint } from '@aztec/foundation/bigint';
+import { EthAddress } from '@aztec/foundation/eth-address';
+import type { PartialBy } from '@aztec/foundation/types';
+
+import { getEpochForOffense } from './helpers.js';
+import type { Offense, ValidatorSlashVote } from './types.js';
+
+/**
+ * Creates a consensus-slash vote for a given set of committees based on a set of Offenses
+ * @param offenses - Array of offenses to consider
+ * @param committees - Array of committees (each containing array of validator addresses)
+ * @param epochsForCommittees - Array of epochs corresponding to each committee
+ * @param settings - Settings including slashingAmounts and optional validator override lists
+ * @returns Array of ValidatorSlashVote, where each vote is how many slash units the validator in that position should be slashed
+ */
+export function getSlashConsensusVotesFromOffenses(
+  offenses: PartialBy<Offense, 'epochOrSlot'>[],
+  committees: EthAddress[][],
+  epochsForCommittees: bigint[],
+  settings: {
+    slashingAmounts: [bigint, bigint, bigint];
+    epochDuration: number;
+  },
+): ValidatorSlashVote[] {
+  const { slashingAmounts } = settings;
+
+  if (committees.length !== epochsForCommittees.length) {
+    throw new Error('committees and epochsForCommittees must have the same length');
+  }
+
+  const votes = committees.flatMap((committee, committeeIndex) => {
+    const committeeEpoch = epochsForCommittees[committeeIndex];
+
+    return committee.map(validator => {
+      // Find offenses for this validator in this specific epoch.
+      // If an offense has no epoch, it is considered for all epochs due to a slashAlways setting.
+      const validatorOffenses = offenses.filter(
+        o =>
+          o.validator.equals(validator) &&
+          (o.epochOrSlot === undefined || getEpochForOffense(o, settings) === committeeEpoch),
+      );
+
+      // Sum up the penalties for this validator in this epoch
+      const slashAmount = sumBigint(validatorOffenses.map(o => o.amount));
+      const slashUnits = getSlashUnitsForAmount(slashAmount, slashingAmounts);
+      return Number(slashUnits);
+    });
+  });
+
+  return votes;
+}
+
+/** Returns the slash vote for the given amount to slash. */
+function getSlashUnitsForAmount(amountToSlash: bigint, slashingAmounts: [bigint, bigint, bigint]): number {
+  if (amountToSlash >= slashingAmounts[2]) {
+    return 3;
+  } else if (amountToSlash >= slashingAmounts[1]) {
+    return 2;
+  } else if (amountToSlash >= slashingAmounts[0]) {
+    return 1;
+  } else {
+    return 0;
+  }
+}
+
+/**
+ * Encodes a set of slash votes into a Buffer for use in a consensus slashing vote transaction.
+ * Each vote is represented as a 2-bit value, which represents how many slashing units the validator should be slashed.
+ * @param votes - The array of slash votes to encode
+ * @returns A Buffer containing the encoded slash votes
+ */
+export function encodeSlashConsensusVotes(votes: ValidatorSlashVote[]): Buffer {
+  if (votes.length % 4 !== 0) {
+    throw new Error('Votes array must have a length that is a multiple of 4');
+  }
+  const buffer = Buffer.alloc(votes.length / 4);
+  for (let i = 0; i < votes.length; i += 4) {
+    // Encode votes to match Solidity's bit order (LSB to MSB)
+    // Bits 0-1: validator at index i
+    // Bits 2-3: validator at index i+1
+    // Bits 4-5: validator at index i+2
+    // Bits 6-7: validator at index i+3
+    const voteByte = votes[i] | (votes[i + 1] << 2) | (votes[i + 2] << 4) | (votes[i + 3] << 6);
+    buffer.writeUInt8(voteByte, i / 4);
+  }
+  return buffer;
+}