Expose abi encoding

analyzer/src/namespace/operations.rs

@@ -52,7 +52,7 @@ mod tests {
 
     const U256_ARRAY_TYPE: Type = Type::Array(Array {
         inner: U256,
-        dimension: 100,
+        size: 100,
     });
     const U256_TYPE: Type = Type::Base(U256);
     const BOOL_TYPE: Type = Type::Base(Base::Bool);

analyzer/src/namespace/types.rs

@@ -62,8 +62,13 @@ pub enum AbiType {
         inner: Box<AbiType>,
         size: AbiArraySize,
     },
+    Tuple {
+        elems: Vec<AbiType>,
+    },
     /// All elements are encoded as a uint or set of uints.
-    Uint { size: AbiUintSize },
+    Uint {
+        size: AbiUintSize,
+    },
 }
 
 /// Data can be decoded from memory or calldata.
@@ -144,7 +149,7 @@ pub const U256: Base = Base::Numeric(Integer::U256);
 
 #[derive(Clone, Debug, PartialEq, PartialOrd, Ord, Eq)]
 pub struct Array {
-    pub dimension: usize,
+    pub size: usize,
     pub inner: Base,
 }
 
@@ -162,7 +167,7 @@ pub struct Tuple {
 #[derive(Clone, Debug, PartialEq, PartialOrd, Ord, Eq)]
 pub struct Struct {
     pub name: String,
-    fields: BTreeMap<String, Base>,
+    fields: BTreeMap<String, FixedSize>,
     order: Vec<String>,
 }
 
@@ -192,13 +197,13 @@ impl Struct {
     }
 
     /// Add a field to the struct
-    pub fn add_field(&mut self, name: &str, value: &Base) -> Option<Base> {
+    pub fn add_field(&mut self, name: &str, value: &FixedSize) -> Option<FixedSize> {
         self.order.push(name.to_string());
         self.fields.insert(name.to_string(), value.clone())
     }
 
     /// Return the type of the given field name
-    pub fn get_field_type(&self, name: &str) -> Option<&Base> {
+    pub fn get_field_type(&self, name: &str) -> Option<&FixedSize> {
         self.fields.get(name)
     }
 
@@ -208,15 +213,13 @@ impl Struct {
     }
 
     /// Return a vector of field types
-    pub fn get_field_types(&self) -> Vec<Type> {
+    pub fn get_field_types(&self) -> Vec<FixedSize> {
         self.order
             .iter()
             .map(|name| {
-                Type::Base(
-                    self.get_field_type(name)
-                        .expect("no entry for field name")
-                        .to_owned(),
-                )
+                self.get_field_type(name)
+                    .expect("no entry for field name")
+                    .to_owned()
             })
             .collect()
     }
@@ -225,6 +228,10 @@ impl Struct {
     pub fn get_field_names(&self) -> Vec<String> {
         self.order.clone()
     }
+
+    pub fn get_num_fields(&self) -> usize {
+        self.order.len()
+    }
 }
 
 impl TryFrom<&str> for FeString {
@@ -561,33 +568,31 @@ impl AbiEncoding for Base {
 
 impl FeSized for Array {
     fn size(&self) -> usize {
-        self.dimension * self.inner.size()
+        self.size * self.inner.size()
     }
 }
 
 impl AbiEncoding for Array {
     fn abi_name(&self) -> String {
         if self.inner == Base::Byte {
-            return format!("bytes{}", self.dimension);
+            return format!("bytes{}", self.size);
         }
 
-        format!("{}[{}]", self.inner.abi_name(), self.dimension)
+        format!("{}[{}]", self.inner.abi_name(), self.size)
     }
 
     fn abi_safe_name(&self) -> String {
         if self.inner == Base::Byte {
-            return format!("bytes{}", self.dimension);
+            return format!("bytes{}", self.size);
         }
 
-        format!("{}{}", self.inner.abi_name(), self.dimension)
+        format!("{}{}", self.inner.abi_name(), self.size)
     }
 
     fn abi_type(&self) -> AbiType {
         AbiType::Array {
             inner: Box::new(self.inner.abi_type()),
-            size: AbiArraySize::Static {
-                size: self.dimension,
-            },
+            size: AbiArraySize::Static { size: self.size },
         }
     }
 }
@@ -622,15 +627,27 @@ impl FeSized for Struct {
 
 impl AbiEncoding for Struct {
     fn abi_name(&self) -> String {
-        unimplemented!();
+        let field_names = self
+            .get_field_types()
+            .iter()
+            .map(|typ| typ.abi_name())
+            .collect::<Vec<String>>();
+        let joined_names = field_names.join(",");
+        format!("({})", joined_names)
     }
 
     fn abi_safe_name(&self) -> String {
-        unimplemented!();
+        self.name.clone()
     }
 
     fn abi_type(&self) -> AbiType {
-        unimplemented!();
+        AbiType::Tuple {
+            elems: self
+                .get_field_types()
+                .iter()
+                .map(|typ| typ.abi_type())
+                .collect(),
+        }
     }
 }
 
@@ -742,7 +759,7 @@ pub fn type_desc(defs: &HashMap<String, Type>, typ: &fe::TypeDesc) -> Result<Typ
         }
         fe::TypeDesc::Array { typ, dimension } => Ok(Type::Array(Array {
             inner: type_desc_base(defs, &typ.node)?,
-            dimension: *dimension,
+            size: *dimension,
         })),
         fe::TypeDesc::Map { from, to } => Ok(Type::Map(Map {
             key: type_desc_base(defs, &from.node)?,

analyzer/src/traversal/assignments.rs

@@ -103,7 +103,7 @@ mod tests {
                 "bar",
                 FixedSize::Array(Array {
                     inner: U256,
-                    dimension: 100,
+                    size: 100,
                 }),
             )
             .unwrap();