refactor!: aligning field names with ts (#240)

Renames fields in `SignedTransaction`, `LogicSignature`, and `MultisigSubsignature`
to align with TypeScript SDK naming conventions.

This change improves consistency across platforms and simplifies future integration efforts.

Author: aorumbayev

src/algokit_transact/codec/signed.py

@@ -11,16 +11,16 @@
 
 
 def _validate_signed_transaction(stx: SignedTransaction) -> None:
-    validate_transaction(stx.transaction)
+    validate_transaction(stx.txn)
 
-    signatures = [stx.signature, stx.multi_signature, stx.logic_signature]
+    signatures = [stx.sig, stx.msig, stx.lsig]
     set_count = sum(1 for item in signatures if item is not None)
     if set_count == 0:
         raise ValueError("At least one signature type must be set")
     if set_count > 1:
         raise ValueError("Only one signature type can be set")
 
-    if stx.signature is not None and len(stx.signature) != SIGNATURE_BYTE_LENGTH:
+    if stx.sig is not None and len(stx.sig) != SIGNATURE_BYTE_LENGTH:
         raise ValueError("Signature must be 64 bytes")
 
 
@@ -40,7 +40,7 @@ def decode_signed_transaction(encoded: bytes) -> SignedTransaction:
         raise ValueError("decoded signed transaction is not a dict")
     dto = cast(dict[str, object], raw)
     stx = from_wire(SignedTransaction, dto)
-    if not isinstance(stx.transaction, Transaction):
+    if not isinstance(stx.txn, Transaction):
         raise ValueError("signed transaction missing 'txn'")
     return stx
 

src/algokit_transact/logicsig.py

@@ -114,16 +114,16 @@ def signer(txn_group: Sequence[AlgokitTransaction], indexes_to_sign: Sequence[in
                 logic_sig = LogicSignature(
                     logic=program,
                     args=args,
-                    signature=signature,
-                    multi_signature=multisig_sig,
+                    sig=signature,
+                    msig=multisig_sig,
                 )
                 auth_addr = lsig_address if txn.sender != lsig_address else None
 
                 signed = SignedTransaction(
-                    transaction=txn,
-                    signature=None,
-                    multi_signature=None,
-                    logic_signature=logic_sig,
+                    txn=txn,
+                    sig=None,
+                    msig=None,
+                    lsig=logic_sig,
                     auth_address=auth_addr,
                 )
                 blobs.append(encode_signed_transaction(signed))
@@ -207,7 +207,7 @@ def delegate_multisig(
 
         address_to_signer = {account.addr: account.delegated_lsig_signer for account in signing_accounts}
 
-        for subsig in msig.subsignatures:
+        for subsig in msig.subsigs:
             subsig_addr = address_from_public_key(subsig.public_key)
             if subsig_addr in address_to_signer:
                 signature = address_to_signer[subsig_addr](self._program, msig_public_key)

src/algokit_transact/models/signed_transaction.py

@@ -8,13 +8,13 @@
 
 @dataclass(slots=True, frozen=True)
 class SignedTransaction:
-    transaction: Transaction = field(metadata=nested("txn", Transaction))
-    signature: bytes | None = field(default=None, metadata=wire("sig"))
-    multi_signature: MultisigSignature | None = field(
+    txn: Transaction = field(metadata=nested("txn", Transaction))
+    sig: bytes | None = field(default=None, metadata=wire("sig"))
+    msig: MultisigSignature | None = field(
         default=None,
         metadata=nested("msig", MultisigSignature),
     )
-    logic_signature: LogicSignature | None = field(
+    lsig: LogicSignature | None = field(
         default=None,
         metadata=nested("lsig", LogicSignature),
     )

src/algokit_transact/multisig.py

@@ -64,17 +64,17 @@ def signer(txn_group: Sequence[AlgokitTransaction], indexes_to_sign: Sequence[in
                 payload = encode_transaction(txn)
 
                 multisig_sig = base_multisig
-                for subsig in base_multisig.subsignatures:
+                for subsig in base_multisig.subsigs:
                     subsig_addr = address_from_public_key(subsig.public_key)
                     if subsig_addr in address_to_signer:
                         signature = address_to_signer[subsig_addr](payload)
                         multisig_sig = apply_multisig_subsignature(multisig_sig, subsig_addr, signature)
 
                 signed = SignedTransaction(
-                    transaction=txn,
-                    signature=None,
-                    multi_signature=multisig_sig,
-                    logic_signature=None,
+                    txn=txn,
+                    sig=None,
+                    msig=multisig_sig,
+                    lsig=None,
                     auth_address=msig_address if txn.sender != msig_address else None,
                 )
                 blobs.append(encode_signed_transaction(signed))

src/algokit_transact/signer.py

@@ -112,8 +112,8 @@ def transaction_signer(txn_group: Sequence[Transaction], indexes_to_sign: Sequen
             bytes_to_sign = encode_transaction(txn)
             signature = raw_ed25519_signer(bytes_to_sign)
             stxn = SignedTransaction(
-                transaction=txn,
-                signature=signature,
+                txn=txn,
+                sig=signature,
                 auth_address=auth_addr if txn.sender != auth_addr else None,
             )
             result.append(encode_signed_transaction(stxn))
@@ -151,8 +151,8 @@ def empty_signer(txn_group: Sequence[Transaction], indexes_to_sign: Sequence[int
         result: list[bytes] = []
         for index in indexes_to_sign:
             stxn = SignedTransaction(
-                transaction=txn_group[index],
-                signature=EMPTY_SIGNATURE,
+                txn=txn_group[index],
+                sig=EMPTY_SIGNATURE,
             )
             result.append(encode_signed_transaction(stxn))
         return result

src/algokit_transact/signing/logic_signature.py

@@ -8,12 +8,12 @@
 class LogicSignature:
     logic: bytes = field(metadata=wire("l"))
     args: list[bytes] | None = field(default=None, metadata=bytes_seq("arg"))
-    signature: bytes | None = field(default=None, metadata=wire("sig"))
-    multi_signature: MultisigSignature | None = field(
+    sig: bytes | None = field(default=None, metadata=wire("sig"))
+    msig: MultisigSignature | None = field(
         default=None,
         metadata=nested("msig", MultisigSignature),
     )
-    logic_multi_signature: MultisigSignature | None = field(
+    lmsig: MultisigSignature | None = field(
         default=None,
         metadata=nested("lmsig", MultisigSignature),
     )

src/algokit_transact/signing/multisig.py

@@ -20,17 +20,17 @@ def new_multisig_signature(version: int, threshold: int, participants: Iterable[
     if threshold == 0 or threshold > len(participants):
         raise ValueError("Threshold must be greater than zero and less than or equal to the number of participants")
 
-    subsignatures = [MultisigSubsignature(public_key=public_key_from_address(address)) for address in participants]
-    return MultisigSignature(version=version, threshold=threshold, subsignatures=subsignatures)
+    subsigs = [MultisigSubsignature(public_key=public_key_from_address(address)) for address in participants]
+    return MultisigSignature(version=version, threshold=threshold, subsigs=subsigs)
 
 
 def participants_from_multisig_signature(multisig_signature: MultisigSignature) -> list[str]:
-    return [address_from_public_key(subsig.public_key) for subsig in multisig_signature.subsignatures]
+    return [address_from_public_key(subsig.public_key) for subsig in multisig_signature.subsigs]
 
 
 def address_from_multisig_signature(multisig_signature: MultisigSignature) -> str:
     prefix = MULTISIG_DOMAIN_SEPARATOR.encode()
-    participant_keys = [subsig.public_key for subsig in multisig_signature.subsignatures]
+    participant_keys = [subsig.public_key for subsig in multisig_signature.subsigs]
 
     buffer = bytearray()
     buffer.extend(prefix)
@@ -51,15 +51,15 @@ def apply_multisig_subsignature(
     found = False
     updated = []
     participant_pk = public_key_from_address(participant)
-    for subsig in multisig_signature.subsignatures:
+    for subsig in multisig_signature.subsigs:
         if subsig.public_key == participant_pk:
             found = True
-            updated.append(MultisigSubsignature(public_key=subsig.public_key, signature=signature))
+            updated.append(MultisigSubsignature(public_key=subsig.public_key, sig=signature))
         else:
             updated.append(subsig)
     if not found:
         raise ValueError("Address not found in multisig signature")
-    return replace(multisig_signature, subsignatures=updated)
+    return replace(multisig_signature, subsigs=updated)
 
 
 def merge_multisignatures(multisig_a: MultisigSignature, multisig_b: MultisigSignature) -> MultisigSignature:
@@ -74,11 +74,11 @@ def merge_multisignatures(multisig_a: MultisigSignature, multisig_b: MultisigSig
         raise ValueError("Cannot merge multisig signatures with different participants")
 
     merged_subsigs = []
-    for subsig_a, subsig_b in zip(multisig_a.subsignatures, multisig_b.subsignatures, strict=False):
-        signature = subsig_b.signature if subsig_b.signature is not None else subsig_a.signature
-        merged_subsigs.append(MultisigSubsignature(public_key=subsig_a.public_key, signature=signature))
+    for subsig_a, subsig_b in zip(multisig_a.subsigs, multisig_b.subsigs, strict=False):
+        sig = subsig_b.sig if subsig_b.sig is not None else subsig_a.sig
+        merged_subsigs.append(MultisigSubsignature(public_key=subsig_a.public_key, sig=sig))
     return MultisigSignature(
         version=multisig_a.version,
         threshold=multisig_a.threshold,
-        subsignatures=merged_subsigs,
+        subsigs=merged_subsigs,
     )

src/algokit_transact/signing/types.py

@@ -27,13 +27,13 @@ def _decode_subsig_seq(value: object) -> object:
 @dataclass(slots=True, frozen=True)
 class MultisigSubsignature:
     public_key: bytes = field(metadata=wire("pk"))
-    signature: bytes | None = field(default=None, metadata=wire("s"))
+    sig: bytes | None = field(default=None, metadata=wire("s"))
 
 
 @dataclass(slots=True, frozen=True)
 class MultisigSignature:
     version: int = field(metadata=wire("v", keep_zero=True))
     threshold: int = field(metadata=wire("thr", keep_zero=True))
-    subsignatures: list[MultisigSubsignature] = field(
+    subsigs: list[MultisigSubsignature] = field(
         metadata=wire("subsig", encode=_encode_subsig_seq, decode=_decode_subsig_seq)
     )

src/algokit_utils/transactions/builders/common.py

@@ -250,7 +250,7 @@ def calculate_inner_fee_delta(
     current = acc
     for inner in reversed(inner_txns):
         recursive_delta = calculate_inner_fee_delta(inner.inner_txns, min_fee, current)
-        txn_fee = inner.txn.transaction.fee or 0
+        txn_fee = inner.txn.txn.fee or 0
         txn_fee_delta = FeeDelta.from_int(min_fee - txn_fee)
         combined = FeeDelta.add(recursive_delta, txn_fee_delta)
 

tests/clients/algorand_client/test_transfer.py

@@ -48,7 +48,7 @@ def test_transfer_algo_is_sent_and_waited_for(algorand: AlgorandClient, funded_a
     assert result.transaction.payment
     assert result.transaction.payment.amount == 5_000_000
 
-    assert result.transaction.sender == funded_account.addr == result.confirmation.txn.transaction.sender
+    assert result.transaction.sender == funded_account.addr == result.confirmation.txn.txn.sender
     assert account_info.amount == 5_000_000