ci: update version string in docs

.github/workflows/engine.yml

@@ -178,3 +178,58 @@ jobs:
           npm publish
         env:
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+
+  in-browser-evm-ver-publish:
+    name: publish-in-browser-evm-verifier-package
+    needs: [publish-wasm-bindings]
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/')
+    steps:
+      - uses: actions/checkout@v4
+      - name: Update version in package.json
+        shell: bash
+        env:
+          RELEASE_TAG: ${{ github.ref_name }}
+        run: |
+          sed -i "s|\"version\": \".*\"|\"version\": \"${{ github.ref_name }}\"|" in-browser-evm-verifier/package.json
+      - name: Prepare tag and fetch package integrity
+        run: |
+          CLEANED_TAG=${{ github.ref_name }} # Get the tag from ref_name
+          CLEANED_TAG="${CLEANED_TAG#v}" # Remove leading 'v'
+          echo "CLEANED_TAG=${CLEANED_TAG}" >> $GITHUB_ENV # Set it as an environment variable for later steps
+          ENGINE_INTEGRITY=$(npm view @ezkljs/engine@$CLEANED_TAG dist.integrity)
+          echo "ENGINE_INTEGRITY=$ENGINE_INTEGRITY" >> $GITHUB_ENV
+      - name: Update @ezkljs/engine version in package.json
+        shell: bash
+        env:
+          RELEASE_TAG: ${{ github.ref_name }}
+        run: |
+          sed -i "s|\"@ezkljs/engine\": \".*\"|\"@ezkljs/engine\": \"$CLEANED_TAG\"|" in-browser-evm-verifier/package.json
+      - name: Update the engine import in in-browser-evm-verifier to use @ezkljs/engine package instead of the local one;
+        run: |
+          sed -i "s|import { encodeVerifierCalldata } from '../nodejs/ezkl';|import { encodeVerifierCalldata } from '@ezkljs/engine';|" in-browser-evm-verifier/src/index.ts
+      - name: Update pnpm-lock.yaml versions and integrity
+        run: |
+          awk -v integrity="$ENGINE_INTEGRITY" -v tag="$CLEANED_TAG" '
+          NR==30{$0="    specifier: \"" tag "\""}
+          NR==31{$0="    version: \"" tag "\""}
+          NR==400{$0="  /@ezkljs/engine@" tag ":"}
+          NR==401{$0="    resolution: {integrity: \"" integrity "\"}"} 1' in-browser-evm-verifier/pnpm-lock.yaml > temp.yaml && mv temp.yaml in-browser-evm-verifier/pnpm-lock.yaml  
+      - name: Use pnpm 8
+        uses: pnpm/action-setup@v2
+        with:
+          version: 8
+      - name: Set up Node.js
+        uses: actions/setup-node@v3
+        with:
+          node-version: "18.12.1"
+          registry-url: "https://registry.npmjs.org"
+      - name: Publish to npm
+        run: |
+          cd in-browser-evm-verifier
+          pnpm install --frozen-lockfile
+          pnpm run build
+          pnpm publish --no-git-checks
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}  

.github/workflows/verify.yml

@@ -1,68 +0,0 @@
-name: Build and Publish EZKL npm packages (wasm bindings and in-browser evm verifier)
-
-on:
-  workflow_dispatch:
-    inputs:
-      tag:
-        description: "The tag to release"
-        required: true
-  push:
-    tags:
-      - "*"
-
-defaults:
-  run:
-    working-directory: .
-jobs:
-  in-browser-evm-ver-publish:
-    name: publish-in-browser-evm-verifier-package
-    runs-on: ubuntu-latest
-    if: startsWith(github.ref, 'refs/tags/')
-    steps:
-      - uses: actions/checkout@v4
-      - name: Update version in package.json
-        shell: bash
-        env:
-          RELEASE_TAG: ${{ github.ref_name }}
-        run: |
-          sed -i "s|\"version\": \".*\"|\"version\": \"${{ github.ref_name }}\"|" in-browser-evm-verifier/package.json
-      - name: Prepare tag and fetch package integrity
-        run: |
-          CLEANED_TAG=${{ github.ref_name }} # Get the tag from ref_name
-          CLEANED_TAG="${CLEANED_TAG#v}" # Remove leading 'v'
-          echo "CLEANED_TAG=${CLEANED_TAG}" >> $GITHUB_ENV # Set it as an environment variable for later steps
-          ENGINE_INTEGRITY=$(npm view @ezkljs/engine@$CLEANED_TAG dist.integrity)
-          echo "ENGINE_INTEGRITY=$ENGINE_INTEGRITY" >> $GITHUB_ENV
-      - name: Update @ezkljs/engine version in package.json
-        shell: bash
-        env:
-          RELEASE_TAG: ${{ github.ref_name }}
-        run: |
-          sed -i "s|\"@ezkljs/engine\": \".*\"|\"@ezkljs/engine\": \"$CLEANED_TAG\"|" in-browser-evm-verifier/package.json
-      - name: Update the engine import in in-browser-evm-verifier to use @ezkljs/engine package instead of the local one;
-        run: |
-          sed -i "s|import { encodeVerifierCalldata } from '../nodejs/ezkl';|import { encodeVerifierCalldata } from '@ezkljs/engine';|" in-browser-evm-verifier/src/index.ts
-      - name: Update pnpm-lock.yaml versions and integrity
-        run: |
-          awk -v integrity="$ENGINE_INTEGRITY" -v tag="$CLEANED_TAG" '
-          NR==30{$0="    specifier: \"" tag "\""}
-          NR==31{$0="    version: \"" tag "\""}
-          NR==400{$0="  /@ezkljs/engine@" tag ":"}
-          NR==401{$0="    resolution: {integrity: \"" integrity "\"}"} 1' in-browser-evm-verifier/pnpm-lock.yaml > temp.yaml && mv temp.yaml in-browser-evm-verifier/pnpm-lock.yaml  
-      - name: Use pnpm 8
-        uses: pnpm/action-setup@v2
-        with:
-          version: 8
-      - name: Set up Node.js
-        uses: actions/setup-node@v3
-        with:
-          node-version: "18.12.1"
-          registry-url: "https://registry.npmjs.org"
-      - name: Publish to npm
-        run: |
-          cd in-browser-evm-verifier
-          pnpm install --frozen-lockfile
-          pnpm run build
-          pnpm publish --no-git-checks
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

Cargo.lock

@@ -1208,6 +1208,15 @@ dependencies = [
  "strsim",
 ]
 
+[[package]]
+name = "clap_complete"
+version = "4.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd79504325bf38b10165b02e89b4347300f855f273c4cb30c4a3209e6583275e"
+dependencies = [
+ "clap 4.5.3",
+]
+
 [[package]]
 name = "clap_derive"
 version = "4.5.3"
