@aztec/stdlib 0.0.1-commit.0c875d939 → 0.0.1-commit.0ec55a70b

package/src/slashing/types.ts

@@ -126,45 +126,13 @@ export type ValidatorSlash = {
   offenses: ValidatorSlashOffense[];
 };
 
-/** Slash payload as published by the empire slash proposer */
-export type SlashPayload = {
-  address: EthAddress;
-  slashes: ValidatorSlash[];
-  timestamp: bigint;
-};
-
-/** Slash payload with round information from empire slash proposer */
-export type SlashPayloadRound = SlashPayload & { votes: bigint; round: bigint };
-
-export const SlashPayloadRoundSchema = zodFor<SlashPayloadRound>()(
-  z.object({
-    address: schemas.EthAddress,
-    timestamp: schemas.BigInt,
-    votes: schemas.BigInt,
-    round: schemas.BigInt,
-    slashes: z.array(
-      z.object({
-        validator: schemas.EthAddress,
-        amount: schemas.BigInt,
-        offenses: z.array(z.object({ offenseType: OffenseTypeSchema, epochOrSlot: schemas.BigInt })),
-      }),
-    ),
-  }),
-);
-
-/** Votes for a validator slash in the consensus slash proposer */
+/** Votes for a validator slash in the slashing proposer */
 export type ValidatorSlashVote = number;
 
 export type ProposerSlashAction =
-  /** Create a new slash payload on an empire-based slash proposer */
-  | { type: 'create-empire-payload'; data: ValidatorSlash[] }
-  /** Vote for a slashing payload on an empire-based slash proposer */
-  | { type: 'vote-empire-payload'; payload: EthAddress }
-  /** Execute a slashing payload on an empire-based slash proposer */
-  | { type: 'execute-empire-payload'; round: bigint }
-  /** Vote for offenses on a consensus slashing proposer */
+  /** Vote for offenses on the slashing proposer */
   | { type: 'vote-offenses'; votes: ValidatorSlashVote[]; committees: EthAddress[][]; round: bigint }
-  /** Execute a slashing round on a consensus slashing proposer */
+  /** Execute a slashing round on the slashing proposer */
   | { type: 'execute-slash'; committees: EthAddress[][]; round: bigint };
 
 export type ProposerSlashActionType = ProposerSlashAction['type'];

package/src/slashing/{tally.ts → votes.ts}

@@ -1,6 +1,7 @@
 import { sumBigint } from '@aztec/foundation/bigint';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { EthAddress } from '@aztec/foundation/eth-address';
+import { type Logger, createLogger } from '@aztec/foundation/log';
 import type { PartialBy } from '@aztec/foundation/types';
 
 import { getEpochForOffense } from './helpers.js';
@@ -12,6 +13,9 @@ import type { Offense, ValidatorSlashVote } from './types.js';
  * @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
+ * @param settings.maxSlashedValidators - If set, limits the total number of [validator, epoch] pairs
+ *   with non-zero votes. The lowest-vote pairs are zeroed out to stay within the limit.
+ * @param logger - Logger, logs which validators were dropped.
  * @returns Array of ValidatorSlashVote, where each vote is how many slash units the validator in that position should be slashed
  */
 export function getSlashConsensusVotesFromOffenses(
@@ -22,9 +26,11 @@ export function getSlashConsensusVotesFromOffenses(
     slashingAmounts: [bigint, bigint, bigint];
     epochDuration: number;
     targetCommitteeSize: number;
+    maxSlashedValidators?: number;
   },
+  logger: Logger = createLogger('slasher:votes'),
 ): ValidatorSlashVote[] {
-  const { slashingAmounts, targetCommitteeSize } = settings;
+  const { slashingAmounts, targetCommitteeSize, maxSlashedValidators } = settings;
 
   if (committees.length !== epochsForCommittees.length) {
     throw new Error('committees and epochsForCommittees must have the same length');
@@ -53,6 +59,33 @@ export function getSlashConsensusVotesFromOffenses(
     return padArrayEnd(votes, 0, targetCommitteeSize);
   });
 
+  // if a cap is set, zero out the lowest-vote [validator, epoch] pairs so that the most severe slashes stay.
+  if (maxSlashedValidators === undefined) {
+    return votes;
+  }
+
+  const nonZeroByDescendingVote = [...votes.entries()].filter(([, vote]) => vote > 0).sort(([, a], [, b]) => b - a);
+
+  const toTruncate = nonZeroByDescendingVote.slice(maxSlashedValidators);
+  for (const [idx] of toTruncate) {
+    votes[idx] = 0;
+  }
+
+  if (toTruncate.length > 0) {
+    const truncated = toTruncate.map(([idx]) => {
+      const committeeIndex = Math.floor(idx / targetCommitteeSize);
+      const positionInCommittee = idx % targetCommitteeSize;
+      return {
+        validator: committees[committeeIndex][positionInCommittee].toString(),
+        epoch: epochsForCommittees[committeeIndex],
+      };
+    });
+    logger.warn(
+      `Truncated ${toTruncate.length} validator-epoch pairs to stay within limit of ${maxSlashedValidators}`,
+      { truncated },
+    );
+  }
+
   return votes;
 }
 

