Merge branch 'staging' into staging

Author: meddle0x53

README.md

@@ -46,6 +46,12 @@ We recommend installing Rust using [rustup](https://www.rustup.rs/). You can ins
   curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
   ```
 
+  For macOS users, you will need to subsequently install the following packages:
+  ```bash
+  brew install pkgconf
+  brew install openssl
+  ```
+
 - Windows (64-bit):
 
   Download the [Windows 64-bit executable](https://win.rustup.rs/x86_64) or

console/network/src/consensus_heights.rs

@@ -45,7 +45,7 @@ pub enum ConsensusVersion {
     V10 = 10,
     /// V11: Expand array size limit to 512 and introduce ECDSA signature verification opcodes.
     V11 = 11,
-    /// V12: Prevent connection to forked nodes.
+    /// V12: Prevent connection to forked nodes, disable StringType.
     V12 = 12,
 }
 

console/program/src/data_types/array_type/mod.rs

@@ -37,7 +37,29 @@ impl<N: Network> ArrayType<N> {
         matches!(self.next_element_type(), PlaintextType::Literal(LiteralType::Boolean))
     }
 
-    /// Returns `true` if the record contains an array type with a size that exceeds the given maximum.
+    /// Returns `true` if the `ArrayType` contains a string type.
+    pub fn contains_string_type(&self) -> bool {
+        // Initialize depth counter and current array type.
+        let mut array_type = self;
+
+        // Check nested array types up to the maximum data depth.
+        for _ in 0..=N::MAX_DATA_DEPTH {
+            // Check if the current element type is a string type.
+            if array_type.next_element_type().contains_string_type() {
+                return true;
+            }
+            // If the next element is an array, continue to the next depth. Otherwise, we can stop checking.
+            if let PlaintextType::Array(next) = array_type.next_element_type() {
+                array_type = next;
+            } else {
+                return false;
+            }
+        }
+        // If we reach here, it means we've exceeded the maximum depth without finding a non-array type.
+        true
+    }
+
+    /// Returns `true` if the `ArrayType` contains an array type with a size that exceeds the given maximum.
     pub fn exceeds_max_array_size(&self, max_array_size: u32) -> bool {
         // Initialize depth counter and current array type.
         let mut array_type = self;
@@ -48,7 +70,7 @@ impl<N: Network> ArrayType<N> {
             if **array_type.length() > max_array_size {
                 return true;
             }
-            // If the next eleemtn is an array, continue to the next depth. Otherwise, we can stop checking.
+            // If the next element is an array, continue to the next depth. Otherwise, we can stop checking.
             if let PlaintextType::Array(next) = array_type.next_element_type() {
                 array_type = next;
             } else {

console/program/src/data_types/plaintext_type/mod.rs

@@ -64,7 +64,16 @@ impl<N: Network> PlaintextType<N> {
     /// Prefix bits for (de)serializing the `Struct` variant.
     pub const STRUCT_PREFIX_BITS: [bool; 2] = [false, true];
 
-    /// Returns `true` if the plaintext type is an array and the size exceeds the given maximum.
+    /// Returns `true` if the `PlaintextType` contains a string type.
+    pub fn contains_string_type(&self) -> bool {
+        match self {
+            Self::Literal(LiteralType::String) => true,
+            Self::Array(array_type) => array_type.contains_string_type(),
+            _ => false, // Structs are checked in their definition.
+        }
+    }
+
+    /// Returns `true` if the `PlaintextType` is an array and the size exceeds the given maximum.
     pub fn exceeds_max_array_size(&self, max_array_size: u32) -> bool {
         match self {
             Self::Literal(_) | Self::Struct(_) => false,

console/program/src/data_types/record_type/mod.rs

@@ -56,6 +56,11 @@ impl<N: Network> RecordType<N> {
         &self.entries
     }
 
+    /// Returns `true` if the record contains a string type.
+    pub fn contains_string_type(&self) -> bool {
+        self.entries.values().any(|entry_type| entry_type.plaintext_type().contains_string_type())
+    }
+
     /// Returns `true` if the record contains an array type with a size that exceeds the given maximum.
     pub fn exceeds_max_array_size(&self, max_array_size: u32) -> bool {
         self.entries.values().any(|entry_type| entry_type.plaintext_type().exceeds_max_array_size(max_array_size))

console/program/src/data_types/register_type/mod.rs

@@ -67,6 +67,14 @@ impl<N: Network> From<FinalizeType<N>> for RegisterType<N> {
 }
 
 impl<N: Network> RegisterType<N> {
+    /// Returns `true` if the register type contains a string type.
+    pub fn contains_string_type(&self) -> bool {
+        match self {
+            Self::Plaintext(plaintext_type) => plaintext_type.contains_string_type(),
+            _ => false, // Record, external record, and future types are checked elsewhere.
+        }
+    }
+
     /// Returns `true` if the register type is an array and the size exceeds the given maximum.
     pub fn exceeds_max_array_size(&self, max_array_size: u32) -> bool {
         match self {

console/program/src/data_types/struct_type/mod.rs

@@ -43,6 +43,11 @@ impl<N: Network> StructType<N> {
         &self.members
     }
 
+    /// Returns `true` if the struct contains a string type.
+    pub fn contains_string_type(&self) -> bool {
+        self.members.values().any(|plaintext_type| plaintext_type.contains_string_type())
+    }
+
     /// Returns `true` if the struct contains an array type with a size that exceeds the given maximum.
     pub fn exceeds_max_array_size(&self, max_array_size: u32) -> bool {
         self.members.values().any(|plaintext_type| plaintext_type.exceeds_max_array_size(max_array_size))

console/program/src/data_types/value_type/mod.rs

@@ -65,6 +65,16 @@ impl<N: Network> From<EntryType<N>> for ValueType<N> {
 }
 
 impl<N: Network> ValueType<N> {
+    /// Returns `true` if the value type contains a string type.
+    /// Record, external record, and future types are checked elsewhere.
+    pub fn contains_string_type(&self) -> bool {
+        use ValueType::*;
+        matches!(
+            self,
+            Constant(plaintext) | Public(plaintext) | Private(plaintext) if plaintext.contains_string_type()
+        )
+    }
+
     /// Returns `true` if the value type is an array and the size exceeds the given maximum.
     pub fn exceeds_max_array_size(&self, max_array_size: u32) -> bool {
         use ValueType::*;

synthesizer/program/src/closure/mod.rs

@@ -70,6 +70,12 @@ impl<N: Network> ClosureCore<N> {
         &self.outputs
     }
 
+    /// Returns `true` if the closure instructions contain a string type.
+    /// Note that input and output types don't have to be checked if we are sure the broader function doesn't contain a string type.
+    pub fn contains_string_type(&self) -> bool {
+        self.instructions.iter().any(|instruction| instruction.contains_string_type())
+    }
+
     /// Returns `true` if the closure contains an array type with a size that exceeds the given maximum.
     pub fn exceeds_max_array_size(&self, max_array_size: u32) -> bool {
         self.inputs.iter().any(|input| input.register_type().exceeds_max_array_size(max_array_size))

synthesizer/program/src/constructor/mod.rs

@@ -51,14 +51,14 @@ impl<N: Network> ConstructorCore<N> {
         &self.positions
     }
 
+    /// Returns `true` if the constructor commands contain a string type.
+    pub fn contains_string_type(&self) -> bool {
+        self.commands.iter().any(|command| command.contains_string_type())
+    }
+
     /// Returns `true` if the constructor contains an array type with a size that exceeds the given maximum.
     pub fn exceeds_max_array_size(&self, max_array_size: u32) -> bool {
-        self.commands.iter().any(|command| {
-            matches!(
-                command,
-                Command::Instruction(instruction) if instruction.exceeds_max_array_size(max_array_size)
-            )
-        })
+        self.commands.iter().any(|command| command.exceeds_max_array_size(max_array_size))
     }
 }