@@ -1832,6 +1841,7 @@ dependencies = [
  "bincode",
  "chrono",
  "clap 4.5.3",
+ "clap_complete",
  "colored",
  "colored_json",
  "console_error_panic_hook",

Cargo.toml

@@ -23,6 +23,7 @@ halo2curves = { git = "https://github.com/privacy-scaling-explorations/halo2curv
 rand = { version = "0.8", default_features = false }
 itertools = { version = "0.10.3", default_features = false }
 clap = { version = "4.5.3", features = ["derive"] }
+clap_complete = "4.5.2"
 serde = { version = "1.0.126", features = ["derive"], optional = true }
 serde_json = { version = "1.0.97", default_features = false, features = [
     "float_roundtrip",

docs/python/requirements-docs.txt

@@ -1,4 +1,4 @@
-ezkl==0.0.0
+ezkl==11.2.3
 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.2.3'
 version = release
 
 

src/bin/ezkl.rs

@@ -1,7 +1,7 @@
 // ignore file if compiling for wasm
 
 #[cfg(not(target_arch = "wasm32"))]
-use clap::Parser;
+use clap::{CommandFactory, Parser};
 #[cfg(not(target_arch = "wasm32"))]
 use colored_json::ToColoredJson;
 #[cfg(not(target_arch = "wasm32"))]
@@ -24,22 +24,30 @@ use std::error::Error;
 #[cfg(not(target_arch = "wasm32"))]
 pub async fn main() -> Result<(), Box<dyn Error>> {
     let args = Cli::parse();
-    init_logger();
-    #[cfg(not(any(target_arch = "wasm32", feature = "no-banner")))]
-    banner();
-    #[cfg(feature = "icicle")]
-    if env::var("ENABLE_ICICLE_GPU").is_ok() {
-        info!("Running with ICICLE GPU");
+
+    if let Some(generator) = args.generator {
+        ezkl::commands::print_completions(generator, &mut Cli::command());
+        Ok(())
+    } else if let Some(command) = args.command {
+        init_logger();
+        #[cfg(not(any(target_arch = "wasm32", feature = "no-banner")))]
+        banner();
+        #[cfg(feature = "icicle")]
+        if env::var("ENABLE_ICICLE_GPU").is_ok() {
+            info!("Running with ICICLE GPU");
+        } else {
+            info!("Running with CPU");
+        }
+        info!("command: \n {}", &command.as_json().to_colored_json_auto()?);
+        let res = run(command).await;
+        match &res {
+            Ok(_) => info!("succeeded"),
+            Err(e) => error!("failed: {}", e),
+        };
+        res.map(|_| ())
     } else {
-        info!("Running with CPU");
+        Err("No command provided".into())
     }
-    info!("command: \n {}", &args.as_json()?.to_colored_json_auto()?);
-    let res = run(args.command).await;
-    match &res {
-        Ok(_) => info!("succeeded"),
-        Err(e) => error!("failed: {}", e),
-    };
-    res.map(|_| ())
 }
 
 #[cfg(target_arch = "wasm32")]

src/commands.rs

@@ -1,6 +1,7 @@
 #[cfg(not(target_arch = "wasm32"))]
 use alloy::primitives::Address as H160;
-use clap::{Parser, Subcommand};
+use clap::{Command, Parser, Subcommand};
+use clap_complete::{generate, Generator, Shell};
 #[cfg(feature = "python-bindings")]
 use pyo3::{
     conversion::{FromPyObject, PyTryFrom},
@@ -10,7 +11,7 @@ use pyo3::{
 };
 use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
-use std::{error::Error, str::FromStr};
+use std::str::FromStr;
 use tosubcommand::{ToFlags, ToSubcommand};
 
 use crate::{pfsys::ProofType, Commitments, RunArgs};
@@ -52,6 +53,8 @@ pub const DEFAULT_VERIFIER_AGGREGATED_ABI: &str = "verifier_aggr_abi.json";
 pub const DEFAULT_VERIFIER_DA_ABI: &str = "verifier_da_abi.json";
 /// Default solidity code
 pub const DEFAULT_SOL_CODE: &str = "evm_deploy.sol";
+/// Default calldata path
+pub const DEFAULT_CALLDATA: &str = "calldata.bytes";
 /// Default solidity code for aggregated proofs
 pub const DEFAULT_SOL_CODE_AGGREGATED: &str = "evm_deploy_aggr.sol";
 /// Default solidity code for data attestation
@@ -253,33 +256,66 @@ lazy_static! {
     };
 }
 
-#[allow(missing_docs)]
-#[derive(Parser, Debug, Clone, Deserialize, Serialize)]
-#[command(author, about, long_about = None)]
-#[clap(version = *VERSION)]
-pub struct Cli {
-    #[command(subcommand)]
-    #[allow(missing_docs)]
-    pub command: Commands,
+/// Get the styles for the CLI
+pub fn get_styles() -> clap::builder::Styles {
+    clap::builder::Styles::styled()
+        .usage(
+            clap::builder::styling::Style::new()
+                .bold()
+                .underline()
+                .fg_color(Some(clap::builder::styling::Color::Ansi(clap::builder::styling::AnsiColor::Cyan))),
+        )
+        .header(
+            clap::builder::styling::Style::new()
+                .bold()
+                .underline()
+                .fg_color(Some(clap::builder::styling::Color::Ansi(clap::builder::styling::AnsiColor::Cyan))),
+        )
+        .literal(
+            clap::builder::styling::Style::new().fg_color(Some(clap::builder::styling::Color::Ansi(clap::builder::styling::AnsiColor::Magenta))),
+        )
+        .invalid(
+            clap::builder::styling::Style::new()
+                .bold()
+                .fg_color(Some(clap::builder::styling::Color::Ansi(clap::builder::styling::AnsiColor::Red))),
+        )
+        .error(
+            clap::builder::styling::Style::new()
+                .bold()
+                .fg_color(Some(clap::builder::styling::Color::Ansi(clap::builder::styling::AnsiColor::Red))),
+        )
+        .valid(
+            clap::builder::styling::Style::new()
+                .bold()
+                .underline()
+                .fg_color(Some(clap::builder::styling::Color::Ansi(clap::builder::styling::AnsiColor::Green))),
+        )
+        .placeholder(
+            clap::builder::styling::Style::new().fg_color(Some(clap::builder::styling::Color::Ansi(clap::builder::styling::AnsiColor::White))),
+        )
 }
 
-impl Cli {
-    /// Export the ezkl configuration as json
-    pub fn as_json(&self) -> Result<String, Box<dyn Error>> {
-        let serialized = match serde_json::to_string(&self) {
-            Ok(s) => s,
-            Err(e) => {
-                return Err(Box::new(e));
-            }
-        };
-        Ok(serialized)
-    }
-    /// Parse an ezkl configuration from a json
-    pub fn from_json(arg_json: &str) -> Result<Self, serde_json::Error> {
-        serde_json::from_str(arg_json)
-    }
+
+/// Print completions for the given generator
+pub fn print_completions<G: Generator>(gen: G, cmd: &mut Command) {
+    generate(gen, cmd, cmd.get_name().to_string(), &mut std::io::stdout());
 }
 
+
+#[allow(missing_docs)]
+#[derive(Parser, Debug, Clone)]
+#[command(author, about, long_about = None)]
+#[clap(version = *VERSION, styles = get_styles(), trailing_var_arg = true)]
+pub struct Cli {
+    /// If provided, outputs the completion file for given shell
+    #[clap(long = "generate", value_parser)]
+    pub generator: Option<Shell>,
+    #[command(subcommand)]
+    #[allow(missing_docs)]
+    pub command: Option<Commands>,
+}
+
+
 #[allow(missing_docs)]
 #[derive(Debug, Subcommand, Clone, Deserialize, Serialize, PartialEq, PartialOrd, ToSubcommand)]
 pub enum Commands {
@@ -289,7 +325,7 @@ pub enum Commands {
     /// Loads model and prints model table
     Table {
         /// The path to the .onnx model file
-        #[arg(short = 'M', long, default_value = DEFAULT_MODEL)]
+        #[arg(short = 'M', long, default_value = DEFAULT_MODEL, value_hint = clap::ValueHint::FilePath)]
         model: Option<PathBuf>,
         /// proving arguments
         #[clap(flatten)]
@@ -299,29 +335,29 @@ pub enum Commands {
     /// Generates the witness from an input file.
     GenWitness {
         /// The path to the .json data file
-        #[arg(short = 'D', long, default_value = DEFAULT_DATA)]
+        #[arg(short = 'D', long, default_value = DEFAULT_DATA, value_hint = clap::ValueHint::FilePath)]
         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)]
+        #[arg(short = 'M', long, default_value = DEFAULT_COMPILED_CIRCUIT, value_hint = clap::ValueHint::FilePath)]
         compiled_circuit: Option<PathBuf>,
         /// Path to output the witness .json file
-        #[arg(short = 'O', long, default_value = DEFAULT_WITNESS)]
+        #[arg(short = 'O', long, default_value = DEFAULT_WITNESS, value_hint = clap::ValueHint::FilePath)]
         output: Option<PathBuf>,
         /// Path to the verification key file (optional - solely used to generate kzg commits)
-        #[arg(short = 'V', long)]
+        #[arg(short = 'V', long, value_hint = clap::ValueHint::FilePath)]
         vk_path: Option<PathBuf>,
         /// Path to the srs file (optional - solely used to generate kzg commits)
-        #[arg(short = 'P', long)]
+        #[arg(short = 'P', long, value_hint = clap::ValueHint::FilePath)]
         srs_path: Option<PathBuf>,
     },
 
     /// Produces the proving hyperparameters, from run-args
     GenSettings {
         /// The path to the .onnx model file
-        #[arg(short = 'M', long, default_value = DEFAULT_MODEL)]
+        #[arg(short = 'M', long, default_value = DEFAULT_MODEL, value_hint = clap::ValueHint::FilePath)]
         model: Option<PathBuf>,
         /// The path to generate the circuit settings .json file to
-        #[arg(short = 'O', long, default_value = DEFAULT_SETTINGS)]
+        #[arg(short = 'O', long, default_value = DEFAULT_SETTINGS, value_hint = clap::ValueHint::FilePath)]
         settings_path: Option<PathBuf>,
         /// proving arguments
         #[clap(flatten)]
@@ -332,33 +368,34 @@ pub enum Commands {
     #[cfg(not(target_arch = "wasm32"))]
     CalibrateSettings {
         /// The path to the .json calibration data file.
-        #[arg(short = 'D', long, default_value = DEFAULT_CALIBRATION_FILE)]
+        #[arg(short = 'D', long, default_value = DEFAULT_CALIBRATION_FILE, value_hint = clap::ValueHint::FilePath)]
         data: Option<PathBuf>,
         /// The path to the .onnx model file
-        #[arg(short = 'M', long, default_value = DEFAULT_MODEL)]
+        #[arg(short = 'M', long, default_value = DEFAULT_MODEL, value_hint = clap::ValueHint::FilePath)]
         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)]
+        #[arg(short = 'O', long, default_value = DEFAULT_SETTINGS, value_hint = clap::ValueHint::FilePath)]
         settings_path: Option<PathBuf>,
-        #[arg(long = "target", default_value = DEFAULT_CALIBRATION_TARGET)]
+        #[arg(long = "target", default_value = DEFAULT_CALIBRATION_TARGET, value_hint = clap::ValueHint::Other)]
         /// Target for calibration. Set to "resources" to optimize for computational resource. Otherwise, set to "accuracy" to optimize for accuracy.
         target: CalibrationTarget,
         /// the lookup safety margin to use for calibration. if the max lookup is 2^k, then the max lookup will be 2^k * lookup_safety_margin. larger = safer but slower
-        #[arg(long, default_value = DEFAULT_LOOKUP_SAFETY_MARGIN)]
+        #[arg(long, default_value = DEFAULT_LOOKUP_SAFETY_MARGIN, value_hint = clap::ValueHint::Other)]
         lookup_safety_margin: i64,
         /// Optional scales to specifically try for calibration. Example, --scales 0,4
-        #[arg(long, value_delimiter = ',', allow_hyphen_values = true)]
+        #[arg(long, value_delimiter = ',', allow_hyphen_values = true, value_hint = clap::ValueHint::Other)]
         scales: Option<Vec<crate::Scale>>,
         /// Optional scale rebase multipliers to specifically try for calibration. This is the multiplier at which we divide to return to the input scale. Example, --scale-rebase-multipliers 0,4
         #[arg(
             long,
             value_delimiter = ',',
             allow_hyphen_values = true,
-            default_value = DEFAULT_SCALE_REBASE_MULTIPLIERS
+            default_value = DEFAULT_SCALE_REBASE_MULTIPLIERS,
+            value_hint = clap::ValueHint::Other
         )]
         scale_rebase_multiplier: Vec<u32>,
         /// max logrows to use for calibration, 26 is the max public SRS size
-        #[arg(long)]
+        #[arg(long, value_hint = clap::ValueHint::Other)]
         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, action = clap::ArgAction::SetTrue)]
@@ -369,13 +406,13 @@ pub enum Commands {
     #[command(name = "gen-srs", arg_required_else_help = true)]
     GenSrs {
         /// The path to output the generated SRS
-        #[arg(long)]
+        #[arg(long, value_hint = clap::ValueHint::FilePath)]
         srs_path: PathBuf,
         /// number of logrows to use for srs
-        #[arg(long)]
+        #[arg(long, value_hint = clap::ValueHint::Other)]
         logrows: usize,
         /// commitment used
-        #[arg(long, default_value = DEFAULT_COMMITMENT)]
+        #[arg(long, default_value = DEFAULT_COMMITMENT, value_hint = clap::ValueHint::Other)]
         commitment: Option<Commitments>,
     },
 
@@ -384,57 +421,57 @@ pub enum Commands {
     #[command(name = "get-srs")]
     GetSrs {
         /// The path to output the desired srs file, if set to None will save to $EZKL_REPO_PATH/srs
-        #[arg(long)]
+        #[arg(long, default_value = None, value_hint = clap::ValueHint::FilePath)]
         srs_path: Option<PathBuf>,
         /// Path to the circuit settings .json file to read in logrows from. Overriden by logrows if specified.
-        #[arg(short = 'S', long, default_value = DEFAULT_SETTINGS)]
+        #[arg(short = 'S', long, default_value = DEFAULT_SETTINGS, value_hint = clap::ValueHint::FilePath)]
         settings_path: Option<PathBuf>,
         /// Number of logrows to use for srs. Overrides settings_path if specified.
-        #[arg(long, default_value = None)]
+        #[arg(long, default_value = None, value_hint = clap::ValueHint::Other)]
         logrows: Option<u32>,
         /// Commitment used
-        #[arg(long, default_value = None)]
+        #[arg(long, default_value = None, value_hint = clap::ValueHint::Other)]
         commitment: Option<Commitments>,
     },
     /// Loads model and input and runs mock prover (for testing)
     Mock {
         /// The path to the .json witness file (generated using the gen-witness command)
-        #[arg(short = 'W', long, default_value = DEFAULT_WITNESS)]
+        #[arg(short = 'W', long, default_value = DEFAULT_WITNESS, value_hint = clap::ValueHint::FilePath)]
         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)]
+        #[arg(short = 'M', long, default_value = DEFAULT_COMPILED_CIRCUIT, value_hint = clap::ValueHint::FilePath)]
         model: Option<PathBuf>,
     },
 
     /// Mock aggregate proofs
     MockAggregate {
         /// The path to the snarks to aggregate over (generated using the prove command with the --proof-type=for-aggr flag)
-        #[arg(long, default_value = DEFAULT_PROOF, value_delimiter = ',', allow_hyphen_values = true)]
+        #[arg(long, default_value = DEFAULT_PROOF, value_delimiter = ',', allow_hyphen_values = true, value_hint = clap::ValueHint::FilePath)]
         aggregation_snarks: Vec<PathBuf>,
         /// logrows used for aggregation circuit
-        #[arg(long, default_value = DEFAULT_AGGREGATED_LOGROWS)]
+        #[arg(long, default_value = DEFAULT_AGGREGATED_LOGROWS, value_hint = clap::ValueHint::Other)]
         logrows: Option<u32>,
         /// whether the accumulated are segments of a larger proof
         #[arg(long, default_value = DEFAULT_SPLIT, action = clap::ArgAction::SetTrue)]
         split_proofs: Option<bool>,
     },
 
-    /// setup aggregation circuit :)
+    /// Setup aggregation circuit and generate pk and vk
     SetupAggregate {
         /// The path to samples of snarks that will be aggregated over (generated using the prove command with the --proof-type=for-aggr flag)
-        #[arg(long, default_value = DEFAULT_PROOF, value_delimiter = ',', allow_hyphen_values = true)]
+        #[arg(long, default_value = DEFAULT_PROOF, value_delimiter = ',', allow_hyphen_values = true, value_hint = clap::ValueHint::FilePath)]
         sample_snarks: Vec<PathBuf>,
         /// The path to save the desired verification key file to
-        #[arg(long, default_value = DEFAULT_VK_AGGREGATED)]
+        #[arg(long, default_value = DEFAULT_VK_AGGREGATED, value_hint = clap::ValueHint::FilePath)]
         vk_path: Option<PathBuf>,
         /// The path to save the proving key to
-        #[arg(long, default_value = DEFAULT_PK_AGGREGATED)]
+        #[arg(long, default_value = DEFAULT_PK_AGGREGATED, value_hint = clap::ValueHint::FilePath)]
         pk_path: Option<PathBuf>,
         /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
-        #[arg(long)]
+        #[arg(long, value_hint = clap::ValueHint::FilePath)]
         srs_path: Option<PathBuf>,
         /// logrows used for aggregation circuit
-        #[arg(long, default_value = DEFAULT_AGGREGATED_LOGROWS)]
+        #[arg(long, default_value = DEFAULT_AGGREGATED_LOGROWS, value_hint = clap::ValueHint::Other)]
         logrows: Option<u32>,
         /// whether the accumulated are segments of a larger proof
         #[arg(long, default_value = DEFAULT_SPLIT, action = clap::ArgAction::SetTrue)]
@@ -443,19 +480,19 @@ pub enum Commands {
         #[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)]
+        #[arg(long, default_value = DEFAULT_COMMITMENT, value_hint = clap::ValueHint::Other)]
         commitment: Option<Commitments>,
     },
-    /// Aggregates proofs :)
+    /// Aggregates proofs
     Aggregate {
         /// The path to the snarks to aggregate over (generated using the prove command with the --proof-type=for-aggr flag)
-        #[arg(long, default_value = DEFAULT_PROOF, value_delimiter = ',', allow_hyphen_values = true)]
+        #[arg(long, default_value = DEFAULT_PROOF, value_delimiter = ',', allow_hyphen_values = true, value_hint = clap::ValueHint::FilePath)]
         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)]
+        #[arg(long, default_value = DEFAULT_PK_AGGREGATED, value_hint = clap::ValueHint::FilePath)]
         pk_path: Option<PathBuf>,
         /// The path to output the proof file to
-        #[arg(long, default_value = DEFAULT_PROOF_AGGREGATED)]
+        #[arg(long, default_value = DEFAULT_PROOF_AGGREGATED, value_hint = clap::ValueHint::FilePath)]
         proof_path: Option<PathBuf>,
         /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
         #[arg(long)]
@@ -465,50 +502,51 @@ pub enum Commands {
             require_equals = true,
             num_args = 0..=1,
             default_value_t = TranscriptType::default(),
-            value_enum
+            value_enum, 
+            value_hint = clap::ValueHint::Other
         )]
         transcript: TranscriptType,
         /// logrows used for aggregation circuit
-        #[arg(long, default_value = DEFAULT_AGGREGATED_LOGROWS)]
+        #[arg(long, default_value = DEFAULT_AGGREGATED_LOGROWS, value_hint = clap::ValueHint::Other)]
         logrows: Option<u32>,
         /// run sanity checks during calculations (safe or unsafe)
-        #[arg(long, default_value = DEFAULT_CHECKMODE)]
+        #[arg(long, default_value = DEFAULT_CHECKMODE, value_hint = clap::ValueHint::Other)]
         check_mode: Option<CheckMode>,
         /// whether the accumulated proofs are segments of a larger circuit
         #[arg(long, default_value = DEFAULT_SPLIT, action = clap::ArgAction::SetTrue)]
         split_proofs: Option<bool>,
         /// commitment used
-        #[arg(long, default_value = DEFAULT_COMMITMENT)]
+        #[arg(long, default_value = DEFAULT_COMMITMENT, value_hint = clap::ValueHint::Other)]
         commitment: Option<Commitments>,
     },
     /// Compiles a circuit from onnx to a simplified graph (einsum + other ops) and parameters as sets of field elements
     CompileCircuit {
         /// The path to the .onnx model file
-        #[arg(short = 'M', long, default_value = DEFAULT_MODEL)]
+        #[arg(short = 'M', long, default_value = DEFAULT_MODEL, value_hint = clap::ValueHint::FilePath)]
         model: Option<PathBuf>,
         /// The path to the compiled model file (generated using the compile-circuit command)
-        #[arg(long, default_value = DEFAULT_COMPILED_CIRCUIT)]
+        #[arg(long, default_value = DEFAULT_COMPILED_CIRCUIT, value_hint = clap::ValueHint::FilePath)]
         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)]
+        #[arg(short = 'S', long, default_value = DEFAULT_SETTINGS, value_hint = clap::ValueHint::FilePath)]
         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)]
+        #[arg(short = 'M', long, default_value = DEFAULT_COMPILED_CIRCUIT, value_hint = clap::ValueHint::FilePath)]
         compiled_circuit: Option<PathBuf>,
         /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
-        #[arg(long)]
+        #[arg(long, value_hint = clap::ValueHint::FilePath)]
         srs_path: Option<PathBuf>,
         /// The path to output the verification key file to
-        #[arg(long, default_value = DEFAULT_VK)]
+        #[arg(long, default_value = DEFAULT_VK, value_hint = clap::ValueHint::FilePath)]
         vk_path: Option<PathBuf>,
         /// The path to output the proving key file to
-        #[arg(long, default_value = DEFAULT_PK)]
+        #[arg(long, default_value = DEFAULT_PK, value_hint = clap::ValueHint::FilePath)]
         pk_path: Option<PathBuf>,
         /// The graph witness (optional - used to override fixed values in the circuit)
-        #[arg(short = 'W', long)]
+        #[arg(short = 'W', long, value_hint = clap::ValueHint::FilePath)]
         witness: Option<PathBuf>,
         /// compress selectors
         #[arg(long, default_value = DEFAULT_DISABLE_SELECTOR_COMPRESSION, action = clap::ArgAction::SetTrue)]
@@ -519,24 +557,24 @@ pub enum Commands {
     #[command(arg_required_else_help = true)]
     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)]
