algokit-utils 5.0.0a3__py3-none-any.whl

algokit_indexer_client/models/_application_logs_response.py

@@ -0,0 +1,33 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+from ._application_log_data import ApplicationLogData
+from ._serde_helpers import decode_model_sequence, encode_model_sequence
+
+
+@dataclass(slots=True)
+class ApplicationLogsResponse:
+    application_id: int = field(
+        default=0,
+        metadata=wire("application-id"),
+    )
+    current_round: int = field(
+        default=0,
+        metadata=wire("current-round"),
+    )
+    log_data: list[ApplicationLogData] | None = field(
+        default=None,
+        metadata=wire(
+            "log-data",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: ApplicationLogData, raw),
+        ),
+    )
+    next_token: str | None = field(
+        default=None,
+        metadata=wire("next-token"),
+    )

algokit_indexer_client/models/_application_params.py

@@ -0,0 +1,62 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested, wire
+
+from ._application_state_schema import ApplicationStateSchema
+from ._serde_helpers import decode_bytes_base64, decode_model_sequence, encode_bytes_base64, encode_model_sequence
+from ._teal_key_value import TealKeyValue
+
+
+@dataclass(slots=True)
+class ApplicationParams:
+    """
+    Stores the global information associated with an application.
+    """
+
+    approval_program: bytes | None = field(
+        default=None,
+        metadata=wire(
+            "approval-program",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )
+    clear_state_program: bytes | None = field(
+        default=None,
+        metadata=wire(
+            "clear-state-program",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )
+    creator: str | None = field(
+        default=None,
+        metadata=wire("creator"),
+    )
+    extra_program_pages: int | None = field(
+        default=None,
+        metadata=wire("extra-program-pages"),
+    )
+    global_state: list[TealKeyValue] | None = field(
+        default=None,
+        metadata=wire(
+            "global-state",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: TealKeyValue, raw),
+        ),
+    )
+    global_state_schema: ApplicationStateSchema | None = field(
+        default=None,
+        metadata=nested("global-state-schema", lambda: ApplicationStateSchema),
+    )
+    local_state_schema: ApplicationStateSchema | None = field(
+        default=None,
+        metadata=nested("local-state-schema", lambda: ApplicationStateSchema),
+    )
+    version: int | None = field(
+        default=None,
+        metadata=wire("version"),
+    )

algokit_indexer_client/models/_application_response.py

@@ -0,0 +1,20 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested, wire
+
+from ._application import Application
+
+
+@dataclass(slots=True)
+class ApplicationResponse:
+    current_round: int = field(
+        default=0,
+        metadata=wire("current-round"),
+    )
+    application: Application | None = field(
+        default=None,
+        metadata=nested("application", lambda: Application),
+    )

algokit_indexer_client/models/_application_state_schema.py

@@ -0,0 +1,22 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+
+@dataclass(slots=True)
+class ApplicationStateSchema:
+    """
+    Specifies maximums on the number of each type that may be stored.
+    """
+
+    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/_applications_response.py

@@ -0,0 +1,29 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+from ._application import Application
+from ._serde_helpers import decode_model_sequence, encode_model_sequence
+
+
+@dataclass(slots=True)
+class ApplicationsResponse:
+    applications: list[Application] = field(
+        default_factory=list,
+        metadata=wire(
+            "applications",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: Application, raw),
+        ),
+    )
+    current_round: int = field(
+        default=0,
+        metadata=wire("current-round"),
+    )
+    next_token: str | None = field(
+        default=None,
+        metadata=wire("next-token"),
+    )

algokit_indexer_client/models/_asset.py

