Passport-zk-circuits Parameter Calculation & Test Data

by Alex Johnson 55 views

Hello! This article aims to clarify how to derive circuit parameters from variant names and locate test data for the passport-zk-circuits-noir project. If you're working on automating circuit compilation or need to understand how parameters are determined, this guide is for you. We will explore the formulas for calculating key parameters, discuss where to find suitable test data, and consider the existence of lookup tables for variant names.

Background: Circuit Variants Naming Convention

In the passport-zk-circuits-noir project, circuit variants follow a specific naming convention that encodes crucial information about the circuit's configuration. This convention is structured as follows:

Z_NOIR_PASSPORT_{sig_type}{hash_bits}{version}{blocks}{ec_shift_bits}{dg1_shift_bits}{aa_sig_type}{dg15_shift_bits}{dg15_blocks}_{aa_shift_bits}

Let's break down each component of this naming scheme:

  • Z_NOIR_PASSPORT: This is a constant prefix indicating that the circuit is part of the passport verification system implemented using Noir.
  • sig_type: Represents the signature type used in the circuit.
  • hash_bits: Denotes the number of bits used in the hash function.
  • version: Specifies the version of the circuit.
  • blocks: Indicates the number of blocks used in the circuit.
  • ec_shift_bits: Represents the shift bits for the elliptic curve.
  • dg1_shift_bits: Specifies the shift bits for DG1 (Document Group 1).
  • aa_sig_type: Represents the signature type for AA (Authentication Authority).
  • dg15_shift_bits: Specifies the shift bits for DG15 (Document Group 15).
  • dg15_blocks: Indicates the number of blocks used for DG15.
  • aa_shift_bits: Represents the shift bits for AA.

For instance, consider the example variant name:

Z_NOIR_PASSPORT_11_256_3_5_576_248_1_1808_5_296

In this name:

  • sig_type is 11.
  • hash_bits is 256.
  • version is 3.
  • blocks is 5.
  • ec_shift_bits is 576.
  • dg1_shift_bits is 248.
  • aa_sig_type is 1.
  • dg15_shift_bits is 1808.
  • dg15_blocks is 5.
  • aa_shift_bits is 296.

Understanding this naming convention is the first step in correctly deriving circuit parameters. The subsequent sections will delve into the specific formulas and methods for calculating parameters like ec_len, dg15_len, and sa_len from these variant names. By dissecting the naming structure, developers can efficiently automate circuit compilation and ensure accurate parameter derivation, which is crucial for the integrity and performance of the passport verification system. This structured approach allows for a systematic understanding of the circuit configurations, facilitating smoother development and deployment processes.

The Problem: Mismatched Calculations

One common challenge when working with these circuit variants is accurately calculating key parameters directly from the variant name. Let’s illustrate this with an example. Consider the variant:

Z_NOIR_PASSPORT_11_256_3_5_576_248_1_1808_5_296

When attempting to reverse-engineer the parameters from this name, discrepancies often arise between calculated values and the actual values used by the circuit. For example, using seemingly logical formulas, one might calculate the following:

  • ec_len = blocks * 64 - 8 = 5 * 64 - 8 = 312 ❌
  • dg15_len = dg15_blocks * 64 - 8 = 5 * 64 - 8 = 312 ❌
  • sa_len = ec_shift + hash_algo + 20 = 72 + 32 + 20 = 124 ❌

However, these calculated values do not align with the correct values found in the working main.nr file, which are:

  • ec_len = 258 ✓
  • dg15_len = 298 ✓
  • sa_len = 104 ✓

This mismatch highlights the core of the problem: the formulas being used for calculation are either incorrect or incomplete. The challenge lies in identifying the correct formulas and understanding the underlying logic that connects the variant name parameters to the circuit's operational parameters. This discrepancy can lead to significant issues when automating the compilation of circuit variants, as incorrect parameters can result in non-functional or insecure circuits. Accurate parameter calculation is crucial for ensuring the integrity and reliability of the passport verification system.

The issue is further compounded by the fact that the naming convention, while informative, does not directly translate into simple arithmetic. The relationships between the parameters are more nuanced and may involve additional factors or constants that are not immediately apparent. Developers need a clear and reliable method to bridge this gap, ensuring that the parameters derived from the variant name accurately reflect the circuit's configuration. This involves not only identifying the correct formulas but also understanding the context in which these parameters are used within the circuit.

Therefore, solving this problem requires a comprehensive understanding of the circuit's internal workings and how each parameter influences its behavior. This understanding is essential for developing a robust and accurate method for parameter calculation, which is a key step in automating the compilation process and ensuring the overall security and efficiency of the passport verification system. The next sections will delve into the specific questions that need to be addressed to resolve this issue, including the correct formulas for parameter calculation, the sources of test data, and the existence of parameter lookup tables.