+        #[arg(short = 'D', long, value_hint = clap::ValueHint::FilePath)]
         data: Option<PathBuf>,
         /// The path to the compiled model file (generated using the compile-circuit command)
-        #[arg(short = 'M', long)]
+        #[arg(short = 'M', long, value_hint = clap::ValueHint::FilePath)]
         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)
-        #[arg(short = 'T', long)]
+        #[arg(short = 'T', long, value_hint = clap::ValueHint::FilePath)]
         test_data: PathBuf,
         /// RPC URL for an Ethereum node, if None will use Anvil but WON'T persist state
-        #[arg(short = 'U', long)]
+        #[arg(short = 'U', long, value_hint = clap::ValueHint::Url)]
         rpc_url: Option<String>,
         /// where the input data come from
-        #[arg(long, default_value = "on-chain")]
+        #[arg(long, default_value = "on-chain", value_hint = clap::ValueHint::Other)]
         input_source: TestDataSource,
         /// where the output data come from
-        #[arg(long, default_value = "on-chain")]
+        #[arg(long, default_value = "on-chain", value_hint = clap::ValueHint::Other)]
         output_source: TestDataSource,
     },
     #[cfg(not(target_arch = "wasm32"))]
@@ -544,23 +582,23 @@ pub enum Commands {
     #[command(arg_required_else_help = true)]
     TestUpdateAccountCalls {
         /// The path to the verifier contract's address
-        #[arg(long)]
+        #[arg(long, value_hint = clap::ValueHint::Other)]
         addr: H160Flag,
         /// The path to the .json data file.
-        #[arg(short = 'D', long)]
+        #[arg(short = 'D', long, value_hint = clap::ValueHint::FilePath)]
         data: Option<PathBuf>,
         /// RPC URL for an Ethereum node, if None will use Anvil but WON'T persist state
-        #[arg(short = 'U', long)]
+        #[arg(short = 'U', long, value_hint = clap::ValueHint::Url)]
         rpc_url: Option<String>,
     },
     #[cfg(not(target_arch = "wasm32"))]
     /// Swaps the positions in the transcript that correspond to commitments
     SwapProofCommitments {
         /// The path to the proof file
-        #[arg(short = 'P', long, default_value = DEFAULT_PROOF)]
+        #[arg(short = 'P', long, default_value = DEFAULT_PROOF, value_hint = clap::ValueHint::FilePath)]
         proof_path: Option<PathBuf>,
         /// The path to the witness file
-        #[arg(short = 'W', long, default_value = DEFAULT_WITNESS)]
+        #[arg(short = 'W', long, default_value = DEFAULT_WITNESS, value_hint = clap::ValueHint::FilePath)]
         witness_path: Option<PathBuf>,
     },
 
@@ -568,50 +606,65 @@ pub enum Commands {
     /// Loads model, data, and creates proof
     Prove {
         /// The path to the .json witness file (generated using the gen-witness command)
-        #[arg(short = 'W', long, default_value = DEFAULT_WITNESS)]
+        #[arg(short = 'W', long, default_value = DEFAULT_WITNESS, value_hint = clap::ValueHint::FilePath)]
         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)]
+        #[arg(short = 'M', long, default_value = DEFAULT_COMPILED_CIRCUIT, value_hint = clap::ValueHint::FilePath)]
         compiled_circuit: Option<PathBuf>,
         /// The path to load the desired proving key file (generated using the setup command)
-        #[arg(long, default_value = DEFAULT_PK)]
+        #[arg(long, default_value = DEFAULT_PK, value_hint = clap::ValueHint::FilePath)]
         pk_path: Option<PathBuf>,
         /// The path to output the proof file to
-        #[arg(long, default_value = DEFAULT_PROOF)]
+        #[arg(long, default_value = DEFAULT_PROOF, value_hint = clap::ValueHint::FilePath)]
         proof_path: Option<PathBuf>,
         /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
-        #[arg(long)]
+        #[arg(long, value_hint = clap::ValueHint::FilePath)]
         srs_path: Option<PathBuf>,
         #[arg(
             long,
             require_equals = true,
             num_args = 0..=1,
             default_value_t = ProofType::Single,
-            value_enum
+            value_enum, 
+            value_hint = clap::ValueHint::Other
         )]
         proof_type: ProofType,
         /// run sanity checks during calculations (safe or unsafe)
