feat: added asset freeze to ak-utils ffi

Added asset freeze test to the current compose tests

Author: lempira

crates/algokit_utils_ffi/src/transactions/asset_freeze.rs

@@ -0,0 +1,34 @@
+use crate::transactions::common::UtilsError;
+
+use super::common::CommonParams;
+use algokit_utils::transactions::AssetFreezeParams as RustAssetFreezeParams;
+
+#[derive(uniffi::Record)]
+pub struct AssetFreezeParams {
+    /// Common transaction parameters.
+    pub common_params: CommonParams,
+
+    /// The ID of the asset being frozen.
+    pub asset_id: u64,
+
+    /// The target account whose asset holdings will be frozen.
+    pub target_address: String,
+}
+
+impl TryFrom<AssetFreezeParams> for RustAssetFreezeParams {
+    type Error = UtilsError;
+
+    fn try_from(params: AssetFreezeParams) -> Result<Self, Self::Error> {
+        let common_params = params.common_params.try_into()?;
+        Ok(RustAssetFreezeParams {
+            common_params,
+            asset_id: params.asset_id,
+            target_address: params
+                .target_address
+                .parse()
+                .map_err(|_| UtilsError::UtilsError {
+                    message: "Invalid target address".to_string(),
+                })?,
+        })
+    }
+}

crates/algokit_utils_ffi/src/transactions/composer.rs

@@ -61,6 +61,15 @@ impl Composer {
             })
     }
 
+    pub fn add_asset_freeze(&self, params: super::asset_freeze::AssetFreezeParams) -> Result<(), UtilsError> {
+        let mut composer = self.inner_composer.blocking_lock();
+        composer
+            .add_asset_freeze(params.try_into()?)
+            .map_err(|e| UtilsError::UtilsError {
+                message: e.to_string(),
+            })
+    }
+
     pub async fn send(&self) -> Result<Vec<String>, UtilsError> {
         let mut composer = self.inner_composer.blocking_lock();
         let result = composer

crates/algokit_utils_ffi/src/transactions/mod.rs

@@ -1,3 +1,4 @@
 pub mod common;
 pub mod composer;
 pub mod payment;
+pub mod asset_freeze;

packages/python/algokit_utils/algokit_utils/algokit_utils_ffi.py

@@ -470,6 +470,8 @@ def _uniffi_check_contract_api_version(lib):
         raise InternalError("UniFFI contract version mismatch: try cleaning and rebuilding your project")
 
 def _uniffi_check_api_checksums(lib):
+    if lib.uniffi_algokit_utils_ffi_checksum_method_composer_add_asset_freeze() != 44087:
+        raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     if lib.uniffi_algokit_utils_ffi_checksum_method_composer_add_payment() != 9188:
         raise InternalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
     if lib.uniffi_algokit_utils_ffi_checksum_method_composer_build() != 13184:
@@ -641,6 +643,12 @@ class _UniffiVTableCallbackInterfaceTransactionSignerGetter(ctypes.Structure):
     ctypes.POINTER(_UniffiRustCallStatus),
 )
 _UniffiLib.uniffi_algokit_utils_ffi_fn_constructor_composer_new.restype = ctypes.c_void_p
+_UniffiLib.uniffi_algokit_utils_ffi_fn_method_composer_add_asset_freeze.argtypes = (
+    ctypes.c_void_p,
+    _UniffiRustBuffer,
+    ctypes.POINTER(_UniffiRustCallStatus),
+)
+_UniffiLib.uniffi_algokit_utils_ffi_fn_method_composer_add_asset_freeze.restype = None
 _UniffiLib.uniffi_algokit_utils_ffi_fn_method_composer_add_payment.argtypes = (
     ctypes.c_void_p,
     _UniffiRustBuffer,
@@ -968,6 +976,9 @@ class _UniffiVTableCallbackInterfaceTransactionSignerGetter(ctypes.Structure):
     ctypes.POINTER(_UniffiRustCallStatus),
 )
 _UniffiLib.ffi_algokit_utils_ffi_rust_future_complete_void.restype = None
+_UniffiLib.uniffi_algokit_utils_ffi_checksum_method_composer_add_asset_freeze.argtypes = (
+)
+_UniffiLib.uniffi_algokit_utils_ffi_checksum_method_composer_add_asset_freeze.restype = ctypes.c_uint16
 _UniffiLib.uniffi_algokit_utils_ffi_checksum_method_composer_add_payment.argtypes = (
 )
 _UniffiLib.uniffi_algokit_utils_ffi_checksum_method_composer_add_payment.restype = ctypes.c_uint16
@@ -1120,6 +1131,61 @@ def write(value, buf):
 
 
 
