algokit-utils 5.0.0a3__py3-none-any.whl

algokit_kmd_client/models/_list_keys_response.py

@@ -0,0 +1,18 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+
+@dataclass(slots=True)
+class ListKeysResponse:
+    """
+    ListKeysResponse is the response to `POST /v1/key/list`
+    """
+
+    addresses: list[str] = field(
+        default_factory=list,
+        metadata=wire("addresses"),
+    )

algokit_kmd_client/models/_list_multisig_request.py

@@ -0,0 +1,18 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+
+@dataclass(slots=True)
+class ListMultisigRequest:
+    """
+    The request for `POST /v1/multisig/list`
+    """
+
+    wallet_handle_token: str = field(
+        default="",
+        metadata=wire("wallet_handle_token"),
+    )

algokit_kmd_client/models/_list_multisig_response.py

@@ -0,0 +1,18 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+
+@dataclass(slots=True)
+class ListMultisigResponse:
+    """
+    ListMultisigResponse is the response to `POST /v1/multisig/list`
+    """
+
+    addresses: list[str] = field(
+        default_factory=list,
+        metadata=wire("addresses"),
+    )

algokit_kmd_client/models/_list_wallets_request.py

@@ -0,0 +1,11 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass
+
+
+@dataclass(slots=True)
+class ListWalletsRequest:
+    """
+    APIV1GETWalletsRequest is the request for `GET /v1/wallets`
+    """

algokit_kmd_client/models/_list_wallets_response.py

@@ -0,0 +1,25 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+from ._serde_helpers import decode_model_sequence, encode_model_sequence
+from ._wallet import Wallet
+
+
+@dataclass(slots=True)
+class ListWalletsResponse:
+    """
+    ListWalletsResponse is the response to `GET /v1/wallets`
+    """
+
+    wallets: list[Wallet] = field(
+        default_factory=list,
+        metadata=wire(
+            "wallets",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: Wallet, raw),
+        ),
+    )

algokit_kmd_client/models/_master_derivation_key.py

@@ -0,0 +1,4 @@
+# AUTO-GENERATED: oas_generator
+
+
+MasterDerivationKey = list[int]

algokit_kmd_client/models/_multisig_sig.py

@@ -0,0 +1,33 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+from ._multisig_subsig import MultisigSubsig
+from ._serde_helpers import decode_model_sequence, encode_model_sequence
+
+
+@dataclass(slots=True)
+class MultisigSig:
+    """
+    MultisigSig is the structure that holds multiple Subsigs
+    """
+
+    subsignatures: list[MultisigSubsig] = field(
+        default_factory=list,
+        metadata=wire(
+            "subsig",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: MultisigSubsig, raw),
+        ),
+    )
+    threshold: int = field(
+        default=0,
+        metadata=wire("thr"),
+    )
+    version: int = field(
+        default=0,
+        metadata=wire("v"),
+    )

algokit_kmd_client/models/_multisig_subsig.py

@@ -0,0 +1,23 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+
+@dataclass(slots=True)
+class MultisigSubsig:
+    """
+    MultisigSubsig is a struct that holds a pair of public key and signatures
+    signatures may be empty
+    """
+
+    public_key: list[int] = field(
+        default_factory=list,
+        metadata=wire("pk"),
+    )
+    signature: list[int] | None = field(
+        default=None,
+        metadata=wire("s"),
+    )

algokit_kmd_client/models/_public_key.py

@@ -0,0 +1,4 @@
+# AUTO-GENERATED: oas_generator
+
+
+PublicKey = list[int]

algokit_kmd_client/models/_release_wallet_handle_token_request.py

@@ -0,0 +1,18 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+
+@dataclass(slots=True)
+class ReleaseWalletHandleTokenRequest:
+    """
+    The request for `POST /v1/wallet/release`
+    """
+
+    wallet_handle_token: str = field(
+        default="",
+        metadata=wire("wallet_handle_token"),
+    )

algokit_kmd_client/models/_rename_wallet_request.py

@@ -0,0 +1,26 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+
+@dataclass(slots=True)
+class RenameWalletRequest:
+    """
+    The request for `POST /v1/wallet/rename`
+    """
+
+    wallet_id: str = field(
+        default="",
+        metadata=wire("wallet_id"),
+    )
+    wallet_name: str = field(
+        default="",
+        metadata=wire("wallet_name"),
+    )
+    wallet_password: str = field(
+        default="",
+        metadata=wire("wallet_password"),
+    )

