feat: add inputs argument

cli/src/main.rs

@@ -51,6 +51,12 @@ struct Args {
     /// Only output the transaction calldata without any extra information.
     #[arg(short, long)]
     quiet: bool,
+
+    /// Quiet mode.
+    ///
+    /// Only output the transaction calldata without any extra information.
+    #[arg(short, long)]
+    inputs: bool,
 }
 
 /// Helper type for parsing hexadecimal byte input from the command line.
@@ -108,9 +114,20 @@ fn main() {
 
     let safe = receiver.recv().expect("missing result");
     let transaction = safe.transaction();
+    let initializer_hex = hex::encode(safe.initializer());
 
     if args.quiet {
         println!("0x{}", hex::encode(&transaction.calldata));
+    } else if args.inputs {
+        println!("address:      {}", safe.creation_address());
+        println!("owners:       {}", args.owners[0]);
+        for owner in &args.owners[1..] {
+            println!("           {}", owner);
+        }
+        println!("--------------------------------------------------------");
+        println!("_singleton:   {}", contracts.singleton);
+        println!("initializer:  0x{}", initializer_hex);
+        println!("saltNonce:   0x{}", hex::encode(&safe.salt_nonce()));
     } else {
         println!("address:   {}", safe.creation_address());
         println!("factory:   {}", contracts.proxy_factory);
@@ -122,6 +139,7 @@ fn main() {
         }
         println!("threshold: {}", args.threshold);
         println!("calldata:  0x{}", hex::encode(&transaction.calldata));
+
     }
 
     let _ = threads;

core/src/safe.rs

@@ -12,6 +12,7 @@ pub struct Safe {
     threshold: usize,
     salt: [u8; 64],
     create2: Create2,
+    initializer_calldata: Vec<u8>,
 }
 
 /// Safe contract data on a given chain.
@@ -39,17 +40,23 @@ pub struct Transaction {
 impl Safe {
     /// Creates a new safe from deployment parameters.
     pub fn new(contracts: Contracts, owners: Vec<Address>, threshold: usize) -> Self {
+        // Compute the initializer calldata once and store it
+        let initializer_calldata = contracts.initializer(&owners, threshold);
+
+        // Compute the salt using the initializer calldata
         let mut salt = [0_u8; 64];
         let mut hasher = Keccak::v256();
-        hasher.update(&contracts.initializer(&owners, threshold));
+        hasher.update(&initializer_calldata);
         hasher.finalize(&mut salt[0..32]);
 
         let mut create2 = Create2::new(
             contracts.proxy_factory,
             Default::default(),
             contracts.proxy_init_code_digest(),
         );
-        let mut hasher = Keccak::v256();
+
+        // Update the salt for the create2 instance
+        hasher = Keccak::v256();
         hasher.update(&salt);
         hasher.finalize(create2.salt_mut());
 
@@ -59,6 +66,7 @@ impl Safe {
             threshold,
             salt,
             create2,
+            initializer_calldata, // Store the initializer data here
         }
     }
 
@@ -72,6 +80,11 @@ impl Safe {
         self.salt[32..64].try_into().unwrap()
     }
 
+    /// Returns the initializer calldata for the Safe.
+    pub fn initializer(&self) -> &[u8] {
+        &self.initializer_calldata
+    }
+
     /// Updates the salt nonce and recomputes the `CREATE2` salt.
     pub fn update_salt_nonce(&mut self, f: impl FnOnce(&mut [u8])) {
         let salt_nonce = unsafe { self.salt.get_unchecked_mut(32..64) };
@@ -147,6 +160,7 @@ impl Contracts {
         buffer.extend_from_slice(&[0_u8; 28]); // padding
         buffer
     }
+
 }
 
 /// Poor man's ABI encode.