feat: sdk and cli parse input.json to the raw numbers

Author: MarcosNicolau

crates/cli/src/main.rs

@@ -926,10 +926,17 @@ fn verification_data_from_args(args: &SubmitArgs) -> Result<VerificationData, Su
                 "--vk",
                 args.verification_key_file_name.clone(),
             )?);
-            pub_input = Some(read_file_option(
-                "--public_input",
-                args.pub_input_file_name.clone(),
-            )?);
+            let pub_input_file =
+                read_file_option("--public_input", args.pub_input_file_name.clone())?;
+            let pub_inputs: Vec<String> = serde_json::from_slice(&pub_input_file)
+                .map_err(|e| SubmitError::MissingRequiredParameter(e.to_string()))?;
+
+            let decode_inputs = aligned_sdk::common::utils::encode_circom_pub_inputs(&pub_inputs)
+                .map_err(|_| {
+                SubmitError::MissingRequiredParameter("Invalid public inputs".into())
+            })?;
+
+            pub_input = Some(decode_inputs);
         }
     }
 

crates/sdk/src/common/mod.rs

@@ -1,3 +1,4 @@
 pub mod constants;
 pub mod errors;
 pub mod types;
+pub mod utils;

crates/sdk/src/common/utils.rs

@@ -0,0 +1,32 @@
+use ethers::{abi::ethereum_types::FromDecStrErr, types::U256};
+
+/// Encodes Circom public inputs into a single byte vector.
+///
+/// Circom normally outputs public inputs as a JSON array of strings, where each
+/// entry is actually a big integer represented in decimal. For example:
+///
+/// ```json
+/// { "pubInputs": ["123", "456", "789"] }
+/// ```
+///
+/// For on-chain usage (e.g. in Solidity), working with JSON is inefficient.
+/// Instead, we prefer the **raw form**: each input is converted to a 32-byte
+/// big-endian encoding of the integer, concatenated together. This makes it
+/// simple to compute commitments and verify proofs on-chain, since the contract
+/// receives a compact `bytes` array rather than parsing JSON.
+///
+/// Each input must fit in 32 bytes (i.e. < 2^256).
+pub fn encode_circom_pub_inputs(input: &[String]) -> Result<Vec<u8>, FromDecStrErr> {
+    let mut out = Vec::with_capacity(input.len() * 32);
+
+    for s in input {
+        // parse as decimal (base 10). Use from_str_radix(s, 16) if they're hex.
+        let n = U256::from_dec_str(s)?;
+        let mut bytes = [0u8; 32];
+        n.to_big_endian(&mut bytes);
+
+        out.extend_from_slice(&bytes);
+    }
+
+    Ok(out)
+}