feat(utils): Adds key registration support

Adds support for online, offline, and non-participation key
registration transactions to the composer.

This enhancement allows users to manage their account's
participation in the consensus protocol. Includes relevant
parameter structs and composer methods.

Also adds integration tests to verify the behavior of the
key registration transactions.

Author: aorumbayev

crates/algokit_utils/src/lib.rs

@@ -11,6 +11,7 @@ pub use testing::{
     AlgorandFixture, AlgorandTestContext, algorand_fixture, algorand_fixture_with_config,
 };
 pub use transactions::{
-    CommonParams, Composer, ComposerError, ComposerTxn, EmptySigner, PaymentParams, TxnSigner,
-    TxnSignerGetter,
+    CommonParams, Composer, ComposerError, ComposerTxn, EmptySigner,
+    NonParticipationKeyRegistrationParams, OfflineKeyRegistrationParams,
+    OnlineKeyRegistrationParams, PaymentParams, TxnSigner, TxnSignerGetter,
 };

crates/algokit_utils/src/transactions/composer.rs

@@ -4,8 +4,8 @@ use algod_client::{
     models::{PendingTransactionResponse, TransactionParams},
 };
 use algokit_transact::{
-    Address, AlgorandMsgpack, FeeParams, PaymentTransactionFields, SignedTransaction, Transaction,
-    TransactionHeader, Transactions,
+    Address, AlgorandMsgpack, FeeParams, KeyRegistrationTransactionFields,
+    PaymentTransactionFields, SignedTransaction, Transaction, TransactionHeader, Transactions,
 };
 use async_trait::async_trait;
 use derive_more::Debug;
@@ -98,6 +98,31 @@ pub struct AssetClawbackParams {
     pub clawback_target: Address,
 }
 