-        #[arg(long, default_value = DEFAULT_CHECKMODE)]
+        #[arg(long, default_value = DEFAULT_CHECKMODE, value_hint = clap::ValueHint::Other)]
         check_mode: Option<CheckMode>,
     },
     #[cfg(not(target_arch = "wasm32"))]
+    /// Encodes a proof into evm calldata
+    #[command(name = "encode-evm-calldata")]
+    EncodeEvmCalldata {
+        /// The path to the proof file (generated using the prove command)
+        #[arg(long, default_value = DEFAULT_PROOF, value_hint = clap::ValueHint::FilePath)]
+        proof_path: Option<PathBuf>,
+        /// The path to save the calldata to
+        #[arg(long, default_value = DEFAULT_CALLDATA, value_hint = clap::ValueHint::FilePath)]
+        calldata_path: Option<PathBuf>,
+        /// The path to the verification key address (only used if the vk is rendered as a separate contract)
+        #[arg(long, value_hint = clap::ValueHint::Other)]
+        addr_vk: Option<H160Flag>,
+    },
+    #[cfg(not(target_arch = "wasm32"))]
     /// Creates an Evm verifier for a single proof
     #[command(name = "create-evm-verifier")]
     CreateEvmVerifier {
         /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
-        #[arg(long)]
+        #[arg(long, value_hint = clap::ValueHint::FilePath)]
         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)]
