feat: consts as enum in ffi (#94)

* feat: consts as enum

Author: CiottiGiorgio

crates/algokit_transact_ffi/src/lib.rs

@@ -1,8 +1,6 @@
-use algokit_transact::{constants, ALGORAND_PUBLIC_KEY_BYTE_LENGTH};
-use algokit_transact::{
-    AlgorandMsgpack, Byte32, EstimateTransactionSize, TransactionId, ALGORAND_SIGNATURE_BYTE_LENGTH,
-};
-use ffi_macros::{ffi_func, ffi_record};
+use algokit_transact::constants::*;
+use algokit_transact::{AlgorandMsgpack, Byte32, EstimateTransactionSize, TransactionId};
+use ffi_macros::{ffi_enum, ffi_func, ffi_record};
 use serde::{Deserialize, Serialize};
 use serde_bytes::ByteBuf;
 
@@ -477,47 +475,51 @@ pub fn get_transaction_id(tx: &Transaction) -> Result<String, AlgoKitTransactErr
     Ok(tx_internal.id()?)
 }
 
-#[ffi_func]
-pub fn get_hash_bytes_length() -> u64 {
-    constants::HASH_BYTES_LENGTH.try_into().unwrap()
-}
+/// Enum containing all constants used in this crate.
+#[ffi_enum]
+pub enum AlgorandConstant {
+    /// Length of hash digests (32)
+    HashLength,
 
-#[ffi_func]
-pub fn get_algorand_checksum_byte_length() -> u64 {
-    constants::ALGORAND_CHECKSUM_BYTE_LENGTH.try_into().unwrap()
-}
+    /// Length of the checksum used in Algorand addresses (4)
+    ChecksumLength,
 
-#[ffi_func]
-pub fn get_algorand_address_length() -> u64 {
-    constants::ALGORAND_ADDRESS_LENGTH.try_into().unwrap()
-}
+    /// Length of a base32-encoded Algorand address (58)
+    AddressLength,
 
-#[ffi_func]
-pub fn get_algorand_public_key_byte_length() -> u64 {
-    constants::ALGORAND_PUBLIC_KEY_BYTE_LENGTH
-        .try_into()
-        .unwrap()
-}
+    /// Length of an Algorand public key in bytes (32)
+    PublicKeyLength,
 
-#[ffi_func]
-pub fn get_algorand_secret_key_byte_length() -> u64 {
-    constants::ALGORAND_SECRET_KEY_BYTE_LENGTH
-        .try_into()
-        .unwrap()
+    /// Length of an Algorand secret key in bytes (32)
+    SecretKeyLength,
+
+    /// Length of an Algorand signature in bytes (64)
+    SignatureLength,
+
+    /// Increment in the encoded byte size when a signature is attached to a transaction (75)
+    SignatureEncodingIncrLength,
 }
 
-#[ffi_func]
-pub fn get_algorand_signature_byte_length() -> u64 {
-    constants::ALGORAND_SIGNATURE_BYTE_LENGTH
-        .try_into()
-        .unwrap()
+impl AlgorandConstant {
+    /// Get the numeric value of the constant
+    pub fn value(&self) -> u64 {
+        match self {
+            AlgorandConstant::HashLength => HASH_BYTES_LENGTH as u64,
+            AlgorandConstant::ChecksumLength => ALGORAND_CHECKSUM_BYTE_LENGTH as u64,
+            AlgorandConstant::AddressLength => ALGORAND_ADDRESS_LENGTH as u64,
+            AlgorandConstant::PublicKeyLength => ALGORAND_PUBLIC_KEY_BYTE_LENGTH as u64,
+            AlgorandConstant::SecretKeyLength => ALGORAND_SECRET_KEY_BYTE_LENGTH as u64,
+            AlgorandConstant::SignatureLength => ALGORAND_SIGNATURE_BYTE_LENGTH as u64,
+            AlgorandConstant::SignatureEncodingIncrLength => {
+                ALGORAND_SIGNATURE_ENCODING_INCR as u64
+            }
+        }
+    }
 }
 
 #[ffi_func]
-pub fn get_algorand_signature_encoding_incr() -> u64 {
-    constants::ALGORAND_SIGNATURE_ENCODING_INCR
-        .try_into()
-        .unwrap()
+pub fn get_algorand_constant(constant: AlgorandConstant) -> u64 {
+    constant.value()
 }
 
 #[cfg(test)]

crates/ffi_macros/src/lib.rs

@@ -3,7 +3,7 @@
 use convert_case::{Case, Casing};
 use proc_macro::TokenStream;
 use quote::{quote, ToTokens};
-use syn::{parse_macro_input, Field, Fields, ItemFn, ItemStruct, Type, TypePath};
+use syn::{parse_macro_input, Field, Fields, ItemEnum, ItemFn, ItemStruct, Type, TypePath};
 
 #[proc_macro_attribute]
 pub fn ffi_func(_attr: TokenStream, item: TokenStream) -> TokenStream {
@@ -56,6 +56,30 @@ pub fn ffi_record(_attr: TokenStream, item: TokenStream) -> TokenStream {
     combined.into()
 }
 
+#[proc_macro_attribute]
+pub fn ffi_enum(_attr: TokenStream, item: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(item as ItemEnum);
+
+    let enum_attrs = quote! {
+        #[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
+        #[cfg_attr(feature = "ffi_wasm", derive(Tsify))]
+        #[cfg_attr(
+            feature = "ffi_wasm",
+            tsify(into_wasm_abi, from_wasm_abi, large_number_types_as_bigints)
+        )]
+        #[cfg_attr(feature = "ffi_wasm", serde(rename_all = "camelCase"))]
+        #[cfg_attr(feature = "ffi_uniffi", derive(uniffi::Enum))]
+    };
+
+    // Combine original attributes with new ones
+    let combined = quote! {
+        #enum_attrs
+        #input
+    };
+
+    combined.into()
+}
+
 fn is_option_type(field: &Field) -> bool {
     if let Type::Path(TypePath { path, .. }) = &field.ty {
         if let Some(segment) = path.segments.last() {