Allow external structs.

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

@@ -66,3 +66,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

@@ -37,7 +37,7 @@ pub enum ConsensusVersion {
     V8 = 8,
     /// V9: Support for program upgradability.
     V9 = 9,
-    /// V10: Support for external records.
+    /// V10: Support for external structs.
     V10 = 10,
 }
 

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/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 annotation 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

@@ -17,7 +17,7 @@ mod bytes;
 mod parse;
 mod serialize;
 
-use crate::{ArrayType, Identifier, LiteralType};
+use crate::{ArrayType, Identifier, LiteralType, Locator, ProgramID};
 use snarkvm_console_network::prelude::*;
 
 /// A `PlaintextType` defines the type parameter for a literal, struct, or array.
@@ -26,12 +26,40 @@ 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> {
@@ -48,6 +76,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 {

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),
         }

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

@@ -17,7 +17,7 @@ mod bytes;
 mod parse;
 mod serialize;
 
-use crate::{FinalizeType, Identifier, Locator, PlaintextType, ValueType};
+use crate::{FinalizeType, Identifier, Locator, PlaintextType, ProgramID, ValueType};
 use snarkvm_console_network::prelude::*;
 
 use enum_index::EnumIndex;
@@ -34,6 +34,22 @@ pub enum RegisterType<N: Network> {
     Future(Locator<N>),
 }
 
+impl<N: Network> RegisterType<N> {
+    // Make unqualified structs or records into external ones with the given `id`.
+    pub fn qualify(self, id: ProgramID<N>) -> Self {
+        match self {
+            RegisterType::Plaintext(plaintext_type) => RegisterType::Plaintext(plaintext_type.qualify(id)),
+            RegisterType::Record(name) => RegisterType::ExternalRecord(Locator::new(id, name)),
+            RegisterType::ExternalRecord(..) | RegisterType::Future(..) => self,
+        }
+    }
+
+    /// Returns whether this type refers to an external struct.
+    pub fn contains_external_struct(&self) -> bool {
+        matches!(self, RegisterType::Plaintext(t) if t.contains_external_struct())
+    }
+}
+
 impl<N: Network> From<ValueType<N>> for RegisterType<N> {
     /// Converts a value type to a register type.
     fn from(value: ValueType<N>) -> Self {

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

@@ -52,6 +52,15 @@ impl<N: Network> ValueType<N> {
             ValueType::Future(..) => 5,
         }
     }
+
+    /// Returns whether this type references an external struct.
+    pub fn contains_external_struct(&self) -> bool {
+        use ValueType::*;
+        matches!(
+            self,
+            Constant(plaintext) | Public(plaintext) | Private(plaintext) if plaintext.contains_external_struct()
+        )
+    }
 }
 
 impl<N: Network> From<EntryType<N>> for ValueType<N> {

synthesizer/process/src/cost.rs

@@ -161,6 +161,10 @@ fn plaintext_size_in_bytes<N: Network>(stack: &Stack<N>, plaintext_type: &Plaint
             // Return the size of the struct.
             Ok(size_of_name.saturating_add(size_of_members))
         }
+        PlaintextType::ExternalStruct(locator) => {
+            let external_stack = stack.get_external_stack(locator.program_id())?;
+            plaintext_size_in_bytes(&*external_stack, &PlaintextType::Struct(*locator.resource()))
+        }
         PlaintextType::Array(array_type) => {
             // Retrieve the number of elements in the array.
             let num_elements = **array_type.length() as u64;
@@ -267,7 +271,9 @@ pub fn cost_per_command<N: Network>(
                 FinalizeType::Plaintext(PlaintextType::Literal(LiteralType::Field)) => Ok(1_500),
                 FinalizeType::Plaintext(PlaintextType::Literal(_)) => Ok(500),
                 FinalizeType::Plaintext(PlaintextType::Array(_)) => bail!("'div' does not support arrays"),
-                FinalizeType::Plaintext(PlaintextType::Struct(_)) => bail!("'div' does not support structs"),
+                FinalizeType::Plaintext(PlaintextType::Struct(_) | PlaintextType::ExternalStruct(_)) => {
+                    bail!("'div' does not support structs")
+                }
                 FinalizeType::Future(_) => bail!("'div' does not support futures"),
             }
         }
@@ -344,7 +350,9 @@ pub fn cost_per_command<N: Network>(
                 FinalizeType::Plaintext(PlaintextType::Literal(LiteralType::Scalar)) => Ok(10_000),
                 FinalizeType::Plaintext(PlaintextType::Literal(_)) => Ok(500),
                 FinalizeType::Plaintext(PlaintextType::Array(_)) => bail!("'mul' does not support arrays"),
-                FinalizeType::Plaintext(PlaintextType::Struct(_)) => bail!("'mul' does not support structs"),
+                FinalizeType::Plaintext(PlaintextType::Struct(_) | PlaintextType::ExternalStruct(_)) => {
+                    bail!("'mul' does not support structs")
+                }
                 FinalizeType::Future(_) => bail!("'mul' does not support futures"),
             }
         }
@@ -362,7 +370,9 @@ pub fn cost_per_command<N: Network>(
                 FinalizeType::Plaintext(PlaintextType::Literal(LiteralType::Field)) => Ok(1_500),
                 FinalizeType::Plaintext(PlaintextType::Literal(_)) => Ok(500),
                 FinalizeType::Plaintext(PlaintextType::Array(_)) => bail!("'pow' does not support arrays"),
-                FinalizeType::Plaintext(PlaintextType::Struct(_)) => bail!("'pow' does not support structs"),
+                FinalizeType::Plaintext(PlaintextType::Struct(_) | PlaintextType::ExternalStruct(_)) => {
+                    bail!("'pow' does not support structs")
+                }
                 FinalizeType::Future(_) => bail!("'pow' does not support futures"),
             }
         }