@@ -0,0 +1,35 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested, wire
+
+from ._asset_params import AssetParams
+
+
+@dataclass(slots=True)
+class Asset:
+    """
+    Specifies both the unique identifier and the parameters for an asset
+    """
+
+    params: AssetParams = field(
+        metadata=nested("params", lambda: AssetParams, required=True),
+    )
+    id_: int = field(
+        default=0,
+        metadata=wire("index"),
+    )
+    created_at_round: int | None = field(
+        default=None,
+        metadata=wire("created-at-round"),
+    )
+    deleted: bool | None = field(
+        default=None,
+        metadata=wire("deleted"),
+    )
+    destroyed_at_round: int | None = field(
+        default=None,
+        metadata=wire("destroyed-at-round"),
+    )

algokit_indexer_client/models/_asset_balances_response.py

@@ -0,0 +1,29 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+from ._mini_asset_holding import MiniAssetHolding
+from ._serde_helpers import decode_model_sequence, encode_model_sequence
+
+
+@dataclass(slots=True)
+class AssetBalancesResponse:
+    balances: list[MiniAssetHolding] = field(
+        default_factory=list,
+        metadata=wire(
+            "balances",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: MiniAssetHolding, raw),
+        ),
+    )
+    current_round: int = field(
+        default=0,
+        metadata=wire("current-round"),
+    )
+    next_token: str | None = field(
+        default=None,
+        metadata=wire("next-token"),
+    )

algokit_indexer_client/models/_asset_holding.py

@@ -0,0 +1,41 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+
+@dataclass(slots=True)
+class AssetHolding:
+    """
+    Describes an asset held by an account.
+
+    Definition:
+    data/basics/userBalance.go : AssetHolding
+    """
+
+    amount: int = field(
+        default=0,
+        metadata=wire("amount"),
+    )
+    asset_id: int = field(
+        default=0,
+        metadata=wire("asset-id"),
+    )
+    is_frozen: bool = field(
+        default=False,
+        metadata=wire("is-frozen"),
+    )
+    deleted: bool | None = field(
+        default=None,
+        metadata=wire("deleted"),
+    )
+    opted_in_at_round: int | None = field(
+        default=None,
+        metadata=wire("opted-in-at-round"),
+    )
+    opted_out_at_round: int | None = field(
+        default=None,
+        metadata=wire("opted-out-at-round"),
+    )

algokit_indexer_client/models/_asset_holdings_response.py

@@ -0,0 +1,29 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+from ._asset_holding import AssetHolding
+from ._serde_helpers import decode_model_sequence, encode_model_sequence
+
+
+@dataclass(slots=True)
+class AssetHoldingsResponse:
+    assets: list[AssetHolding] = field(
+        default_factory=list,
+        metadata=wire(
+            "assets",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: AssetHolding, raw),
+        ),
+    )
+    current_round: int = field(
+        default=0,
+        metadata=wire("current-round"),
+    )
+    next_token: str | None = field(
+        default=None,
+        metadata=wire("next-token"),
+    )

algokit_indexer_client/models/_asset_params.py

