algokit-utils 5.0.0a3__py3-none-any.whl

algokit_algod_client/models/_simulation_opcode_trace_unit.py

@@ -0,0 +1,55 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+from ._application_state_operation import ApplicationStateOperation
+from ._avm_value import AvmValue
+from ._scratch_change import ScratchChange
+from ._serde_helpers import decode_model_sequence, encode_model_sequence
+
+
+@dataclass(slots=True)
+class SimulationOpcodeTraceUnit:
+    """
+    The set of trace information and effect from evaluating a single opcode.
+    """
+
+    pc: int = field(
+        default=0,
+        metadata=wire("pc"),
+    )
+    scratch_changes: list[ScratchChange] | None = field(
+        default=None,
+        metadata=wire(
+            "scratch-changes",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: ScratchChange, raw),
+        ),
+    )
+    spawned_inners: list[int] | None = field(
+        default=None,
+        metadata=wire("spawned-inners"),
+    )
+    stack_additions: list[AvmValue] | None = field(
+        default=None,
+        metadata=wire(
+            "stack-additions",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: AvmValue, raw),
+        ),
+    )
+    stack_pop_count: int | None = field(
+        default=None,
+        metadata=wire("stack-pop-count"),
+    )
+    state_changes: list[ApplicationStateOperation] | None = field(
+        default=None,
+        metadata=wire(
+            "state-changes",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: ApplicationStateOperation, raw),
+        ),
+    )

algokit_algod_client/models/_simulation_transaction_exec_trace.py

@@ -0,0 +1,82 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+from ._serde_helpers import decode_bytes_base64, decode_model_sequence, encode_bytes_base64, encode_model_sequence
+from ._simulation_opcode_trace_unit import SimulationOpcodeTraceUnit
+
+
+@dataclass(slots=True)
+class SimulationTransactionExecTrace:
+    """
+    The execution trace of calling an app or a logic sig, containing the inner app call
+    trace in a recursive way.
+    """
+
+    approval_program_hash: bytes | None = field(
+        default=None,
+        metadata=wire(
+            "approval-program-hash",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )
+    approval_program_trace: list[SimulationOpcodeTraceUnit] | None = field(
+        default=None,
+        metadata=wire(
+            "approval-program-trace",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: SimulationOpcodeTraceUnit, raw),
+        ),
+    )
+    clear_state_program_hash: bytes | None = field(
+        default=None,
+        metadata=wire(
+            "clear-state-program-hash",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )
+    clear_state_program_trace: list[SimulationOpcodeTraceUnit] | None = field(
+        default=None,
+        metadata=wire(
+            "clear-state-program-trace",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: SimulationOpcodeTraceUnit, raw),
+        ),
+    )
+    clear_state_rollback: bool | None = field(
+        default=None,
+        metadata=wire("clear-state-rollback"),
+    )
+    clear_state_rollback_error: str | None = field(
+        default=None,
+        metadata=wire("clear-state-rollback-error"),
+    )
+    inner_trace: list["SimulationTransactionExecTrace"] | None = field(
+        default=None,
+        metadata=wire(
+            "inner-trace",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: SimulationTransactionExecTrace, raw),
+        ),
+    )
+    logic_sig_hash: bytes | None = field(
+        default=None,
+        metadata=wire(
+            "logic-sig-hash",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )
+    logic_sig_trace: list[SimulationOpcodeTraceUnit] | None = field(
+        default=None,
+        metadata=wire(
+            "logic-sig-trace",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: SimulationOpcodeTraceUnit, raw),
+        ),
+    )

algokit_algod_client/models/_source_map.py

@@ -0,0 +1,30 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+
+@dataclass(slots=True)
+class SourceMap:
+    """
+    Source map for the program
+    """
+
+    mappings: str = field(
+        default="",
+        metadata=wire("mappings"),
+    )
+    names: list[str] = field(
+        default_factory=list,
+        metadata=wire("names"),
+    )
+    sources: list[str] = field(
+        default_factory=list,
+        metadata=wire("sources"),
+    )
+    version: int = field(
+        default=0,
+        metadata=wire("version"),
+    )