+        #[arg(short = 'S', long, default_value = DEFAULT_SETTINGS, value_hint = clap::ValueHint::FilePath)]
         settings_path: Option<PathBuf>,
         /// The path to load the desired verification key file
-        #[arg(long, default_value = DEFAULT_VK)]
+        #[arg(long, default_value = DEFAULT_VK, value_hint = clap::ValueHint::FilePath)]
         vk_path: Option<PathBuf>,
         /// The path to output the Solidity code
-        #[arg(long, default_value = DEFAULT_SOL_CODE)]
+        #[arg(long, default_value = DEFAULT_SOL_CODE, value_hint = clap::ValueHint::FilePath)]
         sol_code_path: Option<PathBuf>,
         /// The path to output the Solidity verifier ABI
-        #[arg(long, default_value = DEFAULT_VERIFIER_ABI)]
+        #[arg(long, default_value = DEFAULT_VERIFIER_ABI, value_hint = clap::ValueHint::FilePath)]
         abi_path: Option<PathBuf>,
         /// Whether the verifier key should be rendered as a separate contract.
         /// We recommend disabling selector compression if this is enabled.
@@ -624,19 +677,19 @@ pub enum Commands {
     #[command(name = "create-evm-vk")]
     CreateEvmVK {
         /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
-        #[arg(long)]
+        #[arg(long, value_hint = clap::ValueHint::FilePath)]
         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)]
+        #[arg(short = 'S', long, default_value = DEFAULT_SETTINGS, value_hint = clap::ValueHint::FilePath)]
         settings_path: Option<PathBuf>,
         /// The path to load the desired verification key file
-        #[arg(long, default_value = DEFAULT_VK)]
+        #[arg(long, default_value = DEFAULT_VK, value_hint = clap::ValueHint::FilePath)]
         vk_path: Option<PathBuf>,
         /// The path to output the Solidity code
-        #[arg(long, default_value = DEFAULT_VK_SOL)]
+        #[arg(long, default_value = DEFAULT_VK_SOL, value_hint = clap::ValueHint::FilePath)]
         sol_code_path: Option<PathBuf>,
         /// The path to output the Solidity verifier ABI
-        #[arg(long, default_value = DEFAULT_VK_ABI)]
+        #[arg(long, default_value = DEFAULT_VK_ABI, value_hint = clap::ValueHint::FilePath)]
         abi_path: Option<PathBuf>,
     },
     #[cfg(not(target_arch = "wasm32"))]
