algokit-utils 5.0.0a3__py3-none-any.whl

algokit_indexer_client/models/_serde_helpers.py

@@ -0,0 +1,241 @@
+# AUTO-GENERATED: oas_generator
+import base64
+from binascii import Error as BinasciiError
+from collections.abc import Callable, Iterable, Mapping
+from dataclasses import is_dataclass
+from enum import Enum
+from typing import TypeAlias, TypeVar
+
+from algokit_common.serde import from_wire, to_wire
+
+DecodedT = TypeVar("DecodedT")
+EnumValueT = TypeVar("EnumValueT", bound=Enum)
+MapKeyT = TypeVar("MapKeyT")
+BytesLike: TypeAlias = bytes | bytearray | memoryview
+
+
+def _coerce_bytes(value: bytes | bytearray | memoryview) -> bytes:
+    if isinstance(value, memoryview):
+        return value.tobytes()
+    if isinstance(value, bytearray):
+        return bytes(value)
+    return value
+
+
+def encode_bytes_base64(value: BytesLike) -> str:
+    return base64.b64encode(_coerce_bytes(value)).decode("ascii")
+
+
+def decode_bytes_base64(raw: object) -> bytes:
+    if isinstance(raw, bytes | bytearray | memoryview):
+        return bytes(raw)
+    if isinstance(raw, str):
+        try:
+            return base64.b64decode(raw.encode("ascii"), validate=True)
+        except (BinasciiError, UnicodeEncodeError) as exc:
+            raise ValueError("Invalid base64 payload") from exc
+    raise TypeError(f"Unsupported value for bytes field: {type(raw)!r}")
+
+
+def encode_fixed_bytes_base64(value: BytesLike, expected_length: int) -> str:
+    """Encode fixed-length bytes to base64, validating the length."""
+    coerced = _coerce_bytes(value)
+    if len(coerced) != expected_length:
+        raise ValueError(f"Expected {expected_length} bytes, got {len(coerced)}")
+    return base64.b64encode(coerced).decode("ascii")
+
+
+def decode_fixed_bytes_base64(raw: object, expected_length: int) -> bytes:
+    """Decode base64 to fixed-length bytes, validating the length."""
+    decoded = decode_bytes_base64(raw)
+    if len(decoded) != expected_length:
+        raise ValueError(f"Expected {expected_length} bytes, got {len(decoded)}")
+    return decoded
+
+
+def decode_bytes_map_key(raw: object) -> bytes:
+    if isinstance(raw, bytes | bytearray | memoryview):
+        return bytes(raw)
+    if isinstance(raw, str):
+        try:
+            return decode_bytes_base64(raw)
+        except ValueError:
+            try:
+                return raw.encode("utf-8")
+            except UnicodeEncodeError as fallback_exc:
+                raise ValueError("Invalid bytes map key") from fallback_exc
+    raise TypeError(f"Unsupported map key for bytes field: {type(raw)!r}")
+
+
+def encode_bytes_sequence(values: Iterable[BytesLike | None] | None) -> list[str | None] | None:
+    if values is None:
+        return None
+    encoded: list[str | None] = []
+    for value in values:
+        if value is None:
+            encoded.append(None)
+            continue
+        if not isinstance(value, bytes | bytearray | memoryview):
+            raise TypeError(f"Unsupported value for bytes field sequence: {type(value)!r}")
+        encoded.append(encode_bytes_base64(value))
+    return encoded or None
+
+
+def decode_bytes_sequence(raw: object) -> list[bytes | None] | None:
+    if not isinstance(raw, list):
+        return None
+    decoded: list[bytes | None] = []
+    for item in raw:
+        if item is None:
+            decoded.append(None)
+            continue
+        decoded.append(decode_bytes_base64(item))
+    return decoded or None
+
+
+def encode_fixed_bytes_sequence(
+    values: Iterable[BytesLike | None] | None, expected_length: int
+) -> list[str | None] | None:
+    """Encode a sequence of fixed-length bytes to base64, validating each element's length."""
+    if values is None:
+        return None
+    encoded: list[str | None] = []
+    for value in values:
+        if value is None:
+            encoded.append(None)
+            continue
+        if not isinstance(value, bytes | bytearray | memoryview):
+            raise TypeError(f"Unsupported value for bytes field sequence: {type(value)!r}")
+        encoded.append(encode_fixed_bytes_base64(value, expected_length))
+    return encoded or None
+
+
+def decode_fixed_bytes_sequence(raw: object, expected_length: int) -> list[bytes | None] | None:
+    """Decode a sequence of base64 strings to fixed-length bytes, validating each element's length."""
+    if not isinstance(raw, list):
+        return None
+    decoded: list[bytes | None] = []
+    for item in raw:
+        if item is None:
+            decoded.append(None)
+            continue
+        decoded.append(decode_fixed_bytes_base64(item, expected_length))
+    return decoded or None
+
+
+def encode_model_sequence(values: Iterable[object] | None) -> list[dict[str, object]] | None:
+    if values is None:
+        return None
+    encoded: list[dict[str, object]] = []
+    for value in values:
+        if value is None:
+            continue
+        encoded.append(to_wire(value))
+    return encoded or None
+
+
+def decode_model_sequence(cls_factory: Callable[[], type[DecodedT]], raw: object) -> list[DecodedT] | None:
+    if not isinstance(raw, list):
+        return None
+    cls = cls_factory()
+    decoded: list[DecodedT] = []
+    for item in raw:
+        if isinstance(item, Mapping):
+            decoded.append(from_wire(cls, item))
+    return decoded or None
+
+
+def encode_enum_sequence(values: Iterable[object] | None) -> list[object] | None:
+    if values is None:
+        return None
+    encoded: list[object] = []
+    for value in values:
+        if value is None:
+            continue
+        encoded.append(value.value if hasattr(value, "value") else value)
+    return encoded or None
+
+
+def decode_enum_sequence(enum_factory: Callable[[], type[EnumValueT]], raw: object) -> list[EnumValueT] | None:
+    if not isinstance(raw, list):
+        return None
+    enum_cls = enum_factory()
+    decoded: list[EnumValueT] = []
+    for item in raw:
+        try:
+            decoded.append(enum_cls(item))
+        except Exception:
+            continue
+    return decoded or None
+
+
+def encode_model_mapping(
+    factory: Callable[[], type[DecodedT]],
+    mapping: Mapping[object, object] | None,
+    *,
+    key_encoder: Callable[[object], str] | None = None,
+) -> dict[str, object] | None:
+    if mapping is None:
+        return None
+    cls = factory()
+    encoded: dict[str, object] = {}
+    for key, value in mapping.items():
+        if value is None:
+            continue
+        encoded_key: str
+        if key_encoder is not None:
+            encoded_key = key_encoder(key)
+        elif isinstance(key, str):
+            encoded_key = key
+        else:
+            encoded_key = str(key)
+        if isinstance(value, cls) or is_dataclass(value):
+            encoded[encoded_key] = to_wire(value)
+        else:
+            encoded[encoded_key] = value
+    return encoded or None
+
+
+def decode_model_mapping(
+    factory: Callable[[], type[DecodedT]],
+    raw: object,
+    *,
+    key_decoder: Callable[[object], MapKeyT] | None = None,
+) -> dict[MapKeyT, DecodedT] | None:
+    if not isinstance(raw, Mapping):
+        return None
+    cls = factory()
+    decoded: dict[MapKeyT, DecodedT] = {}
+    for key, value in raw.items():
+        if isinstance(value, Mapping):
+            decoded_key = key_decoder(key) if key_decoder is not None else key
+            decoded[decoded_key] = from_wire(cls, value)
+    return decoded or None
+
+
+def decode_optional_bool(raw: object) -> bool | None:
+    if raw is None:
+        return None
+    return bool(raw)
+
+
+def mapping_encoder(
+    factory: Callable[[], type[DecodedT]],
+    *,
+    key_encoder: Callable[[object], str] | None = None,
+) -> Callable[[Mapping[object, object] | None], dict[str, object] | None]:
+    def _encode(mapping: Mapping[object, object] | None) -> dict[str, object] | None:
+        return encode_model_mapping(factory, mapping, key_encoder=key_encoder)
+
+    return _encode
+
+
+def mapping_decoder(
+    factory: Callable[[], type[DecodedT]],
+    *,
+    key_decoder: Callable[[object], MapKeyT] | None = None,
+) -> Callable[[object], dict[MapKeyT, DecodedT] | None]:
+    def _decode(raw: object) -> dict[MapKeyT, DecodedT] | None:
+        return decode_model_mapping(factory, raw, key_decoder=key_decoder)
+
+    return _decode