@@ -0,0 +1,102 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+from ._serde_helpers import (
+    decode_bytes_base64,
+    decode_fixed_bytes_base64,
+    encode_bytes_base64,
+    encode_fixed_bytes_base64,
+)
+
+
+@dataclass(slots=True)
+class AssetParams:
+    r"""
+    AssetParams specifies the parameters for an asset.
+
+    \[apar\] when part of an AssetConfig transaction.
+
+    Definition:
+    data/transactions/asset.go : AssetParams
+    """
+
+    creator: str = field(
+        default="",
+        metadata=wire("creator"),
+    )
+    decimals: int = field(
+        default=0,
+        metadata=wire("decimals"),
+    )
+    total: int = field(
+        default=0,
+        metadata=wire("total"),
+    )
+    clawback: str | None = field(
+        default=None,
+        metadata=wire("clawback"),
+    )
+    default_frozen: bool | None = field(
+        default=None,
+        metadata=wire("default-frozen"),
+    )
+    freeze: str | None = field(
+        default=None,
+        metadata=wire("freeze"),
+    )
+    manager: str | None = field(
+        default=None,
+        metadata=wire("manager"),
+    )
+    metadata_hash: bytes | None = field(
+        default=None,
+        metadata=wire(
+            "metadata-hash",
+            encode=lambda v: encode_fixed_bytes_base64(v, 32),
+            decode=lambda raw: decode_fixed_bytes_base64(raw, 32),
+        ),
+    )
+    name: str | None = field(
+        default=None,
+        metadata=wire("name"),
+    )
+    name_b64: bytes | None = field(
+        default=None,
+        metadata=wire(
+            "name-b64",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )
+    reserve: str | None = field(
+        default=None,
+        metadata=wire("reserve"),
+    )
+    unit_name: str | None = field(
+        default=None,
+        metadata=wire("unit-name"),
+    )
+    unit_name_b64: bytes | None = field(
+        default=None,
+        metadata=wire(
+            "unit-name-b64",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )
+    url: str | None = field(
+        default=None,
+        metadata=wire("url"),
+    )
+    url_b64: bytes | None = field(
+        default=None,
+        metadata=wire(
+            "url-b64",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )

algokit_indexer_client/models/_asset_response.py

@@ -0,0 +1,19 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested, wire
+
+from ._asset import Asset
+
+
+@dataclass(slots=True)
+class AssetResponse:
+    asset: Asset = field(
+        metadata=nested("asset", lambda: Asset, required=True),
+    )
+    current_round: int = field(
+        default=0,
+        metadata=wire("current-round"),
+    )

algokit_indexer_client/models/_assets_response.py

@@ -0,0 +1,29 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+from ._asset import Asset
+from ._serde_helpers import decode_model_sequence, encode_model_sequence
+
+
+@dataclass(slots=True)
+class AssetsResponse:
+    assets: list[Asset] = field(
+        default_factory=list,
+        metadata=wire(
+            "assets",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: Asset, raw),
+        ),
+    )
+    current_round: int = field(
+        default=0,
+        metadata=wire("current-round"),
+    )
+    next_token: str | None = field(
+        default=None,
+        metadata=wire("next-token"),
+    )

algokit_indexer_client/models/_block.py

@@ -0,0 +1,150 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested, wire
+
+from ._block_rewards import BlockRewards
+from ._block_upgrade_state import BlockUpgradeState
+from ._block_upgrade_vote import BlockUpgradeVote
+from ._participation_updates import ParticipationUpdates
+from ._serde_helpers import (
+    decode_fixed_bytes_base64,
+    decode_model_sequence,
+    encode_fixed_bytes_base64,
+    encode_model_sequence,
+)
+from ._state_proof_tracking import StateProofTracking
+from ._transaction import Transaction
+
+
+@dataclass(slots=True)
+class Block:
+    """
+    Block information.
+
+    Definition:
+    data/bookkeeping/block.go : Block
+    """
+
+    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"),
+    )
+    previous_block_hash: bytes = field(
+        default=b"",
+        metadata=wire(
+            "previous-block-hash",
+            encode=lambda v: encode_fixed_bytes_base64(v, 32),
+            decode=lambda raw: decode_fixed_bytes_base64(raw, 32),
+        ),
+    )
+    round_: int = field(
+        default=0,
+        metadata=wire("round"),
+    )
+    seed: bytes = field(
+        default=b"",
+        metadata=wire(
+            "seed",
+            encode=lambda v: encode_fixed_bytes_base64(v, 32),
+            decode=lambda raw: decode_fixed_bytes_base64(raw, 32),
+        ),
+    )
+    timestamp: int = field(
+        default=0,
+        metadata=wire("timestamp"),
+    )
+    transactions_root: bytes = field(
+        default=b"",
+        metadata=wire(
+            "transactions-root",
+            encode=lambda v: encode_fixed_bytes_base64(v, 32),
+            decode=lambda raw: decode_fixed_bytes_base64(raw, 32),
+        ),
+    )
+    transactions_root_sha256: bytes = field(
+        default=b"",
+        metadata=wire(
+            "transactions-root-sha256",
+            encode=lambda v: encode_fixed_bytes_base64(v, 32),
+            decode=lambda raw: decode_fixed_bytes_base64(raw, 32),
+        ),
+    )
+    bonus: int | None = field(
+        default=None,
+        metadata=wire("bonus"),
+    )
+    fees_collected: int | None = field(
+        default=None,
+        metadata=wire("fees-collected"),
+    )
+    participation_updates: ParticipationUpdates | None = field(
+        default=None,
+        metadata=nested("participation-updates", lambda: ParticipationUpdates),
+    )
+    previous_block_hash_512: bytes | None = field(
+        default=None,
+        metadata=wire(
+            "previous-block-hash-512",
+            encode=lambda v: encode_fixed_bytes_base64(v, 64),
+            decode=lambda raw: decode_fixed_bytes_base64(raw, 64),
+        ),
+    )
+    proposer: str | None = field(
+        default=None,
+        metadata=wire("proposer"),
+    )
+    proposer_payout: int | None = field(
+        default=None,
+        metadata=wire("proposer-payout"),
+    )
+    rewards: BlockRewards | None = field(
+        default=None,
+        metadata=nested("rewards", lambda: BlockRewards),
+    )
+    state_proof_tracking: list[StateProofTracking] | None = field(
+        default=None,
+        metadata=wire(
+            "state-proof-tracking",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: StateProofTracking, raw),
+        ),
+    )
+    transactions: list[Transaction] | None = field(
+        default=None,
+        metadata=wire(
+            "transactions",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: Transaction, raw),
+        ),
+    )
+    transactions_root_sha512: bytes | None = field(
+        default=None,
+        metadata=wire(
+            "transactions-root-sha512",
+            encode=lambda v: encode_fixed_bytes_base64(v, 64),
+            decode=lambda raw: decode_fixed_bytes_base64(raw, 64),
+        ),
+    )
+    txn_counter: int | None = field(
+        default=None,
+        metadata=wire("txn-counter"),
+    )
+    upgrade_state: BlockUpgradeState | None = field(
+        default=None,
+        metadata=nested("upgrade-state", lambda: BlockUpgradeState),
+    )
+    upgrade_vote: BlockUpgradeVote | None = field(
+        default=None,
+        metadata=nested("upgrade-vote", lambda: BlockUpgradeVote),
+    )