+class AssetFreezeParams:
+    common_params: "CommonParams"
+    """
+    Common transaction parameters.
+    """
+
+    asset_id: "int"
+    """
+    The ID of the asset being frozen.
+    """
+
+    target_address: "str"
+    """
+    The target account whose asset holdings will be frozen.
+    """
+
+    def __init__(self, *, common_params: "CommonParams", asset_id: "int", target_address: "str"):
+        self.common_params = common_params
+        self.asset_id = asset_id
+        self.target_address = target_address
+
+    def __str__(self):
+        return "AssetFreezeParams(common_params={}, asset_id={}, target_address={})".format(self.common_params, self.asset_id, self.target_address)
+
+    def __eq__(self, other):
+        if self.common_params != other.common_params:
+            return False
+        if self.asset_id != other.asset_id:
+            return False
+        if self.target_address != other.target_address:
+            return False
+        return True
+
+class _UniffiConverterTypeAssetFreezeParams(_UniffiConverterRustBuffer):
+    @staticmethod
+    def read(buf):
+        return AssetFreezeParams(
+            common_params=_UniffiConverterTypeCommonParams.read(buf),
+            asset_id=_UniffiConverterUInt64.read(buf),
+            target_address=_UniffiConverterString.read(buf),
+        )
+
+    @staticmethod
+    def check_lower(value):
+        _UniffiConverterTypeCommonParams.check_lower(value.common_params)
+        _UniffiConverterUInt64.check_lower(value.asset_id)
+        _UniffiConverterString.check_lower(value.target_address)
+
+    @staticmethod
+    def write(value, buf):
+        _UniffiConverterTypeCommonParams.write(value.common_params, buf)
+        _UniffiConverterUInt64.write(value.asset_id, buf)
+        _UniffiConverterString.write(value.target_address, buf)
+
+
 class CommonParams:
     sender: "str"
     signer: "typing.Optional[TransactionSigner]"
@@ -1938,6 +2004,8 @@ def read(cls, buf: _UniffiRustBuffer):
     def write(cls, value: AlgodClientProtocol, buf: _UniffiRustBuffer):
         buf.write_u64(cls.lower(value))
 class ComposerProtocol(typing.Protocol):
+    def add_asset_freeze(self, params: "AssetFreezeParams"):
+        raise NotImplementedError
     def add_payment(self, params: "PaymentParams"):
         raise NotImplementedError
     def build(self, ):
@@ -1975,6 +2043,17 @@ def _make_instance_(cls, pointer):
         return inst
 
 
+    def add_asset_freeze(self, params: "AssetFreezeParams") -> None:
+        _UniffiConverterTypeAssetFreezeParams.check_lower(params)
+        
+        _uniffi_rust_call_with_error(_UniffiConverterTypeUtilsError,_UniffiLib.uniffi_algokit_utils_ffi_fn_method_composer_add_asset_freeze,self._uniffi_clone_pointer(),
+        _UniffiConverterTypeAssetFreezeParams.lower(params))
+
+
+
+
+
+
     def add_payment(self, params: "PaymentParams") -> None:
         _UniffiConverterTypePaymentParams.check_lower(params)
 
@@ -2174,6 +2253,7 @@ def _uniffi_foreign_future_do_free(task):
 __all__ = [
     "InternalError",
     "UtilsError",
+    "AssetFreezeParams",
     "CommonParams",
     "PaymentParams",
     "AlgodClient",

packages/python/algokit_utils/algokit_utils/libalgokit_utils_ffi.dylib

@@ -1,9 +1,14 @@
 from typing import override
 import typing
 from algokit_utils.algokit_http_client import HttpClient, HttpMethod, HttpResponse
-from algokit_utils.algokit_transact_ffi import SignedTransaction, Transaction, encode_transaction
+from algokit_utils.algokit_transact_ffi import (
+    SignedTransaction,
+    Transaction,
+    encode_transaction,
+)
 from algokit_utils import AlgodClient, TransactionSigner
 from algokit_utils.algokit_utils_ffi import (
+    AssetFreezeParams,
     CommonParams,
     Composer,
     PaymentParams,
@@ -32,7 +37,9 @@ async def sign_transactions(  # type: ignore
         for transaction in transactions:
             tx_for_signing = encode_transaction(transaction)
             sig = KEY.sign(tx_for_signing)
-            stxns.append(SignedTransaction(transaction=transaction, signature=sig.signature))
+            stxns.append(
+                SignedTransaction(transaction=transaction, signature=sig.signature)
+            )
 
         return stxns
 
@@ -65,11 +72,20 @@ async def request(  # type: ignore
         headers["X-Algo-API-Token"] = "a" * 64
 
         if method == HttpMethod.GET:
-            res = requests.get(f"http://localhost:4001/{path}", params=query, headers=headers)
+            res = requests.get(
+                f"http://localhost:4001/{path}", params=query, headers=headers
+            )
         elif method == HttpMethod.POST:
-            res = requests.post(f"http://localhost:4001/{path}", params=query, data=body, headers=headers)
+            res = requests.post(
+                f"http://localhost:4001/{path}",
+                params=query,
+                data=body,
+                headers=headers,
+            )
         else:
-            raise NotImplementedError(f"HTTP method {method} not implemented in test client")
+            raise NotImplementedError(
+                f"HTTP method {method} not implemented in test client"
+            )
 
         if res.status_code != 200:
             raise Exception(f"HTTP request failed: {res.status_code} {res.text}")
@@ -81,7 +97,7 @@ async def request(  # type: ignore
 
         return HttpResponse(
             body=res.content,
-            headers=res.headers # type: ignore
+            headers=res.headers,  # type: ignore
         )
 
 
@@ -106,5 +122,16 @@ async def test_composer():
         )
     )
 
+    # Test asset freeze functionality
+    composer.add_asset_freeze(
+        params=AssetFreezeParams(
+            common_params=CommonParams(
+                sender=ADDR,
+            ),
+            asset_id=12345,
+            target_address=ADDR,
+        )
+    )
+
     await composer.build()
     await composer.send()