Key Questions and Solutions for Parameter Derivation

To address the challenges in calculating circuit parameters from variant names, we need to tackle several key questions. These questions will guide us in finding the correct formulas, locating test data, and understanding the overall structure of the passport-zk-circuits-noir project.

1. Correct Formulas for Parameter Calculation

The first and most crucial question is: What are the correct formulas to calculate ec_len, dg15_len, and sa_len from the variant name parameters? This involves a deep dive into the relationships between the parameters encoded in the variant name and the actual circuit parameters. The initial attempts to calculate these values, as shown in the previous section, highlight the need for accurate formulas that reflect the underlying logic of the circuit design.

To determine these formulas, several approaches can be taken:

  • Code Review: A thorough review of the circuit's source code, particularly the main.nr file and any related modules, is essential. This involves tracing how the input parameters from the variant name are used within the circuit's logic to derive ec_len, dg15_len, and sa_len.

  • Mathematical Analysis: This approach involves analyzing the relationships between the parameters mathematically. This may involve identifying patterns or constants that connect the variant name parameters to the circuit parameters.

  • Empirical Testing: This method involves systematically varying the input parameters and observing the resulting circuit parameters. By analyzing the patterns in the results, it may be possible to derive the correct formulas.

2. Locating Test Data for Circuit Variants

The second critical question is: Where can we find test data (passport JSON files with dg1, dg15, sod) for each circuit variant? The process_passport.js script requires real passport data, but compiling circuits without actual passports necessitates suitable test data. This test data should be representative of real-world data but without the need for actual sensitive information.

Potential sources for test data include:

  • Existing Test Suites: Review the project's existing test suites and identify if there are any test cases that provide sample passport data. These test cases may contain JSON files or other data formats that can be used for testing circuit variants.

  • Data Generation Scripts: If the project lacks sufficient test data, consider creating data generation scripts that can produce synthetic passport data. These scripts can be designed to generate data that covers a wide range of scenarios and parameter values.

  • Community Contributions: Engage with the passport-zk-circuits-noir community and inquire if other developers have created or have access to test data. Sharing test data within the community can be a valuable resource for everyone involved.

3. Existence of Parameter Lookup Tables

The third question to consider is: Is there a lookup table mapping variant names to their exact parameters? A lookup table would provide a direct mapping between the variant name and the corresponding circuit parameters, eliminating the need for complex calculations. This could significantly simplify the process of automating circuit compilation.

To determine if a lookup table exists, consider the following:

  • Project Documentation: Review the project's documentation to see if there is any mention of a lookup table or a similar resource.

  • Configuration Files: Examine the project's configuration files, such as JSON or YAML files, to see if there is a table that maps variant names to parameters.

  • Codebase Search: Search the codebase for any instances where variant names are used to retrieve circuit parameters. This may reveal the existence of a lookup table or a similar data structure.

By systematically addressing these questions, we can develop a comprehensive understanding of how to calculate circuit parameters, locate test data, and streamline the process of working with passport-zk-circuits-noir circuits. The answers to these questions will enable developers to automate circuit compilation, improve testing, and ensure the reliability and security of the passport verification system. The next sections will explore the potential solutions and methodologies for tackling these challenges in detail.

Diving Deeper: Potential Solutions and Methodologies

Now that we've identified the key questions surrounding circuit parameter calculation and test data for passport-zk-circuits-noir, let's explore potential solutions and methodologies for addressing these challenges. This section will delve into the specific steps and approaches that can be taken to derive the correct formulas, locate or generate test data, and investigate the existence of parameter lookup tables.

1. Deriving Correct Formulas for Parameter Calculation: A Multi-Faceted Approach

Deriving the correct formulas for calculating ec_len, dg15_len, and sa_len requires a multi-faceted approach that combines code analysis, mathematical reasoning, and empirical testing. Here's a breakdown of the steps involved:

a. In-Depth Code Analysis

Start with a thorough examination of the main.nr file and any related modules within the passport-zk-circuits-noir codebase. Pay close attention to the following:

  • Input Parameters: Identify how the parameters extracted from the variant name (e.g., blocks, ec_shift_bits, dg15_blocks) are used as inputs within the circuit's logic.
  • Calculations and Transformations: Trace the flow of these input parameters through the circuit's calculations. Look for any transformations or intermediate variables that are used to derive ec_len, dg15_len, and sa_len.
  • Constants and Magic Numbers: Be on the lookout for any constants or