feat: app client

crates/algokit_abi/src/method.rs → crates/algokit_abi/src/abi_method.rs

@@ -1,13 +1,12 @@
+use crate::DefaultValueSource;
 use crate::abi_type::ABIType;
 use crate::abi_value::ABIValue;
+use crate::constants::VOID_RETURN_TYPE;
 use crate::error::ABIError;
 use sha2::{Digest, Sha512_256};
 use std::fmt::Display;
 use std::str::FromStr;
 
-/// Constant for void return type in method signatures.
-const VOID_RETURN_TYPE: &str = "void";
-
 /// Represents a transaction type that can be used as an ABI method argument.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ABITransactionType {
@@ -158,7 +157,7 @@ impl FromStr for ABIMethodArgType {
 }
 
 /// Represents a parsed ABI method, including its name, arguments, and return type.
-#[derive(Debug, Default, Clone, PartialEq, Eq)]
+#[derive(Debug, Default, Clone)]
 pub struct ABIMethod {
     /// The name of the method.
     pub name: String,
@@ -170,57 +169,7 @@ pub struct ABIMethod {
     pub description: Option<String>,
 }
 
-/// Represents an argument in an ABI method.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ABIMethodArg {
-    /// The type of the argument.
-    pub arg_type: ABIMethodArgType,
-    /// An optional name for the argument.
-    pub name: Option<String>,
-    /// An optional description of the argument.
-    pub description: Option<String>,
-}
-
 impl ABIMethod {
-    /// Creates a new ABI method.
-    pub fn new(
-        name: String,
-        args: Vec<ABIMethodArg>,
-        returns: Option<ABIType>,
-        description: Option<String>,
-    ) -> Self {
-        Self {
-            name,
-            args,
-            returns,
-            description,
-        }
-    }
-
-    /// Returns the number of transaction arguments in the method.
-    pub fn transaction_arg_count(&self) -> usize {
-        self.args
-            .iter()
-            .filter(|arg| arg.arg_type.is_transaction())
-            .count()
-    }
-
-    /// Returns the number of reference arguments in the method.
-    pub fn reference_arg_count(&self) -> usize {
-        self.args
-            .iter()
-            .filter(|arg| arg.arg_type.is_reference())
-            .count()
-    }
-
-    /// Returns the number of value-type arguments in the method.
-    pub fn value_arg_count(&self) -> usize {
-        self.args
-            .iter()
-            .filter(|arg| arg.arg_type.is_value_type())
-            .count()
-    }
-
     /// Returns the method selector, which is the first 4 bytes of the SHA-512/256 hash of the method signature.
     pub fn selector(&self) -> Result<Vec<u8>, ABIError> {
         let signature = self.signature()?;
@@ -279,6 +228,71 @@ impl ABIMethod {
     }
 }
 
+/// Default value information for ABI method arguments.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ABIDefaultValue {
+    /// Base64 encoded bytes, base64 ARC4 encoded uint64, or UTF-8 method selector
+    pub data: String,
+    /// Where the default value is coming from
+    pub source: DefaultValueSource,
+    /// How the data is encoded. This is the encoding for the data provided here, not the arg type
+    pub value_type: Option<ABIType>,
+}
+
+/// Represents an argument in an ABI method.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ABIMethodArg {
+    /// The type of the argument.
+    pub arg_type: ABIMethodArgType,
+    /// An optional name for the argument.
+    pub name: Option<String>,
+    /// An optional description of the argument.
+    pub description: Option<String>,
+    /// An optional default value for the argument.
+    pub default_value: Option<ABIDefaultValue>,
+}
+
+impl ABIMethod {
+    /// Creates a new ABI method.
+    pub fn new(
+        name: String,
+        args: Vec<ABIMethodArg>,
+        returns: Option<ABIType>,
+        description: Option<String>,
+    ) -> Self {
+        Self {
+            name,
+            args,
+            returns,
+            description,
+        }
+    }
+
+    /// Returns the number of transaction arguments in the method.
+    pub fn transaction_arg_count(&self) -> usize {
+        self.args
+            .iter()
+            .filter(|arg| arg.arg_type.is_transaction())
+            .count()
+    }
+
+    /// Returns the number of reference arguments in the method.
+    pub fn reference_arg_count(&self) -> usize {
+        self.args
+            .iter()
+            .filter(|arg| arg.arg_type.is_reference())
+            .count()
+    }
+
+    /// Returns the number of value-type arguments in the method.
+    pub fn value_arg_count(&self) -> usize {
+        self.args
+            .iter()
+            .filter(|arg| arg.arg_type.is_value_type())
+            .count()
+    }
+}
+
 impl FromStr for ABIMethod {
     type Err = ABIError;
 
@@ -323,7 +337,7 @@ impl FromStr for ABIMethod {
         for (i, arg_type) in arguments.iter().enumerate() {
             let _type = ABIMethodArgType::from_str(arg_type)?;
             let arg_name = Some(format!("arg{}", i));
-            let arg = ABIMethodArg::new(_type, arg_name, None);
+            let arg = ABIMethodArg::new(_type, arg_name, None, None);
             args.push(arg);
         }
 
@@ -347,11 +361,13 @@ impl ABIMethodArg {
         arg_type: ABIMethodArgType,
         name: Option<String>,
         description: Option<String>,
+        default_value: Option<ABIDefaultValue>,
     ) -> Self {
         Self {
             arg_type,
             name,
             description,
+            default_value,
         }
     }
 }
@@ -424,7 +440,6 @@ fn split_arguments_by_comma(args_str: &str) -> Result<Vec<String>, ABIError> {
 mod tests {
     use super::*;
     use crate::abi_type::parse_tuple_content;
-    use hex;
     use rstest::rstest;
 
     // Transaction type parsing with round-trip validation
@@ -517,19 +532,6 @@ mod tests {
         assert!(ABIMethod::from_str(signature).is_err());
     }
 
-    // Method selector verification - critical for hash correctness
-    #[rstest]
-    #[case("add(uint64,uint64)uint64", "fe6bdf69")]
-    #[case("optIn()void", "29314d95")]
-    #[case("deposit(pay,uint64)void", "f2355b55")]
-    #[case("bootstrap(pay,pay,application)void", "895c2a3b")]
-    fn method_selector(#[case] signature: &str, #[case] expected_hex: &str) {
-        let method = ABIMethod::from_str(signature).unwrap();
-        let selector = method.selector().unwrap();
-        assert_eq!(hex::encode(&selector), expected_hex);
-        assert_eq!(selector.len(), 4);
-    }
-
     // ARC-4 tuple parsing - essential cases
     #[rstest]
     #[case("uint64,string,bool", vec!["uint64", "string", "bool"])]
@@ -549,15 +551,6 @@ mod tests {
         assert!(parse_tuple_content(input).is_err());
     }
 
-    // Signature round-trip
-    #[rstest]
-    #[case("add(uint64,uint64)uint64")]
-    #[case("optIn()void")]
-    fn signature_round_trip(#[case] signature: &str) {
-        let method = ABIMethod::from_str(signature).unwrap();
-        assert_eq!(method.signature().unwrap(), signature);
-    }
-
     // Method argument type predicates
     #[test]
     fn method_arg_type_predicates() {
@@ -569,17 +562,4 @@ mod tests {
         assert!(!ref_arg.is_transaction() && ref_arg.is_reference() && !ref_arg.is_value_type());
         assert!(!val_arg.is_transaction() && !val_arg.is_reference() && val_arg.is_value_type());
     }
-
-    // Edge cases
-    #[test]
-    fn empty_method_name_error() {
-        let method = ABIMethod::new("".to_string(), vec![], None, None);
-        assert!(method.signature().is_err());
-    }
-
-    #[test]
-    fn selector_length() {
-        let method = ABIMethod::new("test".to_string(), vec![], None, None);
-        assert_eq!(method.selector().unwrap().len(), 4);
-    }
 }

crates/algokit_abi/src/abi_type.rs

@@ -1,12 +1,13 @@
 use crate::{
-    ABIError, ABIValue,
+    ABIError, ABIValue, StructField,
     constants::{
         ALGORAND_PUBLIC_KEY_BYTE_LENGTH, BITS_PER_BYTE, MAX_BIT_SIZE, MAX_PRECISION,
         STATIC_ARRAY_REGEX, UFIXED_REGEX,
     },
-    types::collections::tuple::find_bool_sequence_end,
+    types::collections::{r#struct::ABIStruct, tuple::find_bool_sequence_end},
 };
 use std::{
+    collections::HashMap,
     fmt::{Display, Formatter, Result as FmtResult},
     str::FromStr,
 };
@@ -98,6 +99,14 @@ pub enum ABIType {
     StaticArray(Box<ABIType>, usize),
     /// A dynamic-length array of another ABI type.
     DynamicArray(Box<ABIType>),
+    /// A struct type with named fields.
+    Struct(ABIStruct),
+    /// Raw byteslice without the length prefix that is specified in ARC-4.
+    AVMBytes,
+    /// A utf-8 string without the length prefix that is specified in ARC-4.
+    AVMString,
+    /// A 64-bit unsigned integer.
+    AVMUint64,
 }
 
 impl AsRef<ABIType> for ABIType {
@@ -125,6 +134,10 @@ impl ABIType {
             ABIType::String => self.encode_string(value),
             ABIType::Byte => self.encode_byte(value),
             ABIType::Bool => self.encode_bool(value),
+            ABIType::Struct(struct_type) => struct_type.encode(value),
+            ABIType::AVMBytes => self.encode_avm_bytes(value),
+            ABIType::AVMString => self.encode_avm_string(value),
+            ABIType::AVMUint64 => self.encode_avm_uint64(value),
         }
     }
 
@@ -146,14 +159,21 @@ impl ABIType {
             ABIType::Tuple(_) => self.decode_tuple(bytes),
             ABIType::StaticArray(_, _size) => self.decode_static_array(bytes),
             ABIType::DynamicArray(_) => self.decode_dynamic_array(bytes),
+            ABIType::Struct(struct_type) => struct_type.decode(bytes),
+            ABIType::AVMBytes => self.decode_avm_bytes(bytes),
+            ABIType::AVMString => self.decode_avm_string(bytes),
+            ABIType::AVMUint64 => self.decode_avm_uint64(bytes),
         }
     }
 
     pub(crate) fn is_dynamic(&self) -> bool {
         match self {
             ABIType::StaticArray(child_type, _) => child_type.is_dynamic(),
             ABIType::Tuple(child_types) => child_types.iter().any(|t| t.is_dynamic()),
-            ABIType::DynamicArray(_) | ABIType::String => true,
+            ABIType::DynamicArray(_) | ABIType::String | ABIType::AVMBytes | ABIType::AVMString => {
+                true
+            }
+            ABIType::Struct(struct_type) => struct_type.to_tuple_type().is_dynamic(),
             _ => false,
         }
     }
@@ -165,6 +185,7 @@ impl ABIType {
             ABIType::Address => Ok(ALGORAND_PUBLIC_KEY_BYTE_LENGTH),
             ABIType::Bool => Ok(1),
             ABIType::Byte => Ok(1),
+            ABIType::AVMUint64 => Ok(8),
             ABIType::StaticArray(child_type, size) => match child_type.as_ref() {
                 ABIType::Bool => Ok((*size).div_ceil(BITS_PER_BYTE as usize)),
                 _ => Ok(Self::get_size(child_type)? * *size),
@@ -190,14 +211,32 @@ impl ABIType {
                 }
                 Ok(size)
             }
+            ABIType::Struct(struct_type) => {
+                let tuple_type = struct_type.to_tuple_type();
+                Self::get_size(&tuple_type)
+            }
             ABIType::String => Err(ABIError::DecodingError {
                 message: format!("Failed to get size, {} is a dynamic type", abi_type),
             }),
             ABIType::DynamicArray(_) => Err(ABIError::DecodingError {
                 message: format!("Failed to get size, {} is a dynamic type", abi_type),
             }),
+            ABIType::AVMBytes => Err(ABIError::DecodingError {
+                message: format!("Failed to get size, {} is a dynamic type", abi_type),
+            }),
+            ABIType::AVMString => Err(ABIError::DecodingError {
+                message: format!("Failed to get size, {} is a dynamic type", abi_type),
+            }),
         }
     }
+
+    pub(crate) fn from_struct(
+        struct_name: &str,
+        structs: &HashMap<String, Vec<StructField>>,
+    ) -> Result<Self, ABIError> {
+        let struct_type = ABIStruct::get_abi_struct_type(struct_name, structs)?;
+        Ok(Self::Struct(struct_type))
+    }
 }
 
 impl Display for ABIType {
@@ -221,6 +260,10 @@ impl Display for ABIType {
             ABIType::DynamicArray(child_type) => {
                 write!(f, "{}[]", child_type)
             }
+            ABIType::Struct(struct_type) => write!(f, "{}", struct_type), // TODO: test this to make sure the method selector is correct
+            ABIType::AVMBytes => write!(f, "AVMBytes"),
+            ABIType::AVMString => write!(f, "AVMString"),
+            ABIType::AVMUint64 => write!(f, "AVMUint64"),
         }
     }
 }
@@ -321,6 +364,9 @@ impl FromStr for ABIType {
             "bool" => Ok(ABIType::Bool),
             "address" => Ok(ABIType::Address),
             "string" => Ok(ABIType::String),
+            "AVMBytes" => Ok(ABIType::AVMBytes),
+            "AVMString" => Ok(ABIType::AVMString),
+            "AVMUint64" => Ok(ABIType::AVMUint64),
             _ => Err(ABIError::ValidationError {
                 message: format!("Cannot convert string '{}' to an ABI type", s),
             }),