algokit_indexer_client/models/_state_delta.py

@@ -0,0 +1,6 @@
+# AUTO-GENERATED: oas_generator
+
+
+from ._eval_delta_key_value import EvalDeltaKeyValue
+
+StateDelta = list[EvalDeltaKeyValue]

algokit_indexer_client/models/_state_proof_fields.py

@@ -0,0 +1,57 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested, wire
+
+from ._merkle_array_proof import MerkleArrayProof
+from ._serde_helpers import decode_bytes_base64, decode_model_sequence, encode_bytes_base64, encode_model_sequence
+from ._state_proof_reveal import StateProofReveal
+
+
+@dataclass(slots=True)
+class StateProofFields:
+    r"""
+    \[sp\] represents a state proof.
+
+    Definition:
+    crypto/stateproof/structs.go : StateProof
+    """
+
+    part_proofs: MerkleArrayProof | None = field(
+        default=None,
+        metadata=nested("part-proofs", lambda: MerkleArrayProof),
+    )
+    positions_to_reveal: list[int] | None = field(
+        default=None,
+        metadata=wire("positions-to-reveal"),
+    )
+    reveals: list[StateProofReveal] | None = field(
+        default=None,
+        metadata=wire(
+            "reveals",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: StateProofReveal, raw),
+        ),
+    )
+    salt_version: int | None = field(
+        default=None,
+        metadata=wire("salt-version"),
+    )
+    sig_commit: bytes | None = field(
+        default=None,
+        metadata=wire(
+            "sig-commit",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )
+    sig_proofs: MerkleArrayProof | None = field(
+        default=None,
+        metadata=nested("sig-proofs", lambda: MerkleArrayProof),
+    )
+    signed_weight: int | None = field(
+        default=None,
+        metadata=wire("signed-weight"),
+    )

algokit_indexer_client/models/_state_proof_participant.py

@@ -0,0 +1,20 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested, wire
+
+from ._state_proof_verifier import StateProofVerifier
+
+
+@dataclass(slots=True)
+class StateProofParticipant:
+    verifier: StateProofVerifier | None = field(
+        default=None,
+        metadata=nested("verifier", lambda: StateProofVerifier),
+    )
+    weight: int | None = field(
+        default=None,
+        metadata=wire("weight"),
+    )

algokit_indexer_client/models/_state_proof_reveal.py

@@ -0,0 +1,25 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested, wire
+
+from ._state_proof_participant import StateProofParticipant
+from ._state_proof_sig_slot import StateProofSigSlot
+
+
+@dataclass(slots=True)
+class StateProofReveal:
+    participant: StateProofParticipant | None = field(
+        default=None,
+        metadata=nested("participant", lambda: StateProofParticipant),
+    )
+    position: int | None = field(
+        default=None,
+        metadata=wire("position"),
+    )
+    sig_slot: StateProofSigSlot | None = field(
+        default=None,
+        metadata=nested("sig-slot", lambda: StateProofSigSlot),
+    )

algokit_indexer_client/models/_state_proof_sig_slot.py

@@ -0,0 +1,20 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested, wire
+
+from ._state_proof_signature import StateProofSignature
+
+
+@dataclass(slots=True)
+class StateProofSigSlot:
+    lower_sig_weight: int | None = field(
+        default=None,
+        metadata=wire("lower-sig-weight"),
+    )
+    signature: StateProofSignature | None = field(
+        default=None,
+        metadata=nested("signature", lambda: StateProofSignature),
+    )

algokit_indexer_client/models/_state_proof_signature.py

@@ -0,0 +1,37 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested, wire
+
+from ._merkle_array_proof import MerkleArrayProof
+from ._serde_helpers import decode_bytes_base64, encode_bytes_base64
+
+
+@dataclass(slots=True)
+class StateProofSignature:
+    falcon_signature: bytes | None = field(
+        default=None,
+        metadata=wire(
+            "falcon-signature",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )
+    merkle_array_index: int | None = field(
+        default=None,
+        metadata=wire("merkle-array-index"),
+    )
+    proof: MerkleArrayProof | None = field(
+        default=None,
+        metadata=nested("proof", lambda: MerkleArrayProof),
+    )
+    verifying_key: bytes | None = field(
+        default=None,
+        metadata=wire(
+            "verifying-key",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )

algokit_indexer_client/models/_state_proof_tracking.py

@@ -0,0 +1,32 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+from ._serde_helpers import decode_bytes_base64, encode_bytes_base64
+
+
+@dataclass(slots=True)
+class StateProofTracking:
+    next_round: int | None = field(
+        default=None,
+        metadata=wire("next-round"),
+    )
+    online_total_weight: int | None = field(
+        default=None,
+        metadata=wire("online-total-weight"),
+    )
+    type_: int | None = field(
+        default=None,
+        metadata=wire("type"),
+    )
+    voters_commitment: bytes | None = field(
+        default=None,
+        metadata=wire(
+            "voters-commitment",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )

algokit_indexer_client/models/_state_proof_verifier.py

@@ -0,0 +1,24 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+from ._serde_helpers import decode_fixed_bytes_base64, encode_fixed_bytes_base64
+
+
+@dataclass(slots=True)
+class StateProofVerifier:
+    commitment: bytes | None = field(
+        default=None,
+        metadata=wire(
+            "commitment",
+            encode=lambda v: encode_fixed_bytes_base64(v, 64),
+            decode=lambda raw: decode_fixed_bytes_base64(raw, 64),
+        ),
+    )
+    key_lifetime: int | None = field(
+        default=None,
+        metadata=wire("key-lifetime"),
+    )

algokit_indexer_client/models/_state_schema.py

@@ -0,0 +1,25 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+
+@dataclass(slots=True)
+class StateSchema:
+    r"""
+    Represents a \[apls\] local-state or \[apgs\] global-state schema. These schemas
+    determine how much storage may be used in a local-state or global-state for an
+    application. The more space used, the larger minimum balance must be maintained in the
+    account holding the data.
+    """
+
+    num_byte_slices: int = field(
+        default=0,
+        metadata=wire("num-byte-slice"),
+    )
+    num_uints: int = field(
+        default=0,
+        metadata=wire("num-uint"),
+    )

algokit_indexer_client/models/_teal_key_value.py

@@ -0,0 +1,28 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested, wire
+
+from ._serde_helpers import decode_bytes_base64, encode_bytes_base64
+from ._teal_value import TealValue
+
+
+@dataclass(slots=True)
+class TealKeyValue:
+    """
+    Represents a key-value pair in an application store.
+    """
+
+    value: TealValue = field(
+        metadata=nested("value", lambda: TealValue, required=True),
+    )
+    key: bytes = field(
+        default=b"",
+        metadata=wire(
+            "key",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )

algokit_indexer_client/models/_teal_key_value_store.py

@@ -0,0 +1,6 @@
+# AUTO-GENERATED: oas_generator
+
+
+from ._teal_key_value import TealKeyValue
+
+TealKeyValueStore = list[TealKeyValue]

algokit_indexer_client/models/_teal_value.py

@@ -0,0 +1,32 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+from ._serde_helpers import decode_bytes_base64, encode_bytes_base64
+
+
+@dataclass(slots=True)
+class TealValue:
+    """
+    Represents a TEAL value.
+    """
+
+    bytes_: bytes = field(
+        default=b"",
+        metadata=wire(
+            "bytes",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )
+    type_: int = field(
+        default=0,
+        metadata=wire("type"),
+    )
+    uint: int = field(
+        default=0,
+        metadata=wire("uint"),
+    )