Merge pull request #3045 from ProvableHQ/struct-namespace-squashed

Allow external structs.

Author: vicsn

circuit/program/src/data/value/mod.rs

@@ -68,3 +68,24 @@ impl<A: Aleo> Eject for Value<A> {
         }
     }
 }
+
+impl<A: Aleo> From<Plaintext<A>> for Value<A> {
+    /// Initializes the value from a plaintext.
+    fn from(plaintext: Plaintext<A>) -> Self {
+        Self::Plaintext(plaintext)
+    }
+}
+
+impl<A: Aleo> From<Record<A, Plaintext<A>>> for Value<A> {
+    /// Initializes the value from a record.
+    fn from(record: Record<A, Plaintext<A>>) -> Self {
+        Self::Record(record)
+    }
+}
+
+impl<A: Aleo> From<Future<A>> for Value<A> {
+    /// Initializes the value from a future.
+    fn from(future: Future<A>) -> Self {
+        Self::Future(future)
+    }
+}

console/network/src/consensus_heights.rs

@@ -47,6 +47,8 @@ pub enum ConsensusVersion {
     V11 = 11,
     /// V12: Prevent connection to forked nodes, disable StringType, enable block timestamp.
     V12 = 12,
+    /// V13: Introduces external structs.
+    V13 = 13,
 }
 
 impl ToBytes for ConsensusVersion {
@@ -71,6 +73,7 @@ impl FromBytes for ConsensusVersion {
             10 => Ok(Self::V10),
             11 => Ok(Self::V11),
             12 => Ok(Self::V12),
+            13 => Ok(Self::V13),
             _ => Err(io_error("Invalid consensus version")),
         }
     }
@@ -106,6 +109,7 @@ pub const CANARY_V0_CONSENSUS_VERSION_HEIGHTS: [(ConsensusVersion, u32); NUM_CON
     (ConsensusVersion::V10, 8_600_000),
     (ConsensusVersion::V11, 9_510_000),
     (ConsensusVersion::V12, 10_030_000),
+    (ConsensusVersion::V13, u32::MAX),
 ];
 
 /// The consensus version height for `MainnetV0`.
@@ -122,6 +126,7 @@ pub const MAINNET_V0_CONSENSUS_VERSION_HEIGHTS: [(ConsensusVersion, u32); NUM_CO
     (ConsensusVersion::V10, 11_205_000),
     (ConsensusVersion::V11, 12_870_000),
     (ConsensusVersion::V12, 13_815_000),
+    (ConsensusVersion::V13, u32::MAX),
 ];
 
 /// The consensus version heights for `TestnetV0`.
@@ -138,6 +143,7 @@ pub const TESTNET_V0_CONSENSUS_VERSION_HEIGHTS: [(ConsensusVersion, u32); NUM_CO
     (ConsensusVersion::V10, 10_525_000),
     (ConsensusVersion::V11, 11_952_000),
     (ConsensusVersion::V12, 12_669_000),
+    (ConsensusVersion::V13, u32::MAX),
 ];
 
 /// The consensus version heights when the `test_consensus_heights` feature is enabled.
@@ -154,6 +160,7 @@ pub const TEST_CONSENSUS_VERSION_HEIGHTS: [(ConsensusVersion, u32); NUM_CONSENSU
     (ConsensusVersion::V10, 13),
     (ConsensusVersion::V11, 14),
     (ConsensusVersion::V12, 15),
+    (ConsensusVersion::V13, 16),
 ];
 
 #[cfg(any(test, feature = "test", feature = "test_consensus_heights"))]

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

@@ -14,7 +14,7 @@
 // limitations under the License.
 
 use super::*;
