build(android): preliminary Android support for algokit_transact

.github/workflows/android_ci.yml

@@ -0,0 +1,64 @@
+name: Android CI
+
+on:
+  workflow_dispatch:
+  push:
+    branches:
+      - main
+  pull_request:
+    branches:
+      - main
+
+jobs:
+  android:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout Code
+        uses: actions/checkout@v5
+
+      - name: Set up JDK 21
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '21'
+
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: 1.85.0
+          targets: aarch64-linux-android, arm-linux-androideabi, armv7-linux-androideabi, i686-linux-android, thumbv7neon-linux-androideabi, x86_64-linux-android
+
+      - name: Install Cargo-NDK
+        run: cargo install cargo-ndk@^3.5
+
+      - name: Install Android ndk
+        uses: nttld/setup-ndk@v1
+        with:
+          ndk-version: r27d
+
+      - name: Build AAR
+        run: cargo pkg transact aar
+
+      - name: Host Test
+        working-directory: packages/android/algokit_transact
+        run: ./gradlew test
+
+      - name: Enable KVM
+        run: |
+          echo 'KERNEL=="kvm", GROUP="kvm", MODE="0666", OPTIONS+="static_node=kvm"' | sudo tee /etc/udev/rules.d/99-kvm4all.rules
+          sudo udevadm control --reload-rules
+          sudo udevadm trigger --name-match=kvm
+
+      - name: Android Test
+        uses: reactivecircus/android-emulator-runner@v2
+        with:
+          api-level: 34
+          arch: x86_64
+          script: ./gradlew connectedAndroidTest
+          working-directory: packages/android/algokit_transact
+
+      - name: Archive Build Output
+        uses: actions/upload-artifact@v4
+        if: github.event_name == 'push' || github.event_name == 'workflow_dispatch'
+        with:
+          name: algokit_transact.aar
+          path: packages/android/algokit_transact/build/outputs/aar/algokit_transact-release.aar

.gitignore

@@ -1,4 +1,7 @@
 /target
+*.dylib
+*.a
+*.so
 .zed/
 .venv/
 crates/**/dist/
@@ -7,9 +10,18 @@ node_modules/
 .dmypy.json
 .build
 .bin/
+.vscode/
 .DS_Store
+*.idea
 wheelhouse/
 
+# Android/Kotlin
+.gradle/
+build/
+*.iml
+local.properties
+gradle-wrapper.jar
+
 # Insta snapshot testing
 *.snap.new
 *.pending-snap
@@ -22,6 +34,7 @@ AGENTS.md
 .opencode/
 .references/
 .kiro/