@@ -644,20 +697,20 @@ pub enum Commands {
     #[command(name = "create-evm-da")]
     CreateEvmDataAttestation {
         /// The path to load circuit settings .json file from (generated using the gen-settings command)
-        #[arg(short = 'S', long, default_value = DEFAULT_SETTINGS)]
+        #[arg(short = 'S', long, default_value = DEFAULT_SETTINGS, value_hint = clap::ValueHint::FilePath)]
         settings_path: Option<PathBuf>,
         /// The path to output the Solidity code
-        #[arg(long, default_value = DEFAULT_SOL_CODE_DA)]
+        #[arg(long, default_value = DEFAULT_SOL_CODE_DA, value_hint = clap::ValueHint::FilePath)]
         sol_code_path: Option<PathBuf>,
         /// The path to output the Solidity verifier ABI
-        #[arg(long, default_value = DEFAULT_VERIFIER_DA_ABI)]
+        #[arg(long, default_value = DEFAULT_VERIFIER_DA_ABI, value_hint = clap::ValueHint::FilePath)]
         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)]
+        #[arg(short = 'D', long, default_value = DEFAULT_DATA, value_hint = clap::ValueHint::FilePath)]
         data: Option<PathBuf>,
     },
 
@@ -666,22 +719,22 @@ pub enum Commands {
     #[command(name = "create-evm-verifier-aggr")]
     CreateEvmVerifierAggr {
         /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
-        #[arg(long)]
+        #[arg(long, value_hint = clap::ValueHint::FilePath)]
         srs_path: Option<PathBuf>,
         /// The path to load the desired verification key file
-        #[arg(long, default_value = DEFAULT_VK_AGGREGATED)]
+        #[arg(long, default_value = DEFAULT_VK_AGGREGATED, value_hint = clap::ValueHint::FilePath)]
         vk_path: Option<PathBuf>,
         /// The path to the Solidity code
-        #[arg(long, default_value = DEFAULT_SOL_CODE_AGGREGATED)]
+        #[arg(long, default_value = DEFAULT_SOL_CODE_AGGREGATED, value_hint = clap::ValueHint::FilePath)]
         sol_code_path: Option<PathBuf>,
         /// The path to output the Solidity verifier ABI
-        #[arg(long, default_value = DEFAULT_VERIFIER_AGGREGATED_ABI)]
+        #[arg(long, default_value = DEFAULT_VERIFIER_AGGREGATED_ABI, value_hint = clap::ValueHint::FilePath)]
         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)]
+        #[arg(long, default_value = DEFAULT_SETTINGS, value_delimiter = ',', allow_hyphen_values = true, value_hint = clap::ValueHint::FilePath)]
         aggregation_settings: Vec<PathBuf>,
         // logrows used for aggregation circuit
-        #[arg(long, default_value = DEFAULT_AGGREGATED_LOGROWS)]
+        #[arg(long, default_value = DEFAULT_AGGREGATED_LOGROWS, value_hint = clap::ValueHint::Other)]
         logrows: Option<u32>,
         /// Whether the verifier key should be rendered as a separate contract.
         /// We recommend disabling selector compression if this is enabled.
@@ -692,16 +745,16 @@ pub enum Commands {
     /// 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)]
+        #[arg(short = 'S', long, default_value = DEFAULT_SETTINGS, value_hint = clap::ValueHint::FilePath)]
         settings_path: Option<PathBuf>,
         /// The path to the proof file (generated using the prove command)
-        #[arg(long, default_value = DEFAULT_PROOF)]
+        #[arg(long, default_value = DEFAULT_PROOF, value_hint = clap::ValueHint::FilePath)]
         proof_path: Option<PathBuf>,
         /// The path to the verification key file (generated using the setup command)
-        #[arg(long, default_value = DEFAULT_VK)]
+        #[arg(long, default_value = DEFAULT_VK, value_hint = clap::ValueHint::FilePath)]
         vk_path: Option<PathBuf>,
         /// The path to SRS, if None will use $EZKL_REPO_PATH/srs/kzg{logrows}.srs
-        #[arg(long)]
+        #[arg(long, value_hint = clap::ValueHint::FilePath)]
         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, action = clap::ArgAction::SetTrue)]
@@ -710,60 +763,60 @@ pub enum Commands {
     /// 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)]
+        #[arg(long, default_value = DEFAULT_PROOF_AGGREGATED, value_hint = clap::ValueHint::FilePath)]
         proof_path: Option<PathBuf>,
         /// The path to the verification key file (generated using the setup-aggregate command)
-        #[arg(long, default_value = DEFAULT_VK_AGGREGATED)]
+        #[arg(long, default_value = DEFAULT_VK_AGGREGATED, value_hint = clap::ValueHint::FilePath)]
         vk_path: Option<PathBuf>,
         /// reduced srs
         #[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)]
+        #[arg(long, value_hint = clap::ValueHint::FilePath)]
         srs_path: Option<PathBuf>,
         /// logrows used for aggregation circuit
-        #[arg(long, default_value = DEFAULT_AGGREGATED_LOGROWS)]
+        #[arg(long, default_value = DEFAULT_AGGREGATED_LOGROWS, value_hint = clap::ValueHint::Other)]
         logrows: Option<u32>,
         /// commitment
-        #[arg(long, default_value = DEFAULT_COMMITMENT)]
+        #[arg(long, default_value = DEFAULT_COMMITMENT, value_hint = clap::ValueHint::Other)]
         commitment: Option<Commitments>,
     },
     #[cfg(not(target_arch = "wasm32"))]
     /// Deploys an evm verifier that is generated by ezkl
     DeployEvmVerifier {
         /// The path to the Solidity code (generated using the create-evm-verifier command)
-        #[arg(long, default_value = DEFAULT_SOL_CODE)]
+        #[arg(long, default_value = DEFAULT_SOL_CODE, value_hint = clap::ValueHint::FilePath)]
         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)]
+        #[arg(short = 'U', long, value_hint = clap::ValueHint::Url)]
         rpc_url: Option<String>,
-        #[arg(long, default_value = DEFAULT_CONTRACT_ADDRESS)]
+        #[arg(long, default_value = DEFAULT_CONTRACT_ADDRESS, value_hint = clap::ValueHint::Other)]
         /// The path to output the contract address
         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)]
+        #[arg(long, default_value = DEFAULT_OPTIMIZER_RUNS, value_hint = clap::ValueHint::Other)]
         optimizer_runs: usize,
         /// Private secp256K1 key in hex format, 64 chars, no 0x prefix, of the account signing transactions. If None the private key will be generated by Anvil
-        #[arg(short = 'P', long)]
+        #[arg(short = 'P', long, value_hint = clap::ValueHint::Other)]
         private_key: Option<String>,
     },
     #[cfg(not(target_arch = "wasm32"))]
     /// Deploys an evm verifier that is generated by ezkl
     DeployEvmVK {
         /// The path to the Solidity code (generated using the create-evm-verifier command)
-        #[arg(long, default_value = DEFAULT_VK_SOL)]
+        #[arg(long, default_value = DEFAULT_VK_SOL, value_hint = clap::ValueHint::FilePath)]
         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)]
+        #[arg(short = 'U', long, value_hint = clap::ValueHint::Url)]
         rpc_url: Option<String>,
-        #[arg(long, default_value = DEFAULT_CONTRACT_ADDRESS_VK)]
+        #[arg(long, default_value = DEFAULT_CONTRACT_ADDRESS_VK, value_hint = clap::ValueHint::Other)]
         /// The path to output the contract address
         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)]
+        #[arg(long, default_value = DEFAULT_OPTIMIZER_RUNS, value_hint = clap::ValueHint::Other)]
         optimizer_runs: usize,
         /// Private secp256K1 key in hex format, 64 chars, no 0x prefix, of the account signing transactions. If None the private key will be generated by Anvil
