algokit-utils 5.0.0a3__py3-none-any.whl

algokit_common/__init__.py

@@ -0,0 +1,50 @@
+from algokit_common.address import address_from_public_key, get_application_address, public_key_from_address
+from algokit_common.constants import *  # noqa: F403
+from algokit_common.hashing import base32_nopad_decode, base32_nopad_encode, sha512_256
+from algokit_common.serde import (
+    DecodeError,
+    EncodeError,
+    addr,
+    addr_seq,
+    bytes_seq,
+    enum_value,
+    flatten,
+    from_wire,
+    int_seq,
+    nested,
+    to_wire,
+    to_wire_canonical,
+    wire,
+)
+from algokit_common.source_map import (
+    PcLineLocation,
+    ProgramSourceMap,
+    SourceLocation,
+    SourceMapVersionError,
+)
+
+__all__ = [
+    "DecodeError",
+    "EncodeError",
+    "PcLineLocation",
+    "ProgramSourceMap",
+    "SourceLocation",
+    "SourceMapVersionError",
+    "addr",
+    "addr_seq",
+    "address_from_public_key",
+    "base32_nopad_decode",
+    "base32_nopad_encode",
+    "bytes_seq",
+    "enum_value",
+    "flatten",
+    "from_wire",
+    "get_application_address",
+    "int_seq",
+    "nested",
+    "public_key_from_address",
+    "sha512_256",
+    "to_wire",
+    "to_wire_canonical",
+    "wire",
+]

algokit_common/address.py

@@ -0,0 +1,34 @@
+from algokit_common.constants import CHECKSUM_BYTE_LENGTH, PUBLIC_KEY_BYTE_LENGTH
+from algokit_common.hashing import base32_nopad_decode, base32_nopad_encode, sha512_256
+
+APP_ID_PREFIX = b"appID"
+
+
+def public_key_from_address(address: str) -> bytes:
+    if not isinstance(address, str):
+        raise TypeError("address must be str")
+    raw = base32_nopad_decode(address)
+    if len(raw) != PUBLIC_KEY_BYTE_LENGTH + CHECKSUM_BYTE_LENGTH:
+        raise ValueError("invalid address length")
+    pk = raw[:PUBLIC_KEY_BYTE_LENGTH]
+    checksum = raw[PUBLIC_KEY_BYTE_LENGTH:]
+    expected = sha512_256(pk)[-CHECKSUM_BYTE_LENGTH:]
+    if checksum != expected:
+        raise ValueError("invalid address checksum")
+    return pk
+
+
+def address_from_public_key(public_key: bytes) -> str:
+    if len(public_key) != PUBLIC_KEY_BYTE_LENGTH:
+        raise ValueError("invalid public key length")
+    checksum = sha512_256(public_key)[-CHECKSUM_BYTE_LENGTH:]
+    return base32_nopad_encode(public_key + checksum)
+
+
+def get_application_address(app_id: int) -> str:
+    """Return the escrow address of an application."""
+    if not isinstance(app_id, int):
+        raise TypeError(f"Expected an int for app_id but received {type(app_id)}")
+    to_hash = APP_ID_PREFIX + app_id.to_bytes(8, "big")
+    hash_bytes = sha512_256(to_hash)
+    return address_from_public_key(hash_bytes)

algokit_common/constants.py

@@ -0,0 +1,47 @@
+TRANSACTION_DOMAIN_SEPARATOR = "TX"
+TRANSACTION_GROUP_DOMAIN_SEPARATOR = "TG"
+MULTISIG_DOMAIN_SEPARATOR = "MultisigAddr"
+LOGIC_DATA_DOMAIN_SEPARATOR = "ProgData"
+PROGRAM_DOMAIN_SEPARATOR = "Program"
+MX_BYTES_DOMAIN_SEPARATOR = "MX"
+MULTISIG_PROGRAM_DOMAIN_SEPARATOR = "MsigProgram"
+SIGNATURE_ENCODING_INCR = 75
+HASH_BYTES_LENGTH = 32
+PUBLIC_KEY_BYTE_LENGTH = 32
+MAX_TRANSACTION_GROUP_SIZE = 16
+CHECKSUM_BYTE_LENGTH = 4
+ADDRESS_LENGTH = 58
+TRANSACTION_ID_LENGTH = 52
+ZERO_ADDRESS = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAY5HFKQ"
+LENGTH_ENCODE_BYTE_SIZE = 2
+BOOL_TRUE_BYTE = 0x80
+BOOL_FALSE_BYTE = 0x00
+SIGNATURE_BYTE_LENGTH = 64
+EMPTY_SIGNATURE = bytes(SIGNATURE_BYTE_LENGTH)
+
+# Transaction fees and amounts
+MICROALGOS_TO_ALGOS_RATIO = 1_000_000
+MIN_TXN_FEE = 1000
+
+# Application program size constraints
+MAX_EXTRA_PROGRAM_PAGES = 3
+PROGRAM_PAGE_SIZE = 2048  # In bytes
+
+# Application reference limits
+MAX_APP_ARGS = 16
+MAX_ARGS_SIZE = 2048  # Maximum size in bytes of all args combined
+MAX_OVERALL_REFERENCES = 8
+MAX_ACCOUNT_REFERENCES = 8
+MAX_APP_REFERENCES = 8
+MAX_ASSET_REFERENCES = 8
+MAX_BOX_REFERENCES = 8
+
+# Application state schema limits
+MAX_GLOBAL_STATE_KEYS = 64
+MAX_LOCAL_STATE_KEYS = 16
+
+# Asset configuration limits
+MAX_ASSET_NAME_LENGTH = 32  # In bytes
+MAX_ASSET_UNIT_NAME_LENGTH = 8  # In bytes
+MAX_ASSET_URL_LENGTH = 96  # In bytes
+MAX_ASSET_DECIMALS = 19

algokit_common/hashing.py

@@ -0,0 +1,25 @@
+from typing import Final
+
+from Cryptodome.Hash import SHA512
+
+
+def sha512_256(data: bytes) -> bytes:
+    ch = SHA512.new(truncate="256")
+    ch.update(data)
+    return ch.digest()
+
+
+BASE32_ALPHABET_NO_PAD: Final[bytes] = b"ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"
+
+
+def base32_nopad_encode(data: bytes) -> str:
+    import base64
+
+    return base64.b32encode(data).decode().rstrip("=")
+
+
+def base32_nopad_decode(text: str) -> bytes:
+    import base64
+
+    pad_len = (-len(text)) % 8
+    return base64.b32decode(text + ("=" * pad_len))

algokit_common/serde/__init__.py

@@ -0,0 +1,40 @@
+"""Shared serialization helpers for AlgoKit dataclasses.
+
+The implementation mirrors the serde utilities that previously lived in
+``algokit_transact`` so that auto-generated API clients can share the same
+wire-format logic.
+"""
+
+from algokit_common.serde._core import (
+    DecodeError,
+    EncodeError,
+    addr,
+    addr_seq,
+    bytes_seq,
+    enum_value,
+    flatten,
+    from_wire,
+    int_seq,
+    nested,
+    sort_msgpack_value,
+    to_wire,
+    to_wire_canonical,
+    wire,
+)
+
+__all__ = [
+    "DecodeError",
+    "EncodeError",
+    "addr",
+    "addr_seq",
+    "bytes_seq",
+    "enum_value",
+    "flatten",
+    "from_wire",
+    "int_seq",
+    "nested",
+    "sort_msgpack_value",
+    "to_wire",
+    "to_wire_canonical",
+    "wire",
+]