algokit_kmd_client/models/_rename_wallet_response.py

@@ -0,0 +1,19 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested
+
+from ._wallet import Wallet
+
+
+@dataclass(slots=True)
+class RenameWalletResponse:
+    """
+    RenameWalletResponse is the response to `POST /v1/wallet/rename`
+    """
+
+    wallet: Wallet = field(
+        metadata=nested("wallet", lambda: Wallet, required=True),
+    )

algokit_kmd_client/models/_renew_wallet_handle_token_request.py

@@ -0,0 +1,18 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+
+@dataclass(slots=True)
+class RenewWalletHandleTokenRequest:
+    """
+    The request for `POST /v1/wallet/renew`
+    """
+
+    wallet_handle_token: str = field(
+        default="",
+        metadata=wire("wallet_handle_token"),
+    )

algokit_kmd_client/models/_renew_wallet_handle_token_response.py

@@ -0,0 +1,19 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested
+
+from ._wallet_handle import WalletHandle
+
+
+@dataclass(slots=True)
+class RenewWalletHandleTokenResponse:
+    """
+    RenewWalletHandleTokenResponse is the response to `POST /v1/wallet/renew`
+    """
+
+    wallet_handle: WalletHandle = field(
+        metadata=nested("wallet_handle", lambda: WalletHandle, required=True),
+    )

algokit_kmd_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_kmd_client/models/_sign_multisig_response.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_bytes_base64, encode_bytes_base64
+
+
+@dataclass(slots=True)
+class SignMultisigResponse:
+    """
+    SignMultisigResponse is the response to `POST /v1/multisig/sign`
+    """
+
+    multisig: bytes = field(
+        default=b"",
+        metadata=wire(
+            "multisig",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )

algokit_kmd_client/models/_sign_multisig_txn_request.py

@@ -0,0 +1,45 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested, wire
+
+from ._multisig_sig import MultisigSig
+from ._serde_helpers import decode_bytes_base64, encode_bytes_base64
+
+
+@dataclass(slots=True)
+class SignMultisigTxnRequest:
+    """
+    The request for `POST /v1/multisig/sign`
+    """
+
+    public_key: list[int] = field(
+        default_factory=list,
+        metadata=wire("public_key"),
+    )
+    transaction: bytes = field(
+        default=b"",
+        metadata=wire(
+            "transaction",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )
+    wallet_handle_token: str = field(
+        default="",
+        metadata=wire("wallet_handle_token"),
+    )
+    partial_multisig: MultisigSig | None = field(
+        default=None,
+        metadata=nested("partial_multisig", lambda: MultisigSig),
+    )
+    signer: list[int] | None = field(
+        default=None,
+        metadata=wire("signer"),
+    )
+    wallet_password: str | None = field(
+        default=None,
+        metadata=wire("wallet_password"),
+    )

algokit_kmd_client/models/_sign_program_multisig_request.py

@@ -0,0 +1,50 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.constants import ZERO_ADDRESS
+from algokit_common.serde import nested, wire
+
+from ._multisig_sig import MultisigSig
+from ._serde_helpers import decode_bytes_base64, encode_bytes_base64
+
+
+@dataclass(slots=True)
+class SignProgramMultisigRequest:
+    """
+    The request for `POST /v1/multisig/signprogram`
+    """
+
+    address: str = field(
+        default=ZERO_ADDRESS,
+        metadata=wire("address"),
+    )
+    program: bytes = field(
+        default=b"",
+        metadata=wire(
+            "data",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )
+    public_key: list[int] = field(
+        default_factory=list,
+        metadata=wire("public_key"),
+    )
+    wallet_handle_token: str = field(
+        default="",
+        metadata=wire("wallet_handle_token"),
+    )
+    partial_multisig: MultisigSig | None = field(
+        default=None,
+        metadata=nested("partial_multisig", lambda: MultisigSig),
+    )
+    use_legacy_msig: bool | None = field(
+        default=None,
+        metadata=wire("use_legacy_msig"),
+    )
+    wallet_password: str | None = field(
+        default=None,
+        metadata=wire("wallet_password"),
+    )

algokit_kmd_client/models/_sign_program_multisig_response.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_bytes_base64, encode_bytes_base64
+
+
+@dataclass(slots=True)
+class SignProgramMultisigResponse:
+    """
+    SignProgramMultisigResponse is the response to `POST /v1/multisig/signdata`
+    """
+
+    multisig: bytes = field(
+        default=b"",
+        metadata=wire(
+            "multisig",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )