ci: update version string in docs

Cargo.lock

@@ -2276,7 +2276,7 @@ dependencies = [
 [[package]]
 name = "halo2_solidity_verifier"
 version = "0.1.0"
-source = "git+https://github.com/alexander-camuto/halo2-solidity-verifier?branch=main#eb04be1f7d005e5b9dd3ff41efa30aeb5e0c34a3"
+source = "git+https://github.com/alexander-camuto/halo2-solidity-verifier?branch=main#fd74f1da2ce51664e2d4349965987ee606551060"
 dependencies = [
  "askama",
  "blake2b_simd",

docs/python/requirements-docs.txt

@@ -1,4 +1,4 @@
-ezkl==0.0.0
+ezkl==11.0.6
 sphinx
 sphinx-rtd-theme
 sphinxcontrib-napoleon

docs/python/src/conf.py

@@ -1,7 +1,7 @@
 import ezkl
 
 project = 'ezkl'
-release = '0.0.0'
+release = '11.0.6'
 version = release
 
 

examples/notebooks/logistic_regression.ipynb

@@ -0,0 +1,279 @@
+{
+    "cells": [
+        {
+            "cell_type": "markdown",
+            "id": "cf69bb3f-94e6-4dba-92cd-ce08df117d67",
+            "metadata": {},
+            "source": [
+                "## Logistic Regression\n",
+                "\n",
+                "\n",
+                "Sklearn based models are slightly finicky to get into a suitable onnx format. \n",
+                "This notebook showcases how to do so using the `hummingbird-ml` python package for a Logistic Regression model. "
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "95613ee9",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# check if notebook is in colab\n",
+                "try:\n",
+                "    # install ezkl\n",
+                "    import google.colab\n",
+                "    import subprocess\n",
+                "    import sys\n",
+                "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"ezkl\"])\n",
+                "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"onnx\"])\n",
+                "    subprocess.check_call([sys.executable, \"-m\", \"pip\", \"install\", \"hummingbird-ml\"])\n",
+                "\n",
+                "# rely on local installation of ezkl if the notebook is not in colab\n",
+                "except:\n",
+                "    pass\n",
+                "\n",
+                "import os\n",
+                "import torch\n",
+                "import ezkl\n",
+                "import json\n",
+                "from hummingbird.ml import convert\n",
+                "\n",
+                "\n",
+                "# here we create and (potentially train a model)\n",
+                "\n",
+                "# make sure you have the dependencies required here already installed\n",
+                "import numpy as np\n",
+                "from sklearn.linear_model import LogisticRegression\n",
+                "X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])\n",
+                "# y = 1 * x_0 + 2 * x_1 + 3\n",
+                "y = np.dot(X, np.array([1, 2])) + 3\n",
+                "reg = LogisticRegression().fit(X, y)\n",
+                "reg.score(X, y)\n",
+                "\n",
+                "circuit = convert(reg, \"torch\", X[:1]).model\n",
+                "\n",
+                "\n",
+                "\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "b37637c4",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "model_path = os.path.join('network.onnx')\n",
+                "compiled_model_path = os.path.join('network.compiled')\n",
+                "pk_path = os.path.join('test.pk')\n",
+                "vk_path = os.path.join('test.vk')\n",
+                "settings_path = os.path.join('settings.json')\n",
+                "\n",
+                "witness_path = os.path.join('witness.json')\n",
+                "data_path = os.path.join('input.json')"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "82db373a",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "\n",
+                "\n",
+                "# export to onnx format\n",
+                "# !!!!!!!!!!!!!!!!! This will flash a warning but it is fine !!!!!!!!!!!!!!!!!!!!!\n",
+                "\n",
+                "# Input to the model\n",
+                "shape = X.shape[1:]\n",
+                "x = torch.rand(1, *shape, requires_grad=True)\n",
+                "torch_out = circuit(x)\n",
+                "# Export the model\n",
+                "torch.onnx.export(circuit,               # model being run\n",
+                "                  # model input (or a tuple for multiple inputs)\n",
+                "                  x,\n",
+                "                  # where to save the model (can be a file or file-like object)\n",
+                "                  \"network.onnx\",\n",
+                "                  export_params=True,        # store the trained parameter weights inside the model file\n",
+                "                  opset_version=10,          # the ONNX version to export the model to\n",
+                "                  do_constant_folding=True,  # whether to execute constant folding for optimization\n",
+                "                  input_names=['input'],   # the model's input names\n",
+                "                  output_names=['output'],  # the model's output names\n",
+                "                  dynamic_axes={'input': {0: 'batch_size'},    # variable length axes\n",
+                "                                'output': {0: 'batch_size'}})\n",
+                "\n",
+                "d = ((x).detach().numpy()).reshape([-1]).tolist()\n",
+                "\n",
+                "data = dict(input_shapes=[shape],\n",
+                "            input_data=[d],\n",
+                "            output_data=[((o).detach().numpy()).reshape([-1]).tolist() for o in torch_out])\n",
+                "\n",
+                "# Serialize data into file:\n",
+                "json.dump(data, open(\"input.json\", 'w'))\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "d5e374a2",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "!RUST_LOG=trace\n",
+                "# TODO: Dictionary outputs\n",
+                "res = ezkl.gen_settings(model_path, settings_path)\n",
+                "assert res == True\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "cal_path = os.path.join(\"calibration.json\")\n",
+                "\n",
+                "data_array = (torch.randn(20, *shape).detach().numpy()).reshape([-1]).tolist()\n",
+                "\n",
+                "data = dict(input_data = [data_array])\n",
+                "\n",
+                "# Serialize data into file:\n",
+                "json.dump(data, open(cal_path, 'w'))\n",
+                "\n",
+                "res = ezkl.calibrate_settings(data_path, model_path, settings_path, \"resources\")\n",
+                "assert res == True\n"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "3aa4f090",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "res = ezkl.compile_circuit(model_path, compiled_model_path, settings_path)\n",
+                "assert res == True"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "8b74dcee",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# srs path\n",
+                "res = ezkl.get_srs( settings_path)"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "18c8b7c7",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# now generate the witness file \n",
+                "\n",
+                "res = ezkl.gen_witness(data_path, compiled_model_path, witness_path)\n",
+                "assert os.path.isfile(witness_path)"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "b1c561a8",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "\n",
+                "# HERE WE SETUP THE CIRCUIT PARAMS\n",
+                "# WE GOT KEYS\n",
+                "# WE GOT CIRCUIT PARAMETERS\n",
+                "# EVERYTHING ANYONE HAS EVER NEEDED FOR ZK\n",
+                "\n",
+                "\n",
+                "\n",
+                "res = ezkl.setup(\n",
+                "        compiled_model_path,\n",
+                "        vk_path,\n",
+                "        pk_path,\n",
+                "        \n",
+                "    )\n",
+                "\n",
+                "assert res == True\n",
+                "assert os.path.isfile(vk_path)\n",
+                "assert os.path.isfile(pk_path)\n",
+                "assert os.path.isfile(settings_path)"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "c384cbc8",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# GENERATE A PROOF\n",
+                "\n",
+                "\n",
+                "proof_path = os.path.join('test.pf')\n",
+                "\n",
+                "res = ezkl.prove(\n",
+                "        witness_path,\n",
+                "        compiled_model_path,\n",
+                "        pk_path,\n",
+                "        proof_path,\n",
+                "        \n",
+                "        \"single\",\n",
+                "    )\n",
+                "\n",
+                "print(res)\n",
+                "assert os.path.isfile(proof_path)"
+            ]
+        },
+        {
+            "cell_type": "code",
+            "execution_count": null,
+            "id": "76f00d41",
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# VERIFY IT\n",
+                "\n",
+                "res = ezkl.verify(\n",
+                "        proof_path,\n",
+                "        settings_path,\n",
+                "        vk_path,\n",
+                "        \n",
+                "    )\n",
+                "\n",
+                "assert res == True\n",
+                "print(\"verified\")"
+            ]
+        }
+    ],
+    "metadata": {
+        "kernelspec": {
+            "display_name": "Python 3 (ipykernel)",
+            "language": "python",
+            "name": "python3"
+        },
+        "language_info": {
+            "codemirror_mode": {
+                "name": "ipython",
+                "version": 3
+            },
+            "file_extension": ".py",
+            "mimetype": "text/x-python",
+            "name": "python",
+            "nbconvert_exporter": "python",
+            "pygments_lexer": "ipython3",
+            "version": "3.12.2"
+        }
+    },
+    "nbformat": 4,
+    "nbformat_minor": 5
+}

src/circuit/ops/chip.rs

@@ -80,14 +80,18 @@ impl ToFlags for CheckMode {
 
 impl From<String> for CheckMode {
     fn from(value: String) -> Self {
-        match value.to_lowercase().as_str() {
-            "safe" => CheckMode::SAFE,
-            "unsafe" => CheckMode::UNSAFE,
-            _ => {
-                log::error!("Invalid value for CheckMode");
-                log::warn!("defaulting to SAFE");
-                CheckMode::SAFE
-            }
+        Self::from_str(value.as_str()).unwrap()
+    }
+}
+
+impl FromStr for CheckMode {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "safe" => Ok(CheckMode::SAFE),
+            "unsafe" => Ok(CheckMode::UNSAFE),
+            _ => Err("Invalid value for CheckMode".to_string()),
         }
     }
 }

src/commands.rs

@@ -290,7 +290,7 @@ pub enum Commands {
     Table {
         /// The path to the .onnx model file
         #[arg(short = 'M', long, default_value = DEFAULT_MODEL)]
-        model: PathBuf,
+        model: Option<PathBuf>,
         /// proving arguments
         #[clap(flatten)]
         args: RunArgs,
@@ -300,13 +300,13 @@ pub enum Commands {
     GenWitness {
         /// The path to the .json data file
         #[arg(short = 'D', long, default_value = DEFAULT_DATA)]
-        data: PathBuf,
+        data: Option<PathBuf>,
         /// The path to the compiled model file (generated using the compile-circuit command)
         #[arg(short = 'M', long, default_value = DEFAULT_COMPILED_CIRCUIT)]
-        compiled_circuit: PathBuf,
+        compiled_circuit: Option<PathBuf>,
         /// Path to output the witness .json file
         #[arg(short = 'O', long, default_value = DEFAULT_WITNESS)]
-        output: PathBuf,
+        output: Option<PathBuf>,
         /// Path to the verification key file (optional - solely used to generate kzg commits)
         #[arg(short = 'V', long)]
         vk_path: Option<PathBuf>,
@@ -319,10 +319,10 @@ pub enum Commands {
     GenSettings {
         /// The path to the .onnx model file
         #[arg(short = 'M', long, default_value = DEFAULT_MODEL)]
-        model: PathBuf,
+        model: Option<PathBuf>,
         /// The path to generate the circuit settings .json file to
         #[arg(short = 'O', long, default_value = DEFAULT_SETTINGS)]
-        settings_path: PathBuf,
+        settings_path: Option<PathBuf>,
         /// proving arguments
         #[clap(flatten)]
         args: RunArgs,
@@ -333,13 +333,13 @@ pub enum Commands {
     CalibrateSettings {
         /// The path to the .json calibration data file.
         #[arg(short = 'D', long, default_value = DEFAULT_CALIBRATION_FILE)]
-        data: PathBuf,
+        data: Option<PathBuf>,
         /// The path to the .onnx model file
         #[arg(short = 'M', long, default_value = DEFAULT_MODEL)]
-        model: PathBuf,
+        model: Option<PathBuf>,
         /// The path to load circuit settings .json file AND overwrite (generated using the gen-settings command).
         #[arg(short = 'O', long, default_value = DEFAULT_SETTINGS)]
-        settings_path: PathBuf,
+        settings_path: Option<PathBuf>,
         #[arg(long = "target", default_value = DEFAULT_CALIBRATION_TARGET)]
         /// Target for calibration. Set to "resources" to optimize for computational resource. Otherwise, set to "accuracy" to optimize for accuracy.
         target: CalibrationTarget,
@@ -361,8 +361,8 @@ pub enum Commands {
         #[arg(long)]
         max_logrows: Option<u32>,
         // whether to only range check rebases (instead of trying both range check and lookup)
-        #[arg(long, default_value = DEFAULT_ONLY_RANGE_CHECK_REBASE)]
-        only_range_check_rebase: bool,
+        #[arg(long, default_value = DEFAULT_ONLY_RANGE_CHECK_REBASE, action = clap::ArgAction::SetTrue)]
+        only_range_check_rebase: Option<bool>,
     },
 
     /// Generates a dummy SRS
@@ -376,7 +376,7 @@ pub enum Commands {
         logrows: usize,
         /// commitment used
         #[arg(long, default_value = DEFAULT_COMMITMENT)]
-        commitment: Commitments,
+        commitment: Option<Commitments>,
     },
 
     #[cfg(not(target_arch = "wasm32"))]
@@ -400,10 +400,10 @@ pub enum Commands {
     Mock {
         /// The path to the .json witness file (generated using the gen-witness command)
         #[arg(short = 'W', long, default_value = DEFAULT_WITNESS)]
-        witness: PathBuf,
+        witness: Option<PathBuf>,
         /// The path to the compiled model file (generated using the compile-circuit command)
         #[arg(short = 'M', long, default_value = DEFAULT_COMPILED_CIRCUIT)]
-        model: PathBuf,
+        model: Option<PathBuf>,
     },
 
     /// Mock aggregate proofs
@@ -413,10 +413,10 @@ pub enum Commands {
         aggregation_snarks: Vec<PathBuf>,
         /// logrows used for aggregation circuit
         #[arg(long, default_value = DEFAULT_AGGREGATED_LOGROWS)]
-        logrows: u32,
+        logrows: Option<u32>,
         /// whether the accumulated are segments of a larger proof
-        #[arg(long, default_value = DEFAULT_SPLIT)]
-        split_proofs: bool,
+        #[arg(long, default_value = DEFAULT_SPLIT, action = clap::ArgAction::SetTrue)]
+        split_proofs: Option<bool>,
     },
 
     /// setup aggregation circuit :)
@@ -426,22 +426,22 @@ pub enum Commands {
         sample_snarks: Vec<PathBuf>,
         /// The path to save the desired verification key file to
         #[arg(long, default_value = DEFAULT_VK_AGGREGATED)]
-        vk_path: PathBuf,
+        vk_path: Option<PathBuf>,
         /// The path to save the proving key to
         #[arg(long, default_value = DEFAULT_PK_AGGREGATED)]
-        pk_path: PathBuf,
+        pk_path: Option<PathBuf>,
         /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
         #[arg(long)]
         srs_path: Option<PathBuf>,
         /// logrows used for aggregation circuit
         #[arg(long, default_value = DEFAULT_AGGREGATED_LOGROWS)]
-        logrows: u32,
+        logrows: Option<u32>,
         /// whether the accumulated are segments of a larger proof
-        #[arg(long, default_value = DEFAULT_SPLIT)]
-        split_proofs: bool,
+        #[arg(long, default_value = DEFAULT_SPLIT, action = clap::ArgAction::SetTrue)]
+        split_proofs: Option<bool>,
         /// compress selectors
-        #[arg(long, default_value = DEFAULT_DISABLE_SELECTOR_COMPRESSION)]
-        disable_selector_compression: bool,
+        #[arg(long, default_value = DEFAULT_DISABLE_SELECTOR_COMPRESSION, action = clap::ArgAction::SetTrue)]
+        disable_selector_compression: Option<bool>,
         /// commitment used
         #[arg(long, default_value = DEFAULT_COMMITMENT)]
         commitment: Option<Commitments>,
@@ -453,10 +453,10 @@ pub enum Commands {
         aggregation_snarks: Vec<PathBuf>,
         /// The path to load the desired proving key file (generated using the setup-aggregate command)
         #[arg(long, default_value = DEFAULT_PK_AGGREGATED)]
-        pk_path: PathBuf,
+        pk_path: Option<PathBuf>,
         /// The path to output the proof file to
         #[arg(long, default_value = DEFAULT_PROOF_AGGREGATED)]
-        proof_path: PathBuf,
+        proof_path: Option<PathBuf>,
         /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
         #[arg(long)]
         srs_path: Option<PathBuf>,
@@ -470,13 +470,13 @@ pub enum Commands {
         transcript: TranscriptType,
         /// logrows used for aggregation circuit
         #[arg(long, default_value = DEFAULT_AGGREGATED_LOGROWS)]
-        logrows: u32,
+        logrows: Option<u32>,
         /// run sanity checks during calculations (safe or unsafe)
         #[arg(long, default_value = DEFAULT_CHECKMODE)]
-        check_mode: CheckMode,
+        check_mode: Option<CheckMode>,
         /// whether the accumulated proofs are segments of a larger circuit
-        #[arg(long, default_value = DEFAULT_SPLIT)]
-        split_proofs: bool,
+        #[arg(long, default_value = DEFAULT_SPLIT, action = clap::ArgAction::SetTrue)]
+        split_proofs: Option<bool>,
         /// commitment used
         #[arg(long, default_value = DEFAULT_COMMITMENT)]
         commitment: Option<Commitments>,
@@ -485,34 +485,34 @@ pub enum Commands {
     CompileCircuit {
         /// The path to the .onnx model file
         #[arg(short = 'M', long, default_value = DEFAULT_MODEL)]
-        model: PathBuf,
+        model: Option<PathBuf>,
         /// The path to the compiled model file (generated using the compile-circuit command)
         #[arg(long, default_value = DEFAULT_COMPILED_CIRCUIT)]
-        compiled_circuit: PathBuf,
+        compiled_circuit: Option<PathBuf>,
         /// The path to load circuit settings .json file from (generated using the gen-settings command)
         #[arg(short = 'S', long, default_value = DEFAULT_SETTINGS)]
-        settings_path: PathBuf,
+        settings_path: Option<PathBuf>,
     },
     /// Creates pk and vk
     Setup {
         /// The path to the compiled model file (generated using the compile-circuit command)
         #[arg(short = 'M', long, default_value = DEFAULT_COMPILED_CIRCUIT)]
-        compiled_circuit: PathBuf,
+        compiled_circuit: Option<PathBuf>,
         /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
         #[arg(long)]
         srs_path: Option<PathBuf>,
         /// The path to output the verification key file to
         #[arg(long, default_value = DEFAULT_VK)]
-        vk_path: PathBuf,
+        vk_path: Option<PathBuf>,
         /// The path to output the proving key file to
         #[arg(long, default_value = DEFAULT_PK)]
-        pk_path: PathBuf,
+        pk_path: Option<PathBuf>,
         /// The graph witness (optional - used to override fixed values in the circuit)
         #[arg(short = 'W', long)]
         witness: Option<PathBuf>,
         /// compress selectors
-        #[arg(long, default_value = DEFAULT_DISABLE_SELECTOR_COMPRESSION)]
-        disable_selector_compression: bool,
+        #[arg(long, default_value = DEFAULT_DISABLE_SELECTOR_COMPRESSION, action = clap::ArgAction::SetTrue)]
+        disable_selector_compression: Option<bool>,
     },
     #[cfg(not(target_arch = "wasm32"))]
     /// Deploys a test contact that the data attester reads from and creates a data attestation formatted input.json file that contains call data information
@@ -520,10 +520,10 @@ pub enum Commands {
     SetupTestEvmData {
         /// The path to the .json data file, which should include both the network input (possibly private) and the network output (public input to the proof)
         #[arg(short = 'D', long)]
-        data: PathBuf,
+        data: Option<PathBuf>,
         /// The path to the compiled model file (generated using the compile-circuit command)
         #[arg(short = 'M', long)]
-        compiled_circuit: PathBuf,
+        compiled_circuit: Option<PathBuf>,
         /// For testing purposes only. The optional path to the .json data file that will be generated that contains the OnChain data storage information
         /// derived from the file information in the data .json file.
         /// Should include both the network input (possibly private) and the network output (public input to the proof)
@@ -548,7 +548,7 @@ pub enum Commands {
         addr: H160Flag,
         /// The path to the .json data file.
         #[arg(short = 'D', long)]
-        data: PathBuf,
+        data: Option<PathBuf>,
         /// RPC URL for an Ethereum node, if None will use Anvil but WON'T persist state
         #[arg(short = 'U', long)]
         rpc_url: Option<String>,
@@ -558,10 +558,10 @@ pub enum Commands {
     SwapProofCommitments {
         /// The path to the proof file
         #[arg(short = 'P', long, default_value = DEFAULT_PROOF)]
-        proof_path: PathBuf,
+        proof_path: Option<PathBuf>,
         /// The path to the witness file
         #[arg(short = 'W', long, default_value = DEFAULT_WITNESS)]
-        witness_path: PathBuf,
+        witness_path: Option<PathBuf>,
     },
 
     #[cfg(not(target_arch = "wasm32"))]
@@ -569,16 +569,16 @@ pub enum Commands {
     Prove {
         /// The path to the .json witness file (generated using the gen-witness command)
         #[arg(short = 'W', long, default_value = DEFAULT_WITNESS)]
-        witness: PathBuf,
+        witness: Option<PathBuf>,
         /// The path to the compiled model file (generated using the compile-circuit command)
         #[arg(short = 'M', long, default_value = DEFAULT_COMPILED_CIRCUIT)]
-        compiled_circuit: PathBuf,
+        compiled_circuit: Option<PathBuf>,
         /// The path to load the desired proving key file (generated using the setup command)
         #[arg(long, default_value = DEFAULT_PK)]
-        pk_path: PathBuf,
+        pk_path: Option<PathBuf>,
         /// The path to output the proof file to
         #[arg(long, default_value = DEFAULT_PROOF)]
-        proof_path: PathBuf,
+        proof_path: Option<PathBuf>,
         /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
         #[arg(long)]
         srs_path: Option<PathBuf>,
@@ -592,7 +592,7 @@ pub enum Commands {
         proof_type: ProofType,
         /// run sanity checks during calculations (safe or unsafe)
         #[arg(long, default_value = DEFAULT_CHECKMODE)]
-        check_mode: CheckMode,
+        check_mode: Option<CheckMode>,
     },
     #[cfg(not(target_arch = "wasm32"))]
     /// Creates an Evm verifier for a single proof
@@ -603,21 +603,21 @@ pub enum Commands {
         srs_path: Option<PathBuf>,
         /// The path to load circuit settings .json file from (generated using the gen-settings command)
         #[arg(short = 'S', long, default_value = DEFAULT_SETTINGS)]
-        settings_path: PathBuf,
+        settings_path: Option<PathBuf>,
         /// The path to load the desired verification key file
         #[arg(long, default_value = DEFAULT_VK)]
-        vk_path: PathBuf,
+        vk_path: Option<PathBuf>,
         /// The path to output the Solidity code
         #[arg(long, default_value = DEFAULT_SOL_CODE)]
-        sol_code_path: PathBuf,
+        sol_code_path: Option<PathBuf>,
         /// The path to output the Solidity verifier ABI
         #[arg(long, default_value = DEFAULT_VERIFIER_ABI)]
-        abi_path: PathBuf,
+        abi_path: Option<PathBuf>,
         /// Whether the verifier key should be rendered as a separate contract.
         /// We recommend disabling selector compression if this is enabled.
         /// To save the verifier key as a separate contract, set this to true and then call the create-evm-vk command.        
-        #[arg(long, default_value = DEFAULT_RENDER_VK_SEPERATELY)]
-        render_vk_seperately: bool,
+        #[arg(long, default_value = DEFAULT_RENDER_VK_SEPERATELY, action = clap::ArgAction::SetTrue)]
+        render_vk_seperately: Option<bool>,
     },
     #[cfg(not(target_arch = "wasm32"))]
     /// Creates an Evm verifier for a single proof
@@ -628,16 +628,16 @@ pub enum Commands {
         srs_path: Option<PathBuf>,
         /// The path to load circuit settings .json file from (generated using the gen-settings command)
         #[arg(short = 'S', long, default_value = DEFAULT_SETTINGS)]
-        settings_path: PathBuf,
+        settings_path: Option<PathBuf>,
         /// The path to load the desired verification key file
         #[arg(long, default_value = DEFAULT_VK)]
-        vk_path: PathBuf,
+        vk_path: Option<PathBuf>,
         /// The path to output the Solidity code
         #[arg(long, default_value = DEFAULT_VK_SOL)]
-        sol_code_path: PathBuf,
+        sol_code_path: Option<PathBuf>,
         /// The path to output the Solidity verifier ABI
         #[arg(long, default_value = DEFAULT_VK_ABI)]
-        abi_path: PathBuf,
+        abi_path: Option<PathBuf>,
     },
     #[cfg(not(target_arch = "wasm32"))]
     /// Creates an Evm verifier that attests to on-chain inputs for a single proof
@@ -645,20 +645,20 @@ pub enum Commands {
     CreateEvmDataAttestation {
         /// The path to load circuit settings .json file from (generated using the gen-settings command)
         #[arg(short = 'S', long, default_value = DEFAULT_SETTINGS)]
-        settings_path: PathBuf,
+        settings_path: Option<PathBuf>,
         /// The path to output the Solidity code
         #[arg(long, default_value = DEFAULT_SOL_CODE_DA)]
-        sol_code_path: PathBuf,
+        sol_code_path: Option<PathBuf>,
         /// The path to output the Solidity verifier ABI
         #[arg(long, default_value = DEFAULT_VERIFIER_DA_ABI)]
-        abi_path: PathBuf,
+        abi_path: Option<PathBuf>,
         /// The path to the .json data file, which should
         /// contain the necessary calldata and account addresses
         /// needed to read from all the on-chain
         /// view functions that return the data that the network
         /// ingests as inputs.
         #[arg(short = 'D', long, default_value = DEFAULT_DATA)]
-        data: PathBuf,
+        data: Option<PathBuf>,
     },
 
     #[cfg(not(target_arch = "wasm32"))]
@@ -670,60 +670,60 @@ pub enum Commands {
         srs_path: Option<PathBuf>,
         /// The path to load the desired verification key file
         #[arg(long, default_value = DEFAULT_VK_AGGREGATED)]
-        vk_path: PathBuf,
+        vk_path: Option<PathBuf>,
         /// The path to the Solidity code
         #[arg(long, default_value = DEFAULT_SOL_CODE_AGGREGATED)]
-        sol_code_path: PathBuf,
+        sol_code_path: Option<PathBuf>,
         /// The path to output the Solidity verifier ABI
         #[arg(long, default_value = DEFAULT_VERIFIER_AGGREGATED_ABI)]
-        abi_path: PathBuf,
+        abi_path: Option<PathBuf>,
         // aggregated circuit settings paths, used to calculate the number of instances in the aggregate proof
         #[arg(long, default_value = DEFAULT_SETTINGS, value_delimiter = ',', allow_hyphen_values = true)]
         aggregation_settings: Vec<PathBuf>,
         // logrows used for aggregation circuit
         #[arg(long, default_value = DEFAULT_AGGREGATED_LOGROWS)]
-        logrows: u32,
+        logrows: Option<u32>,
         /// Whether the verifier key should be rendered as a separate contract.
         /// We recommend disabling selector compression if this is enabled.
         /// To save the verifier key as a separate contract, set this to true and then call the create-evm-vk command.        
-        #[arg(long, default_value = DEFAULT_RENDER_VK_SEPERATELY)]
-        render_vk_seperately: bool,
+        #[arg(long, default_value = DEFAULT_RENDER_VK_SEPERATELY, action = clap::ArgAction::SetTrue)]
+        render_vk_seperately: Option<bool>,
     },
     /// Verifies a proof, returning accept or reject
     Verify {
         /// The path to load circuit settings .json file from (generated using the gen-settings command)
         #[arg(short = 'S', long, default_value = DEFAULT_SETTINGS)]
-        settings_path: PathBuf,
+        settings_path: Option<PathBuf>,
         /// The path to the proof file (generated using the prove command)
         #[arg(long, default_value = DEFAULT_PROOF)]
-        proof_path: PathBuf,
+        proof_path: Option<PathBuf>,
         /// The path to the verification key file (generated using the setup command)
         #[arg(long, default_value = DEFAULT_VK)]
-        vk_path: PathBuf,
+        vk_path: Option<PathBuf>,
         /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
         #[arg(long)]
         srs_path: Option<PathBuf>,
         /// Reduce SRS logrows to the number of instances rather than the number of logrows used for proofs (only works if the srs were generated in the same ceremony)
-        #[arg(long, default_value = DEFAULT_USE_REDUCED_SRS_FOR_VERIFICATION)]
-        reduced_srs: bool,
+        #[arg(long, default_value = DEFAULT_USE_REDUCED_SRS_FOR_VERIFICATION, action = clap::ArgAction::SetTrue)]
+        reduced_srs: Option<bool>,
     },
     /// Verifies an aggregate proof, returning accept or reject
     VerifyAggr {
         /// The path to the proof file (generated using the prove command)
         #[arg(long, default_value = DEFAULT_PROOF_AGGREGATED)]
-        proof_path: PathBuf,
+        proof_path: Option<PathBuf>,
         /// The path to the verification key file (generated using the setup-aggregate command)
         #[arg(long, default_value = DEFAULT_VK_AGGREGATED)]
-        vk_path: PathBuf,
+        vk_path: Option<PathBuf>,
         /// reduced srs
-        #[arg(long, default_value = DEFAULT_USE_REDUCED_SRS_FOR_VERIFICATION)]
-        reduced_srs: bool,
+        #[arg(long, default_value = DEFAULT_USE_REDUCED_SRS_FOR_VERIFICATION, action = clap::ArgAction::SetTrue)]
+        reduced_srs: Option<bool>,
         /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
         #[arg(long)]
         srs_path: Option<PathBuf>,
         /// logrows used for aggregation circuit
         #[arg(long, default_value = DEFAULT_AGGREGATED_LOGROWS)]
-        logrows: u32,
+        logrows: Option<u32>,
         /// commitment
         #[arg(long, default_value = DEFAULT_COMMITMENT)]
         commitment: Option<Commitments>,
@@ -733,13 +733,13 @@ pub enum Commands {
     DeployEvmVerifier {
         /// The path to the Solidity code (generated using the create-evm-verifier command)
         #[arg(long, default_value = DEFAULT_SOL_CODE)]
-        sol_code_path: PathBuf,
+        sol_code_path: Option<PathBuf>,
         /// RPC URL for an Ethereum node, if None will use Anvil but WON'T persist state
         #[arg(short = 'U', long)]
         rpc_url: Option<String>,
         #[arg(long, default_value = DEFAULT_CONTRACT_ADDRESS)]
         /// The path to output the contract address
-        addr_path: PathBuf,
+        addr_path: Option<PathBuf>,
         /// The optimizer runs to set on the verifier. Lower values optimize for deployment cost, while higher values optimize for gas cost.
         #[arg(long, default_value = DEFAULT_OPTIMIZER_RUNS)]
         optimizer_runs: usize,
@@ -752,13 +752,13 @@ pub enum Commands {
     DeployEvmVK {
         /// The path to the Solidity code (generated using the create-evm-verifier command)
         #[arg(long, default_value = DEFAULT_VK_SOL)]
-        sol_code_path: PathBuf,
+        sol_code_path: Option<PathBuf>,
         /// RPC URL for an Ethereum node, if None will use Anvil but WON'T persist state
         #[arg(short = 'U', long)]
         rpc_url: Option<String>,
         #[arg(long, default_value = DEFAULT_CONTRACT_ADDRESS_VK)]
         /// The path to output the contract address
-        addr_path: PathBuf,
+        addr_path: Option<PathBuf>,
         /// The optimizer runs to set on the verifier. Lower values optimize for deployment cost, while higher values optimize for gas cost.
         #[arg(long, default_value = DEFAULT_OPTIMIZER_RUNS)]
         optimizer_runs: usize,
@@ -772,19 +772,19 @@ pub enum Commands {
     DeployEvmDataAttestation {
         /// The path to the .json data file, which should include both the network input (possibly private) and the network output (public input to the proof)
         #[arg(short = 'D', long, default_value = DEFAULT_DATA)]
-        data: PathBuf,
+        data: Option<PathBuf>,
         /// The path to load circuit settings .json file from (generated using the gen-settings command)
         #[arg(long, default_value = DEFAULT_SETTINGS)]
-        settings_path: PathBuf,
+        settings_path: Option<PathBuf>,
         /// The path to the Solidity code
         #[arg(long, default_value = DEFAULT_SOL_CODE_DA)]
-        sol_code_path: PathBuf,
+        sol_code_path: Option<PathBuf>,
         /// RPC URL for an Ethereum node, if None will use Anvil but WON'T persist state
         #[arg(short = 'U', long)]
         rpc_url: Option<String>,
         #[arg(long, default_value = DEFAULT_CONTRACT_ADDRESS_DA)]
         /// The path to output the contract address
-        addr_path: PathBuf,
+        addr_path: Option<PathBuf>,
         /// The optimizer runs to set on the verifier. (Lower values optimize for deployment, while higher values optimize for execution)
         #[arg(long, default_value = DEFAULT_OPTIMIZER_RUNS)]
         optimizer_runs: usize,
@@ -798,7 +798,7 @@ pub enum Commands {
     VerifyEvm {
         /// The path to the proof file (generated using the prove command)
         #[arg(long, default_value = DEFAULT_PROOF)]
-        proof_path: PathBuf,
+        proof_path: Option<PathBuf>,
         /// The path to verifier contract's address
         #[arg(long, default_value = DEFAULT_CONTRACT_ADDRESS)]
         addr_verifier: H160Flag,

src/execute.rs

@@ -1,9 +1,7 @@
 use crate::circuit::CheckMode;
 #[cfg(not(target_arch = "wasm32"))]
 use crate::commands::CalibrationTarget;
-use crate::commands::Commands;
-#[cfg(not(target_arch = "wasm32"))]
-use crate::commands::H160Flag;
+use crate::commands::*;
 #[cfg(not(target_arch = "wasm32"))]
 use crate::eth::{deploy_contract_via_solidity, deploy_da_verifier_via_solidity};
 #[cfg(not(target_arch = "wasm32"))]
@@ -71,6 +69,7 @@ use std::path::Path;
 use std::path::PathBuf;
 #[cfg(not(target_arch = "wasm32"))]
 use std::process::Command;
+use std::str::FromStr;
 #[cfg(not(target_arch = "wasm32"))]
 use std::sync::OnceLock;
 
@@ -152,7 +151,11 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             srs_path,
             logrows,
             commitment,
-        } => gen_srs_cmd(srs_path, logrows as u32, commitment),
+        } => gen_srs_cmd(
+            srs_path,
+            logrows as u32,
+            commitment.unwrap_or(Commitments::from_str(DEFAULT_COMMITMENT)?),
+        ),
         #[cfg(not(target_arch = "wasm32"))]
         Commands::GetSrs {
             srs_path,
@@ -160,12 +163,16 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             logrows,
             commitment,
         } => get_srs_cmd(srs_path, settings_path, logrows, commitment).await,
-        Commands::Table { model, args } => table(model, args),
+        Commands::Table { model, args } => table(model.unwrap_or(DEFAULT_MODEL.into()), args),
         Commands::GenSettings {
             model,
             settings_path,
             args,
-        } => gen_circuit_settings(model, settings_path, args),
+        } => gen_circuit_settings(
+            model.unwrap_or(DEFAULT_MODEL.into()),
+            settings_path.unwrap_or(DEFAULT_SETTINGS.into()),
+            args,
+        ),
         #[cfg(not(target_arch = "wasm32"))]
         Commands::CalibrateSettings {
             model,
@@ -178,14 +185,14 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             max_logrows,
             only_range_check_rebase,
         } => calibrate(
-            model,
-            data,
-            settings_path,
+            model.unwrap_or(DEFAULT_MODEL.into()),
+            data.unwrap_or(DEFAULT_DATA.into()),
+            settings_path.unwrap_or(DEFAULT_SETTINGS.into()),
             target,
             lookup_safety_margin,
             scales,
             scale_rebase_multiplier,
-            only_range_check_rebase,
+            only_range_check_rebase.unwrap_or(DEFAULT_ONLY_RANGE_CHECK_REBASE.parse()?),
             max_logrows,
         )
         .map(|e| serde_json::to_string(&e).unwrap()),
@@ -195,9 +202,18 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             output,
             vk_path,
             srs_path,
-        } => gen_witness(compiled_circuit, data, Some(output), vk_path, srs_path)
-            .map(|e| serde_json::to_string(&e).unwrap()),
-        Commands::Mock { model, witness } => mock(model, witness),
+        } => gen_witness(
+            compiled_circuit.unwrap_or(DEFAULT_COMPILED_CIRCUIT.into()),
+            data.unwrap_or(DEFAULT_DATA.into()),
+            Some(output.unwrap_or(DEFAULT_WITNESS.into())),
+            vk_path,
+            srs_path,
+        )
+        .map(|e| serde_json::to_string(&e).unwrap()),
+        Commands::Mock { model, witness } => mock(
+            model.unwrap_or(DEFAULT_MODEL.into()),
+            witness.unwrap_or(DEFAULT_WITNESS.into()),
+        ),
         #[cfg(not(target_arch = "wasm32"))]
         Commands::CreateEvmVerifier {
             vk_path,
@@ -207,12 +223,12 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             abi_path,
             render_vk_seperately,
         } => create_evm_verifier(
-            vk_path,
+            vk_path.unwrap_or(DEFAULT_VK.into()),
             srs_path,
-            settings_path,
-            sol_code_path,
-            abi_path,
-            render_vk_seperately,
+            settings_path.unwrap_or(DEFAULT_SETTINGS.into()),
+            sol_code_path.unwrap_or(DEFAULT_SOL_CODE.into()),
+            abi_path.unwrap_or(DEFAULT_VERIFIER_ABI.into()),
+            render_vk_seperately.unwrap_or(DEFAULT_RENDER_VK_SEPERATELY.parse()?),
         ),
         Commands::CreateEvmVK {
             vk_path,
@@ -220,14 +236,25 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             settings_path,
             sol_code_path,
             abi_path,
-        } => create_evm_vk(vk_path, srs_path, settings_path, sol_code_path, abi_path),
+        } => create_evm_vk(
+            vk_path.unwrap_or(DEFAULT_VK.into()),
+            srs_path,
+            settings_path.unwrap_or(DEFAULT_SETTINGS.into()),
+            sol_code_path.unwrap_or(DEFAULT_VK_SOL.into()),
+            abi_path.unwrap_or(DEFAULT_VK_ABI.into()),
+        ),
         #[cfg(not(target_arch = "wasm32"))]
         Commands::CreateEvmDataAttestation {
             settings_path,
             sol_code_path,
             abi_path,
             data,
-        } => create_evm_data_attestation(settings_path, sol_code_path, abi_path, data),
+        } => create_evm_data_attestation(
+            settings_path.unwrap_or(DEFAULT_SETTINGS.into()),
+            sol_code_path.unwrap_or(DEFAULT_SOL_CODE_DA.into()),
+            abi_path.unwrap_or(DEFAULT_VERIFIER_DA_ABI.into()),
+            data.unwrap_or(DEFAULT_DATA.into()),
+        ),
         #[cfg(not(target_arch = "wasm32"))]
         Commands::CreateEvmVerifierAggr {
             vk_path,
@@ -238,19 +265,23 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             logrows,
             render_vk_seperately,
         } => create_evm_aggregate_verifier(
-            vk_path,
+            vk_path.unwrap_or(DEFAULT_VK.into()),
             srs_path,
-            sol_code_path,
-            abi_path,
+            sol_code_path.unwrap_or(DEFAULT_SOL_CODE_AGGREGATED.into()),
+            abi_path.unwrap_or(DEFAULT_VERIFIER_AGGREGATED_ABI.into()),
             aggregation_settings,
-            logrows,
-            render_vk_seperately,
+            logrows.unwrap_or(DEFAULT_AGGREGATED_LOGROWS.parse()?),
+            render_vk_seperately.unwrap_or(DEFAULT_RENDER_VK_SEPERATELY.parse()?),
         ),
         Commands::CompileCircuit {
             model,
             compiled_circuit,
             settings_path,
-        } => compile_circuit(model, compiled_circuit, settings_path),
+        } => compile_circuit(
+            model.unwrap_or(DEFAULT_MODEL.into()),
+            compiled_circuit.unwrap_or(DEFAULT_COMPILED_CIRCUIT.into()),
+            settings_path.unwrap_or(DEFAULT_SETTINGS.into()),
+        ),
         Commands::Setup {
             compiled_circuit,
             srs_path,
@@ -259,12 +290,12 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             witness,
             disable_selector_compression,
         } => setup(
-            compiled_circuit,
+            compiled_circuit.unwrap_or(DEFAULT_COMPILED_CIRCUIT.into()),
             srs_path,
-            vk_path,
-            pk_path,
+            vk_path.unwrap_or(DEFAULT_VK.into()),
+            pk_path.unwrap_or(DEFAULT_PK.into()),
             witness,
-            disable_selector_compression,
+            disable_selector_compression.unwrap_or(DEFAULT_DISABLE_SELECTOR_COMPRESSION.parse()?),
         ),
         #[cfg(not(target_arch = "wasm32"))]
         Commands::SetupTestEvmData {
@@ -276,8 +307,8 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             output_source,
         } => {
             setup_test_evm_witness(
-                data,
-                compiled_circuit,
+                data.unwrap_or(DEFAULT_DATA.into()),
+                compiled_circuit.unwrap_or(DEFAULT_COMPILED_CIRCUIT.into()),
                 test_data,
                 rpc_url,
                 input_source,
@@ -290,13 +321,17 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             addr,
             data,
             rpc_url,
-        } => test_update_account_calls(addr, data, rpc_url).await,
+        } => test_update_account_calls(addr, data.unwrap_or(DEFAULT_DATA.into()), rpc_url).await,
         #[cfg(not(target_arch = "wasm32"))]
         Commands::SwapProofCommitments {
             proof_path,
             witness_path,
-        } => swap_proof_commitments_cmd(proof_path, witness_path)
-            .map(|e| serde_json::to_string(&e).unwrap()),
+        } => swap_proof_commitments_cmd(
+            proof_path.unwrap_or(DEFAULT_PROOF.into()),
+            witness_path.unwrap_or(DEFAULT_WITNESS.into()),
+        )
+        .map(|e| serde_json::to_string(&e).unwrap()),
+
         #[cfg(not(target_arch = "wasm32"))]
         Commands::Prove {
             witness,
@@ -307,20 +342,24 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             proof_type,
             check_mode,
         } => prove(
-            witness,
-            compiled_circuit,
-            pk_path,
-            Some(proof_path),
+            witness.unwrap_or(DEFAULT_WITNESS.into()),
+            compiled_circuit.unwrap_or(DEFAULT_COMPILED_CIRCUIT.into()),
+            pk_path.unwrap_or(DEFAULT_PK.into()),
+            Some(proof_path.unwrap_or(DEFAULT_PROOF.into())),
             srs_path,
             proof_type,
-            check_mode,
+            check_mode.unwrap_or(DEFAULT_CHECKMODE.parse()?),
         )
         .map(|e| serde_json::to_string(&e).unwrap()),
         Commands::MockAggregate {
             aggregation_snarks,
             logrows,
             split_proofs,
-        } => mock_aggregate(aggregation_snarks, logrows, split_proofs),
+        } => mock_aggregate(
+            aggregation_snarks,
+            logrows.unwrap_or(DEFAULT_AGGREGATED_LOGROWS.parse()?),
+            split_proofs.unwrap_or(DEFAULT_SPLIT.parse()?),
+        ),
         Commands::SetupAggregate {
             sample_snarks,
             vk_path,
@@ -332,12 +371,12 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             commitment,
         } => setup_aggregate(
             sample_snarks,
-            vk_path,
-            pk_path,
+            vk_path.unwrap_or(DEFAULT_VK_AGGREGATED.into()),
+            pk_path.unwrap_or(DEFAULT_PK_AGGREGATED.into()),
             srs_path,
-            logrows,
-            split_proofs,
-            disable_selector_compression,
+            logrows.unwrap_or(DEFAULT_AGGREGATED_LOGROWS.parse()?),
+            split_proofs.unwrap_or(DEFAULT_SPLIT.parse()?),
+            disable_selector_compression.unwrap_or(DEFAULT_DISABLE_SELECTOR_COMPRESSION.parse()?),
             commitment.into(),
         ),
         Commands::Aggregate {
@@ -351,14 +390,14 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             split_proofs,
             commitment,
         } => aggregate(
-            proof_path,
+            proof_path.unwrap_or(DEFAULT_PROOF_AGGREGATED.into()),
             aggregation_snarks,
-            pk_path,
+            pk_path.unwrap_or(DEFAULT_PK_AGGREGATED.into()),
             srs_path,
             transcript,
-            logrows,
-            check_mode,
-            split_proofs,
+            logrows.unwrap_or(DEFAULT_AGGREGATED_LOGROWS.parse()?),
+            check_mode.unwrap_or(DEFAULT_CHECKMODE.parse()?),
+            split_proofs.unwrap_or(DEFAULT_SPLIT.parse()?),
             commitment.into(),
         )
         .map(|e| serde_json::to_string(&e).unwrap()),
@@ -368,8 +407,14 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             vk_path,
             srs_path,
             reduced_srs,
-        } => verify(proof_path, settings_path, vk_path, srs_path, reduced_srs)
-            .map(|e| serde_json::to_string(&e).unwrap()),
+        } => verify(
+            proof_path.unwrap_or(DEFAULT_PROOF.into()),
+            settings_path.unwrap_or(DEFAULT_SETTINGS.into()),
+            vk_path.unwrap_or(DEFAULT_VK.into()),
+            srs_path,
+            reduced_srs.unwrap_or(DEFAULT_USE_REDUCED_SRS_FOR_VERIFICATION.parse()?),
+        )
+        .map(|e| serde_json::to_string(&e).unwrap()),
         Commands::VerifyAggr {
             proof_path,
             vk_path,
@@ -378,11 +423,11 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             logrows,
             commitment,
         } => verify_aggr(
-            proof_path,
-            vk_path,
+            proof_path.unwrap_or(DEFAULT_PROOF_AGGREGATED.into()),
+            vk_path.unwrap_or(DEFAULT_VK_AGGREGATED.into()),
             srs_path,
-            logrows,
-            reduced_srs,
+            logrows.unwrap_or(DEFAULT_AGGREGATED_LOGROWS.parse()?),
+            reduced_srs.unwrap_or(DEFAULT_USE_REDUCED_SRS_FOR_VERIFICATION.parse()?),
             commitment.into(),
         )
         .map(|e| serde_json::to_string(&e).unwrap()),
@@ -395,9 +440,9 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             private_key,
         } => {
             deploy_evm(
-                sol_code_path,
+                sol_code_path.unwrap_or(DEFAULT_SOL_CODE.into()),
                 rpc_url,
-                addr_path,
+                addr_path.unwrap_or(DEFAULT_CONTRACT_ADDRESS.into()),
                 optimizer_runs,
                 private_key,
                 "Halo2Verifier",
@@ -413,9 +458,9 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             private_key,
         } => {
             deploy_evm(
-                sol_code_path,
+                sol_code_path.unwrap_or(DEFAULT_VK_SOL.into()),
                 rpc_url,
-                addr_path,
+                addr_path.unwrap_or(DEFAULT_CONTRACT_ADDRESS_VK.into()),
                 optimizer_runs,
                 private_key,
                 "Halo2VerifyingKey",
@@ -433,11 +478,11 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             private_key,
         } => {
             deploy_da_evm(
-                data,
-                settings_path,
-                sol_code_path,
+                data.unwrap_or(DEFAULT_DATA.into()),
+                settings_path.unwrap_or(DEFAULT_SETTINGS.into()),
+                sol_code_path.unwrap_or(DEFAULT_SOL_CODE_DA.into()),
                 rpc_url,
-                addr_path,
+                addr_path.unwrap_or(DEFAULT_CONTRACT_ADDRESS_DA.into()),
                 optimizer_runs,
                 private_key,
             )
@@ -450,7 +495,16 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             rpc_url,
             addr_da,
             addr_vk,
-        } => verify_evm(proof_path, addr_verifier, rpc_url, addr_da, addr_vk).await,
+        } => {
+            verify_evm(
+                proof_path.unwrap_or(DEFAULT_PROOF.into()),
+                addr_verifier,
+                rpc_url,
+                addr_da,
+                addr_vk,
+            )
+            .await
+        }
     }
 }
 

src/lib.rs

@@ -201,13 +201,13 @@ pub struct RunArgs {
     /// Hand-written parser for graph variables, eg. batch_size=1
     #[arg(short = 'V', long, value_parser = parse_key_val::<String, usize>, default_value = "batch_size->1", value_delimiter = ',')]
     pub variables: Vec<(String, usize)>,
-    /// Flags whether inputs are public, private, hashed, fixed, kzgcommit
+    /// Flags whether inputs are public, private, fixed, hashed, polycommit
     #[arg(long, default_value = "private")]
     pub input_visibility: Visibility,
-    /// Flags whether outputs are public, private, fixed, hashed, kzgcommit
+    /// Flags whether outputs are public, private, fixed, hashed, polycommit
     #[arg(long, default_value = "public")]
     pub output_visibility: Visibility,
-    /// Flags whether params are fixed, private, hashed, kzgcommit
+    /// Flags whether params are fixed, private, hashed, polycommit
     #[arg(long, default_value = "private")]
     pub param_visibility: Visibility,
     #[arg(long, default_value = "false")]

tests/py_integration_tests.rs

@@ -123,7 +123,7 @@ mod py_tests {
         }
     }
 
-    const TESTS: [&str; 32] = [
+    const TESTS: [&str; 33] = [
         "proof_splitting.ipynb", // 0
         "variance.ipynb",
         "mnist_gan.ipynb",
@@ -157,6 +157,7 @@ mod py_tests {
         "generalized_inverse.ipynb",
         "mnist_classifier.ipynb", // 30
         "world_rotation.ipynb",
+        "logistic_regression.ipynb",
     ];
 
     macro_rules! test_func {
@@ -169,7 +170,7 @@ mod py_tests {
             use super::*;
 
 
-            seq!(N in 0..=31 {
+            seq!(N in 0..=32 {
 
             #(#[test_case(TESTS[N])])*
             fn run_notebook_(test: &str) {