package/src/tests/factories.ts

@@ -9,7 +9,6 @@ import {
   AVM_V2_PROOF_LENGTH_IN_FIELDS_PADDED,
   CHONK_PROOF_LENGTH,
   CONTRACT_CLASS_LOG_SIZE_IN_FIELDS,
-  GeneratorIndex,
   L1_TO_L2_MSG_SUBTREE_ROOT_SIBLING_PATH_LENGTH,
   MAX_CHECKPOINTS_PER_EPOCH,
   MAX_CONTRACT_CLASS_LOGS_PER_TX,
@@ -46,7 +45,6 @@ import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
 import { BlockNumber, CheckpointNumber, SlotNumber } from '@aztec/foundation/branded-types';
 import { compact } from '@aztec/foundation/collection';
 import { Grumpkin } from '@aztec/foundation/crypto/grumpkin';
-import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
 import { SchnorrSignature } from '@aztec/foundation/crypto/schnorr';
 import { sha256 } from '@aztec/foundation/crypto/sha256';
 import { Fq, Fr } from '@aztec/foundation/curves/bn254';
@@ -92,17 +90,16 @@ import {
   type ContractClassPublic,
   ContractDeploymentData,
   type ContractInstanceWithAddress,
-  type ExecutablePrivateFunctionWithMembershipProof,
   type PrivateFunction,
   SerializableContractInstance,
-  type UtilityFunctionWithMembershipProof,
   computeContractClassId,
+  computePartialAddress,
   computePublicBytecodeCommitment,
 } from '../contract/index.js';
 import { Gas, GasFees, GasSettings } from '../gas/index.js';
 import { computeCalldataHash } from '../hash/hash.js';
 import { KeyValidationRequest } from '../kernel/hints/key_validation_request.js';
-import { KeyValidationRequestAndGenerator } from '../kernel/hints/key_validation_request_and_generator.js';
+import { KeyValidationRequestAndSeparator } from '../kernel/hints/key_validation_request_and_separator.js';
 import { ReadRequest, ScopedReadRequest } from '../kernel/hints/read_request.js';
 import {
   ClaimedLengthArray,
@@ -128,6 +125,7 @@ import {
   PublicCallRequestArrayLengths,
 } from '../kernel/public_call_request.js';
 import { PublicKeys, computeAddress } from '../keys/index.js';
+import { ExtendedDirectionalAppTaggingSecret } from '../logs/extended_directional_app_tagging_secret.js';
 import { ContractClassLog, ContractClassLogFields } from '../logs/index.js';
 import { PrivateLog } from '../logs/private_log.js';
 import { FlatPublicLogs, PublicLog } from '../logs/public_log.js';
@@ -177,7 +175,7 @@ import { TxHash } from '../tx/tx_hash.js';
 import { TxRequest } from '../tx/tx_request.js';
 import { Vector } from '../types/index.js';
 import { VkData } from '../vks/index.js';
-import { VerificationKey, VerificationKeyAsFields, VerificationKeyData } from '../vks/verification_key.js';
+import { VerificationKeyAsFields, VerificationKeyData } from '../vks/verification_key.js';
 
 /**
  * Creates an arbitrary side effect object with the given seed.
@@ -233,7 +231,7 @@ export function makeTxContext(seed: number = 1): TxContext {
  * Creates a default instance of gas settings. No seed value is used to ensure we allocate a sensible amount of gas for testing.
  */
 export function makeGasSettings() {
-  return GasSettings.default({ maxFeesPerGas: new GasFees(10, 10) });
+  return GasSettings.fallback({ maxFeesPerGas: new GasFees(10, 10) });
 }
 
 /**
@@ -259,12 +257,12 @@ function makeKeyValidationRequests(seed: number): KeyValidationRequest {
 }
 
 /**
- * Creates arbitrary KeyValidationRequestAndGenerator from the given seed.
- * @param seed - The seed to use for generating the KeyValidationRequestAndGenerator.
- * @returns A KeyValidationRequestAndGenerator.
+ * Creates arbitrary KeyValidationRequestAndSeparator from the given seed.
+ * @param seed - The seed to use for generating the KeyValidationRequestAndSeparator.
+ * @returns A KeyValidationRequestAndSeparator.
  */
-function makeKeyValidationRequestAndGenerators(seed: number): KeyValidationRequestAndGenerator {
-  return new KeyValidationRequestAndGenerator(makeKeyValidationRequests(seed), fr(seed + 4));
+function makeKeyValidationRequestAndSeparators(seed: number): KeyValidationRequestAndSeparator {
+  return new KeyValidationRequestAndSeparator(makeKeyValidationRequests(seed), fr(seed + 4));
 }
 
 export function makePublicDataWrite(seed = 1) {
@@ -574,14 +572,6 @@ export function makeVerificationKeyAsFields(size: number): VerificationKeyAsFiel
   return VerificationKeyAsFields.makeFake(size);
 }
 
-/**
- * Creates arbitrary/mocked verification key.
- * @returns A verification key object
- */
-export function makeVerificationKey(): VerificationKey {
-  return VerificationKey.makeFake();
-}
-
 /**
  * Creates an arbitrary point in a curve.
  * @param seed - Seed to generate the point values.
@@ -656,7 +646,7 @@ function makeClaimedLengthArray<T extends Serializable, N extends number>(
  */
 export function makePrivateCircuitPublicInputs(seed = 0): PrivateCircuitPublicInputs {
   return PrivateCircuitPublicInputs.from({
-    includeByTimestamp: BigInt(seed + 0x31415),
+    expirationTimestamp: BigInt(seed + 0x31415),
     callContext: makeCallContext(seed, { isStaticCall: true }),
     argsHash: fr(seed + 0x100),
     returnsHash: fr(seed + 0x200),
@@ -671,9 +661,9 @@ export function makePrivateCircuitPublicInputs(seed = 0): PrivateCircuitPublicIn
       makeScopedReadRequest,
       seed + 0x310,
     ),
-    keyValidationRequestsAndGenerators: makeClaimedLengthArray(
+    keyValidationRequestsAndSeparators: makeClaimedLengthArray(
       MAX_KEY_VALIDATION_REQUESTS_PER_CALL,
-      makeKeyValidationRequestAndGenerators,
+      makeKeyValidationRequestAndSeparators,
       seed + 0x320,
     ),
     noteHashes: makeClaimedLengthArray(MAX_NOTE_HASHES_PER_CALL, makeNoteHash, seed + 0x400),
@@ -864,11 +854,16 @@ export function makeParityPublicInputs(seed = 0): ParityPublicInputs {
     new Fr(BigInt(seed + 0x200)),
     new Fr(BigInt(seed + 0x300)),
     new Fr(BigInt(seed + 0x400)),
+    new Fr(BigInt(seed + 0x500)),
   );
 }
 
 export function makeParityBasePrivateInputs(seed = 0): ParityBasePrivateInputs {
-  return new ParityBasePrivateInputs(makeTuple(NUM_MSGS_PER_BASE_PARITY, fr, seed + 0x3000), new Fr(seed + 0x4000));
+  return new ParityBasePrivateInputs(
+    makeTuple(NUM_MSGS_PER_BASE_PARITY, fr, seed + 0x3000),
+    new Fr(seed + 0x4000),
+    new Fr(seed + 0x5000),
+  );
 }
 
 export function makeParityRootPrivateInputs(seed = 0) {
@@ -1182,35 +1177,6 @@ export function makePublicTxBaseRollupPrivateInputs(seed = 0) {
   });
 }
 
-export function makeExecutablePrivateFunctionWithMembershipProof(
-  seed = 0,
-): ExecutablePrivateFunctionWithMembershipProof {
-  return {
-    selector: makeSelector(seed),
-    bytecode: makeBytes(100, seed + 1),
-    artifactTreeSiblingPath: makeTuple(3, fr, seed + 2),
-    artifactTreeLeafIndex: seed + 2,
-    privateFunctionTreeSiblingPath: makeTuple(3, fr, seed + 3),
-    privateFunctionTreeLeafIndex: seed + 3,
-    artifactMetadataHash: fr(seed + 4),
-    functionMetadataHash: fr(seed + 5),
-    utilityFunctionsTreeRoot: fr(seed + 6),
-    vkHash: fr(seed + 7),
-  };
-}
-
-export function makeUtilityFunctionWithMembershipProof(seed = 0): UtilityFunctionWithMembershipProof {
-  return {
-    selector: makeSelector(seed),
-    bytecode: makeBytes(100, seed + 1),
-    artifactTreeSiblingPath: makeTuple(3, fr, seed + 2),
-    artifactTreeLeafIndex: seed + 2,
-    artifactMetadataHash: fr(seed + 4),
-    functionMetadataHash: fr(seed + 5),
-    privateFunctionsArtifactTreeRoot: fr(seed + 6),
-  };
-}
-
 export async function makeContractClassPublic(seed = 0, publicBytecode?: Buffer): Promise<ContractClassPublic> {
   const artifactHash = fr(seed + 1);
   const privateFunctionsRoot = fr(seed + 3);
@@ -1222,8 +1188,6 @@ export async function makeContractClassPublic(seed = 0, publicBytecode?: Buffer)
     artifactHash,
     packedBytecode,
     privateFunctionsRoot,
-    privateFunctions: [],
-    utilityFunctions: [],
     version: 1,
   };
 }
@@ -1285,14 +1249,12 @@ export async function makeContractInstanceFromClassId(
   const deployer = overrides?.deployer ?? new AztecAddress(new Fr(seed + 2));
   const publicKeys = overrides?.publicKeys ?? (await makePublicKeys(seed + 3));
 
-  const saltedInitializationHash = await poseidon2HashWithSeparator(
-    [salt, initializationHash, deployer],
-    GeneratorIndex.PARTIAL_ADDRESS,
-  );
-  const partialAddress = await poseidon2HashWithSeparator(
-    [classId, saltedInitializationHash],
-    GeneratorIndex.PARTIAL_ADDRESS,
-  );
+  const partialAddress = await computePartialAddress({
+    originalContractClassId: classId,
+    salt,
+    initializationHash,
+    deployer,
+  });
   const address = await computeAddress(publicKeys, partialAddress);
   return new SerializableContractInstance({
     version: 1,
@@ -1747,6 +1709,10 @@ export function makeL2Tips(
       block: { number: bn, hash },
       checkpoint: { number: cpn, hash: cph },
     },
+    proposedCheckpoint: {
+      block: { number: bn, hash },
+      checkpoint: { number: cpn, hash: cph },
+    },
     proven: {
       block: { number: bn, hash },
       checkpoint: { number: cpn, hash: cph },
@@ -1757,3 +1723,11 @@ export function makeL2Tips(
     },
   };
 }
+
+export async function randomExtendedDirectionalAppTaggingSecret(): Promise<ExtendedDirectionalAppTaggingSecret> {
+  const resolvedApp = await AztecAddress.random();
+  // Using the fromString method like this is messy as it leaks the underlying serialization format but I don't want to
+  // expose the type's constructor just for tests since in prod the secret is always constructed via compute. Also this
+  // method is tested in extended_directional_app_tagging_secret.test.ts hence all should be fine.
+  return ExtendedDirectionalAppTaggingSecret.fromString(`${Fr.random().toString()}:${resolvedApp.toString()}`);
+}

package/src/tests/mocks.ts

@@ -1,10 +1,11 @@
 import {
-  FIXED_DA_GAS,
-  FIXED_L2_GAS,
   MAX_ENQUEUED_CALLS_PER_TX,
-  MAX_INCLUDE_BY_TIMESTAMP_DURATION,
   MAX_NULLIFIERS_PER_TX,
   MAX_TOTAL_PUBLIC_DATA_UPDATE_REQUESTS_PER_TX,
+  MAX_TX_LIFETIME,
+  PRIVATE_TX_L2_GAS_OVERHEAD,
+  PUBLIC_TX_L2_GAS_OVERHEAD,
+  TX_DA_GAS_OVERHEAD,
 } from '@aztec/constants';
 import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
 import { BlockNumber, CheckpointNumber, IndexWithinCheckpoint, SlotNumber } from '@aztec/foundation/branded-types';
@@ -13,8 +14,11 @@ import { padArrayEnd, times } from '@aztec/foundation/collection';
 import { randomBytes } from '@aztec/foundation/crypto/random';
 import { Secp256k1Signer } from '@aztec/foundation/crypto/secp256k1-signer';
 import { Fr } from '@aztec/foundation/curves/bn254';
+import { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
 
+import { type TypedDataDefinition, hashTypedData } from 'viem';
+
 import type { ContractArtifact } from '../abi/abi.js';
 import { PublicTxEffect } from '../avm/avm.js';
 import type { AvmAccumulatedData } from '../avm/avm_accumulated_data.js';
@@ -50,7 +54,7 @@ import { BlockProposal } from '../p2p/block_proposal.js';
 import { CheckpointAttestation } from '../p2p/checkpoint_attestation.js';
 import { CheckpointProposal } from '../p2p/checkpoint_proposal.js';
 import { ConsensusPayload } from '../p2p/consensus_payload.js';
-import { SignatureDomainSeparator, getHashedSignaturePayloadEthSignedMessage } from '../p2p/signature_utils.js';
+import { type CoordinationSignatureContext, getHashedSignaturePayloadTypedData } from '../p2p/signature_utils.js';
 import { ChonkProof } from '../proofs/chonk_proof.js';
 import { ProvingRequestType } from '../proofs/proving_request_type.js';
 import { CheckpointHeader } from '../rollup/checkpoint_header.js';
@@ -85,6 +89,15 @@ import {
   makePublicDataWrite,
 } from './factories.js';
 
+export const TEST_COORDINATION_SIGNATURE_CONTEXT: CoordinationSignatureContext = {
+  chainId: 31337,
+  rollupAddress: EthAddress.fromNumber(1),
+};
+
+function signTypedData(signer: Secp256k1Signer, typedData: TypedDataDefinition): Signature {
+  return signer.sign(Buffer32.fromString(hashTypedData(typedData)));
+}
+
 export const randomTxHash = (): TxHash => TxHash.random();
 
 export const mockTx = async (
@@ -97,6 +110,7 @@ export const mockTx = async (
     publicCalldataSize = 2,
     feePayer,
     chonkProof = ChonkProof.random(),
+    gasLimits,
     maxFeesPerGas = new GasFees(10, 10),
     maxPriorityFeesPerGas,
     gasUsed = Gas.empty(),
@@ -113,6 +127,7 @@ export const mockTx = async (
     publicCalldataSize?: number;
     feePayer?: AztecAddress;
     chonkProof?: ChonkProof;
+    gasLimits?: Gas;
     maxFeesPerGas?: GasFees;
     maxPriorityFeesPerGas?: GasFees;
     gasUsed?: Gas;
@@ -131,7 +146,7 @@ export const mockTx = async (
   const data = PrivateKernelTailCircuitPublicInputs.empty();
   const firstNullifier = new Nullifier(new Fr(seed + 1), Fr.ZERO, 0);
   data.constants.anchorBlockHeader = anchorBlockHeader;
-  data.constants.txContext.gasSettings = GasSettings.default({ maxFeesPerGas, maxPriorityFeesPerGas });
+  data.constants.txContext.gasSettings = GasSettings.fallback({ gasLimits, maxFeesPerGas, maxPriorityFeesPerGas });
   data.feePayer = feePayer ?? (await AztecAddress.random());
   data.gasUsed = gasUsed;
   data.constants.txContext.chainId = chainId;
@@ -139,8 +154,8 @@ export const mockTx = async (
   data.constants.vkTreeRoot = vkTreeRoot;
   data.constants.protocolContractsHash = protocolContractsHash;
 
-  // Set includeByTimestamp to the maximum allowed duration from the current time.
-  data.includeByTimestamp = BigInt(Math.floor(Date.now() / 1000) + MAX_INCLUDE_BY_TIMESTAMP_DURATION);
+  // Set expirationTimestamp to the maximum allowed duration from the current time.
+  data.expirationTimestamp = BigInt(Math.floor(Date.now() / 1000) + MAX_TX_LIFETIME);
 
   const publicFunctionCalldata: HashedValues[] = [];
   if (!isForPublic) {
@@ -197,7 +212,7 @@ export async function mockProcessedTx({
   db,
   chainId = Fr.ZERO,
   version = Fr.ZERO,
-  gasSettings = GasSettings.default({ maxFeesPerGas: new GasFees(10, 10) }),
+  gasSettings = GasSettings.fallback({ maxFeesPerGas: new GasFees(10, 10) }),
   vkTreeRoot = Fr.ZERO,
   protocolContracts = makeProtocolContracts(seed + 0x100),
   globalVariables = GlobalVariables.empty(),
@@ -205,8 +220,11 @@ export async function mockProcessedTx({
   feePayer,
   feePaymentPublicDataWrite,
   // The default gasUsed is the tx overhead.
-  gasUsed = Gas.from({ daGas: FIXED_DA_GAS, l2Gas: FIXED_L2_GAS }),
   privateOnly = false,
+  gasUsed = Gas.from({
+    daGas: TX_DA_GAS_OVERHEAD,
+    l2Gas: privateOnly ? PRIVATE_TX_L2_GAS_OVERHEAD : PUBLIC_TX_L2_GAS_OVERHEAD,
+  }),
   avmAccumulatedData,
   ...mockTxOpts
 }: {
@@ -421,10 +439,13 @@ export async function mockCheckpointAndMessages(
     Partial<Parameters<typeof L2Block.random>[1]> = {},
 ) {
   const slotNumber = options.slotNumber ?? SlotNumber(Number(checkpointNumber) * 10);
+  const globals = GlobalVariables.random({ slotNumber, ...options });
   const blocksAndMessages = [];
+
   // Track the previous block's archive to ensure consecutive blocks have consistent archive roots.
   // The current block's header.lastArchive must equal the previous block's archive.
   let lastArchive: AppendOnlyTreeSnapshot | undefined = previousArchive;
+
   // Pass maxEffects via txOptions so it reaches TxEffect.random
   const txOptions = maxEffects !== undefined ? { maxEffects } : {};
   for (let i = 0; i < (blocks?.length ?? numBlocks); i++) {
@@ -433,11 +454,11 @@ export async function mockCheckpointAndMessages(
       block:
         blocks?.[i] ??
         (await L2Block.random(blockNumber, {
+          ...globals,
           checkpointNumber,
           indexWithinCheckpoint: IndexWithinCheckpoint(i),
           txsPerBlock: numTxsPerBlock,
           txOptions,
-          slotNumber,
           ...options,
           ...makeBlockOptions(blockNumber),
           ...(lastArchive ? { lastArchive } : {}),
@@ -451,12 +472,18 @@ export async function mockCheckpointAndMessages(
 
   const messages = blocksAndMessages[0].messages;
   const inHash = computeInHashFromL1ToL2Messages(messages);
-  const checkpoint = await Checkpoint.random(checkpointNumber, { numBlocks: 0, slotNumber, inHash, ...options });
+  const firstBlockLastArchive = blocksAndMessages[0].block.header.lastArchive;
+  const checkpoint = await Checkpoint.random(checkpointNumber, {
+    numBlocks: 0,
+    inHash,
+    ...options,
+    ...globals,
+    lastArchive: firstBlockLastArchive,
+    lastArchiveRoot: firstBlockLastArchive.root,
+    archive: lastArchive,
+  });
+
   checkpoint.blocks = blocksAndMessages.map(({ block }) => block);
-  // Set the checkpoint's archive to match the last block's archive for proper chaining.
-  // When the archiver reconstructs checkpoints from L1, it uses the checkpoint's archive root
-  // from the L1 event to set the last block's archive. Without this, the archive chain breaks.
-  checkpoint.archive = lastArchive!;
 
   // Return lastArchive so callers can chain it across multiple checkpoints
   return { checkpoint, messages, lastArchive };
@@ -504,6 +531,7 @@ export interface MakeConsensusPayloadOptions {
   txHashes?: TxHash[];
   txs?: Tx[];
   feeAssetPriceModifier?: bigint;
+  signatureContext?: CoordinationSignatureContext;
 }
 
 export interface MakeBlockProposalOptions {
@@ -514,6 +542,7 @@ export interface MakeBlockProposalOptions {
   archiveRoot?: Fr;
   txHashes?: TxHash[];
   txs?: Tx[];
+  signatureContext?: CoordinationSignatureContext;
 }
 
 export interface MakeCheckpointProposalOptions {
@@ -521,6 +550,7 @@ export interface MakeCheckpointProposalOptions {
   checkpointHeader?: CheckpointHeader;
   archiveRoot?: Fr;
   feeAssetPriceModifier?: bigint;
+  signatureContext?: CoordinationSignatureContext;
   /** Options for the lastBlock - if undefined, no lastBlock is included */
   lastBlock?: {
     blockHeader?: BlockHeader;
@@ -531,10 +561,7 @@ export interface MakeCheckpointProposalOptions {
 }
 
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-const makeAndSignConsensusPayload = (
-  domainSeparator: SignatureDomainSeparator,
-  options?: MakeConsensusPayloadOptions,
-) => {
+const makeAndSignConsensusPayload = (options?: MakeConsensusPayloadOptions) => {
   const header = options?.header ?? makeCheckpointHeader(1);
   const { signer = Secp256k1Signer.random(), archive = Fr.random(), feeAssetPriceModifier = 0n } = options ?? {};
 
@@ -542,9 +569,10 @@ const makeAndSignConsensusPayload = (
     header,
     archive,
     feeAssetPriceModifier,
+    signatureContext: TEST_COORDINATION_SIGNATURE_CONTEXT,
   });
 
-  const hash = getHashedSignaturePayloadEthSignedMessage(payload, domainSeparator);
+  const hash = getHashedSignaturePayloadTypedData(payload);
   const signature = signer.sign(hash);
 
   return { blockNumber: header.slotNumber, payload, signature };
@@ -554,10 +582,7 @@ export const makeAndSignCommitteeAttestationsAndSigners = (
   attestationsAndSigners: CommitteeAttestationsAndSigners,
   signer: Secp256k1Signer = Secp256k1Signer.random(),
 ) => {
-  const hash = getHashedSignaturePayloadEthSignedMessage(
-    attestationsAndSigners,
-    SignatureDomainSeparator.attestationsAndSigners,
-  );
+  const hash = getHashedSignaturePayloadTypedData(attestationsAndSigners);
   return signer.sign(hash);
 };
 
@@ -569,41 +594,51 @@ export const makeBlockProposal = (options?: MakeBlockProposalOptions): Promise<B
   const txHashes = options?.txHashes ?? [0, 1, 2, 3, 4, 5].map(() => TxHash.random());
   const txs = options?.txs;
   const signer = options?.signer ?? Secp256k1Signer.random();
+  const signatureContext = options?.signatureContext ?? TEST_COORDINATION_SIGNATURE_CONTEXT;
 
   return BlockProposal.createProposalFromSigner(
     blockHeader,
+    CheckpointNumber(1),
     indexWithinCheckpoint,
     inHash,
     archiveRoot,
     txHashes,
     txs,
-    (_payload, _context) => Promise.resolve(signer.signMessage(_payload)),
+    signatureContext,
+    (typedData, _context) => Promise.resolve(signTypedData(signer, typedData)),
+    (typedData, _context) => Promise.resolve(signTypedData(signer, typedData)),
   );
 };
 
-export const makeCheckpointProposal = (options?: MakeCheckpointProposalOptions): Promise<CheckpointProposal> => {
-  const blockHeader = options?.lastBlock?.blockHeader ?? makeBlockHeader(1);
+export const makeCheckpointProposal = async (options?: MakeCheckpointProposalOptions): Promise<CheckpointProposal> => {
   const checkpointHeader = options?.checkpointHeader ?? makeCheckpointHeader(1);
   const archiveRoot = options?.archiveRoot ?? Fr.random();
   const feeAssetPriceModifier = options?.feeAssetPriceModifier ?? 0n;
   const signer = options?.signer ?? Secp256k1Signer.random();
-
-  // Build lastBlock info if provided
-  const lastBlockInfo = options?.lastBlock
-    ? {
-        blockHeader,
-        indexWithinCheckpoint: options.lastBlock.indexWithinCheckpoint ?? IndexWithinCheckpoint(4), // Last block in a 5-block checkpoint
-        txHashes: options.lastBlock.txHashes ?? [0, 1, 2, 3, 4, 5].map(() => TxHash.random()),
+  const signatureContext = options?.signatureContext ?? TEST_COORDINATION_SIGNATURE_CONTEXT;
+
+  // Build a signed block proposal if lastBlock options are provided
+  const lastBlockProposal = options?.lastBlock
+    ? await makeBlockProposal({
+        blockHeader: options.lastBlock.blockHeader,
+        indexWithinCheckpoint: options.lastBlock.indexWithinCheckpoint ?? IndexWithinCheckpoint(4),
+        inHash: checkpointHeader.inHash,
+        archiveRoot,
+        txHashes: options.lastBlock.txHashes,
         txs: options.lastBlock.txs,
-      }
+        signer,
+        signatureContext,
+      })
     : undefined;
 
   return CheckpointProposal.createProposalFromSigner(
     checkpointHeader,
     archiveRoot,
+    CheckpointNumber(1),
     feeAssetPriceModifier,
-    lastBlockInfo,
-    payload => Promise.resolve(signer.signMessage(payload)),
+    lastBlockProposal,
+    signatureContext,
+    typedData => Promise.resolve(signTypedData(signer, typedData)),
   );
 };
 
@@ -617,6 +652,7 @@ export type MakeCheckpointAttestationOptions = {
   attesterSigner?: Secp256k1Signer;
   proposerSigner?: Secp256k1Signer;
   signer?: Secp256k1Signer;
+  signatureContext?: CoordinationSignatureContext;
 };
 
 /**
@@ -626,26 +662,27 @@ export const makeCheckpointAttestation = (options: MakeCheckpointAttestationOpti
   const header = options.header ?? makeCheckpointHeader(1);
   const archive = options.archive ?? Fr.random();
   const feeAssetPriceModifier = options.feeAssetPriceModifier ?? 0n;
+  const signatureContext = options.signatureContext ?? TEST_COORDINATION_SIGNATURE_CONTEXT;
   const { signer, attesterSigner = signer, proposerSigner = signer } = options;
 
-  const payload = new ConsensusPayload(header, archive, feeAssetPriceModifier);
+  const payload = new ConsensusPayload(header, archive, feeAssetPriceModifier, signatureContext);
 
   // Sign as attester
-  const attestationHash = getHashedSignaturePayloadEthSignedMessage(
-    payload,
-    SignatureDomainSeparator.checkpointAttestation,
-  );
+  const attestationHash = getHashedSignaturePayloadTypedData(payload);
   const attestationSigner = attesterSigner ?? Secp256k1Signer.random();
   const attestationSignature = attestationSigner.sign(attestationHash);
 
   // Sign as proposer - use CheckpointProposal's payload format (serializeToBuffer)
   // This is different from ConsensusPayload's format (ABI encoding)
   const proposalSignerToUse = proposerSigner ?? Secp256k1Signer.random();
-  const tempProposal = new CheckpointProposal(header, archive, feeAssetPriceModifier, Signature.empty());
-  const proposalHash = getHashedSignaturePayloadEthSignedMessage(
-    tempProposal,
-    SignatureDomainSeparator.checkpointProposal,
+  const tempProposal = new CheckpointProposal(
+    header,
+    archive,
+    feeAssetPriceModifier,
+    Signature.empty(),
+    signatureContext,
   );
+  const proposalHash = getHashedSignaturePayloadTypedData(tempProposal);
   const proposerSignature = proposalSignerToUse.sign(proposalHash);
 
   return new CheckpointAttestation(payload, attestationSignature, proposerSignature);
@@ -658,13 +695,15 @@ export const makeCheckpointAttestationFromProposal = (
   proposal: CheckpointProposal,
   attesterSigner?: Secp256k1Signer,
 ): CheckpointAttestation => {
-  const payload = new ConsensusPayload(proposal.checkpointHeader, proposal.archive, proposal.feeAssetPriceModifier);
+  const payload = new ConsensusPayload(
+    proposal.checkpointHeader,
+    proposal.archive,
+    proposal.feeAssetPriceModifier,
+    proposal.signatureContext,
+  );
 
   // Sign as attester
-  const attestationHash = getHashedSignaturePayloadEthSignedMessage(
-    payload,
-    SignatureDomainSeparator.checkpointAttestation,
-  );
+  const attestationHash = getHashedSignaturePayloadTypedData(payload);
   const attestationSigner = attesterSigner ?? Secp256k1Signer.random();
   const attestationSignature = attestationSigner.sign(attestationHash);