algokit_indexer_client/models/_block_headers_response.py

@@ -0,0 +1,29 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+from ._block import Block
+from ._serde_helpers import decode_model_sequence, encode_model_sequence
+
+
+@dataclass(slots=True)
+class BlockHeadersResponse:
+    blocks: list[Block] = field(
+        default_factory=list,
+        metadata=wire(
+            "blocks",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: Block, raw),
+        ),
+    )
+    current_round: int = field(
+        default=0,
+        metadata=wire("current-round"),
+    )
+    next_token: str | None = field(
+        default=None,
+        metadata=wire("next-token"),
+    )

algokit_indexer_client/models/_block_rewards.py

@@ -0,0 +1,38 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+
+@dataclass(slots=True)
+class BlockRewards:
+    """
+    Fields relating to rewards,
+    """
+
+    fee_sink: str = field(
+        default="",
+        metadata=wire("fee-sink"),
+    )
+    rewards_calculation_round: int = field(
+        default=0,
+        metadata=wire("rewards-calculation-round"),
+    )
+    rewards_level: int = field(
+        default=0,
+        metadata=wire("rewards-level"),
+    )
+    rewards_pool: str = field(
+        default="",
+        metadata=wire("rewards-pool"),
+    )
+    rewards_rate: int = field(
+        default=0,
+        metadata=wire("rewards-rate"),
+    )
+    rewards_residue: int = field(
+        default=0,
+        metadata=wire("rewards-residue"),
+    )