@aztec/stdlib 2.1.0-rc.8 → 2.1.1-rc.1

package/src/interfaces/p2p.ts

@@ -57,6 +57,9 @@ export interface P2PApiWithAttestations extends P2PApiWithoutAttestations {
    * @returns BlockAttestations
    */
   getAttestationsForSlot(slot: bigint, proposalId?: string): Promise<BlockAttestation[]>;
+
+  /** Deletes a given attestation manually from the p2p client attestation pool. */
+  deleteAttestation(attestation: BlockAttestation): Promise<void>;
 }
 
 export interface P2PClient extends P2PApiWithAttestations {
@@ -85,4 +88,5 @@ export const P2PApiSchema: ApiSchemaFor<P2PApi> = {
   getPendingTxCount: z.function().returns(schemas.Integer),
   getEncodedEnr: z.function().returns(z.string().optional()),
   getPeers: z.function().args(optional(z.boolean())).returns(z.array(PeerInfoSchema)),
+  deleteAttestation: z.function().args(BlockAttestation.schema).returns(z.void()),
 };

package/src/interfaces/tx_provider.ts

@@ -9,6 +9,7 @@ export interface ITxProvider {
 
   getTxsForBlockProposal(
     blockProposal: BlockProposal,
+    blockNumber: number,
     opts: { pinnedPeer: PeerId | undefined; deadline: Date },
   ): Promise<{ txs: Tx[]; missingTxs: TxHash[] }>;
 

package/src/interfaces/validator.ts

@@ -11,6 +11,7 @@ import type { PeerId } from '@libp2p/interface';
 import { z } from 'zod';
 
 import type { CommitteeAttestationsAndSigners } from '../block/index.js';
+import { AllowedElementSchema } from './allowed_element.js';
 
 /**
  * Validator client configuration
@@ -43,7 +44,13 @@ export interface ValidatorClientConfig {
 
 export type ValidatorClientFullConfig = ValidatorClientConfig &
   Pick<SequencerConfig, 'txPublicSetupAllowList'> &
-  Pick<SlasherConfig, 'slashBroadcastedInvalidBlockPenalty'>;
+  Pick<SlasherConfig, 'slashBroadcastedInvalidBlockPenalty'> & {
+    /**
+     * Whether transactions are disabled for this node
+     * @remarks This should match the property in P2PConfig. It's not picked from there to avoid circular dependencies.
+     */
+    disableTransactions?: boolean;
+  };
 
 export const ValidatorClientConfigSchema = z.object({
   validatorAddresses: z.array(schemas.EthAddress).optional(),
@@ -55,6 +62,12 @@ export const ValidatorClientConfigSchema = z.object({
   alwaysReexecuteBlockProposals: z.boolean().optional(),
 }) satisfies ZodFor<Omit<ValidatorClientConfig, 'validatorPrivateKeys'>>;
 
+export const ValidatorClientFullConfigSchema = ValidatorClientConfigSchema.extend({
+  txPublicSetupAllowList: z.array(AllowedElementSchema).optional(),
+  slashBroadcastedInvalidBlockPenalty: schemas.BigInt,
+  disableTransactions: z.boolean().optional(),
+}) satisfies ZodFor<Omit<ValidatorClientFullConfig, 'validatorPrivateKeys'>>;
+
 export interface Validator {
   start(): Promise<void>;
   updateConfig(config: Partial<ValidatorClientFullConfig>): void;

package/src/p2p/block_attestation.ts

@@ -1,5 +1,5 @@
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { keccak256, recoverAddress } from '@aztec/foundation/crypto';
+import { keccak256, tryRecoverAddress } from '@aztec/foundation/crypto';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
@@ -7,8 +7,7 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { z } from 'zod';
 
-import { type ZodFor, schemas } from '../schemas/index.js';
-import type { UInt32 } from '../types/index.js';
+import type { ZodFor } from '../schemas/index.js';
 import { ConsensusPayload } from './consensus_payload.js';
 import { Gossipable } from './gossipable.js';
 import { SignatureDomainSeparator, getHashedSignaturePayloadEthSignedMessage } from './signature_utils.js';
@@ -30,16 +29,17 @@ export class BlockAttestation extends Gossipable {
   static override p2pTopic = TopicType.block_attestation;
 
   private sender: EthAddress | undefined;
+  private proposer: EthAddress | undefined;
 
   constructor(
-    /** The block number of the attestation. */
-    public readonly blockNumber: UInt32,
-
     /** The payload of the message, and what the signature is over */
     public readonly payload: ConsensusPayload,
 
     /** The signature of the block attester */
     public readonly signature: Signature,
+
+    /** The signature from the block proposer */
+    public readonly proposerSignature: Signature,
   ) {
     super();
   }
@@ -47,11 +47,11 @@ export class BlockAttestation extends Gossipable {
   static get schema(): ZodFor<BlockAttestation> {
     return z
       .object({
-        blockNumber: schemas.UInt32,
         payload: ConsensusPayload.schema,
         signature: Signature.schema,
+        proposerSignature: Signature.schema,
       })
-      .transform(obj => new BlockAttestation(obj.blockNumber, obj.payload, obj.signature));
+      .transform(obj => new BlockAttestation(obj.payload, obj.signature, obj.proposerSignature));
   }
 
   override generateP2PMessageIdentifier(): Promise<Buffer32> {
@@ -68,29 +68,32 @@ export class BlockAttestation extends Gossipable {
 
   /**
    * Lazily evaluate and cache the signer of the attestation
-   * @returns The signer of the attestation
+   * @returns The signer of the attestation, or undefined if signature recovery fails
    */
-  getSender(): EthAddress {
+  getSender(): EthAddress | undefined {
     if (!this.sender) {
       // Recover the sender from the attestation
       const hashed = getHashedSignaturePayloadEthSignedMessage(this.payload, SignatureDomainSeparator.blockAttestation);
       // Cache the sender for later use
-      this.sender = recoverAddress(hashed, this.signature);
+      this.sender = tryRecoverAddress(hashed, this.signature);
     }
 
     return this.sender;
   }
 
   /**
-   * Tries to get the sender of the attestation
-   * @returns The sender of the attestation or undefined if it fails during recovery
+   * Lazily evaluate and cache the proposer of the block
+   * @returns The proposer of the block
    */
-  tryGetSender(): EthAddress | undefined {
-    try {
-      return this.getSender();
-    } catch {
-      return undefined;
+  getProposer(): EthAddress | undefined {
+    if (!this.proposer) {
+      // Recover the proposer from the proposal signature
+      const hashed = getHashedSignaturePayloadEthSignedMessage(this.payload, SignatureDomainSeparator.blockProposal);
+      // Cache the proposer for later use
+      this.proposer = tryRecoverAddress(hashed, this.proposerSignature);
     }
+
+    return this.proposer;
   }
 
   getPayload(): Buffer {
@@ -98,31 +101,35 @@ export class BlockAttestation extends Gossipable {
   }
 
   toBuffer(): Buffer {
-    return serializeToBuffer([this.blockNumber, this.payload, this.signature]);
+    return serializeToBuffer([this.payload, this.signature, this.proposerSignature]);
   }
 
   static fromBuffer(buf: Buffer | BufferReader): BlockAttestation {
     const reader = BufferReader.asReader(buf);
-    return new BlockAttestation(reader.readNumber(), reader.readObject(ConsensusPayload), reader.readObject(Signature));
+    return new BlockAttestation(
+      reader.readObject(ConsensusPayload),
+      reader.readObject(Signature),
+      reader.readObject(Signature),
+    );
   }
 
   static empty(): BlockAttestation {
-    return new BlockAttestation(0, ConsensusPayload.empty(), Signature.empty());
+    return new BlockAttestation(ConsensusPayload.empty(), Signature.empty(), Signature.empty());
   }
 
   static random(): BlockAttestation {
-    return new BlockAttestation(Math.floor(Math.random() * 1000) + 1, ConsensusPayload.random(), Signature.random());
+    return new BlockAttestation(ConsensusPayload.random(), Signature.random(), Signature.random());
   }
 
   getSize(): number {
-    return 4 /* blockNumber */ + this.payload.getSize() + this.signature.getSize();
+    return this.payload.getSize() + this.signature.getSize() + this.proposerSignature.getSize();
   }
 
   toInspect() {
     return {
-      blockNumber: this.blockNumber,
       payload: this.payload.toInspect(),
       signature: this.signature.toString(),
+      proposerSignature: this.proposerSignature.toString(),
     };
   }
 }

package/src/p2p/block_proposal.ts

@@ -1,5 +1,5 @@
 import { Buffer32 } from '@aztec/foundation/buffer';
-import { keccak256, recoverAddress } from '@aztec/foundation/crypto';
+import { keccak256, tryRecoverAddress } from '@aztec/foundation/crypto';
 import type { EthAddress } from '@aztec/foundation/eth-address';
 import { Signature } from '@aztec/foundation/eth-signature';
 import { Fr } from '@aztec/foundation/fields';
@@ -8,7 +8,6 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import type { L2BlockInfo } from '../block/l2_block_info.js';
 import { TxHash } from '../tx/index.js';
 import { Tx } from '../tx/tx.js';
-import type { UInt32 } from '../types/index.js';
 import { ConsensusPayload } from './consensus_payload.js';
 import { Gossipable } from './gossipable.js';
 import {
@@ -40,9 +39,6 @@ export class BlockProposal extends Gossipable {
   private sender: EthAddress | undefined;
 
   constructor(
-    /** The number of the block */
-    public readonly blockNumber: UInt32,
-
     /** The payload of the message, and what the signature is over */
     public readonly payload: ConsensusPayload,
 
@@ -71,9 +67,8 @@ export class BlockProposal extends Gossipable {
     return this.payload.header.slotNumber;
   }
 
-  toBlockInfo(): L2BlockInfo {
+  toBlockInfo(): Omit<L2BlockInfo, 'blockNumber'> {
     return {
-      blockNumber: this.blockNumber,
       slotNumber: this.slotNumber.toNumber(),
       lastArchive: this.payload.header.lastArchiveRoot,
       timestamp: this.payload.header.timestamp,
@@ -83,7 +78,6 @@ export class BlockProposal extends Gossipable {
   }
 
   static async createProposalFromSigner(
-    blockNumber: UInt32,
     payload: ConsensusPayload,
     txHashes: TxHash[],
     // Note(md): Provided separately to tx hashes such that this function can be optional
@@ -93,17 +87,18 @@ export class BlockProposal extends Gossipable {
     const hashed = getHashedSignaturePayload(payload, SignatureDomainSeparator.blockProposal);
     const sig = await payloadSigner(hashed);
 
-    return new BlockProposal(blockNumber, payload, sig, txHashes, txs);
+    return new BlockProposal(payload, sig, txHashes, txs);
   }
 
   /**Get Sender
    * Lazily evaluate the sender of the proposal; result is cached
+   * @returns The sender address, or undefined if signature recovery fails
    */
-  getSender() {
+  getSender(): EthAddress | undefined {
     if (!this.sender) {
       const hashed = getHashedSignaturePayloadEthSignedMessage(this.payload, SignatureDomainSeparator.blockProposal);
       // Cache the sender for later use
-      this.sender = recoverAddress(hashed, this.signature);
+      this.sender = tryRecoverAddress(hashed, this.signature);
     }
 
     return this.sender;
@@ -114,7 +109,7 @@ export class BlockProposal extends Gossipable {
   }
 
   toBuffer(): Buffer {
-    const buffer: any[] = [this.blockNumber, this.payload, this.signature, this.txHashes.length, this.txHashes];
+    const buffer: any[] = [this.payload, this.signature, this.txHashes.length, this.txHashes];
     if (this.txs) {
       buffer.push(this.txs.length);
       buffer.push(this.txs);
@@ -125,22 +120,20 @@ export class BlockProposal extends Gossipable {
   static fromBuffer(buf: Buffer | BufferReader): BlockProposal {
     const reader = BufferReader.asReader(buf);
 
-    const blockNumber = reader.readNumber();
     const payload = reader.readObject(ConsensusPayload);
     const sig = reader.readObject(Signature);
     const txHashes = reader.readArray(reader.readNumber(), TxHash);
 
     if (!reader.isEmpty()) {
       const txs = reader.readArray(reader.readNumber(), Tx);
-      return new BlockProposal(blockNumber, payload, sig, txHashes, txs);
+      return new BlockProposal(payload, sig, txHashes, txs);
     }
 
-    return new BlockProposal(blockNumber, payload, sig, txHashes);
+    return new BlockProposal(payload, sig, txHashes);
   }
 
   getSize(): number {
     return (
-      4 /* blockNumber */ +
       this.payload.getSize() +
       this.signature.getSize() +
       4 /* txHashes.length */ +

package/src/p2p/gossipable.ts

@@ -28,15 +28,12 @@ export class P2PMessage {
  */
 export abstract class Gossipable {
   private cachedId: Buffer32 | undefined;
-  /** p2p Topic
-   *
-   * - The p2p topic identifier, this determines how the message is handled
-   */
+  /** The p2p topic identifier, this determines how the message is handled */
   static p2pTopic: TopicType;
 
-  /** p2p Message Identifier
-   *
-   *  - A digest of the message information, this key is used for deduplication
+  /**
+   * A digest of the message information **used for logging only**.
+   * The identifier used for deduplication is `getMsgIdFn` as defined in `encoding.ts` which is a hash over topic and data.
    */
   async p2pMessageIdentifier(): Promise<Buffer32> {
     if (this.cachedId) {
@@ -48,10 +45,6 @@ export abstract class Gossipable {
 
   abstract generateP2PMessageIdentifier(): Promise<Buffer32>;
 
-  /** To Buffer
-   *
-   * - Serialization method
-   */
   abstract toBuffer(): Buffer;
 
   toMessage(): Buffer {
@@ -60,7 +53,6 @@ export abstract class Gossipable {
 
   /**
    * Get the size of the gossipable object.
-   *
    * This is used for metrics recording.
    */
   abstract getSize(): number;

package/src/p2p/topic_type.ts

@@ -1,18 +1,25 @@
 import { P2PClientType } from './client_type.js';
 
-/** Create Topic String
- *
- * The topic channel identifier
- * @param topicType
- * @returns
+/**
+ * Creates the topic channel identifier string from a given topic type
  */
 export function createTopicString(topicType: TopicType, protocolVersion: string) {
   return `/aztec/${TopicType[topicType]}/${protocolVersion}`;
 }
 
-/**
- *
- */
+/** Extracts the topic type from a topic string */
+export function getTopicFromString(topicStr: string): TopicType | undefined {
+  const parts = topicStr.split('/');
+  if (parts.length < 4 || parts[1] !== 'aztec') {
+    return undefined;
+  }
+  const topic = parts[2];
+  if (Object.values(TopicType).includes(topic as TopicType)) {
+    return topic as TopicType;
+  }
+  return undefined;
+}
+
 export enum TopicType {
   tx = 'tx',
   block_proposal = 'block_proposal',

package/src/tests/factories.ts

@@ -46,9 +46,9 @@ import {
 } from '@aztec/constants';
 import { type FieldsOf, makeHalfFullTuple, makeTuple } from '@aztec/foundation/array';
 import { compact, padArrayEnd } from '@aztec/foundation/collection';
-import { SchnorrSignature, poseidon2HashWithSeparator, sha256 } from '@aztec/foundation/crypto';
+import { Grumpkin, SchnorrSignature, poseidon2HashWithSeparator, sha256 } from '@aztec/foundation/crypto';
 import { EthAddress } from '@aztec/foundation/eth-address';
-import { BLS12Point, Fr, GrumpkinScalar, Point } from '@aztec/foundation/fields';
+import { BLS12Point, Fq, Fr, GrumpkinScalar, Point } from '@aztec/foundation/fields';
 import type { Bufferable, Serializable, Tuple } from '@aztec/foundation/serialize';
 import { MembershipWitness } from '@aztec/foundation/trees';
 
@@ -1250,13 +1250,10 @@ export async function makeMapAsync<T>(size: number, fn: (i: number) => Promise<[
   return new Map(await makeArrayAsync(size, i => fn(i + offset)));
 }
 
-export function makePublicKeys(seed = 0): PublicKeys {
-  return new PublicKeys(
-    new Point(new Fr(seed + 0), new Fr(seed + 1), false),
-    new Point(new Fr(seed + 2), new Fr(seed + 3), false),
-    new Point(new Fr(seed + 4), new Fr(seed + 5), false),
-    new Point(new Fr(seed + 6), new Fr(seed + 7), false),
-  );
+export async function makePublicKeys(seed = 0): Promise<PublicKeys> {
+  const f = (offset: number) => new Grumpkin().mul(Grumpkin.generator, new Fq(seed + offset));
+
+  return new PublicKeys(await f(0), await f(1), await f(2), await f(3));
 }
 
 export async function makeContractInstanceFromClassId(
@@ -1272,7 +1269,7 @@ export async function makeContractInstanceFromClassId(
   const salt = new Fr(seed);
   const initializationHash = overrides?.initializationHash ?? new Fr(seed + 1);
   const deployer = overrides?.deployer ?? new AztecAddress(new Fr(seed + 2));
-  const publicKeys = overrides?.publicKeys ?? makePublicKeys(seed + 3);
+  const publicKeys = overrides?.publicKeys ?? (await makePublicKeys(seed + 3));
 
   const saltedInitializationHash = await poseidon2HashWithSeparator(
     [salt, initializationHash, deployer],

package/src/tests/mocks.ts

@@ -248,6 +248,8 @@ export const randomDeployedContract = async () => {
 
 export interface MakeConsensusPayloadOptions {
   signer?: Secp256k1Signer;
+  attesterSigner?: Secp256k1Signer;
+  proposerSigner?: Secp256k1Signer;
   header?: BlockHeader;
   archive?: Fr;
   stateReference?: StateReference;
@@ -286,31 +288,65 @@ export const makeAndSignCommitteeAttestationsAndSigners = (
 };
 
 export const makeBlockProposal = (options?: MakeConsensusPayloadOptions): BlockProposal => {
-  const { blockNumber, payload, signature } = makeAndSignConsensusPayload(
-    SignatureDomainSeparator.blockProposal,
-    options,
-  );
+  const { payload, signature } = makeAndSignConsensusPayload(SignatureDomainSeparator.blockProposal, options);
   const txHashes = options?.txHashes ?? [0, 1, 2, 3, 4, 5].map(() => TxHash.random());
-  return new BlockProposal(blockNumber, payload, signature, txHashes, options?.txs ?? []);
+  return new BlockProposal(payload, signature, txHashes, options?.txs ?? []);
 };
 
 // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8028)
 export const makeBlockAttestation = (options?: MakeConsensusPayloadOptions): BlockAttestation => {
-  const { blockNumber, payload, signature } = makeAndSignConsensusPayload(
-    SignatureDomainSeparator.blockAttestation,
-    options,
-  );
-  return new BlockAttestation(blockNumber, payload, signature);
+  const header = options?.header ?? makeHeader(1);
+  const {
+    signer,
+    attesterSigner = signer ?? Secp256k1Signer.random(),
+    proposerSigner = signer ?? Secp256k1Signer.random(),
+    archive = Fr.random(),
+    stateReference = header.state,
+  } = options ?? {};
+
+  const payload = ConsensusPayload.fromFields({
+    header: header.toPropose(),
+    archive,
+    stateReference,
+  });
+
+  // Sign as attester
+  const attestationHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
+  const attestationSignature = attesterSigner.sign(attestationHash);
+
+  // Sign as proposer
+  const proposalHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockProposal);
+  const proposerSignature = proposerSigner.sign(proposalHash);
+
+  return new BlockAttestation(payload, attestationSignature, proposerSignature);
 };
 
-export const makeBlockAttestationFromBlock = (block: L2Block, signer?: Secp256k1Signer): BlockAttestation => {
-  return makeBlockAttestation({
-    signer,
-    header: block.header,
-    archive: block.archive.root,
-    stateReference: block.header.state,
-    txHashes: block.body.txEffects.map(tx => tx.txHash),
+export const makeBlockAttestationFromBlock = (
+  block: L2Block,
+  attesterSigner?: Secp256k1Signer,
+  proposerSigner?: Secp256k1Signer,
+): BlockAttestation => {
+  const header = block.header;
+  const archive = block.archive.root;
+  const stateReference = block.header.state;
+
+  const payload = ConsensusPayload.fromFields({
+    header: header.toPropose(),
+    archive,
+    stateReference,
   });
+
+  // Sign as attester
+  const attestationHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockAttestation);
+  const attestationSigner = attesterSigner ?? Secp256k1Signer.random();
+  const attestationSignature = attestationSigner.sign(attestationHash);
+
+  // Sign as proposer
+  const proposalHash = getHashedSignaturePayloadEthSignedMessage(payload, SignatureDomainSeparator.blockProposal);
+  const proposalSignerToUse = proposerSigner ?? Secp256k1Signer.random();
+  const proposerSignature = proposalSignerToUse.sign(proposalHash);
+
+  return new BlockAttestation(payload, attestationSignature, proposerSignature);
 };
 
 export async function randomPublishedL2Block(

package/src/zkpassport/index.ts

@@ -5,15 +5,20 @@ import { BufferReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { withoutHexPrefix } from '@aztec/foundation/string';
 
 export type ViemZkPassportProofParams = {
-  vkeyHash: `0x${string}`;
-  proof: `0x${string}`;
-  publicInputs: `0x${string}`[];
-  committedInputs: `0x${string}`;
-  committedInputCounts: bigint[];
-  validityPeriodInSeconds: bigint;
-  domain: string;
-  scope: string;
-  devMode: boolean;
+  proofVerificationData: {
+    vkeyHash: `0x${string}`;
+    proof: `0x${string}`;
+    publicInputs: `0x${string}`[];
+  };
+  commitments: {
+    committedInputs: `0x${string}`;
+  };
+  serviceConfig: {
+    validityPeriodInSeconds: bigint;
+    domain: string;
+    scope: string;
+    devMode: boolean;
+  };
 };
 
 // NOTE: Must match the ZkPassportProofParams struct in the zkpassport verifier contract
@@ -25,7 +30,6 @@ export class ZkPassportProofParams {
     public proof: Buffer,
     public publicInputs: Fr[],
     public committedInputs: Buffer,
-    public committedInputCounts: bigint[],
     public validityPeriodInSeconds: bigint,
     public domain: string,
     public scope: string,
@@ -41,8 +45,6 @@ export class ZkPassportProofParams {
       this.publicInputs,
       this.committedInputs.length,
       this.committedInputs,
-      this.committedInputCounts.length,
-      this.committedInputCounts,
       this.validityPeriodInSeconds,
       this.domain,
       this.scope,
@@ -63,8 +65,7 @@ export class ZkPassportProofParams {
       randomBytes(1024),
       publicInputs,
       committedInputs,
-      committedInputCounts,
-      BigInt(100 * 60 * 60 * 24),
+      BigInt(7 * 24 * 60 * 60), // 7 days
       'sequencer.alpha-testnet.aztec.network',
       'personhood',
     );
@@ -78,7 +79,6 @@ export class ZkPassportProofParams {
       reader.readBuffer(),
       reader.readVector(Fr),
       reader.readBuffer(),
-      reader.readUint256Vector(),
       reader.readUInt256(),
       reader.readString(),
       reader.readString(),
@@ -87,29 +87,33 @@ export class ZkPassportProofParams {
 
   static fromViem(params: ViemZkPassportProofParams) {
     return new ZkPassportProofParams(
-      params.devMode,
-      Buffer32.fromString(params.vkeyHash),
-      Buffer.from(withoutHexPrefix(params.proof), 'hex'),
-      params.publicInputs.map(input => Fr.fromString(input)),
-      Buffer.from(withoutHexPrefix(params.committedInputs), 'hex'),
-      params.committedInputCounts,
-      params.validityPeriodInSeconds,
-      params.domain,
-      params.scope,
+      params.serviceConfig.devMode,
+      Buffer32.fromString(params.proofVerificationData.vkeyHash),
+      Buffer.from(withoutHexPrefix(params.proofVerificationData.proof), 'hex'),
+      params.proofVerificationData.publicInputs.map(input => Fr.fromString(input)),
+      Buffer.from(withoutHexPrefix(params.commitments.committedInputs), 'hex'),
+      params.serviceConfig.validityPeriodInSeconds,
+      params.serviceConfig.domain,
+      params.serviceConfig.scope,
     );
   }
 
   toViem(): ViemZkPassportProofParams {
     return {
-      devMode: this.devMode,
-      vkeyHash: this.vkeyHash.toString(),
-      proof: `0x${this.proof.toString('hex')}`,
-      publicInputs: this.publicInputs.map(input => input.toString()),
-      committedInputs: `0x${this.committedInputs.toString('hex')}`,
-      committedInputCounts: this.committedInputCounts,
-      validityPeriodInSeconds: this.validityPeriodInSeconds,
-      domain: this.domain,
-      scope: this.scope,
+      serviceConfig: {
+        devMode: this.devMode,
+        validityPeriodInSeconds: this.validityPeriodInSeconds,
+        domain: this.domain,
+        scope: this.scope,
+      },
+      proofVerificationData: {
+        vkeyHash: this.vkeyHash.toString(),
+        proof: `0x${this.proof.toString('hex')}`,
+        publicInputs: this.publicInputs.map(input => input.toString()),
+      },
+      commitments: {
+        committedInputs: `0x${this.committedInputs.toString('hex')}`,
+      },
     };
   }
 }