-use crate::{Identifier, LiteralType};
+use crate::{Identifier, LiteralType, Locator};
 
 impl<N: Network> FromBytes for ArrayType<N> {
     fn read_le<R: Read>(mut reader: R) -> IoResult<Self> {
@@ -23,7 +23,8 @@ impl<N: Network> FromBytes for ArrayType<N> {
         let element_type = match variant {
             0 => PlaintextType::Literal(LiteralType::read_le(&mut reader)?),
             1 => PlaintextType::Struct(Identifier::read_le(&mut reader)?),
-            2.. => return Err(error(format!("Failed to deserialize element type {variant}"))),
+            2 => PlaintextType::ExternalStruct(Locator::read_le(&mut reader)?),
+            _ => return Err(error(format!("Failed to deserialize element type {variant}"))),
         };
 
         // Read the number of dimensions of the array.
@@ -58,7 +59,7 @@ impl<N: Network> ToBytes for ArrayType<N> {
         // Note that the lengths are in the order of the outermost dimension to the innermost dimension.
         for _ in 1..N::MAX_DATA_DEPTH {
             element_type = match element_type {
-                PlaintextType::Literal(_) | PlaintextType::Struct(_) => break,
+                PlaintextType::Literal(_) | PlaintextType::Struct(_) | PlaintextType::ExternalStruct(_) => break,
                 PlaintextType::Array(array_type) => {
                     lengths.push(*array_type.length());
                     array_type.next_element_type().clone()
@@ -81,6 +82,10 @@ impl<N: Network> ToBytes for ArrayType<N> {
                 1u8.write_le(&mut writer)?;
                 identifier.write_le(&mut writer)?;
             }
+            PlaintextType::ExternalStruct(locator) => {
+                2u8.write_le(&mut writer)?;
+                locator.write_le(&mut writer)?;
+            }
             PlaintextType::Array(_) => {
                 // This is technically unreachable by definition, however we return an error
                 // out of an abundance of caution.

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

@@ -14,15 +14,20 @@
 // limitations under the License.
 
 use super::*;
-use crate::{Identifier, LiteralType};
+use crate::{Identifier, LiteralType, Locator};
 
 impl<N: Network> Parser for ArrayType<N> {
     /// Parses a string into a literal type.
     #[inline]
     fn parse(string: &str) -> ParserResult<Self> {
         // A helper function to parse the innermost element type.
         fn parse_inner_element_type<N: Network>(string: &str) -> ParserResult<PlaintextType<N>> {
-            alt((map(LiteralType::parse, PlaintextType::from), map(Identifier::parse, PlaintextType::from)))(string)
+            // Order matters - we shouldn't try to parse Identifier before Locator.
+            alt((
+                map(Locator::parse, PlaintextType::from),
+                map(LiteralType::parse, PlaintextType::from),
+                map(Identifier::parse, PlaintextType::from),
+            ))(string)
         }
 
         // A helper function to parse the length of each dimension.

console/program/src/data_types/finalize_type/size_in_bits.rs

@@ -20,26 +20,41 @@ use super::*;
 impl<N: Network> FinalizeType<N> {
     /// Returns the number of bits of a finalize type.
     /// Note. The plaintext variant is assumed to be an argument of a `Future` and this does not have a "raw" serialization.
-    pub fn future_size_in_bits<F0, F1>(locator: &Locator<N>, get_struct: &F0, get_future: &F1) -> Result<usize>
+    pub fn future_size_in_bits<F0, F1, F2>(
+        locator: &Locator<N>,
+        get_struct: &F0,
+        get_external_struct: &F1,
+        get_future: &F2,
+    ) -> Result<usize>
     where
         F0: Fn(&Identifier<N>) -> Result<StructType<N>>,
-        F1: Fn(&Locator<N>) -> Result<Vec<FinalizeType<N>>>,
+        F1: Fn(&Locator<N>) -> Result<StructType<N>>,
+        F2: Fn(&Locator<N>) -> Result<Vec<FinalizeType<N>>>,
     {
-        FinalizeType::Future(*locator).size_in_bits_internal(get_struct, get_future, 0)
+        FinalizeType::Future(*locator).size_in_bits_internal(get_struct, get_external_struct, get_future, 0)
     }
 
     /// A helper function to determine the number of bits of a plaintext type, while tracking the depth of the data.
     /// Note. The plaintext variant is assumed to be an argument of a `Future` and thus does not have a "raw" serialization.
-    fn size_in_bits_internal<F0, F1>(&self, get_struct: &F0, get_future: &F1, depth: usize) -> Result<usize>
+    fn size_in_bits_internal<F0, F1, F2>(
+        &self,
+        get_struct: &F0,
+        get_external_struct: &F1,
+        get_future: &F2,
+        depth: usize,
+    ) -> Result<usize>
     where
         F0: Fn(&Identifier<N>) -> Result<StructType<N>>,
-        F1: Fn(&Locator<N>) -> Result<Vec<FinalizeType<N>>>,
+        F1: Fn(&Locator<N>) -> Result<StructType<N>>,
+        F2: Fn(&Locator<N>) -> Result<Vec<FinalizeType<N>>>,
     {
         // Ensure that the depth is within the maximum limit.
         ensure!(depth <= N::MAX_DATA_DEPTH, "Finalize type depth exceeds maximum limit: {}", N::MAX_DATA_DEPTH);
 
         match self {
-            Self::Plaintext(plaintext_type) => plaintext_type.size_in_bits_internal(get_struct, depth),
+            Self::Plaintext(plaintext_type) => {
+                plaintext_type.size_in_bits_internal(get_struct, get_external_struct, depth)
+            }
             Self::Future(locator) => {
                 // Initialize the size in bits.
                 let mut size = 0usize;
@@ -79,7 +94,12 @@ impl<N: Network> FinalizeType<N> {
 
                     // Account for the argument bits.
                     size = size
-                        .checked_add(argument.size_in_bits_internal(get_struct, get_future, depth + 1)?)
+                        .checked_add(argument.size_in_bits_internal(
+                            get_struct,
+                            get_external_struct,
+                            get_future,
+                            depth + 1,
+                        )?)
                         .ok_or(anyhow!("`size_in_bits` overflowed"))?;
                 }
 
@@ -89,11 +109,17 @@ impl<N: Network> FinalizeType<N> {
     }
 
     /// Returns the number of raw bits of a finlaize type.
-    pub fn future_size_in_bits_raw<F0, F1>(locator: &Locator<N>, get_struct: &F0, get_future: &F1) -> Result<usize>
+    pub fn future_size_in_bits_raw<F0, F1, F2>(
+        locator: &Locator<N>,
+        get_struct: &F0,
+        get_external_struct: &F1,
+        get_future: &F2,
+    ) -> Result<usize>
     where
         F0: Fn(&Identifier<N>) -> Result<StructType<N>>,
-        F1: Fn(&Locator<N>) -> Result<Vec<FinalizeType<N>>>,
+        F1: Fn(&Locator<N>) -> Result<StructType<N>>,
+        F2: Fn(&Locator<N>) -> Result<Vec<FinalizeType<N>>>,
     {
-        Self::future_size_in_bits(locator, get_struct, get_future)
+        Self::future_size_in_bits(locator, get_struct, get_external_struct, get_future)
     }
 }

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

@@ -23,7 +23,8 @@ impl<N: Network> FromBytes for PlaintextType<N> {
             0 => Ok(Self::Literal(LiteralType::read_le(&mut reader)?)),
             1 => Ok(Self::Struct(Identifier::read_le(&mut reader)?)),
             2 => Ok(Self::Array(ArrayType::read_le(&mut reader)?)),
-            3.. => Err(error(format!("Failed to deserialize annotation variant {variant}"))),
+            3 => Ok(Self::ExternalStruct(Locator::read_le(&mut reader)?)),
+            4.. => Err(error(format!("Failed to deserialize plaintext type variant {variant}"))),
         }
     }
 }
@@ -44,6 +45,10 @@ impl<N: Network> ToBytes for PlaintextType<N> {
                 2u8.write_le(&mut writer)?;
                 array_type.write_le(&mut writer)
             }
+            Self::ExternalStruct(locator) => {
+                3u8.write_le(&mut writer)?;
+                locator.write_le(&mut writer)
+            }
         }
     }
 }

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

@@ -18,21 +18,49 @@ mod parse;
 mod serialize;
 mod size_in_bits;
 
-use crate::{ArrayType, Identifier, LiteralType, StructType};
+use crate::{ArrayType, Identifier, LiteralType, Locator, ProgramID, StructType};
 use snarkvm_console_network::prelude::*;
 
-/// A `PlaintextType` defines the type parameter for a literal, struct, or array.
+/// A `PlaintextType` defines the type parameter for a literal, struct, array, or external struct.
 #[derive(Clone, PartialEq, Eq, Hash)]
 pub enum PlaintextType<N: Network> {
     /// A literal type contains its type name.
     /// The format of the type is `<type_name>`.
     Literal(LiteralType),
-    /// An struct type contains its identifier.
+    /// A struct type contains its identifier.
     /// The format of the type is `<identifier>`.
     Struct(Identifier<N>),
     /// An array type contains its element type and length.
     /// The format of the type is `[<element_type>; <length>]`.
     Array(ArrayType<N>),
+    /// An external struct type contains its locator.
+    /// The format of the type is `<program_id>/<identifier>`.
+    ExternalStruct(Locator<N>),
+}
+
+impl<N: Network> PlaintextType<N> {
+    /// Returns whether this type refers to an external struct.
+    pub fn contains_external_struct(&self) -> bool {
+        use PlaintextType::*;
+
+        match self {
+            Literal(..) | Struct(..) => false,
+            ExternalStruct(..) => true,
+            Array(array_type) => array_type.base_element_type().contains_external_struct(),
+        }
+    }
+
+    // Make unqualified structs into external ones with the given `id`.
+    pub fn qualify(self, id: ProgramID<N>) -> Self {
+        match self {
+            PlaintextType::ExternalStruct(..) | PlaintextType::Literal(..) => self,
+            PlaintextType::Struct(name) => PlaintextType::ExternalStruct(Locator::new(id, name)),
+            PlaintextType::Array(array_type) => {
+                let element_type = array_type.next_element_type().clone().qualify(id);
+                PlaintextType::Array(ArrayType::new(element_type, vec![*array_type.length()]).unwrap())
+            }
+        }
+    }
 }
 
 impl<N: Network> From<LiteralType> for PlaintextType<N> {
@@ -49,6 +77,13 @@ impl<N: Network> From<Identifier<N>> for PlaintextType<N> {
     }
 }
 
+impl<N: Network> From<Locator<N>> for PlaintextType<N> {
+    /// Initializes a plaintext type from an external struct type.
+    fn from(locator: Locator<N>) -> Self {
+        PlaintextType::ExternalStruct(locator)
+    }
+}
+
 impl<N: Network> From<ArrayType<N>> for PlaintextType<N> {
     /// Initializes a plaintext type from an array type.
     fn from(array: ArrayType<N>) -> Self {
@@ -76,7 +111,7 @@ impl<N: Network> PlaintextType<N> {
     /// 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,
+            Self::Literal(_) | Self::Struct(_) | Self::ExternalStruct(_) => false,
             Self::Array(array_type) => array_type.exceeds_max_array_size(max_array_size),
         }
     }

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

@@ -21,7 +21,9 @@ impl<N: Network> Parser for PlaintextType<N> {
     fn parse(string: &str) -> ParserResult<Self> {
         // Parse to determine the plaintext type (order matters).
         alt((
+            // Order matters - we shouldn't try to parse Identifier before Locator.
             map(ArrayType::parse, |type_| Self::Array(type_)),
+            map(Locator::parse, |locator| Self::ExternalStruct(locator)),
             map(Identifier::parse, |identifier| Self::Struct(identifier)),
             map(LiteralType::parse, |type_| Self::Literal(type_)),
         ))(string)
@@ -60,6 +62,8 @@ impl<N: Network> Display for PlaintextType<N> {
             Self::Literal(literal) => Display::fmt(literal, f),
             // Prints the struct, i.e. signature
             Self::Struct(struct_) => Display::fmt(struct_, f),
+            // Prints the external struct, i.e. foo.aleo/bar
+            Self::ExternalStruct(locator) => Display::fmt(locator, f),
             // Prints the array type, i.e. [field; 2u32]
             Self::Array(array) => Display::fmt(array, f),
         }