algokit-utils 5.0.0a3__py3-none-any.whl

algokit_kmd_client/models/_sign_program_request.py

@@ -0,0 +1,37 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.constants import ZERO_ADDRESS
+from algokit_common.serde import wire
+
+from ._serde_helpers import decode_bytes_base64, encode_bytes_base64
+
+
+@dataclass(slots=True)
+class SignProgramRequest:
+    """
+    The request for `POST /v1/program/sign`
+    """
+
+    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,
+        ),
+    )
+    wallet_handle_token: str = field(
+        default="",
+        metadata=wire("wallet_handle_token"),
+    )
+    wallet_password: str | None = field(
+        default=None,
+        metadata=wire("wallet_password"),
+    )

algokit_kmd_client/models/_sign_program_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 SignProgramResponse:
+    """
+    SignProgramResponse is the response to `POST /v1/data/sign`
+    """
+
+    sig: bytes = field(
+        default=b"",
+        metadata=wire(
+            "sig",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )

algokit_kmd_client/models/_sign_transaction_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 SignTransactionResponse:
+    """
+    SignTransactionResponse is the response to `POST /v1/transaction/sign`
+    """
+
+    signed_transaction: bytes = field(
+        default=b"",
+        metadata=wire(
+            "signed_transaction",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )

algokit_kmd_client/models/_sign_txn_request.py

@@ -0,0 +1,36 @@
+# 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 SignTxnRequest:
+    """
+    The request for `POST /v1/transaction/sign`
+    """
+
+    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"),
+    )
+    public_key: list[int] | None = field(
+        default=None,
+        metadata=wire("public_key"),
+    )
+    wallet_password: str | None = field(
+        default=None,
+        metadata=wire("wallet_password"),
+    )

algokit_kmd_client/models/_signature.py

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

algokit_kmd_client/models/_tx_type.py

@@ -0,0 +1,4 @@
+# AUTO-GENERATED: oas_generator
+
+
+TxType = str

algokit_kmd_client/models/_versions_request.py

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

algokit_kmd_client/models/_versions_response.py

@@ -0,0 +1,19 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+
+@dataclass(slots=True)
+class VersionsResponse:
+    """
+    VersionsResponse is the response to `GET /versions`
+    friendly:VersionsResponse
+    """
+
+    versions: list[str] = field(
+        default_factory=list,
+        metadata=wire("versions"),
+    )

algokit_kmd_client/models/_wallet.py

@@ -0,0 +1,38 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+
+@dataclass(slots=True)
+class Wallet:
+    """
+    Wallet is the API's representation of a wallet
+    """
+
+    driver_name: str = field(
+        default="",
+        metadata=wire("driver_name"),
+    )
+    driver_version: int = field(
+        default=0,
+        metadata=wire("driver_version"),
+    )
+    id_: str = field(
+        default="",
+        metadata=wire("id"),
+    )
+    mnemonic_ux: bool = field(
+        default=False,
+        metadata=wire("mnemonic_ux"),
+    )
+    name: str = field(
+        default="",
+        metadata=wire("name"),
+    )
+    supported_txs: list[str] = field(
+        default_factory=list,
+        metadata=wire("supported_txs"),
+    )

algokit_kmd_client/models/_wallet_handle.py

@@ -0,0 +1,24 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested, wire
+
+from ._wallet import Wallet
+
+
+@dataclass(slots=True)
+class WalletHandle:
+    """
+    WalletHandle includes the wallet the handle corresponds to
+    and the number of number of seconds to expiration
+    """
+
+    wallet: Wallet = field(
+        metadata=nested("wallet", lambda: Wallet, required=True),
+    )
+    expires_seconds: int = field(
+        default=0,
+        metadata=wire("expires_seconds"),
+    )

algokit_kmd_client/models/_wallet_info_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 WalletInfoRequest:
+    """
+    The request for `POST /v1/wallet/info`
+    """
+
+    wallet_handle_token: str = field(
+        default="",
+        metadata=wire("wallet_handle_token"),
+    )

algokit_kmd_client/models/_wallet_info_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 WalletInfoResponse:
+    """
+    WalletInfoResponse is the response to `POST /v1/wallet/info`
+    """
+
+    wallet_handle: WalletHandle = field(
+        metadata=nested("wallet_handle", lambda: WalletHandle, required=True),
+    )

algokit_kmd_client/py.typed

@@ -0,0 +1 @@
+# AUTO-GENERATED: oas_generator

algokit_kmd_client/types.py

@@ -0,0 +1,7 @@
+# AUTO-GENERATED: oas_generator
+
+
+from typing import Any
+
+JSONMapping = dict[str, Any]
+Headers = dict[str, str]

algokit_transact/__init__.py

@@ -0,0 +1,190 @@
+from algokit_transact.codec.signed import (
+    decode_logic_signature,
+    decode_signed_transaction,
+    decode_signed_transactions,
+    encode_signed_transaction,
+    encode_signed_transactions,
+)
+from algokit_transact.codec.transaction import (
+    decode_transaction,
+    decode_transactions,
+    encode_transaction,
+    encode_transaction_raw,
+    encode_transactions,
+    from_transaction_dto,
+    get_encoded_transaction_type,
+    to_transaction_dto,
+)
+from algokit_transact.exceptions import (
+    AlgokitTransactError,
+    TransactionValidationError,
+)
+from algokit_transact.logicsig import LogicSigAccount
+from algokit_transact.models.app_call import (
+    AppCallTransactionFields,
+    BoxReference,
+    HoldingReference,
+    LocalsReference,
+    ResourceReference,
+)
+from algokit_transact.models.asset_config import AssetConfigTransactionFields
+from algokit_transact.models.asset_freeze import AssetFreezeTransactionFields
+from algokit_transact.models.asset_transfer import AssetTransferTransactionFields
+from algokit_transact.models.common import OnApplicationComplete, StateSchema
+from algokit_transact.models.heartbeat import HeartbeatProof, HeartbeatTransactionFields
+from algokit_transact.models.key_registration import KeyRegistrationTransactionFields
+from algokit_transact.models.payment import PaymentTransactionFields
+from algokit_transact.models.signed_transaction import SignedTransaction
+from algokit_transact.models.state_proof import (
+    FalconSignatureStruct,
+    FalconVerifier,
+    HashFactory,
+    MerkleArrayProof,
+    MerkleSignatureVerifier,
+    Participant,
+    Reveal,
+    SigslotCommit,
+    StateProof,
+    StateProofMessage,
+    StateProofTransactionFields,
+)
+from algokit_transact.models.transaction import Transaction, TransactionType
+from algokit_transact.multisig import MultisigAccount, MultisigMetadata
+from algokit_transact.ops.fees import (
+    assign_fee,
+    calculate_fee,
+    estimate_transaction_size,
+)
+from algokit_transact.ops.group import (
+    group_transactions,
+)
+from algokit_transact.ops.ids import (
+    get_transaction_id,
+    get_transaction_id_raw,
+)
+from algokit_transact.ops.validate import (
+    ValidationIssue,
+    ValidationIssueCode,
+    validate_app_call_fields,
+    validate_asset_config_fields,
+    validate_asset_freeze_fields,
+    validate_asset_transfer_fields,
+    validate_key_registration_fields,
+    validate_transaction,
+)
+from algokit_transact.signer import (
+    Addressable,
+    AddressWithDelegatedLsigSigner,
+    AddressWithMxBytesSigner,
+    AddressWithProgramDataSigner,
+    AddressWithSigners,
+    AddressWithTransactionSigner,
+    BytesSigner,
+    DelegatedLsigSigner,
+    MxBytesSigner,
+    ProgramDataSigner,
+    TransactionSigner,
+    bytes_to_sign_for_delegation,
+    generate_address_with_signers,
+    make_basic_account_transaction_signer,
+    make_empty_transaction_signer,
+    program_data_to_sign,
+)
+from algokit_transact.signing.logic_signature import LogicSignature
+from algokit_transact.signing.multisig import (
+    address_from_multisig_signature,
+    apply_multisig_subsignature,
+    merge_multisignatures,
+    new_multisig_signature,
+    participants_from_multisig_signature,
+)
+from algokit_transact.signing.types import MultisigSignature, MultisigSubsignature
+from algokit_transact.signing.validation import sanity_check_program
+
+__all__ = [
+    "Addressable",
+    "AddressWithDelegatedLsigSigner",
+    "AddressWithMxBytesSigner",
+    "AddressWithProgramDataSigner",
+    "AddressWithSigners",
+    "AddressWithTransactionSigner",
+    "AlgokitTransactError",
+    "AppCallTransactionFields",
+    "BoxReference",
+    "BytesSigner",
+    "HoldingReference",
+    "LocalsReference",
+    "ResourceReference",
+    "AssetConfigTransactionFields",
+    "AssetFreezeTransactionFields",
+    "AssetTransferTransactionFields",
+    "FalconSignatureStruct",
+    "FalconVerifier",
+    "HashFactory",
+    "HeartbeatTransactionFields",
+    "HeartbeatProof",
+    "KeyRegistrationTransactionFields",
+    "LogicSigAccount",
+    "LogicSignature",
+    "DelegatedLsigSigner",
+    "MerkleArrayProof",
+    "MerkleSignatureVerifier",
+    "MultisigAccount",
+    "MultisigMetadata",
+    "MultisigSignature",
+    "MultisigSubsignature",
+    "MxBytesSigner",
+    "OnApplicationComplete",
+    "Participant",
+    "PaymentTransactionFields",
+    "ProgramDataSigner",
+    "Reveal",
+    "SigslotCommit",
+    "SignedTransaction",
+    "StateProof",
+    "StateProofTransactionFields",
+    "StateProofMessage",
+    "StateSchema",
+    "Transaction",
+    "TransactionSigner",
+    "TransactionType",
+    "TransactionValidationError",
+    "address_from_multisig_signature",
+    "apply_multisig_subsignature",
+    "assign_fee",
+    "bytes_to_sign_for_delegation",
+    "calculate_fee",
+    "decode_logic_signature",
+    "decode_signed_transaction",
+    "decode_signed_transactions",
+    "decode_transaction",
+    "decode_transactions",
+    "encode_signed_transaction",
+    "encode_signed_transactions",
+    "encode_transaction",
+    "encode_transaction_raw",
+    "encode_transactions",
+    "estimate_transaction_size",
+    "from_transaction_dto",
+    "generate_address_with_signers",
+    "get_encoded_transaction_type",
+    "get_transaction_id",
+    "get_transaction_id_raw",
+    "group_transactions",
+    "make_basic_account_transaction_signer",
+    "make_empty_transaction_signer",
+    "merge_multisignatures",
+    "new_multisig_signature",
+    "participants_from_multisig_signature",
+    "program_data_to_sign",
+    "sanity_check_program",
+    "to_transaction_dto",
+    "validate_app_call_fields",
+    "validate_asset_config_fields",
+    "validate_asset_freeze_fields",
+    "validate_asset_transfer_fields",
+    "validate_key_registration_fields",
+    "validate_transaction",
+    "ValidationIssue",
+    "ValidationIssueCode",
+]

algokit_transact/codec/msgpack.py

@@ -0,0 +1,11 @@
+from msgpack import packb, unpackb
+
+
+def encode_msgpack(value: object) -> bytes:
+    """Encode a Python value into canonical msgpack bytes."""
+    return packb(value, use_bin_type=True, strict_types=True)
+
+
+def decode_msgpack(data: bytes) -> object:
+    """Decode msgpack bytes into a Python structure."""
+    return unpackb(data, raw=False, strict_map_key=False)

algokit_transact/codec/serde.py

@@ -0,0 +1,7 @@
+"""Compatibility shim for serde helpers.
+
+The implementation now lives in ``algokit_common.serde`` so that external
+packages (including generated API clients) can share the same primitives.
+"""
+
+from algokit_common.serde import *  # noqa: F403

algokit_transact/codec/signed.py

@@ -0,0 +1,57 @@
+from collections.abc import Iterable
+from typing import cast
+
+from algokit_common.constants import SIGNATURE_BYTE_LENGTH
+from algokit_transact.codec.msgpack import decode_msgpack, encode_msgpack
+from algokit_transact.codec.serde import from_wire, to_wire_canonical
+from algokit_transact.models.signed_transaction import SignedTransaction
+from algokit_transact.models.transaction import Transaction
+from algokit_transact.ops.validate import validate_transaction
+from algokit_transact.signing.logic_signature import LogicSignature
+
+
+def _validate_signed_transaction(stx: SignedTransaction) -> None:
+    validate_transaction(stx.txn)
+
+    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.sig is not None and len(stx.sig) != SIGNATURE_BYTE_LENGTH:
+        raise ValueError("Signature must be 64 bytes")
+
+
+def encode_signed_transaction(stx: SignedTransaction) -> bytes:
+    _validate_signed_transaction(stx)
+    payload = to_wire_canonical(stx)
+    return encode_msgpack(payload)
+
+
+def encode_signed_transactions(signed_transactions: Iterable[SignedTransaction]) -> list[bytes]:
+    return [encode_signed_transaction(stx) for stx in signed_transactions]
+
+
+def decode_signed_transaction(encoded: bytes) -> SignedTransaction:
+    raw: object = decode_msgpack(encoded)
+    if not isinstance(raw, dict):
+        raise ValueError("decoded signed transaction is not a dict")
+    dto = cast(dict[str, object], raw)
+    stx = from_wire(SignedTransaction, dto)
+    if not isinstance(stx.txn, Transaction):
+        raise ValueError("signed transaction missing 'txn'")
+    return stx
+
+
+def decode_signed_transactions(encoded_signed_transactions: Iterable[bytes]) -> list[SignedTransaction]:
+    return [decode_signed_transaction(item) for item in encoded_signed_transactions]
+
+
+def decode_logic_signature(encoded: bytes) -> LogicSignature:
+    raw: object = decode_msgpack(encoded)
+    if not isinstance(raw, dict):
+        raise ValueError("decoded logic signature is not a dict")
+    dto = cast(dict[str, object], raw)
+    return from_wire(LogicSignature, dto)

algokit_transact/codec/transaction.py

@@ -0,0 +1,65 @@
+from collections.abc import Iterable, Mapping
+from typing import cast
+
+from algokit_common.constants import TRANSACTION_DOMAIN_SEPARATOR
+from algokit_transact.codec.msgpack import decode_msgpack, encode_msgpack
+from algokit_transact.codec.serde import from_wire, to_wire, to_wire_canonical
+from algokit_transact.models.transaction import Transaction, TransactionType
+from algokit_transact.ops.validate import validate_transaction
+
+
+def _from_type_str(s: str) -> TransactionType:
+    return TransactionType(s)
+
+
+def to_transaction_dto(tx: Transaction) -> dict[str, object]:
+    return to_wire(tx)
+
+
+def encode_transaction_raw(tx: Transaction) -> bytes:
+    validate_transaction(tx)
+    canonical = to_wire_canonical(tx)
+    return encode_msgpack(canonical)
+
+
+def encode_transaction(tx: Transaction) -> bytes:
+    raw = encode_transaction_raw(tx)
+    prefix = TRANSACTION_DOMAIN_SEPARATOR.encode()
+    return prefix + raw
+
+
+def encode_transactions(transactions: Iterable[Transaction]) -> list[bytes]:
+    return [encode_transaction(tx) for tx in transactions]
+
+
+def from_transaction_dto(dto: Mapping[str, object]) -> Transaction:
+    return from_wire(Transaction, dto)
+
+
+def decode_transaction(encoded: bytes) -> Transaction:
+    if not encoded:
+        raise ValueError("attempted to decode 0 bytes")
+
+    prefix = TRANSACTION_DOMAIN_SEPARATOR.encode()
+    payload = encoded[len(prefix) :] if encoded.startswith(prefix) else encoded
+
+    raw = decode_msgpack(payload)
+    if not isinstance(raw, dict):
+        raise ValueError("decoded msgpack is not a dict")
+
+    return from_transaction_dto(cast(dict[str, object], raw))
+
+
+def decode_transactions(encoded_transactions: Iterable[bytes]) -> list[Transaction]:
+    return [decode_transaction(item) for item in encoded_transactions]
+
+
+def get_encoded_transaction_type(encoded_transaction: bytes) -> TransactionType:
+    prefix = TRANSACTION_DOMAIN_SEPARATOR.encode()
+    payload = encoded_transaction[len(prefix) :] if encoded_transaction.startswith(prefix) else encoded_transaction
+
+    raw = decode_msgpack(payload)
+    if isinstance(raw, dict) and isinstance(tx_type := raw.get("type"), str):
+        return _from_type_str(tx_type)
+
+    return decode_transaction(encoded_transaction).transaction_type

algokit_transact/exceptions.py

@@ -0,0 +1,17 @@
+from collections.abc import Sequence
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from algokit_transact.ops.validate import ValidationIssue
+
+
+class AlgokitTransactError(Exception):
+    """Base error for algokit-transact."""
+
+
+class TransactionValidationError(AlgokitTransactError):
+    """Raised when a transaction fails validation."""
+
+    def __init__(self, message: str, *, issues: "Sequence[ValidationIssue] | None" = None) -> None:
+        super().__init__(message)
+        self.issues: list[ValidationIssue] = list(issues or [])