-        #[arg(short = 'P', long)]
+        #[arg(short = 'P', long, value_hint = clap::ValueHint::Other)]
         private_key: Option<String>,
     },
     #[cfg(not(target_arch = "wasm32"))]
@@ -771,25 +824,25 @@ pub enum Commands {
     #[command(name = "deploy-evm-da")]
     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)]
+        #[arg(short = 'D', long, default_value = DEFAULT_DATA, value_hint = clap::ValueHint::FilePath)]
         data: Option<PathBuf>,
         /// The path to load circuit settings .json file from (generated using the gen-settings command)
-        #[arg(long, default_value = DEFAULT_SETTINGS)]
+        #[arg(long, default_value = DEFAULT_SETTINGS, value_hint = clap::ValueHint::FilePath)]
         settings_path: Option<PathBuf>,
         /// The path to the Solidity code
-        #[arg(long, default_value = DEFAULT_SOL_CODE_DA)]
+        #[arg(long, default_value = DEFAULT_SOL_CODE_DA, value_hint = clap::ValueHint::FilePath)]
         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)]
+        #[arg(short = 'U', long, value_hint = clap::ValueHint::Url)]
         rpc_url: Option<String>,
-        #[arg(long, default_value = DEFAULT_CONTRACT_ADDRESS_DA)]
+        #[arg(long, default_value = DEFAULT_CONTRACT_ADDRESS_DA, value_hint = clap::ValueHint::FilePath)]
         /// The path to output the contract address
         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)]
+        #[arg(long, default_value = DEFAULT_OPTIMIZER_RUNS, value_hint = clap::ValueHint::Other)]
         optimizer_runs: usize,
         /// Private secp256K1 key in hex format, 64 chars, no 0x prefix, of the account signing transactions. If None the private key will be generated by Anvil
-        #[arg(short = 'P', long)]
+        #[arg(short = 'P', long, value_hint = clap::ValueHint::Other)]
         private_key: Option<String>,
     },
     #[cfg(not(target_arch = "wasm32"))]
@@ -797,19 +850,32 @@ pub enum Commands {
     #[command(name = "verify-evm")]
     VerifyEvm {
         /// The path to the proof file (generated using the prove command)
-        #[arg(long, default_value = DEFAULT_PROOF)]
+        #[arg(long, default_value = DEFAULT_PROOF, value_hint = clap::ValueHint::FilePath)]
         proof_path: Option<PathBuf>,
         /// The path to verifier contract's address
-        #[arg(long, default_value = DEFAULT_CONTRACT_ADDRESS)]
+        #[arg(long, default_value = DEFAULT_CONTRACT_ADDRESS, value_hint = clap::ValueHint::Other)]
         addr_verifier: H160Flag,
         /// RPC URL for an Ethereum node, if None will use Anvil but WON'T persist state
-        #[arg(short = 'U', long)]
+        #[arg(short = 'U', long, value_hint = clap::ValueHint::Url)]
         rpc_url: Option<String>,
         /// does the verifier use data attestation ?
-        #[arg(long)]
+        #[arg(long, value_hint = clap::ValueHint::Other)]
         addr_da: Option<H160Flag>,
         // is the vk rendered seperately, if so specify an address
-        #[arg(long)]
+        #[arg(long, value_hint = clap::ValueHint::Other)]
         addr_vk: Option<H160Flag>,
     },
 }
+
+
+impl Commands {
+    /// Converts the commands to a json string
+    pub fn as_json(&self) -> String {
+        serde_json::to_string(self).unwrap()
+    }
+
+    /// Converts a json string to a Commands struct
+    pub fn from_json(json: &str) -> Self {
+        serde_json::from_str(json).unwrap()
+    }
+}

src/eth.rs

@@ -922,13 +922,15 @@ pub async fn get_contract_artifacts(
         return Err(format!("file not found: {:#?}", sol_code_path).into());
     }
 
