feat(cast): new pad cmd for hex data (#11152)

* chore(cast): add `--left` flag to cmd `to-bytes32`

* revert and create new `pad` cmd

* make left-pad default

Author: 0xrusowsky

crates/cast/src/args.rs

@@ -165,6 +165,10 @@ pub async fn run_command(args: CastArgs) -> Result<()> {
             let value = stdin::unwrap_line(bytes)?;
             sh_println!("{}", SimpleCast::to_bytes32(&value)?)?
         }
+        CastSubcommand::Pad { data, right, left: _, len } => {
+            let value = stdin::unwrap_line(data)?;
+            sh_println!("{}", SimpleCast::pad(&value, right, len)?)?
+        }
         CastSubcommand::FormatBytes32String { string } => {
             let value = stdin::unwrap_line(string)?;
             sh_println!("{}", SimpleCast::format_bytes32_string(&value)?)?

crates/cast/src/lib.rs

@@ -1634,6 +1634,48 @@ impl SimpleCast {
         Ok(hex::encode_prefixed(bytes32))
     }
 
+    /// Pads hex data to a specified length
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use cast::SimpleCast as Cast;
+    ///
+    /// let padded = Cast::pad("abcd", true, 20)?;
+    /// assert_eq!(padded, "0xabcd000000000000000000000000000000000000");
+    ///
+    /// let padded = Cast::pad("abcd", false, 20)?;
+    /// assert_eq!(padded, "0x000000000000000000000000000000000000abcd");
+    ///
+    /// let padded = Cast::pad("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", true, 32)?;
+    /// assert_eq!(padded, "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2000000000000000000000000");
+    ///
+    /// let padded = Cast::pad("0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", false, 32)?;
+    /// assert_eq!(padded, "0x000000000000000000000000C02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2");
+    ///
+    /// let err = Cast::pad("1234", false, 1).unwrap_err();
+    /// assert_eq!(err.to_string(), "input length exceeds target length");
+    ///
+    /// let err = Cast::pad("foobar", false, 32).unwrap_err();
+    /// assert_eq!(err.to_string(), "input is not a valid hex");
+    ///
+    /// # Ok::<_, eyre::Report>(())
+    /// ```
+    pub fn pad(s: &str, right: bool, len: usize) -> Result<String> {
+        let s = strip_0x(s);
+        let hex_len = len * 2;
+
+        // Validate input
+        if s.len() > hex_len {
+            eyre::bail!("input length exceeds target length");
+        }
+        if !s.chars().all(|c| c.is_ascii_hexdigit()) {
+            eyre::bail!("input is not a valid hex");
+        }
+
+        Ok(if right { format!("0x{s:0<hex_len$}") } else { format!("0x{s:0>hex_len$}") })
+    }
+
     /// Decodes string from bytes32 value
     pub fn parse_bytes32_string(s: &str) -> Result<String> {
         let bytes = hex::decode(s)?;

crates/cast/src/opts.rs

@@ -151,6 +151,25 @@ pub enum CastSubcommand {
         bytes: Option<String>,
     },
 
+    /// Pads hex data to a specified length.
+    #[command(visible_aliases = &["pd"])]
+    Pad {
+        /// The hex data to pad.
+        data: Option<String>,
+
+        /// Right-pad the data (instead of left-pad).
+        #[arg(long)]
+        right: bool,
+
+        /// Left-pad the data (default).
+        #[arg(long, conflicts_with = "right")]
+        left: bool,
+
+        /// Target length in bytes (default: 32).
+        #[arg(long, default_value = "32")]
+        len: usize,
+    },
+
     /// Convert an integer into a fixed point number.
     #[command(visible_aliases = &["--to-fix", "tf", "2f"])]
     ToFixedPoint {