+.kotlin/
 
 packages/python/**/*algokit_*.py
 packages/python**/*.dll

README.md

@@ -30,6 +30,12 @@ The exported interfaces should be purely functional without any state owned by R
 
 ## Contributing
 
+## Build Scripts
+
+`cargo pkg` will run the build script. For example: `cargo pkg transact kt` builds `algokit_transact` for `kotlin`.
+
+The scripts are defined in [tools/build_pkgs] for each language.
+
 ### Learning Resources
 
 If you are new to Rust or UniFFI, check out the [learning resources document](./docs/contributing/learning_resources.md)

crates/algokit_transact/src/address.rs

@@ -65,12 +65,12 @@ impl FromStr for Address {
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         if s.len() != ALGORAND_ADDRESS_LENGTH {
             return Err(AlgoKitTransactError::InvalidAddress {
-                message: "Algorand address must be exactly 58 characters".into(),
+                err_msg: "Algorand address must be exactly 58 characters".into(),
             });
         }
         let decoded_address = base32::decode(base32::Alphabet::Rfc4648 { padding: false }, s)
             .ok_or_else(|| AlgoKitTransactError::InvalidAddress {
-                message: "Invalid base32 encoding for Algorand address".into(),
+                err_msg: "Invalid base32 encoding for Algorand address".into(),
             })?;
 
         // Although this is called public key (and it actually is when the account is a `KeyPairAccount`),
@@ -80,18 +80,18 @@ impl FromStr for Address {
             [..ALGORAND_PUBLIC_KEY_BYTE_LENGTH]
             .try_into()
             .map_err(|_| AlgoKitTransactError::InvalidAddress {
-                message: "Could not decode address into 32-byte public key".to_string(),
+                err_msg: "Could not decode address into 32-byte public key".to_string(),
             })?;
         let checksum: [u8; ALGORAND_CHECKSUM_BYTE_LENGTH] = decoded_address
             [ALGORAND_PUBLIC_KEY_BYTE_LENGTH..]
             .try_into()
             .map_err(|_| AlgoKitTransactError::InvalidAddress {
-                message: "Could not get 4-byte checksum from decoded address".to_string(),
+                err_msg: "Could not get 4-byte checksum from decoded address".to_string(),
             })?;
 
         if pub_key_to_checksum(&pub_key) != checksum {
             return Err(AlgoKitTransactError::InvalidAddress {
-                message: "Checksum is invalid".to_string(),
+                err_msg: "Checksum is invalid".to_string(),
             });
         }
         Ok(Address(pub_key))

crates/algokit_transact/src/error.rs

@@ -24,17 +24,17 @@ pub enum AlgoKitTransactError {
     #[snafu(display("Error ocurred during msgpack decoding: {source}"))]
     MsgpackDecodingError { source: rmpv::decode::Error },
 
-    #[snafu(display("Unknown transaction type: {message}"))]
-    UnknownTransactionType { message: String },
+    #[snafu(display("Unknown transaction type: {err_msg}"))]
+    UnknownTransactionType { err_msg: String },
 
-    #[snafu(display("{message}"))]
-    InputError { message: String },
+    #[snafu(display("{err_msg}"))]
+    InputError { err_msg: String },
 
-    #[snafu(display("{message}"))]
-    InvalidAddress { message: String },
+    #[snafu(display("{err_msg}"))]
+    InvalidAddress { err_msg: String },
 
-    #[snafu(display("Invalid multisig signature: {message}"))]
-    InvalidMultisigSignature { message: String },
+    #[snafu(display("Invalid multisig signature: {err_msg}"))]
+    InvalidMultisigSignature { err_msg: String },
 }
 
 impl From<rmp_serde::encode::Error> for AlgoKitTransactError {

crates/algokit_transact/src/multisig.rs

@@ -78,16 +78,16 @@ impl MultisigSignature {
     ) -> Result<Self, AlgoKitTransactError> {
         if version == 0 {
             return Err(AlgoKitTransactError::InvalidMultisigSignature {
-                message: "Version cannot be zero".to_string(),
+                err_msg: "Version cannot be zero".to_string(),
             });
         }
         if subsignatures.is_empty() {
             return Err(AlgoKitTransactError::InvalidMultisigSignature {
-                message: "Subsignatures cannot be empty".to_string(),
+                err_msg: "Subsignatures cannot be empty".to_string(),
             });
         }
         if threshold == 0 || threshold as usize > subsignatures.len() {
-            return Err(AlgoKitTransactError::InvalidMultisigSignature { message: "Threshold must be greater than zero and less than or equal to the number of sub-signers".to_string() });
+            return Err(AlgoKitTransactError::InvalidMultisigSignature { err_msg:"Threshold must be greater than zero and less than or equal to the number of sub-signers".to_string() });
         }
         Ok(Self {
             version,
@@ -138,7 +138,7 @@ impl MultisigSignature {
         }
         if !found {
             return Err(AlgoKitTransactError::InvalidMultisigSignature {
-                message: "Address not found in multisig signature".to_string(),
+                err_msg: "Address not found in multisig signature".to_string(),
             });
         }
 
@@ -161,17 +161,17 @@ impl MultisigSignature {
     pub fn merge(&self, other: &Self) -> Result<Self, AlgoKitTransactError> {
         if self.version != other.version {
             return Err(AlgoKitTransactError::InvalidMultisigSignature {
-                message: "Cannot merge multisig signatures with different versions".to_string(),
+                err_msg: "Cannot merge multisig signatures with different versions".to_string(),
             });
         }
         if self.threshold != other.threshold {
             return Err(AlgoKitTransactError::InvalidMultisigSignature {
-                message: "Cannot merge multisig signatures with different thresholds".to_string(),
+                err_msg: "Cannot merge multisig signatures with different thresholds".to_string(),
             });
         }
         if self.participants() != other.participants() {
             return Err(AlgoKitTransactError::InvalidMultisigSignature {
-                message: "Cannot merge multisig signatures with different participants".to_string(),
+                err_msg: "Cannot merge multisig signatures with different participants".to_string(),
             });
         }
 

crates/algokit_transact/src/traits.rs

@@ -63,7 +63,7 @@ pub trait AlgorandMsgpack: Serialize + for<'de> Deserialize<'de> {
     fn decode(bytes: &[u8]) -> Result<Self, AlgoKitTransactError> {
         if bytes.is_empty() {
             return Err(AlgoKitTransactError::InputError {
-                message: "attempted to decode 0 bytes".to_string(),
+                err_msg: "attempted to decode 0 bytes".to_string(),
             });
         }
 

crates/algokit_transact/src/transactions/mod.rs

@@ -138,7 +138,7 @@ impl Transaction {
         if let Some(max_fee) = request.max_fee {
             if calculated_fee > max_fee {
                 return Err(AlgoKitTransactError::InputError {
-                    message: format!(
+                    err_msg: format!(
                         "Transaction fee {} µALGO is greater than max fee {} µALGO",
                         calculated_fee, max_fee
                     ),
@@ -230,7 +230,7 @@ impl AlgorandMsgpack for SignedTransaction {
                 Ok(stxn)
             }
             _ => Err(AlgoKitTransactError::InputError {
-                message: format!(
+                err_msg: format!(
                     "expected signed transaction to be a map, but got a: {:#?}",
                     value.type_id()
                 ),

crates/algokit_transact/src/transactions/payment.rs

@@ -150,7 +150,7 @@ mod tests {
         let msg = format!("{}", err);
         assert!(
             msg == "Transaction fee 2470 µALGO is greater than max fee 1000 µALGO",
-            "Unexpected error message: {}",
+            "Unexpected error err_msg:{}",
             msg
         );
     }

crates/algokit_transact/src/utils.rs

@@ -32,7 +32,7 @@ pub fn sort_msgpack_value(value: rmpv::Value) -> Result<rmpv::Value, AlgoKitTran
                     rmpv::Value::Binary(bytes) => binary_entries.push((bytes, sorted_v)),
                     _ => {
                         return Err(AlgoKitTransactError::InputError {
-                            message: "Unsupported MessagePack map key type; only integer, string, and binary keys are supported".to_string(),
+                            err_msg: "Unsupported MessagePack map key type; only integer, string, and binary keys are supported".to_string(),
                         })
                     }
                 }
@@ -286,13 +286,13 @@ pub fn hash(bytes: &Vec<u8>) -> Byte32 {
 pub fn compute_group(txs: &[Transaction]) -> Result<Byte32, AlgoKitTransactError> {
     if txs.is_empty() {
         return Err(AlgoKitTransactError::InputError {
-            message: String::from("Transaction group size cannot be 0"),
+            err_msg: String::from("Transaction group size cannot be 0"),
         });
     }
 
     if txs.len() > MAX_TX_GROUP_SIZE {
         return Err(AlgoKitTransactError::InputError {
-            message: format!(
+            err_msg: format!(
                 "Transaction group size exceeds the max limit of {}",
                 MAX_TX_GROUP_SIZE
             ),
@@ -304,7 +304,7 @@ pub fn compute_group(txs: &[Transaction]) -> Result<Byte32, AlgoKitTransactError
         .map(|tx| {
             if tx.header().group.is_some() {
                 return Err(AlgoKitTransactError::InputError {
-                    message: "Transactions must not already be grouped".to_string(),
+                    err_msg: "Transactions must not already be grouped".to_string(),
                 });
             }
             tx.id_raw()