+#[derive(Debug, Clone)]
+pub struct OnlineKeyRegistrationParams {
+    pub common_params: CommonParams,
+    pub vote_key: [u8; 32],
+    pub selection_key: [u8; 32],
+    pub vote_first: u64,
+    pub vote_last: u64,
+    pub vote_key_dilution: u64,
+    pub state_proof_key: Option<[u8; 64]>,
+}
+
+#[derive(Debug, Clone)]
+pub struct OfflineKeyRegistrationParams {
+    pub common_params: CommonParams,
+    /// Whether to prevent the account from ever participating in consensus again.
+    /// - `false`: Temporary offline (can be brought back online later)
+    /// - `true`: Permanent offline (account can never participate again)
+    pub prevent_account_from_ever_participating_again: bool,
+}
+
+#[derive(Debug, Clone)]
+pub struct NonParticipationKeyRegistrationParams {
+    pub common_params: CommonParams,
+}
+
 #[derive(Debug, Clone)]
 pub enum ComposerTxn {
     Transaction(Transaction),
@@ -106,6 +131,9 @@ pub enum ComposerTxn {
     AssetOptIn(AssetOptInParams),
     AssetOptOut(AssetOptOutParams),
     AssetClawback(AssetClawbackParams),
+    OnlineKeyRegistration(OnlineKeyRegistrationParams),
+    OfflineKeyRegistration(OfflineKeyRegistrationParams),
+    NonParticipationKeyRegistration(NonParticipationKeyRegistrationParams),
 }
 
 impl ComposerTxn {
@@ -124,6 +152,15 @@ impl ComposerTxn {
             ComposerTxn::AssetClawback(asset_clawback_params) => {
                 asset_clawback_params.common_params.clone()
             }
+            ComposerTxn::OnlineKeyRegistration(online_key_reg_params) => {
+                online_key_reg_params.common_params.clone()
+            }
+            ComposerTxn::OfflineKeyRegistration(offline_key_reg_params) => {
+                offline_key_reg_params.common_params.clone()
+            }
+            ComposerTxn::NonParticipationKeyRegistration(non_participation_params) => {
+                non_participation_params.common_params.clone()
+            }
             _ => CommonParams::default(),
         }
     }
@@ -205,6 +242,10 @@ impl Composer {
         self.built_group.as_ref()
     }
 
+    pub fn signed_group(&self) -> Option<&Vec<SignedTransaction>> {
+        self.signed_group.as_ref()
+    }
+
     #[cfg(feature = "default_http_client")]
     pub fn testnet() -> Self {
         Composer {
@@ -256,6 +297,29 @@ impl Composer {
         self.push(ComposerTxn::AssetClawback(asset_clawback_params))
     }
 
+    pub fn add_online_key_registration(
+        &mut self,
+        online_key_reg_params: OnlineKeyRegistrationParams,
+    ) -> Result<(), String> {
+        self.push(ComposerTxn::OnlineKeyRegistration(online_key_reg_params))
+    }
+
+    pub fn add_offline_key_registration(
+        &mut self,
+        offline_key_reg_params: OfflineKeyRegistrationParams,
+    ) -> Result<(), String> {
+        self.push(ComposerTxn::OfflineKeyRegistration(offline_key_reg_params))
+    }
+
+    pub fn add_non_participation_key_registration(
+        &mut self,
+        non_participation_params: NonParticipationKeyRegistrationParams,
+    ) -> Result<(), String> {
+        self.push(ComposerTxn::NonParticipationKeyRegistration(
+            non_participation_params,
+        ))
+    }
+
     pub fn add_transaction(&mut self, transaction: Transaction) -> Result<(), String> {
         self.push(ComposerTxn::Transaction(transaction))
     }
@@ -378,6 +442,48 @@ impl Composer {
                             },
                         )
                     }
+                    ComposerTxn::OnlineKeyRegistration(online_key_reg_params) => {
+                        Transaction::KeyRegistration(KeyRegistrationTransactionFields {
+                            header,
+                            vote_key: Some(online_key_reg_params.vote_key),
+                            selection_key: Some(online_key_reg_params.selection_key),
+                            vote_first: Some(online_key_reg_params.vote_first),
+                            vote_last: Some(online_key_reg_params.vote_last),
+                            vote_key_dilution: Some(online_key_reg_params.vote_key_dilution),
+                            state_proof_key: online_key_reg_params.state_proof_key,
+                            non_participation: None,
+                        })
+                    }
+                    ComposerTxn::OfflineKeyRegistration(offline_key_reg_params) => {
+                        Transaction::KeyRegistration(KeyRegistrationTransactionFields {
+                            header,
+                            vote_key: None,
+                            selection_key: None,
+                            vote_first: None,
+                            vote_last: None,
+                            vote_key_dilution: None,
+                            state_proof_key: None,
+                            non_participation: if offline_key_reg_params
+                                .prevent_account_from_ever_participating_again
+                            {
+                                Some(true)
+                            } else {
+                                None
+                            },
+                        })
+                    }
+                    ComposerTxn::NonParticipationKeyRegistration(_) => {
+                        Transaction::KeyRegistration(KeyRegistrationTransactionFields {
+                            header,
+                            vote_key: None,
+                            selection_key: None,
+                            vote_first: None,
+                            vote_last: None,
+                            vote_key_dilution: None,
+                            state_proof_key: None,
+                            non_participation: Some(true),
+                        })
+                    }
                 };
 
                 if calculate_fee {
@@ -731,6 +837,94 @@ mod tests {
         assert!(composer.built_group().is_some());
     }
 
+    #[tokio::test]
+    async fn test_build_online_key_registration() {
+        let mut composer = Composer::testnet();
+        let online_key_reg_params = OnlineKeyRegistrationParams {
+            common_params: CommonParams {
+                sender: AddressMother::address(),
+                signer: None,
+                rekey_to: None,
+                note: None,
+                lease: None,
+                static_fee: None,
+                extra_fee: None,
+                max_fee: None,
+                validity_window: None,
+                first_valid_round: None,
+                last_valid_round: None,
+            },
+            vote_key: [1u8; 32],
+            selection_key: [2u8; 32],
+            vote_first: 100000,
+            vote_last: 200000,
+            vote_key_dilution: 10000,
+            state_proof_key: Some([3u8; 64]),
+        };
+        assert!(
+            composer
+                .add_online_key_registration(online_key_reg_params)
+                .is_ok()
+        );
+        assert!(composer.build().await.is_ok());
+        assert!(composer.built_group().is_some());
+    }
+
+    #[tokio::test]
+    async fn test_build_offline_key_registration() {
+        let mut composer = Composer::testnet();
+        let offline_key_reg_params = OfflineKeyRegistrationParams {
+            common_params: CommonParams {
+                sender: AddressMother::address(),
+                signer: None,
+                rekey_to: None,
+                note: None,
+                lease: None,
+                static_fee: None,
+                extra_fee: None,
+                max_fee: None,
+                validity_window: None,
+                first_valid_round: None,
+                last_valid_round: None,
+            },
+            prevent_account_from_ever_participating_again: false,
+        };
+        assert!(
+            composer
+                .add_offline_key_registration(offline_key_reg_params)
+                .is_ok()
+        );
+        assert!(composer.build().await.is_ok());
+        assert!(composer.built_group().is_some());
+    }
+
+    #[tokio::test]
+    async fn test_build_non_participation_key_registration() {
+        let mut composer = Composer::testnet();
+        let non_participation_params = NonParticipationKeyRegistrationParams {
+            common_params: CommonParams {
+                sender: AddressMother::address(),
+                signer: None,
+                rekey_to: None,
+                note: None,
+                lease: None,
+                static_fee: None,
+                extra_fee: None,
+                max_fee: None,
+                validity_window: None,
+                first_valid_round: None,
+                last_valid_round: None,
+            },
+        };
+        assert!(
+            composer
+                .add_non_participation_key_registration(non_participation_params)
+                .is_ok()
+        );
+        assert!(composer.build().await.is_ok());
+        assert!(composer.built_group().is_some());
+    }
+
     #[tokio::test]
     async fn test_gather_signatures() {
         let mut composer = Composer::new(AlgodClient::testnet(), Some(Arc::new(EmptySigner {})));

crates/algokit_utils/src/transactions/mod.rs

@@ -2,6 +2,7 @@ pub mod composer;
 
 // Re-export commonly used transaction types
 pub use composer::{
-    CommonParams, Composer, ComposerError, ComposerTxn, EmptySigner, PaymentParams, TxnSigner,
-    TxnSignerGetter,
+    CommonParams, Composer, ComposerError, ComposerTxn, EmptySigner,
+    NonParticipationKeyRegistrationParams, OfflineKeyRegistrationParams,
+    OnlineKeyRegistrationParams, PaymentParams, TxnSigner, TxnSignerGetter,
 };