algokit-utils 5.0.0a3__py3-none-any.whl

algokit_algod_client/models/_post_transactions_response.py

@@ -0,0 +1,14 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+
+@dataclass(slots=True)
+class PostTransactionsResponse:
+    tx_id: str = field(
+        default="",
+        metadata=wire("txId"),
+    )

algokit_algod_client/models/_scratch_change.py

@@ -0,0 +1,23 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested, wire
+
+from ._avm_value import AvmValue
+
+
+@dataclass(slots=True)
+class ScratchChange:
+    """
+    A write operation into a scratch slot.
+    """
+
+    new_value: AvmValue = field(
+        metadata=nested("new-value", lambda: AvmValue, required=True),
+    )
+    slot: int = field(
+        default=0,
+        metadata=wire("slot"),
+    )

algokit_algod_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_algod_client/models/_simulate_initial_states.py

@@ -0,0 +1,25 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+from ._application_initial_states import ApplicationInitialStates
+from ._serde_helpers import decode_model_sequence, encode_model_sequence
+
+
+@dataclass(slots=True)
+class SimulateInitialStates:
+    """
+    Initial states of resources that were accessed during simulation.
+    """
+
+    app_initial_states: list[ApplicationInitialStates] | None = field(
+        default=None,
+        metadata=wire(
+            "app-initial-states",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: ApplicationInitialStates, raw),
+        ),
+    )

algokit_algod_client/models/_simulate_request.py

@@ -0,0 +1,54 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested, wire
+
+from ._serde_helpers import decode_model_sequence, encode_model_sequence
+from ._simulate_request_transaction_group import SimulateRequestTransactionGroup
+from ._simulate_trace_config import SimulateTraceConfig
+
+
+@dataclass(slots=True)
+class SimulateRequest:
+    """
+    Request type for simulation endpoint.
+    """
+
+    txn_groups: list[SimulateRequestTransactionGroup] = field(
+        default_factory=list,
+        metadata=wire(
+            "txn-groups",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: SimulateRequestTransactionGroup, raw),
+        ),
+    )
+    allow_empty_signatures: bool | None = field(
+        default=None,
+        metadata=wire("allow-empty-signatures"),
+    )
+    allow_more_logging: bool | None = field(
+        default=None,
+        metadata=wire("allow-more-logging"),
+    )
+    allow_unnamed_resources: bool | None = field(
+        default=None,
+        metadata=wire("allow-unnamed-resources"),
+    )
+    exec_trace_config: SimulateTraceConfig | None = field(
+        default=None,
+        metadata=nested("exec-trace-config", lambda: SimulateTraceConfig),
+    )
+    extra_opcode_budget: int | None = field(
+        default=None,
+        metadata=wire("extra-opcode-budget"),
+    )
+    fix_signers: bool | None = field(
+        default=None,
+        metadata=wire("fix-signers"),
+    )
+    round_: int | None = field(
+        default=None,
+        metadata=wire("round"),
+    )

algokit_algod_client/models/_simulate_request_transaction_group.py

@@ -0,0 +1,25 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+from algokit_transact.models.signed_transaction import SignedTransaction
+
+from ._serde_helpers import decode_model_sequence, encode_model_sequence
+
+
+@dataclass(slots=True)
+class SimulateRequestTransactionGroup:
+    """
+    A transaction group to simulate.
+    """
+
+    txns: list[SignedTransaction] = field(
+        default_factory=list,
+        metadata=wire(
+            "txns",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: SignedTransaction, raw),
+        ),
+    )

algokit_algod_client/models/_simulate_response.py

@@ -0,0 +1,44 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested, wire
+
+from ._serde_helpers import decode_model_sequence, encode_model_sequence
+from ._simulate_initial_states import SimulateInitialStates
+from ._simulate_trace_config import SimulateTraceConfig
+from ._simulate_transaction_group_result import SimulateTransactionGroupResult
+from ._simulation_eval_overrides import SimulationEvalOverrides
+
+
+@dataclass(slots=True)
+class SimulateResponse:
+    last_round: int = field(
+        default=0,
+        metadata=wire("last-round"),
+    )
+    txn_groups: list[SimulateTransactionGroupResult] = field(
+        default_factory=list,
+        metadata=wire(
+            "txn-groups",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: SimulateTransactionGroupResult, raw),
+        ),
+    )
+    version: int = field(
+        default=0,
+        metadata=wire("version"),
+    )
+    eval_overrides: SimulationEvalOverrides | None = field(
+        default=None,
+        metadata=nested("eval-overrides", lambda: SimulationEvalOverrides),
+    )
+    exec_trace_config: SimulateTraceConfig | None = field(
+        default=None,
+        metadata=nested("exec-trace-config", lambda: SimulateTraceConfig),
+    )
+    initial_states: SimulateInitialStates | None = field(
+        default=None,
+        metadata=nested("initial-states", lambda: SimulateInitialStates),
+    )

algokit_algod_client/models/_simulate_trace_config.py

@@ -0,0 +1,30 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+
+@dataclass(slots=True)
+class SimulateTraceConfig:
+    """
+    An object that configures simulation execution trace.
+    """
+
+    enable: bool | None = field(
+        default=None,
+        metadata=wire("enable"),
+    )
+    scratch_change: bool | None = field(
+        default=None,
+        metadata=wire("scratch-change"),
+    )
+    stack_change: bool | None = field(
+        default=None,
+        metadata=wire("stack-change"),
+    )
+    state_change: bool | None = field(
+        default=None,
+        metadata=wire("state-change"),
+    )

algokit_algod_client/models/_simulate_transaction_group_result.py

