algokit-utils 5.0.0a3__py3-none-any.whl

algokit_indexer_client/models/_transaction.py

@@ -0,0 +1,213 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested, wire
+
+from ._account_state_delta import AccountStateDelta
+from ._eval_delta_key_value import EvalDeltaKeyValue
+from ._serde_helpers import (
+    decode_bytes_base64,
+    decode_bytes_sequence,
+    decode_fixed_bytes_base64,
+    decode_model_sequence,
+    encode_bytes_base64,
+    encode_bytes_sequence,
+    encode_fixed_bytes_base64,
+    encode_model_sequence,
+)
+from ._transaction_application import TransactionApplication
+from ._transaction_asset_config import TransactionAssetConfig
+from ._transaction_asset_freeze import TransactionAssetFreeze
+from ._transaction_asset_transfer import TransactionAssetTransfer
+from ._transaction_heartbeat import TransactionHeartbeat
+from ._transaction_keyreg import TransactionKeyreg
+from ._transaction_payment import TransactionPayment
+from ._transaction_signature import TransactionSignature
+from ._transaction_state_proof import TransactionStateProof
+
+
+@dataclass(slots=True)
+class Transaction:
+    """
+    Contains all fields common to all transactions and serves as an envelope to all
+    transactions type. Represents both regular and inner transactions.
+
+    Definition:
+    data/transactions/signedtxn.go : SignedTxn
+    data/transactions/transaction.go : Transaction
+    """
+
+    fee: int = field(
+        default=0,
+        metadata=wire("fee"),
+    )
+    first_valid: int = field(
+        default=0,
+        metadata=wire("first-valid"),
+    )
+    last_valid: int = field(
+        default=0,
+        metadata=wire("last-valid"),
+    )
+    sender: str = field(
+        default="",
+        metadata=wire("sender"),
+    )
+    tx_type: str = field(
+        default="",
+        metadata=wire("tx-type"),
+    )
+    application_transaction: TransactionApplication | None = field(
+        default=None,
+        metadata=nested("application-transaction", lambda: TransactionApplication),
+    )
+    asset_config_transaction: TransactionAssetConfig | None = field(
+        default=None,
+        metadata=nested("asset-config-transaction", lambda: TransactionAssetConfig),
+    )
+    asset_freeze_transaction: TransactionAssetFreeze | None = field(
+        default=None,
+        metadata=nested("asset-freeze-transaction", lambda: TransactionAssetFreeze),
+    )
+    asset_transfer_transaction: TransactionAssetTransfer | None = field(
+        default=None,
+        metadata=nested("asset-transfer-transaction", lambda: TransactionAssetTransfer),
+    )
+    auth_addr: str | None = field(
+        default=None,
+        metadata=wire("auth-addr"),
+    )
+    close_rewards: int | None = field(
+        default=None,
+        metadata=wire("close-rewards"),
+    )
+    closing_amount: int | None = field(
+        default=None,
+        metadata=wire("closing-amount"),
+    )
+    confirmed_round: int | None = field(
+        default=None,
+        metadata=wire("confirmed-round"),
+    )
+    created_app_id: int | None = field(
+        default=None,
+        metadata=wire("created-application-index"),
+    )
+    created_asset_id: int | None = field(
+        default=None,
+        metadata=wire("created-asset-index"),
+    )
+    genesis_hash: bytes | None = field(
+        default=None,
+        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 | None = field(
+        default=None,
+        metadata=wire("genesis-id"),
+    )
+    global_state_delta: list[EvalDeltaKeyValue] | None = field(
+        default=None,
+        metadata=wire(
+            "global-state-delta",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: EvalDeltaKeyValue, raw),
+        ),
+    )
+    group: bytes | None = field(
+        default=None,
+        metadata=wire(
+            "group",
+            encode=lambda v: encode_fixed_bytes_base64(v, 32),
+            decode=lambda raw: decode_fixed_bytes_base64(raw, 32),
+        ),
+    )
+    heartbeat_transaction: TransactionHeartbeat | None = field(
+        default=None,
+        metadata=nested("heartbeat-transaction", lambda: TransactionHeartbeat),
+    )
+    id_: str | None = field(
+        default=None,
+        metadata=wire("id"),
+    )
+    inner_txns: list["Transaction"] | None = field(
+        default=None,
+        metadata=wire(
+            "inner-txns",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: Transaction, raw),
+        ),
+    )
+    intra_round_offset: int | None = field(
+        default=None,
+        metadata=wire("intra-round-offset"),
+    )
+    keyreg_transaction: TransactionKeyreg | None = field(
+        default=None,
+        metadata=nested("keyreg-transaction", lambda: TransactionKeyreg),
+    )
+    lease: bytes | None = field(
+        default=None,
+        metadata=wire(
+            "lease",
+            encode=lambda v: encode_fixed_bytes_base64(v, 32),
+            decode=lambda raw: decode_fixed_bytes_base64(raw, 32),
+        ),
+    )
+    local_state_delta: list[AccountStateDelta] | None = field(
+        default=None,
+        metadata=wire(
+            "local-state-delta",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: AccountStateDelta, raw),
+        ),
+    )
+    logs: list[bytes] | None = field(
+        default=None,
+        metadata=wire(
+            "logs",
+            encode=encode_bytes_sequence,
+            decode=decode_bytes_sequence,
+        ),
+    )
+    note: bytes | None = field(
+        default=None,
+        metadata=wire(
+            "note",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )
+    payment_transaction: TransactionPayment | None = field(
+        default=None,
+        metadata=nested("payment-transaction", lambda: TransactionPayment),
+    )
+    receiver_rewards: int | None = field(
+        default=None,
+        metadata=wire("receiver-rewards"),
+    )
+    rekey_to: str | None = field(
+        default=None,
+        metadata=wire("rekey-to"),
+    )
+    round_time: int | None = field(
+        default=None,
+        metadata=wire("round-time"),
+    )
+    sender_rewards: int | None = field(
+        default=None,
+        metadata=wire("sender-rewards"),
+    )
+    signature: TransactionSignature | None = field(
+        default=None,
+        metadata=nested("signature", lambda: TransactionSignature),
+    )
+    state_proof_transaction: TransactionStateProof | None = field(
+        default=None,
+        metadata=nested("state-proof-transaction", lambda: TransactionStateProof),
+    )

algokit_indexer_client/models/_transaction_application.py

@@ -0,0 +1,105 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import enum_value, nested, wire
+
+from ._box_reference import BoxReference
+from ._on_completion import OnCompletion
+from ._resource_ref import ResourceRef
+from ._serde_helpers import (
+    decode_bytes_base64,
+    decode_bytes_sequence,
+    decode_model_sequence,
+    encode_bytes_base64,
+    encode_bytes_sequence,
+    encode_model_sequence,
+)
+from ._state_schema import StateSchema
+
+
+@dataclass(slots=True)
+class TransactionApplication:
+    """
+    Fields for application transactions.
+
+    Definition:
+    data/transactions/application.go : ApplicationCallTxnFields
+    """
+
+    on_completion: OnCompletion = field(
+        metadata=enum_value("on-completion", OnCompletion),
+    )
+    application_id: int = field(
+        default=0,
+        metadata=wire("application-id"),
+    )
+    access: list[ResourceRef] | None = field(
+        default=None,
+        metadata=wire(
+            "access",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: ResourceRef, raw),
+        ),
+    )
+    accounts: list[str] | None = field(
+        default=None,
+        metadata=wire("accounts"),
+    )
+    application_args: list[bytes] | None = field(
+        default=None,
+        metadata=wire(
+            "application-args",
+            encode=encode_bytes_sequence,
+            decode=decode_bytes_sequence,
+        ),
+    )
+    approval_program: bytes | None = field(
+        default=None,
+        metadata=wire(
+            "approval-program",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )
+    box_references: list[BoxReference] | None = field(
+        default=None,
+        metadata=wire(
+            "box-references",
+            encode=encode_model_sequence,
+            decode=lambda raw: decode_model_sequence(lambda: BoxReference, raw),
+        ),
+    )
+    clear_state_program: bytes | None = field(
+        default=None,
+        metadata=wire(
+            "clear-state-program",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )
+    extra_program_pages: int | None = field(
+        default=None,
+        metadata=wire("extra-program-pages"),
+    )
+    foreign_apps: list[int] | None = field(
+        default=None,
+        metadata=wire("foreign-apps"),
+    )
+    foreign_assets: list[int] | None = field(
+        default=None,
+        metadata=wire("foreign-assets"),
+    )
+    global_state_schema: StateSchema | None = field(
+        default=None,
+        metadata=nested("global-state-schema", lambda: StateSchema),
+    )
+    local_state_schema: StateSchema | None = field(
+        default=None,
+        metadata=nested("local-state-schema", lambda: StateSchema),
+    )
+    reject_version: int | None = field(
+        default=None,
+        metadata=wire("reject-version"),
+    )

algokit_indexer_client/models/_transaction_asset_config.py

@@ -0,0 +1,31 @@
+# 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 TransactionAssetConfig:
+    """
+    Fields for asset allocation, re-configuration, and destruction.
+
+
+    A zero value for asset-id indicates asset creation.
+    A zero value for the params indicates asset destruction.
+
+    Definition:
+    data/transactions/asset.go : AssetConfigTxnFields
+    """
+
+    asset_id: int | None = field(
+        default=None,
+        metadata=wire("asset-id"),
+    )
+    params: AssetParams | None = field(
+        default=None,
+        metadata=nested("params", lambda: AssetParams),
+    )

algokit_indexer_client/models/_transaction_asset_freeze.py

@@ -0,0 +1,29 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+
+@dataclass(slots=True)
+class TransactionAssetFreeze:
+    """
+    Fields for an asset freeze transaction.
+
+    Definition:
+    data/transactions/asset.go : AssetFreezeTxnFields
+    """
+
+    address: str = field(
+        default="",
+        metadata=wire("address"),
+    )
+    asset_id: int = field(
+        default=0,
+        metadata=wire("asset-id"),
+    )
+    new_freeze_status: bool = field(
+        default=False,
+        metadata=wire("new-freeze-status"),
+    )

algokit_indexer_client/models/_transaction_asset_transfer.py

@@ -0,0 +1,41 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+
+@dataclass(slots=True)
+class TransactionAssetTransfer:
+    """
+    Fields for an asset transfer transaction.
+
+    Definition:
+    data/transactions/asset.go : AssetTransferTxnFields
+    """
+
+    amount: int = field(
+        default=0,
+        metadata=wire("amount"),
+    )
+    asset_id: int = field(
+        default=0,
+        metadata=wire("asset-id"),
+    )
+    receiver: str = field(
+        default="",
+        metadata=wire("receiver"),
+    )
+    close_amount: int | None = field(
+        default=None,
+        metadata=wire("close-amount"),
+    )
+    close_to: str | None = field(
+        default=None,
+        metadata=wire("close-to"),
+    )
+    sender: str | None = field(
+        default=None,
+        metadata=wire("sender"),
+    )

algokit_indexer_client/models/_transaction_heartbeat.py

@@ -0,0 +1,52 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested, wire
+
+from ._hb_proof_fields import HbProofFields
+from ._serde_helpers import (
+    decode_bytes_base64,
+    decode_fixed_bytes_base64,
+    encode_bytes_base64,
+    encode_fixed_bytes_base64,
+)
+
+
+@dataclass(slots=True)
+class TransactionHeartbeat:
+    """
+    Fields for a heartbeat transaction.
+
+    Definition:
+    data/transactions/heartbeat.go : HeartbeatTxnFields
+    """
+
+    hb_proof: HbProofFields = field(
+        metadata=nested("hb-proof", lambda: HbProofFields, required=True),
+    )
+    hb_address: str = field(
+        default="",
+        metadata=wire("hb-address"),
+    )
+    hb_key_dilution: int = field(
+        default=0,
+        metadata=wire("hb-key-dilution"),
+    )
+    hb_seed: bytes = field(
+        default=b"",
+        metadata=wire(
+            "hb-seed",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )
+    hb_vote_id: bytes = field(
+        default=b"",
+        metadata=wire(
+            "hb-vote-id",
+            encode=lambda v: encode_fixed_bytes_base64(v, 32),
+            decode=lambda raw: decode_fixed_bytes_base64(raw, 32),
+        ),
+    )

algokit_indexer_client/models/_transaction_keyreg.py

@@ -0,0 +1,59 @@
+# 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 TransactionKeyreg:
+    """
+    Fields for a keyreg transaction.
+
+    Definition:
+    data/transactions/keyreg.go : KeyregTxnFields
+    """
+
+    non_participation: bool | None = field(
+        default=None,
+        metadata=wire("non-participation"),
+    )
+    selection_participation_key: bytes | None = field(
+        default=None,
+        metadata=wire(
+            "selection-participation-key",
+            encode=lambda v: encode_fixed_bytes_base64(v, 32),
+            decode=lambda raw: decode_fixed_bytes_base64(raw, 32),
+        ),
+    )
+    state_proof_key: bytes | None = field(
+        default=None,
+        metadata=wire(
+            "state-proof-key",
+            encode=lambda v: encode_fixed_bytes_base64(v, 64),
+            decode=lambda raw: decode_fixed_bytes_base64(raw, 64),
+        ),
+    )
+    vote_first_valid: int | None = field(
+        default=None,
+        metadata=wire("vote-first-valid"),
+    )
+    vote_key_dilution: int | None = field(
+        default=None,
+        metadata=wire("vote-key-dilution"),
+    )
+    vote_last_valid: int | None = field(
+        default=None,
+        metadata=wire("vote-last-valid"),
+    )
+    vote_participation_key: bytes | None = field(
+        default=None,
+        metadata=wire(
+            "vote-participation-key",
+            encode=lambda v: encode_fixed_bytes_base64(v, 32),
+            decode=lambda raw: decode_fixed_bytes_base64(raw, 32),
+        ),
+    )

algokit_indexer_client/models/_transaction_payment.py

@@ -0,0 +1,33 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import wire
+
+
+@dataclass(slots=True)
+class TransactionPayment:
+    """
+    Fields for a payment transaction.
+
+    Definition:
+    data/transactions/payment.go : PaymentTxnFields
+    """
+
+    amount: int = field(
+        default=0,
+        metadata=wire("amount"),
+    )
+    receiver: str = field(
+        default="",
+        metadata=wire("receiver"),
+    )
+    close_amount: int | None = field(
+        default=None,
+        metadata=wire("close-amount"),
+    )
+    close_remainder_to: str | None = field(
+        default=None,
+        metadata=wire("close-remainder-to"),
+    )

algokit_indexer_client/models/_transaction_response.py

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

algokit_indexer_client/models/_transaction_signature.py

@@ -0,0 +1,35 @@
+# 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 ._transaction_signature_logicsig import TransactionSignatureLogicsig
+from ._transaction_signature_multisig import TransactionSignatureMultisig
+
+
+@dataclass(slots=True)
+class TransactionSignature:
+    """
+    Validation signature associated with some data. Only one of the signatures should be
+    provided.
+    """
+
+    logicsig: TransactionSignatureLogicsig | None = field(
+        default=None,
+        metadata=nested("logicsig", lambda: TransactionSignatureLogicsig),
+    )
+    multisig: TransactionSignatureMultisig | None = field(
+        default=None,
+        metadata=nested("multisig", lambda: TransactionSignatureMultisig),
+    )
+    sig: bytes | None = field(
+        default=None,
+        metadata=wire(
+            "sig",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )

algokit_indexer_client/models/_transaction_signature_logicsig.py

@@ -0,0 +1,59 @@
+# AUTO-GENERATED: oas_generator
+
+
+from dataclasses import dataclass, field
+
+from algokit_common.serde import nested, wire
+
+from ._serde_helpers import (
+    decode_bytes_base64,
+    decode_bytes_sequence,
+    decode_fixed_bytes_base64,
+    encode_bytes_base64,
+    encode_bytes_sequence,
+    encode_fixed_bytes_base64,
+)
+from ._transaction_signature_multisig import TransactionSignatureMultisig
+
+
+@dataclass(slots=True)
+class TransactionSignatureLogicsig:
+    r"""
+    \[lsig\] Programatic transaction signature.
+
+    Definition:
+    data/transactions/logicsig.go
+    """
+
+    logic: bytes = field(
+        default=b"",
+        metadata=wire(
+            "logic",
+            encode=encode_bytes_base64,
+            decode=decode_bytes_base64,
+        ),
+    )
+    args: list[bytes] | None = field(
+        default=None,
+        metadata=wire(
+            "args",
+            encode=encode_bytes_sequence,
+            decode=decode_bytes_sequence,
+        ),
+    )
+    logic_multisig_signature: TransactionSignatureMultisig | None = field(
+        default=None,
+        metadata=nested("logic-multisig-signature", lambda: TransactionSignatureMultisig),
+    )
+    multisig_signature: TransactionSignatureMultisig | None = field(
+        default=None,
+        metadata=nested("multisig-signature", lambda: TransactionSignatureMultisig),
+    )
+    signature: bytes | None = field(
+        default=None,
+        metadata=wire(
+            "signature",
+            encode=lambda v: encode_fixed_bytes_base64(v, 64),
+            decode=lambda raw: decode_fixed_bytes_base64(raw, 64),
+        ),
+    )