wip: ABI value in utils ffi

Author: joe-p

Cargo.lock

@@ -8,12 +8,14 @@ crate-type = ["lib", "cdylib", "staticlib"]
 
 [dependencies]
 algod_client = { version = "0.0.1", path = "../algod_client", default-features = false }
+algokit_abi = { version = "0.1.0", path = "../algokit_abi" }
 algokit_http_client = { version = "0.1.0", path = "../algokit_http_client", features = ["ffi_uniffi"], default-features = false }
 algokit_transact = { version = "0.1.0", path = "../algokit_transact" }
 algokit_transact_ffi = { version = "0.1.0", path = "../algokit_transact_ffi" }
 algokit_utils = { version = "0.1.0", path = "../algokit_utils" }
 async-trait = "0.1.89"
 derive_more = "2.0.1"
+num-bigint = "0.4.6"
 snafu.workspace = true
 tokio = "1.47.1"
 uniffi = { workspace = true, features = [

crates/algokit_utils_ffi/Cargo.toml

@@ -0,0 +1,30 @@
+use algokit_abi::ABIType as RustABIType;
+
+use super::{ABIType, FfiToRustABIType};
+
+#[derive(uniffi::Object, Clone)]
+pub struct ABIAddress {}
+
+impl From<ABIAddress> for RustABIType {
+    fn from(_: ABIAddress) -> Self {
+        RustABIType::Address
+    }
+}
+
+impl From<RustABIType> for ABIAddress {
+    fn from(value: RustABIType) -> Self {
+        if let RustABIType::Address = value {
+            ABIAddress {}
+        } else {
+            panic!("Expected RustABIType::Address");
+        }
+    }
+}
+
+impl FfiToRustABIType for ABIAddress {
+    fn to_rust_abi_type(&self) -> RustABIType {
+        (*self).clone().into()
+    }
+}
+
+impl ABIType for ABIAddress {}

crates/algokit_utils_ffi/src/abi/abi_type/address.rs

@@ -0,0 +1,30 @@
+use algokit_abi::ABIType as RustABIType;
+
+use super::{ABIType, FfiToRustABIType};
+
+#[derive(uniffi::Object, Clone)]
+pub struct ABIBool {}
+
+impl From<ABIBool> for RustABIType {
+    fn from(_: ABIBool) -> Self {
+        RustABIType::Bool
+    }
+}
+
+impl From<RustABIType> for ABIBool {
+    fn from(value: RustABIType) -> Self {
+        if let RustABIType::Bool = value {
+            ABIBool {}
+        } else {
+            panic!("Expected RustABIType::Bool");
+        }
+    }
+}
+
+impl FfiToRustABIType for ABIBool {
+    fn to_rust_abi_type(&self) -> RustABIType {
+        (*self).clone().into()
+    }
+}
+
+impl ABIType for ABIBool {}

crates/algokit_utils_ffi/src/abi/abi_type/bool.rs

@@ -0,0 +1,29 @@
+use super::{ABIType, FfiToRustABIType};
+use algokit_abi::ABIType as RustABIType;
+
+#[derive(uniffi::Object, Clone)]
+pub struct ABIByte {}
+
+impl From<ABIByte> for RustABIType {
+    fn from(_: ABIByte) -> Self {
+        RustABIType::Byte
+    }
+}
+
+impl From<RustABIType> for ABIByte {
+    fn from(value: RustABIType) -> Self {
+        if let RustABIType::Byte = value {
+            ABIByte {}
+        } else {
+            panic!("Expected RustABIType::Byte");
+        }
+    }
+}
+
+impl FfiToRustABIType for ABIByte {
+    fn to_rust_abi_type(&self) -> RustABIType {
+        (*self).clone().into()
+    }
+}
+
+impl ABIType for ABIByte {}

crates/algokit_utils_ffi/src/abi/abi_type/byte.rs

@@ -0,0 +1,36 @@
+use std::sync::Arc;
+
+use algokit_abi::ABIType as RustABIType;
+
+use super::{ABIType, FfiToRustABIType, RustToFfiABIType};
+
+#[derive(uniffi::Object, Clone)]
+pub struct ABIDynamicArray {
+    element_type: Arc<dyn ABIType>,
+}
+
+impl From<ABIDynamicArray> for RustABIType {
+    fn from(value: ABIDynamicArray) -> Self {
+        RustABIType::DynamicArray(Box::new(value.element_type.to_rust_abi_type()))
+    }
+}
+
+impl From<RustABIType> for ABIDynamicArray {
+    fn from(value: RustABIType) -> Self {
+        if let RustABIType::DynamicArray(rs_element_type) = value {
+            ABIDynamicArray {
+                element_type: rs_element_type.to_ffi_abi_type(),
+            }
+        } else {
+            panic!("Expected RustABIType::DynamicArray");
+        }
+    }
+}
+
+impl FfiToRustABIType for ABIDynamicArray {
+    fn to_rust_abi_type(&self) -> RustABIType {
+        (*self).clone().into()
+    }
+}
+
+impl ABIType for ABIDynamicArray {}

crates/algokit_utils_ffi/src/abi/abi_type/dynamic_array.rs

@@ -0,0 +1,63 @@
+use std::sync::Arc;
+
+use super::abi_value::ABIValue;
+use algokit_abi::ABIType as RustABIType;
+
+mod address;
+mod bool;
+mod byte;
+mod dynamic_array;
+mod static_array;
+mod string;
+mod tuple;
+mod ufixed;
+mod uint;
+
+// TODO: remove unwraps in this module
+
+/// This trait is used to convert FFI ABI types to Rust ABI types
+/// This is needed because we can't implement From on Arc<dyn ABIType>
+pub trait FfiToRustABIType {
+    /// Convert the FFI ABI type to a Rust ABI type
+    fn to_rust_abi_type(&self) -> RustABIType;
+}
+
+/// This trait is used to convert Rust ABI types to FFI ABI types
+/// This is needed because we can't implement From on Arc<dyn ABIType>
+trait RustToFfiABIType {
+    fn to_ffi_abi_type(&self) -> Arc<dyn ABIType>;
+}
+
+impl RustToFfiABIType for RustABIType {
+    fn to_ffi_abi_type(&self) -> Arc<dyn ABIType> {
+        let abi_type: Arc<dyn ABIType> = match self {
+            RustABIType::Uint(_) => Arc::new(uint::ABIUint::from(self.clone())),
+            RustABIType::Tuple(_) => Arc::new(tuple::ABITuple::from(self.clone())),
+            RustABIType::UFixed(_, _) => Arc::new(ufixed::ABIUfixed::from(self.clone())),
+            RustABIType::String => Arc::new(string::ABIString::from(self.clone())),
+            RustABIType::Byte => Arc::new(byte::ABIByte::from(self.clone())),
+            RustABIType::Bool => Arc::new(bool::ABIBool::from(self.clone())),
+            RustABIType::DynamicArray(_) => {
+                Arc::new(dynamic_array::ABIDynamicArray::from(self.clone()))
+            }
+            RustABIType::StaticArray(_, _) => {
+                Arc::new(static_array::ABIStaticArray::from(self.clone()))
+            }
+            RustABIType::Address => Arc::new(address::ABIAddress::from(self.clone())),
+        };
+        abi_type
+    }
+}
+
+#[uniffi::export]
+pub trait ABIType: Send + Sync + FfiToRustABIType {
+    fn decoode(&self, data: &[u8]) -> ABIValue {
+        let rust_abi_type = self.to_rust_abi_type();
+        ABIValue::from(rust_abi_type.decode(data).unwrap())
+    }
+
+    fn encode(&self, value: ABIValue) -> Vec<u8> {
+        let rust_abi_type = self.to_rust_abi_type();
+        rust_abi_type.encode(&value.into()).unwrap()
+    }
+}

crates/algokit_utils_ffi/src/abi/abi_type/mod.rs

@@ -0,0 +1,41 @@
+use std::sync::Arc;
+
+use algokit_abi::ABIType as RustABIType;
+
+use super::{ABIType, FfiToRustABIType, RustToFfiABIType};
+
+#[derive(uniffi::Object, Clone)]
+pub struct ABIStaticArray {
+    element_type: Arc<dyn ABIType>,
+    length: u32,
+}
+
+impl From<ABIStaticArray> for RustABIType {
+    fn from(value: ABIStaticArray) -> Self {
+        RustABIType::StaticArray(
+            Box::new(value.element_type.to_rust_abi_type()),
+            value.length.try_into().unwrap(),
+        )
+    }
+}
+
+impl From<RustABIType> for ABIStaticArray {
+    fn from(value: RustABIType) -> Self {
+        if let RustABIType::StaticArray(rs_element_type, rs_length) = value {
+            ABIStaticArray {
+                element_type: rs_element_type.to_ffi_abi_type(),
+                length: rs_length.try_into().unwrap(),
+            }
+        } else {
+            panic!("Expected RustABIType::StaticArray");
+        }
+    }
+}
+
+impl FfiToRustABIType for ABIStaticArray {
+    fn to_rust_abi_type(&self) -> RustABIType {
+        (*self).clone().into()
+    }
+}
+
+impl ABIType for ABIStaticArray {}

crates/algokit_utils_ffi/src/abi/abi_type/static_array.rs

@@ -0,0 +1,30 @@
+use algokit_abi::ABIType as RustABIType;
+
+use super::{ABIType, FfiToRustABIType};
+
+#[derive(uniffi::Object, Clone)]
+pub struct ABIString {}
+
+impl From<ABIString> for RustABIType {
+    fn from(_: ABIString) -> Self {
+        RustABIType::String
+    }
+}
+
+impl From<RustABIType> for ABIString {
+    fn from(value: RustABIType) -> Self {
+        if let RustABIType::String = value {
+            ABIString {}
+        } else {
+            panic!("Expected RustABIType::String");
+        }
+    }
+}
+
+impl FfiToRustABIType for ABIString {
+    fn to_rust_abi_type(&self) -> RustABIType {
+        (*self).clone().into()
+    }
+}
+
+impl ABIType for ABIString {}

crates/algokit_utils_ffi/src/abi/abi_type/string.rs

@@ -0,0 +1,44 @@
+use std::sync::Arc;
+
+use algokit_abi::ABIType as RustABIType;
+
+use super::RustToFfiABIType;
+use super::{ABIType, FfiToRustABIType};
+
+#[derive(uniffi::Object, Clone)]
+pub struct ABITuple {
+    components: Vec<Arc<dyn ABIType>>,
+}
+
+impl FfiToRustABIType for ABITuple {
+    fn to_rust_abi_type(&self) -> RustABIType {
+        (*self).clone().into()
+    }
+}
+
+impl ABIType for ABITuple {}
+
+impl From<ABITuple> for RustABIType {
+    fn from(value: ABITuple) -> Self {
+        let rust_components = value
+            .components
+            .into_iter()
+            .map(|comp| comp.to_rust_abi_type())
+            .collect();
+        RustABIType::Tuple(rust_components)
+    }
+}
+
+impl From<RustABIType> for ABITuple {
+    fn from(value: RustABIType) -> Self {
+        if let RustABIType::Tuple(rust_components) = value {
+            let components = rust_components
+                .into_iter()
+                .map(|comp| comp.to_ffi_abi_type())
+                .collect();
+            ABITuple { components }
+        } else {
+            panic!("Expected RustABIType::Tuple");
+        }
+    }
+}