-    let mut settings = SolcSettings::default();
-    settings.optimizer = Optimizer {
-        enabled: Some(true),
-        runs: Some(runs),
-        details: None,
+    let settings = SolcSettings {
+        optimizer: Optimizer {
+            enabled: Some(true),
+            runs: Some(runs),
+            details: None,
+        },
+        output_selection: OutputSelection::default_output_selection(),
+        ..Default::default()
     };
-    settings.output_selection = OutputSelection::default_output_selection();
 
     let input = SolcInput::build(
         std::collections::BTreeMap::from([(

src/execute.rs

@@ -204,6 +204,18 @@ pub async fn run(command: Commands) -> Result<String, Box<dyn Error>> {
             )
             .await
         }
+        #[cfg(not(target_arch = "wasm32"))]
+        Commands::EncodeEvmCalldata {
+            proof_path,
+            calldata_path,
+            addr_vk,
+        } => encode_evm_calldata(
+            proof_path.unwrap_or(DEFAULT_PROOF.into()),
+            calldata_path.unwrap_or(DEFAULT_CALLDATA.into()),
+            addr_vk,
+        )
+        .map(|e| serde_json::to_string(&e).unwrap()),
+
         Commands::CreateEvmVK {
             vk_path,
             srs_path,
@@ -1530,6 +1542,32 @@ pub(crate) async fn deploy_evm(
     Ok(String::new())
 }
 
+/// Encodes the calldata for the EVM verifier (both aggregated and single proof)
+pub(crate) fn encode_evm_calldata(
+    proof_path: PathBuf,
+    calldata_path: PathBuf,
+    addr_vk: Option<H160Flag>,
+) -> Result<Vec<u8>, Box<dyn Error>> {
+    let snark = Snark::load::<IPACommitmentScheme<G1Affine>>(&proof_path)?;
+
+    let flattened_instances = snark.instances.into_iter().flatten();
+
+    let encoded = halo2_solidity_verifier::encode_calldata(
+        addr_vk
+            .as_ref()
+            .map(|x| alloy::primitives::Address::from(*x).0)
+            .map(|x| x.0),
+        &snark.proof,
+        &flattened_instances.collect::<Vec<_>>(),
+    );
+
+    log::debug!("Encoded calldata: {:?}", encoded);
+
+    File::create(calldata_path)?.write_all(encoded.as_slice())?;
+
+    Ok(encoded)
+}
+
 #[cfg(not(target_arch = "wasm32"))]
 pub(crate) async fn verify_evm(
     proof_path: PathBuf,

src/lib.rs

@@ -178,37 +178,37 @@ impl From<String> for Commitments {
 #[derive(Debug, Args, Deserialize, Serialize, Clone, PartialEq, PartialOrd, ToFlags)]
 pub struct RunArgs {
     /// The tolerance for error on model outputs
-    #[arg(short = 'T', long, default_value = "0")]
+    #[arg(short = 'T', long, default_value = "0", value_hint = clap::ValueHint::Other)]
     pub tolerance: Tolerance,
     /// The denominator in the fixed point representation used when quantizing inputs
-    #[arg(short = 'S', long, default_value = "7", allow_hyphen_values = true)]
+    #[arg(short = 'S', long, default_value = "7", value_hint = clap::ValueHint::Other)]
     pub input_scale: Scale,
     /// The denominator in the fixed point representation used when quantizing parameters
-    #[arg(long, default_value = "7", allow_hyphen_values = true)]
+    #[arg(long, default_value = "7", value_hint = clap::ValueHint::Other)]
     pub param_scale: Scale,
     /// if the scale is ever > scale_rebase_multiplier * input_scale then the scale is rebased to input_scale (this a more advanced parameter, use with caution)
-    #[arg(long, default_value = "1")]
+    #[arg(long, default_value = "1",  value_hint = clap::ValueHint::Other)]
     pub scale_rebase_multiplier: u32,
     /// The min and max elements in the lookup table input column
     #[arg(short = 'B', long, value_parser = parse_key_val::<i64, i64>, default_value = "-32768->32768")]
     pub lookup_range: Range,
     /// The log_2 number of rows
-    #[arg(short = 'K', long, default_value = "17")]
+    #[arg(short = 'K', long, default_value = "17", value_hint = clap::ValueHint::Other)]
     pub logrows: u32,
     /// The log_2 number of rows
-    #[arg(short = 'N', long, default_value = "2")]
+    #[arg(short = 'N', long, default_value = "2", value_hint = clap::ValueHint::Other)]
     pub num_inner_cols: usize,
     /// 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 = ',')]
+    #[arg(short = 'V', long, value_parser = parse_key_val::<String, usize>, default_value = "batch_size->1", value_delimiter = ',', value_hint = clap::ValueHint::Other)]
     pub variables: Vec<(String, usize)>,
     /// Flags whether inputs are public, private, fixed, hashed, polycommit
-    #[arg(long, default_value = "private")]
+    #[arg(long, default_value = "private", value_hint = clap::ValueHint::Other)]
     pub input_visibility: Visibility,
     /// Flags whether outputs are public, private, fixed, hashed, polycommit
-    #[arg(long, default_value = "public")]
+    #[arg(long, default_value = "public", value_hint = clap::ValueHint::Other)]
     pub output_visibility: Visibility,
     /// Flags whether params are fixed, private, hashed, polycommit
-    #[arg(long, default_value = "private")]
+    #[arg(long, default_value = "private", value_hint = clap::ValueHint::Other)]
     pub param_visibility: Visibility,
     #[arg(long, default_value = "false")]
     /// Rebase the scale using lookup table for division instead of using a range check
@@ -217,10 +217,10 @@ pub struct RunArgs {
     #[arg(long, default_value = "false")]
     pub rebase_frac_zero_constants: bool,
     /// check mode (safe, unsafe, etc)
-    #[arg(long, default_value = "unsafe")]
+    #[arg(long, default_value = "unsafe", value_hint = clap::ValueHint::Other)]
     pub check_mode: CheckMode,
     /// commitment scheme
-    #[arg(long, default_value = "kzg")]
+    #[arg(long, default_value = "kzg", value_hint = clap::ValueHint::Other)]
     pub commitment: Option<Commitments>,
 }
 

src/python.rs

@@ -1430,6 +1430,47 @@ fn verify_aggr(
     Ok(true)
 }
 
+/// Creates encoded evm calldata from a proof file
+///
+/// Arguments
+/// ---------
+/// proof: str
+///     Path to the proof file
+///
+/// calldata: str
+///    Path to the calldata file to save
+///
+/// addr_vk: str
+///    The address of the verification key contract (if the verifier key is to be rendered as a separate contract)
+///
+/// Returns
+/// -------
+/// vec[u8]
+///    The encoded calldata
+///
+#[pyfunction(signature = (
+    proof=PathBuf::from(DEFAULT_PROOF),
+    calldata=PathBuf::from(DEFAULT_CALLDATA),
+    addr_vk=None,
+))]
+fn encode_evm_calldata<'a>(
+    proof: PathBuf,
+    calldata: PathBuf,
+    addr_vk: Option<&'a str>,
+) -> Result<Vec<u8>, PyErr> {
+    let addr_vk = if let Some(addr_vk) = addr_vk {
+        let addr_vk = H160Flag::from(addr_vk);
+        Some(addr_vk)
+    } else {
+        None
+    };
+
+    crate::execute::encode_evm_calldata(proof, calldata, addr_vk).map_err(|e| {
+        let err_str = format!("Failed to generate calldata: {}", e);
+        PyRuntimeError::new_err(err_str)
+    })
+}
+
 /// Creates an EVM compatible verifier, you will need solc installed in your environment to run this
 ///
 /// Arguments
@@ -1888,6 +1929,6 @@ fn ezkl(_py: Python<'_>, m: &PyModule) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(setup_test_evm_witness, m)?)?;
     m.add_function(wrap_pyfunction!(create_evm_verifier_aggr, m)?)?;
     m.add_function(wrap_pyfunction!(create_evm_data_attestation, m)?)?;
-
+    m.add_function(wrap_pyfunction!(encode_evm_calldata, m)?)?;
     Ok(())
 }

tests/integration_tests.rs

@@ -1814,6 +1814,18 @@ mod native_tests {
         let settings_arg = format!("{}/{}/settings.json", test_dir, example_name);
         let private_key = format!("--private-key={}", *ANVIL_DEFAULT_PRIVATE_KEY);
 
+        // create encoded calldata
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+            .args([
+                "encode-evm-calldata",
+                "--proof-path",
+                &format!("{}/{}/aggr.pf", test_dir, example_name),
+            ])
+            .status()
+            .expect("failed to execute process");
+
+        assert!(status.success());
+
         let base_args = vec![
             "create-evm-verifier-aggr",
             "--vk-path",
@@ -2036,6 +2048,18 @@ mod native_tests {
         let addr_path_arg = format!("--addr-path={}/{}/addr.txt", test_dir, example_name);
         let settings_arg = format!("--settings-path={}", settings_path);
 
+        // create encoded calldata
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+            .args([
+                "encode-evm-calldata",
+                "--proof-path",
+                &format!("{}/{}/proof.pf", test_dir, example_name),
+            ])
+            .status()
+            .expect("failed to execute process");
+
+        assert!(status.success());
+
         // create the verifier
         let mut args = vec!["create-evm-verifier", "--vk-path", &vk_arg, &settings_arg];
 
@@ -2205,6 +2229,19 @@ mod native_tests {
 
         let deployed_addr_arg_vk = format!("--addr-vk={}", addr_vk);
 
+        // create encoded calldata
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+            .args([
+                "encode-evm-calldata",
+                "--proof-path",
+                &format!("{}/{}/proof.pf", test_dir, example_name),
+                &deployed_addr_arg_vk,
+            ])
+            .status()
+            .expect("failed to execute process");
+
+        assert!(status.success());
+
         // now verify the proof
         let pf_arg = format!("{}/{}/proof.pf", test_dir, example_name);
         let mut args = vec![
@@ -2376,6 +2413,18 @@ mod native_tests {
 
         let settings_arg = format!("--settings-path={}", settings_path);
 
+        // create encoded calldata
+        let status = Command::new(format!("{}/release/ezkl", *CARGO_TARGET_DIR))
+            .args([
+                "encode-evm-calldata",
+                "--proof-path",
+                &format!("{}/{}/proof.pf", test_dir, example_name),
+            ])
+            .status()
+            .expect("failed to execute process");
+
+        assert!(status.success());
+
         // create the verifier
         let mut args = vec!["create-evm-verifier", "--vk-path", &vk_arg, &settings_arg];
 

tests/python/binding_tests.py

@@ -402,6 +402,15 @@ async def test_create_evm_verifier():
     settings_path = os.path.join(folder_path, 'settings.json')
     sol_code_path = os.path.join(folder_path, 'test.sol')
     abi_path = os.path.join(folder_path, 'test.abi')
+    proof_path = os.path.join(folder_path, 'test_evm.pf')
+    calldata_path = os.path.join(folder_path, 'calldata.bytes')
+
+    # res is now a vector of bytes
+    res = ezkl.encode_evm_calldata(proof_path, calldata_path)
+
+    assert os.path.isfile(calldata_path)
+    assert len(res) > 0
+
 
     res = await ezkl.create_evm_verifier(
         vk_path,