algokit_algod_client/models/_state_delta.py

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

algokit_algod_client/models/_state_proof.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 ._state_proof_message import StateProofMessage
+
+
+@dataclass(slots=True)
+class StateProof:
+    """
+    Represents a state proof and its corresponding message
+    """
+
+    message: StateProofMessage = field(
+        metadata=nested("Message", lambda: StateProofMessage, required=True),
+    )
+    state_proof: bytes = field(
+        default=b"",
+        metadata=wire(
+            "StateProof",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )

algokit_algod_client/models/_state_proof_message.py

@@ -0,0 +1,44 @@
+# 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 StateProofMessage:
+    """
+    Represents the message that the state proofs are attesting to.
+    """
+
+    block_headers_commitment: bytes = field(
+        default=b"",
+        metadata=wire(
+            "BlockHeadersCommitment",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )
+    first_attested_round: int = field(
+        default=0,
+        metadata=wire("FirstAttestedRound"),
+    )
+    last_attested_round: int = field(
+        default=0,
+        metadata=wire("LastAttestedRound"),
+    )
+    ln_proven_weight: int = field(
+        default=0,
+        metadata=wire("LnProvenWeight"),
+    )
+    voters_commitment: bytes = field(
+        default=b"",
+        metadata=wire(
+            "VotersCommitment",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )

algokit_algod_client/models/_supply_response.py

@@ -0,0 +1,26 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+
+@dataclass(slots=True)
+class SupplyResponse:
+    """
+    Supply represents the current supply of MicroAlgos in the system
+    """
+
+    current_round: int = field(
+        default=0,
+        metadata=wire("current_round"),
+    )
+    online_money: int = field(
+        default=0,
+        metadata=wire("online-money"),
+    )
+    total_money: int = field(
+        default=0,
+        metadata=wire("total-money"),
+    )

algokit_algod_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_algod_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_algod_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"),
+    )

algokit_algod_client/models/_transaction_group_ledger_state_deltas_for_round_response.py

@@ -0,0 +1,21 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+from ._ledger_state_delta import LedgerStateDeltaForTransactionGroup
+from ._serde_helpers import decode_model_sequence, encode_model_sequence
+
+
+@dataclass(slots=True)
+class TransactionGroupLedgerStateDeltasForRoundResponse:
+    deltas: list[LedgerStateDeltaForTransactionGroup] = field(
+        default_factory=list,
+        metadata=wire(
+            "Deltas",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: LedgerStateDeltaForTransactionGroup, raw),
+        ),
+    )

algokit_algod_client/models/_transaction_parameters_response.py

@@ -0,0 +1,45 @@
+# 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 TransactionParametersResponse:
+    """
+    TransactionParams contains the parameters that help a client construct
+    a new transaction.
+    """
+
+    consensus_version: str = field(
+        default="",
+        metadata=wire("consensus-version"),
+    )
+    fee: int = field(
+        default=0,
+        metadata=wire("fee"),
+    )
+    genesis_hash: bytes = field(
+        default=b"",
+        metadata=wire(
+            "genesis-hash",
+            encode=lambda v: encode_fixed_bytes_base64(v, 32),
+            decode=lambda raw: decode_fixed_bytes_base64(raw, 32),
+        ),
+    )
+    genesis_id: str = field(
+        default="",
+        metadata=wire("genesis-id"),
+    )
+    last_round: int = field(
+        default=0,
+        metadata=wire("last-round"),
+    )
+    min_fee: int = field(
+        default=0,
+        metadata=wire("min-fee"),
+    )

algokit_algod_client/models/_transaction_proof.py

@@ -0,0 +1,44 @@
+# 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 TransactionProof:
+    """
+    Proof of transaction in a block.
+    """
+
+    hashtype: str = field(
+        default="",
+        metadata=wire("hashtype"),
+    )
+    idx: int = field(
+        default=0,
+        metadata=wire("idx"),
+    )
+    proof: bytes = field(
+        default=b"",
+        metadata=wire(
+            "proof",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )
+    stibhash: bytes = field(
+        default=b"",
+        metadata=wire(
+            "stibhash",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )
+    treedepth: int = field(
+        default=0,
+        metadata=wire("treedepth"),
+    )

algokit_algod_client/models/_version_contains_the_current_algod_version.py

@@ -0,0 +1,38 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested, wire
+
+from ._build_version_contains_the_current_algod_build_version_information import (
+    BuildVersionContainsTheCurrentAlgodBuildVersionInformation,
+)
+from ._serde_helpers import decode_bytes_base64, encode_bytes_base64
+
+
+@dataclass(slots=True)
+class VersionContainsTheCurrentAlgodVersion:
+    """
+    algod version information.
+    """
+
+    build: BuildVersionContainsTheCurrentAlgodBuildVersionInformation = field(
+        metadata=nested("build", lambda: BuildVersionContainsTheCurrentAlgodBuildVersionInformation, required=True),
+    )
+    genesis_hash_b64: bytes = field(
+        default=b"",
+        metadata=wire(
+            "genesis_hash_b64",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )
+    genesis_id: str = field(
+        default="",
+        metadata=wire("genesis_id"),
+    )
+    versions: list[str] = field(
+        default_factory=list,
+        metadata=wire("versions"),
+    )

algokit_algod_client/models/suggested_params.py

@@ -0,0 +1,42 @@
+# 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 SuggestedParams:
+    """Contains parameters relevant to creating a new transaction over a time window."""
+
+    consensus_version: str = field(
+        metadata=wire("consensus-version"),
+    )
+    fee: int = field(
+        metadata=wire("fee"),
+    )
+    genesis_hash: bytes = field(
+        metadata=wire(
+            "genesis-hash",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )
+    genesis_id: str = field(
+        metadata=wire("genesis-id"),
+    )
+    min_fee: int = field(
+        metadata=wire("min-fee"),
+    )
+    flat_fee: bool = field(
+        metadata=wire("flat-fee"),
+    )
+    first_valid: int = field(
+        metadata=wire("first-valid"),
+    )
+    last_valid: int = field(
+        metadata=wire("last-valid"),
+    )

algokit_algod_client/py.typed

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

algokit_algod_client/types.py

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

algokit_algosdk/__init__.py

@@ -0,0 +1,38 @@
+"""
+Vendored utilities from py-algorand-sdk used for signing functionality.
+
+The contents of this package are cherry-picked from
+`references/py-algorand-sdk/algosdk` and adapted for AlgoKit.
+
+Note: Signing functionality has been moved to algokit_transact. Import from there:
+
+    from algokit_transact import (
+        TransactionSigner,
+        make_basic_account_transaction_signer,
+        make_empty_transaction_signer,
+    )
+"""
+
+from . import (
+    account,
+    box_reference,
+    constants,
+    encoding,
+    logic,
+    logicsig,
+    mnemonic,
+    multisig,
+    transaction,
+)
+
+__all__ = [
+    "account",
+    "box_reference",
+    "constants",
+    "encoding",
+    "logic",
+    "logicsig",
+    "mnemonic",
+    "multisig",
+    "transaction",
+]

algokit_algosdk/account.py

@@ -0,0 +1,32 @@
+from nacl.signing import SigningKey
+import base64
+from . import encoding, constants
+
+
+def generate_account():
+    """
+    Generate an account.
+
+    Returns:
+        (str, str): private key, account address
+    """
+    sk = SigningKey.generate()
+    vk = sk.verify_key
+    a = encoding.encode_address(vk.encode())
+    private_key = base64.b64encode(sk.encode() + vk.encode()).decode()
+    return private_key, a
+
+
+def address_from_private_key(private_key):
+    """
+    Return the address for the private key.
+
+    Args:
+        private_key (str): private key of the account in base64
+
+    Returns:
+        str: address of the account
+    """
+    pk = base64.b64decode(private_key)[constants.key_len_bytes :]
+    address = encoding.encode_address(pk)
+    return address