Merge pull request #79 from algorandfoundation/chore/extract-signature-bytes-length

feat: better constants for the rust crate and exposed through an enum + impl in the ffi crate

Author: CiottiGiorgio

crates/algokit_transact/src/address.rs

@@ -70,7 +70,8 @@ impl FromStr for Address {
         let decoded = base32::decode(base32::Alphabet::Rfc4648 { padding: false }, s)
             .expect("decoded value should exist");
 
-        let pub_key: [u8; 32] = decoded[..ALGORAND_PUBLIC_KEY_BYTE_LENGTH]
+        let pub_key: [u8; ALGORAND_PUBLIC_KEY_BYTE_LENGTH] = decoded
+            [..ALGORAND_PUBLIC_KEY_BYTE_LENGTH]
             .try_into()
             .map_err(|_| {
                 AlgoKitTransactError::InvalidAddress(
@@ -107,12 +108,13 @@ impl Display for Address {
     /// # Returns
     /// A formatting result with a string containing the base32-encoded address or error
     fn fmt(&self, f: &mut Formatter<'_>) -> FmtResult {
-        let mut address_bytes = [0u8; 36]; // 32 bytes pub_key + 4 bytes checksum
+        let mut address_bytes =
+            [0u8; ALGORAND_PUBLIC_KEY_BYTE_LENGTH + ALGORAND_CHECKSUM_BYTE_LENGTH];
 
-        address_bytes[..32].copy_from_slice(&self.pub_key);
+        address_bytes[..ALGORAND_PUBLIC_KEY_BYTE_LENGTH].copy_from_slice(&self.pub_key);
 
         let checksum = self.checksum();
-        address_bytes[32..].copy_from_slice(&checksum);
+        address_bytes[ALGORAND_PUBLIC_KEY_BYTE_LENGTH..].copy_from_slice(&checksum);
 
         let result = base32::encode(base32::Alphabet::Rfc4648 { padding: false }, &address_bytes);
         write!(f, "{}", result)

crates/algokit_transact/src/constants.rs

@@ -2,5 +2,7 @@ pub const HASH_BYTES_LENGTH: usize = 32;
 pub const ALGORAND_CHECKSUM_BYTE_LENGTH: usize = 4;
 pub const ALGORAND_ADDRESS_LENGTH: usize = 58;
 pub const ALGORAND_PUBLIC_KEY_BYTE_LENGTH: usize = 32;
+pub const ALGORAND_SECRET_KEY_BYTE_LENGTH: usize = 32;
+pub const ALGORAND_SIGNATURE_BYTE_LENGTH: usize = 64;
 pub const ALGORAND_SIGNATURE_ENCODING_INCR: usize = 75;
 pub type Byte32 = [u8; 32];

crates/algokit_transact/src/lib.rs

@@ -1,16 +1,13 @@
 mod address;
-mod constants;
+pub mod constants;
 mod error;
 mod traits;
 mod transactions;
 mod utils;
 
 // Re-export all the public items
 pub use address::Address;
-pub use constants::{
-    Byte32, ALGORAND_ADDRESS_LENGTH, ALGORAND_CHECKSUM_BYTE_LENGTH,
-    ALGORAND_PUBLIC_KEY_BYTE_LENGTH, HASH_BYTES_LENGTH,
-};
+pub use constants::*;
 pub use error::AlgoKitTransactError;
 pub use traits::{AlgorandMsgpack, EstimateTransactionSize, TransactionId};
 pub use transactions::{

crates/algokit_transact/src/test_utils/mod.rs

@@ -1,7 +1,7 @@
 use crate::{
     transactions::{AssetTransferTransactionBuilder, PaymentTransactionBuilder},
     Address, AlgorandMsgpack, Byte32, SignedTransaction, Transaction, TransactionHeaderBuilder,
-    TransactionId,
+    TransactionId, ALGORAND_PUBLIC_KEY_BYTE_LENGTH, HASH_BYTES_LENGTH,
 };
 use base64::{prelude::BASE64_STANDARD, Engine};
 use convert_case::{Case, Casing};
@@ -107,7 +107,7 @@ impl TransactionMother {
 pub struct AddressMother {}
 impl AddressMother {
     pub fn zero_address() -> Address {
-        Address::from_pubkey(&[0; 32])
+        Address::from_pubkey(&[0; ALGORAND_PUBLIC_KEY_BYTE_LENGTH])
     }
 
     pub fn address() -> Address {
@@ -131,7 +131,7 @@ impl TransactionTestData {
     pub fn new(transaction: Transaction, signing_private_key: Byte32) -> Self {
         let signing_key: SigningKey = SigningKey::from_bytes(&signing_private_key);
         let id = transaction.id().unwrap();
-        let raw_id: [u8; 32] = transaction.raw_id().unwrap();
+        let raw_id: [u8; HASH_BYTES_LENGTH] = transaction.raw_id().unwrap();
         let unsigned_bytes = transaction.encode().unwrap();
         let signature = signing_key.sign(&unsigned_bytes);
         let signed_txn = SignedTransaction {

crates/algokit_transact/src/tests.rs

@@ -1,4 +1,4 @@
-use crate::constants::ALGORAND_SIGNATURE_ENCODING_INCR;
+use crate::constants::{ALGORAND_SIGNATURE_BYTE_LENGTH, ALGORAND_SIGNATURE_ENCODING_INCR};
 use crate::{
     test_utils::{AddressMother, TransactionMother},
     Address, AlgorandMsgpack, EstimateTransactionSize, SignedTransaction, Transaction,
@@ -19,7 +19,7 @@ fn test_payment_transaction_encoding() {
 
     let signed_tx = SignedTransaction {
         transaction: payment_tx.clone(),
-        signature: [0; 64],
+        signature: [0; ALGORAND_SIGNATURE_BYTE_LENGTH],
     };
     let encoded_stx = signed_tx.encode().unwrap();
     let decoded_stx = SignedTransaction::decode(&encoded_stx).unwrap();
@@ -50,7 +50,7 @@ fn test_asset_transfer_transaction_encoding() {
 
     let signed_tx = SignedTransaction {
         transaction: asset_transfer_tx.clone(),
-        signature: [0; 64],
+        signature: [0; ALGORAND_SIGNATURE_BYTE_LENGTH],
     };
     let encoded_stx = signed_tx.encode().unwrap();
     let decoded_stx = SignedTransaction::decode(&encoded_stx).unwrap();
@@ -100,7 +100,7 @@ fn test_pay_transaction_raw_id() {
     let payment_tx = tx_builder.build().unwrap();
     let signed_tx = SignedTransaction {
         transaction: payment_tx.clone(),
-        signature: [0; 64],
+        signature: [0; ALGORAND_SIGNATURE_BYTE_LENGTH],
     };
 
     assert_eq!(payment_tx.raw_id().unwrap(), expected_tx_id);
@@ -115,7 +115,7 @@ fn test_pay_transaction_id() {
     let payment_tx = tx_builder.build().unwrap();
     let signed_tx = SignedTransaction {
         transaction: payment_tx.clone(),
-        signature: [0; 64],
+        signature: [0; ALGORAND_SIGNATURE_BYTE_LENGTH],
     };
 
     assert_eq!(payment_tx.id().unwrap(), expected_tx_id);
@@ -131,7 +131,7 @@ fn test_estimate_transaction_size() {
 
     let signed_tx = SignedTransaction {
         transaction: payment_tx.clone(),
-        signature: [0; 64],
+        signature: [0; ALGORAND_SIGNATURE_BYTE_LENGTH],
     };
     let actual_size = signed_tx.encode().unwrap().len();
 

crates/algokit_transact/src/transactions/mod.rs

@@ -14,7 +14,9 @@ pub use common::{TransactionHeader, TransactionHeaderBuilder};
 use payment::PaymentTransactionBuilderError;
 pub use payment::{PaymentTransactionBuilder, PaymentTransactionFields};
 
-use crate::constants::{ALGORAND_SIGNATURE_ENCODING_INCR, HASH_BYTES_LENGTH};
+use crate::constants::{
+    ALGORAND_SIGNATURE_BYTE_LENGTH, ALGORAND_SIGNATURE_ENCODING_INCR, HASH_BYTES_LENGTH,
+};
 use crate::error::AlgoKitTransactError;
 use crate::traits::{AlgorandMsgpack, EstimateTransactionSize, TransactionId};
 use serde::{Deserialize, Serialize};
@@ -76,7 +78,7 @@ pub struct SignedTransaction {
     /// The Ed25519 signature authorizing the transaction.
     #[serde(rename = "sig")]
     #[serde_as(as = "Bytes")]
-    pub signature: [u8; 64],
+    pub signature: [u8; ALGORAND_SIGNATURE_BYTE_LENGTH],
 }
 
 impl AlgorandMsgpack for SignedTransaction {

crates/algokit_transact/src/utils.rs

@@ -1,5 +1,6 @@
 use crate::address::Address;
 use crate::constants::{Byte32, ALGORAND_CHECKSUM_BYTE_LENGTH, HASH_BYTES_LENGTH};
+use crate::ALGORAND_PUBLIC_KEY_BYTE_LENGTH;
 use sha2::{Digest, Sha512_256};
 use std::collections::BTreeMap;
 
@@ -37,7 +38,7 @@ pub fn is_zero(n: &u64) -> bool {
 }
 
 pub fn is_zero_addr(addr: &Address) -> bool {
-    addr.pub_key == [0u8; 32]
+    addr.pub_key == [0u8; ALGORAND_PUBLIC_KEY_BYTE_LENGTH]
 }
 
 pub fn is_zero_addr_opt(addr: &Option<Address>) -> bool {

crates/algokit_transact_ffi/build.rs

@@ -1,3 +1,5 @@
+use algokit_transact::{ALGORAND_SECRET_KEY_BYTE_LENGTH, HASH_BYTES_LENGTH};
+
 include!("src/lib.rs");
 
 fn main() {
@@ -11,12 +13,12 @@ fn generate_test_data() {
 
     #[derive(Serialize)]
     struct TransactionTestData {
-        signing_private_key: [u8; 32],
+        signing_private_key: [u8; ALGORAND_SECRET_KEY_BYTE_LENGTH],
         transaction: Transaction,
         unsigned_bytes: Vec<u8>,
         signed_bytes: Vec<u8>,
         id: String,
-        raw_id: [u8; 32],
+        raw_id: [u8; HASH_BYTES_LENGTH],
     }
 
     test_utils::TestDataMother::export(

crates/algokit_transact_ffi/src/lib.rs

@@ -1,5 +1,6 @@
+use algokit_transact::constants::*;
 use algokit_transact::{AlgorandMsgpack, Byte32, EstimateTransactionSize, TransactionId};
-use ffi_macros::{ffi_func, ffi_record};
+use ffi_macros::{ffi_enum, ffi_func, ffi_record};
 use serde::{Deserialize, Serialize};
 use serde_bytes::ByteBuf;
 
@@ -116,9 +117,16 @@ impl TryFrom<Address> for algokit_transact::Address {
     type Error = AlgoKitTransactError;
 
     fn try_from(value: Address) -> Result<Self, Self::Error> {
-        let pub_key: [u8; 32] = value.pub_key.to_vec().try_into().map_err(|_| {
-            AlgoKitTransactError::EncodingError("public key should be 32 bytes".to_string())
-        })?;
+        let pub_key: [u8; ALGORAND_PUBLIC_KEY_BYTE_LENGTH] =
+            value.pub_key.to_vec().try_into().map_err(|_| {
+                AlgoKitTransactError::EncodingError(
+                    format!(
+                        "public key should be {} bytes",
+                        ALGORAND_PUBLIC_KEY_BYTE_LENGTH
+                    )
+                    .to_string(),
+                )
+            })?;
 
         Ok(algokit_transact::Address::from_pubkey(&pub_key))
     }
@@ -401,7 +409,10 @@ pub fn attach_signature(
     let encoded_tx = algokit_transact::Transaction::decode(encoded_tx)?;
     let signed_tx = algokit_transact::SignedTransaction {
         transaction: encoded_tx,
-        signature: signature.try_into().expect("signature should be 64 bytes"),
+        signature: signature.try_into().expect(&format!(
+            "signature should be {} bytes",
+            ALGORAND_SIGNATURE_BYTE_LENGTH
+        )),
     };
     Ok(signed_tx.encode()?)
 }
@@ -429,7 +440,13 @@ pub fn estimate_transaction_size(transaction: &Transaction) -> Result<u64, AlgoK
 pub fn address_from_pub_key(pub_key: &[u8]) -> Result<Address, AlgoKitTransactError> {
     Ok(
         algokit_transact::Address::from_pubkey(pub_key.try_into().map_err(|_| {
-            AlgoKitTransactError::EncodingError("public key should be 32 bytes".to_string())
+            AlgoKitTransactError::EncodingError(
+                format!(
+                    "public key should be {} bytes",
+                    ALGORAND_PUBLIC_KEY_BYTE_LENGTH
+                )
+                .to_string(),
+            )
         })?)
         .into(),
     )
@@ -458,6 +475,53 @@ pub fn get_transaction_id(tx: &Transaction) -> Result<String, AlgoKitTransactErr
     Ok(tx_internal.id()?)
 }
 
+/// Enum containing all constants used in this crate.
+#[ffi_enum]
+pub enum AlgorandConstant {
+    /// Length of hash digests (32)
+    HashLength,
+
+    /// Length of the checksum used in Algorand addresses (4)
+    ChecksumLength,
+
+    /// Length of a base32-encoded Algorand address (58)
+    AddressLength,
+
+    /// Length of an Algorand public key in bytes (32)
+    PublicKeyLength,
+
+    /// 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,
+}
+
+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_constant(constant: AlgorandConstant) -> u64 {
+    constant.value()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

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() {