@@ -0,0 +1,46 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested, wire
+
+from ._serde_helpers import decode_model_sequence, encode_model_sequence
+from ._simulate_transaction_result import SimulateTransactionResult
+from ._simulate_unnamed_resources_accessed import SimulateUnnamedResourcesAccessed
+
+
+@dataclass(slots=True)
+class SimulateTransactionGroupResult:
+    """
+    Simulation result for an atomic transaction group
+    """
+
+    txn_results: list[SimulateTransactionResult] = field(
+        default_factory=list,
+        metadata=wire(
+            "txn-results",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: SimulateTransactionResult, raw),
+        ),
+    )
+    app_budget_added: int | None = field(
+        default=None,
+        metadata=wire("app-budget-added"),
+    )
+    app_budget_consumed: int | None = field(
+        default=None,
+        metadata=wire("app-budget-consumed"),
+    )
+    failed_at: list[int] | None = field(
+        default=None,
+        metadata=wire("failed-at"),
+    )
+    failure_message: str | None = field(
+        default=None,
+        metadata=wire("failure-message"),
+    )
+    unnamed_resources_accessed: SimulateUnnamedResourcesAccessed | None = field(
+        default=None,
+        metadata=nested("unnamed-resources-accessed", lambda: SimulateUnnamedResourcesAccessed),
+    )

algokit_algod_client/models/_simulate_transaction_result.py

@@ -0,0 +1,41 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested, wire
+
+from ._pending_transaction_response import PendingTransactionResponse
+from ._simulate_unnamed_resources_accessed import SimulateUnnamedResourcesAccessed
+from ._simulation_transaction_exec_trace import SimulationTransactionExecTrace
+
+
+@dataclass(slots=True)
+class SimulateTransactionResult:
+    """
+    Simulation result for an individual transaction
+    """
+
+    txn_result: PendingTransactionResponse = field(
+        metadata=nested("txn-result", lambda: PendingTransactionResponse, required=True),
+    )
+    app_budget_consumed: int | None = field(
+        default=None,
+        metadata=wire("app-budget-consumed"),
+    )
+    exec_trace: SimulationTransactionExecTrace | None = field(
+        default=None,
+        metadata=nested("exec-trace", lambda: SimulationTransactionExecTrace),
+    )
+    fixed_signer: str | None = field(
+        default=None,
+        metadata=wire("fixed-signer"),
+    )
+    logic_sig_budget_consumed: int | None = field(
+        default=None,
+        metadata=wire("logic-sig-budget-consumed"),
+    )
+    unnamed_resources_accessed: SimulateUnnamedResourcesAccessed | None = field(
+        default=None,
+        metadata=nested("unnamed-resources-accessed", lambda: SimulateUnnamedResourcesAccessed),
+    )

algokit_algod_client/models/_simulate_unnamed_resources_accessed.py

@@ -0,0 +1,64 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+from algokit_transact.models.app_call import BoxReference, HoldingReference, LocalsReference
+
+from ._serde_helpers import decode_model_sequence, encode_model_sequence
+
+
+@dataclass(slots=True)
+class SimulateUnnamedResourcesAccessed:
+    """
+    These are resources that were accessed by this group that would normally have caused
+    failure, but were allowed in simulation. Depending on where this object is in the
+    response, the unnamed resources it contains may or may not qualify for group resource
+    sharing. If this is a field in SimulateTransactionGroupResult, the resources do qualify,
+    but if this is a field in SimulateTransactionResult, they do not qualify. In order to
+    make this group valid for actual submission, resources that qualify for group sharing
+    can be made available by any transaction of the group; otherwise, resources must be
+    placed in the same transaction which accessed them.
+    """
+
+    accounts: list[str] | None = field(
+        default=None,
+        metadata=wire("accounts"),
+    )
+    app_locals: list[LocalsReference] | None = field(
+        default=None,
+        metadata=wire(
+            "app-locals",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: LocalsReference, raw),
+        ),
+    )
+    apps: list[int] | None = field(
+        default=None,
+        metadata=wire("apps"),
+    )
+    asset_holdings: list[HoldingReference] | None = field(
+        default=None,
+        metadata=wire(
+            "asset-holdings",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: HoldingReference, raw),
+        ),
+    )
+    assets: list[int] | None = field(
+        default=None,
+        metadata=wire("assets"),
+    )
+    boxes: list[BoxReference] | None = field(
+        default=None,
+        metadata=wire(
+            "boxes",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: BoxReference, raw),
+        ),
+    )
+    extra_box_refs: int | None = field(
+        default=None,
+        metadata=wire("extra-box-refs"),
+    )

algokit_algod_client/models/_simulation_eval_overrides.py

@@ -0,0 +1,40 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+
+@dataclass(slots=True)
+class SimulationEvalOverrides:
+    """
+    The set of parameters and limits override during simulation. If this set of parameters
+    is present, then evaluation parameters may differ from standard evaluation in certain
+    ways.
+    """
+
+    allow_empty_signatures: bool | None = field(
+        default=None,
+        metadata=wire("allow-empty-signatures"),
+    )
+    allow_unnamed_resources: bool | None = field(
+        default=None,
+        metadata=wire("allow-unnamed-resources"),
+    )
+    extra_opcode_budget: int | None = field(
+        default=None,
+        metadata=wire("extra-opcode-budget"),
+    )
+    fix_signers: bool | None = field(
+        default=None,
+        metadata=wire("fix-signers"),
+    )
+    max_log_calls: int | None = field(
+        default=None,
+        metadata=wire("max-log-calls"),
+    )
+    max_log_size: int | None = field(
+        default=None,
+        metadata=wire("max-log-size"),
+    )