arc56-generated-d13co-ghostkit 1.2.2026072010__tar.gz

arc56_generated_d13co_ghostkit-1.2.2026072010/.gitignore

@@ -0,0 +1,16 @@
+# .NET build output
+bin/
+obj/
+artifacts/
+
+# npm/TypeScript build output
+node_modules/
+clients/*/*/npm/dist/
+
+# Python
+__pycache__/
+*.pyc
+
+# OS
+.DS_Store
+Thumbs.db

arc56_generated_d13co_ghostkit-1.2.2026072010/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.5
+Name: arc56-generated-d13co-ghostkit
+Version: 1.2.2026072010
+Summary: Generated ARC-56 Algorand smart-contract clients for d13co/ghostkit.
+Project-URL: Homepage, https://github.com/scholtz/Arc56Registry
+Project-URL: Repository, https://github.com/scholtz/Arc56Registry
+Author: d13co
+Keywords: algorand,arc56,avm,d13co,generated-client,ghostkit,smart-contract
+Requires-Python: >=3.10
+Requires-Dist: algokit-utils<5.0.0,>=4.2.3
+Requires-Dist: py-algorand-sdk<3.0.0,>=2.11.1
+Description-Content-Type: text/markdown
+
+# arc56-generated-d13co-ghostkit
+
+Auto-generated typed Algorand smart-contract clients for **[d13co/ghostkit](https://github.com/d13co/ghostkit)**,
+built from the [ARC-56](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0056.md)
+specs listed below.
+
+Generated by the [Arc56Registry](https://github.com/scholtz/Arc56Registry) pipeline,
+using the [algorandfoundation/algokit-client-generator-py](https://github.com/algorandfoundation/algokit-client-generator-py)
+ARC-56 client generator. Do not edit these files by hand — they are regenerated
+automatically whenever the source ARC-56 spec changes.
+
+## Install
+
+```bash
+pip install arc56-generated-d13co-ghostkit
+```
+
+## Basic usage
+
+Each contract in this package is a separate module (a hash of its source URL is
+appended to its filename to keep multiple contracts in the same repository from
+colliding), containing a typed `<Name>Client` for interacting with an already-deployed
+instance of that contract, plus a `<Name>Factory` for deploying new instances.
+
+```python
+from algokit_utils import AlgorandClient
+from arc56_generated_d13co_ghostkit import Ghostofavm_a552bf7f
+
+algorand = AlgorandClient.mainnet()
+client = Ghostofavm_a552bf7f.GhostofavmClient(
+    algorand=algorand,
+    app_id=123456789,
+)
+
+# call a contract method, e.g.:
+# result = client.send.some_method(args=(...))
+```
+
+### `full` vs `minimal` generator mode
+
+Contracts in this package are generated with the client generator's `full` mode by
+default, which emits both the typed `Client` and a deploy/create `Factory` class plus
+deployment metadata (source code, bytecode, template variables). For the rare contract
+whose `full`-mode output fails to generate or fails to byte-compile, this package falls
+back to `minimal` mode (`Client` only, no `Factory`) for that contract instead of
+failing outright. The contracts table below flags any contract generated this way;
+every other contract includes a working `Factory`.
+
+## Contracts included in this package
+
+| Module | Client class | Source ARC-56 spec |
+| --- | --- | --- |
+| `Ghostofavm_a552bf7f` | `GhostofavmClient` | [https://raw.githubusercontent.com/d13co/ghostkit/HEAD/examples/Ghostofavm.arc56.json](https://raw.githubusercontent.com/d13co/ghostkit/HEAD/examples/Ghostofavm.arc56.json) |
+
+## Versioning
+
+This package uses `1.<increment>.<yyyyMMddHH>`-style versioning: a new version is
+published whenever any of the contracts above change, or whenever the client generator
+itself is updated. See [Arc56Registry](https://github.com/scholtz/Arc56Registry) for
+the full generation pipeline and source ARC-56 registry.

arc56_generated_d13co_ghostkit-1.2.2026072010/README.md

@@ -0,0 +1,60 @@
+# arc56-generated-d13co-ghostkit
+
+Auto-generated typed Algorand smart-contract clients for **[d13co/ghostkit](https://github.com/d13co/ghostkit)**,
+built from the [ARC-56](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0056.md)
+specs listed below.
+
+Generated by the [Arc56Registry](https://github.com/scholtz/Arc56Registry) pipeline,
+using the [algorandfoundation/algokit-client-generator-py](https://github.com/algorandfoundation/algokit-client-generator-py)
+ARC-56 client generator. Do not edit these files by hand — they are regenerated
+automatically whenever the source ARC-56 spec changes.
+
+## Install
+
+```bash
+pip install arc56-generated-d13co-ghostkit
+```
+
+## Basic usage
+
+Each contract in this package is a separate module (a hash of its source URL is
+appended to its filename to keep multiple contracts in the same repository from
+colliding), containing a typed `<Name>Client` for interacting with an already-deployed
+instance of that contract, plus a `<Name>Factory` for deploying new instances.
+
+```python
+from algokit_utils import AlgorandClient
+from arc56_generated_d13co_ghostkit import Ghostofavm_a552bf7f
+
+algorand = AlgorandClient.mainnet()
+client = Ghostofavm_a552bf7f.GhostofavmClient(
+    algorand=algorand,
+    app_id=123456789,
+)
+
+# call a contract method, e.g.:
+# result = client.send.some_method(args=(...))
+```
+
+### `full` vs `minimal` generator mode
+
+Contracts in this package are generated with the client generator's `full` mode by
+default, which emits both the typed `Client` and a deploy/create `Factory` class plus
+deployment metadata (source code, bytecode, template variables). For the rare contract
+whose `full`-mode output fails to generate or fails to byte-compile, this package falls
+back to `minimal` mode (`Client` only, no `Factory`) for that contract instead of
+failing outright. The contracts table below flags any contract generated this way;
+every other contract includes a working `Factory`.
+
+## Contracts included in this package
+
+| Module | Client class | Source ARC-56 spec |
+| --- | --- | --- |
+| `Ghostofavm_a552bf7f` | `GhostofavmClient` | [https://raw.githubusercontent.com/d13co/ghostkit/HEAD/examples/Ghostofavm.arc56.json](https://raw.githubusercontent.com/d13co/ghostkit/HEAD/examples/Ghostofavm.arc56.json) |
+
+## Versioning
+
+This package uses `1.<increment>.<yyyyMMddHH>`-style versioning: a new version is
+published whenever any of the contracts above change, or whenever the client generator
+itself is updated. See [Arc56Registry](https://github.com/scholtz/Arc56Registry) for
+the full generation pipeline and source ARC-56 registry.

arc56_generated_d13co_ghostkit-1.2.2026072010/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "arc56-generated-d13co-ghostkit"
+version = "1.2.2026072010"
+description = "Generated ARC-56 Algorand smart-contract clients for d13co/ghostkit."
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "d13co" }]
+keywords = ["algorand", "arc56", "avm", "smart-contract", "generated-client", "d13co", "ghostkit"]
+dependencies = [
+    "algokit-utils>=4.2.3,<5.0.0",
+    "py-algorand-sdk>=2.11.1,<3.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/scholtz/Arc56Registry"
+Repository = "https://github.com/scholtz/Arc56Registry"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/arc56_generated_d13co_ghostkit"]

arc56_generated_d13co_ghostkit-1.2.2026072010/src/arc56_generated_d13co_ghostkit/Ghostofavm_a552bf7f.py

@@ -0,0 +1,826 @@
+# flake8: noqa
+# fmt: off
+# mypy: ignore-errors
+# This file was automatically generated by algokit-client-generator.
+# DO NOT MODIFY IT BY HAND.
+# requires: algokit-utils@^3.0.0
+
+# common
+import dataclasses
+import typing
+# core algosdk
+import algosdk
+from algosdk.transaction import OnComplete
+from algosdk.atomic_transaction_composer import TransactionSigner
+from algosdk.source_map import SourceMap
+from algosdk.transaction import Transaction
+from algosdk.v2client.models import SimulateTraceConfig
+# utils
+import algokit_utils
+from algokit_utils import AlgorandClient as _AlgoKitAlgorandClient
+
+_APP_SPEC_JSON = r"""{"arcs": [22, 28], "bareActions": {"call": [], "create": []}, "methods": [{"actions": {"call": ["NoOp"], "create": ["NoOp"]}, "args": [{"type": "uint64", "name": "firstRound"}, {"type": "uint64", "name": "lastRound"}], "name": "blkTimestamp", "returns": {"type": "uint64"}, "events": [], "readonly": true, "recommendations": {}}, {"actions": {"call": ["NoOp"], "create": ["NoOp"]}, "args": [{"type": "uint64", "name": "firstRound"}, {"type": "uint64", "name": "lastRound"}], "name": "blkTxnCounter", "returns": {"type": "uint64"}, "events": [], "readonly": true, "recommendations": {}}, {"actions": {"call": ["NoOp"], "create": ["NoOp"]}, "args": [{"type": "uint64", "name": "firstRound"}, {"type": "uint64", "name": "lastRound"}], "name": "blkProposer", "returns": {"type": "address"}, "events": [], "readonly": true, "recommendations": {}}, {"actions": {"call": ["NoOp"], "create": ["NoOp"]}, "args": [{"type": "uint64", "name": "firstRound"}, {"type": "uint64", "name": "lastRound"}], "name": "blkData", "returns": {"type": "(uint64,uint64,uint64,address)", "struct": "BlkData"}, "events": [], "readonly": true, "recommendations": {}}, {"actions": {"call": ["NoOp"], "create": ["NoOp"]}, "args": [{"type": "address[]", "name": "accounts"}], "name": "acctBalanceData", "returns": {"type": "(address,uint64,uint64)", "struct": "AcctBalanceData"}, "events": [], "readonly": true, "recommendations": {}}], "name": "Ghostofavm", "state": {"keys": {"box": {}, "global": {}, "local": {}}, "maps": {"box": {}, "global": {}, "local": {}}, "schema": {"global": {"bytes": 0, "ints": 0}, "local": {"bytes": 0, "ints": 0}}}, "structs": {"AcctBalanceData": [{"name": "address", "type": "address"}, {"name": "balance", "type": "uint64"}, {"name": "minBalance", "type": "uint64"}], "BlkData": [{"name": "round", "type": "uint64"}, {"name": "timestamp", "type": "uint64"}, {"name": "txnCounter", "type": "uint64"}, {"name": "proposer", "type": "address"}]}, "events": [], "networks": {}, "sourceInfo": {"approval": {"pcOffsetMethod": "none", "sourceInfo": [{"pc": [24], "errorMessage": "OnCompletion must be NoOp"}, {"pc": [343], "errorMessage": "index access is out of bounds"}]}, "clear": {"pcOffsetMethod": "none", "sourceInfo": []}}}"""
+APP_SPEC = algokit_utils.Arc56Contract.from_json(_APP_SPEC_JSON)
+
+def _parse_abi_args(args: object | None = None) -> list[object] | None:
+    """Helper to parse ABI args into the format expected by underlying client"""
+    if args is None:
+        return None
+
+    def convert_dataclass(value: object) -> object:
+        if dataclasses.is_dataclass(value):
+            return tuple(convert_dataclass(getattr(value, field.name)) for field in dataclasses.fields(value))
+        elif isinstance(value, (list, tuple)):
+            return type(value)(convert_dataclass(item) for item in value)
+        return value
+
+    match args:
+        case tuple():
+            method_args = list(args)
+        case _ if dataclasses.is_dataclass(args):
+            method_args = [getattr(args, field.name) for field in dataclasses.fields(args)]
+        case _:
+            raise ValueError("Invalid 'args' type. Expected 'tuple' or 'TypedDict' for respective typed arguments.")
+
+    return [
+        convert_dataclass(arg) if not isinstance(arg, algokit_utils.AppMethodCallTransactionArgument) else arg
+        for arg in method_args
+    ] if method_args else None
+
+def _init_dataclass(cls: type, data: dict) -> object:
+    """
+    Recursively instantiate a dataclass of type `cls` from `data`.
+
+    For each field on the dataclass, if the field type is also a dataclass
+    and the corresponding data is a dict, instantiate that field recursively.
+    """
+    field_values = {}
+    for field in dataclasses.fields(cls):
+        field_value = data.get(field.name)
+        # Check if the field expects another dataclass and the value is a dict.
+        if dataclasses.is_dataclass(field.type) and isinstance(field_value, dict):
+            field_values[field.name] = _init_dataclass(typing.cast(type, field.type), field_value)
+        else:
+            field_values[field.name] = field_value
+    return cls(**field_values)
+
+@dataclasses.dataclass(frozen=True)
+class AcctBalanceData:
+    """Struct for AcctBalanceData"""
+    address: str
+    balance: int
+    minBalance: int
+
+@dataclasses.dataclass(frozen=True)
+class BlkData:
+    """Struct for BlkData"""
+    round: int
+    timestamp: int
+    txnCounter: int
+    proposer: str
+
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class BlkTimestampArgs:
+    """Dataclass for blk_timestamp arguments"""
+    firstRound: int
+    lastRound: int
+
+    @property
+    def abi_method_signature(self) -> str:
+        return "blkTimestamp(uint64,uint64)uint64"
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class BlkTxnCounterArgs:
+    """Dataclass for blk_txn_counter arguments"""
+    firstRound: int
+    lastRound: int
+
+    @property
+    def abi_method_signature(self) -> str:
+        return "blkTxnCounter(uint64,uint64)uint64"
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class BlkProposerArgs:
+    """Dataclass for blk_proposer arguments"""
+    firstRound: int
+    lastRound: int
+
+    @property
+    def abi_method_signature(self) -> str:
+        return "blkProposer(uint64,uint64)address"
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class BlkDataArgs:
+    """Dataclass for blk_data arguments"""
+    firstRound: int
+    lastRound: int
+
+    @property
+    def abi_method_signature(self) -> str:
+        return "blkData(uint64,uint64)(uint64,uint64,uint64,address)"
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class AcctBalanceDataArgs:
+    """Dataclass for acct_balance_data arguments"""
+    accounts: list[str]
+
+    @property
+    def abi_method_signature(self) -> str:
+        return "acctBalanceData(address[])(address,uint64,uint64)"
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class BlkTimestampArgs:
+    """Dataclass for blk_timestamp arguments"""
+    firstRound: int
+    lastRound: int
+
+    @property
+    def abi_method_signature(self) -> str:
+        return "blkTimestamp(uint64,uint64)uint64"
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class BlkTxnCounterArgs:
+    """Dataclass for blk_txn_counter arguments"""
+    firstRound: int
+    lastRound: int
+
+    @property
+    def abi_method_signature(self) -> str:
+        return "blkTxnCounter(uint64,uint64)uint64"
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class BlkProposerArgs:
+    """Dataclass for blk_proposer arguments"""
+    firstRound: int
+    lastRound: int
+
+    @property
+    def abi_method_signature(self) -> str:
+        return "blkProposer(uint64,uint64)address"
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class BlkDataArgs:
+    """Dataclass for blk_data arguments"""
+    firstRound: int
+    lastRound: int
+
+    @property
+    def abi_method_signature(self) -> str:
+        return "blkData(uint64,uint64)(uint64,uint64,uint64,address)"
+
+@dataclasses.dataclass(frozen=True, kw_only=True)
+class AcctBalanceDataArgs:
+    """Dataclass for acct_balance_data arguments"""
+    accounts: list[str]
+
+    @property
+    def abi_method_signature(self) -> str:
+        return "acctBalanceData(address[])(address,uint64,uint64)"
+
+
+class GhostofavmParams:
+    def __init__(self, app_client: algokit_utils.AppClient):
+        self.app_client = app_client
+
+    def blk_timestamp(
+        self,
+        args: tuple[int, int] | BlkTimestampArgs,
+        params: algokit_utils.CommonAppCallParams | None = None
+    ) -> algokit_utils.AppCallMethodCallParams:
+        method_args = _parse_abi_args(args)
+        params = params or algokit_utils.CommonAppCallParams()
+        return self.app_client.params.call(algokit_utils.AppClientMethodCallParams(**{
+            **dataclasses.asdict(params),
+            "method": "blkTimestamp(uint64,uint64)uint64",
+            "args": method_args,
+        }))
+
+    def blk_txn_counter(
+        self,
+        args: tuple[int, int] | BlkTxnCounterArgs,
+        params: algokit_utils.CommonAppCallParams | None = None
+    ) -> algokit_utils.AppCallMethodCallParams:
+        method_args = _parse_abi_args(args)
+        params = params or algokit_utils.CommonAppCallParams()
+        return self.app_client.params.call(algokit_utils.AppClientMethodCallParams(**{
+            **dataclasses.asdict(params),
+            "method": "blkTxnCounter(uint64,uint64)uint64",
+            "args": method_args,
+        }))
+
+    def blk_proposer(
+        self,
+        args: tuple[int, int] | BlkProposerArgs,
+        params: algokit_utils.CommonAppCallParams | None = None
+    ) -> algokit_utils.AppCallMethodCallParams:
+        method_args = _parse_abi_args(args)
+        params = params or algokit_utils.CommonAppCallParams()
+        return self.app_client.params.call(algokit_utils.AppClientMethodCallParams(**{
+            **dataclasses.asdict(params),
+            "method": "blkProposer(uint64,uint64)address",
+            "args": method_args,
+        }))
+
+    def blk_data(
+        self,
+        args: tuple[int, int] | BlkDataArgs,
+        params: algokit_utils.CommonAppCallParams | None = None
+    ) -> algokit_utils.AppCallMethodCallParams:
+        method_args = _parse_abi_args(args)
+        params = params or algokit_utils.CommonAppCallParams()
+        return self.app_client.params.call(algokit_utils.AppClientMethodCallParams(**{
+            **dataclasses.asdict(params),
+            "method": "blkData(uint64,uint64)(uint64,uint64,uint64,address)",
+            "args": method_args,
+        }))
+
+    def acct_balance_data(
+        self,
+        args: tuple[list[str]] | AcctBalanceDataArgs,
+        params: algokit_utils.CommonAppCallParams | None = None
+    ) -> algokit_utils.AppCallMethodCallParams:
+        method_args = _parse_abi_args(args)
+        params = params or algokit_utils.CommonAppCallParams()
+        return self.app_client.params.call(algokit_utils.AppClientMethodCallParams(**{
+            **dataclasses.asdict(params),
+            "method": "acctBalanceData(address[])(address,uint64,uint64)",
+            "args": method_args,
+        }))
+
+    def clear_state(
+        self,
+        params: algokit_utils.AppClientBareCallParams | None = None,
+        
+    ) -> algokit_utils.AppCallParams:
+        return self.app_client.params.bare.clear_state(
+            params,
+            
+        )
+
+
+class GhostofavmCreateTransactionParams:
+    def __init__(self, app_client: algokit_utils.AppClient):
+        self.app_client = app_client
+
+    def blk_timestamp(
+        self,
+        args: tuple[int, int] | BlkTimestampArgs,
+        params: algokit_utils.CommonAppCallParams | None = None
+    ) -> algokit_utils.BuiltTransactions:
+        method_args = _parse_abi_args(args)
+        params = params or algokit_utils.CommonAppCallParams()
+        return self.app_client.create_transaction.call(algokit_utils.AppClientMethodCallParams(**{
+            **dataclasses.asdict(params),
+            "method": "blkTimestamp(uint64,uint64)uint64",
+            "args": method_args,
+        }))
+
+    def blk_txn_counter(
+        self,
+        args: tuple[int, int] | BlkTxnCounterArgs,
+        params: algokit_utils.CommonAppCallParams | None = None
+    ) -> algokit_utils.BuiltTransactions:
+        method_args = _parse_abi_args(args)
+        params = params or algokit_utils.CommonAppCallParams()
+        return self.app_client.create_transaction.call(algokit_utils.AppClientMethodCallParams(**{
+            **dataclasses.asdict(params),
+            "method": "blkTxnCounter(uint64,uint64)uint64",
+            "args": method_args,
+        }))
+
+    def blk_proposer(
+        self,
+        args: tuple[int, int] | BlkProposerArgs,
+        params: algokit_utils.CommonAppCallParams | None = None
+    ) -> algokit_utils.BuiltTransactions:
+        method_args = _parse_abi_args(args)
+        params = params or algokit_utils.CommonAppCallParams()
+        return self.app_client.create_transaction.call(algokit_utils.AppClientMethodCallParams(**{
+            **dataclasses.asdict(params),
+            "method": "blkProposer(uint64,uint64)address",
+            "args": method_args,
+        }))
+
+    def blk_data(
+        self,
+        args: tuple[int, int] | BlkDataArgs,
+        params: algokit_utils.CommonAppCallParams | None = None
+    ) -> algokit_utils.BuiltTransactions:
+        method_args = _parse_abi_args(args)
+        params = params or algokit_utils.CommonAppCallParams()
+        return self.app_client.create_transaction.call(algokit_utils.AppClientMethodCallParams(**{
+            **dataclasses.asdict(params),
+            "method": "blkData(uint64,uint64)(uint64,uint64,uint64,address)",
+            "args": method_args,
+        }))
+
+    def acct_balance_data(
+        self,
+        args: tuple[list[str]] | AcctBalanceDataArgs,
+        params: algokit_utils.CommonAppCallParams | None = None
+    ) -> algokit_utils.BuiltTransactions:
+        method_args = _parse_abi_args(args)
+        params = params or algokit_utils.CommonAppCallParams()
+        return self.app_client.create_transaction.call(algokit_utils.AppClientMethodCallParams(**{
+            **dataclasses.asdict(params),
+            "method": "acctBalanceData(address[])(address,uint64,uint64)",
+            "args": method_args,
+        }))
+
+    def clear_state(
+        self,
+        params: algokit_utils.AppClientBareCallParams | None = None,
+        
+    ) -> Transaction:
+        return self.app_client.create_transaction.bare.clear_state(
+            params,
+            
+        )
+
+
+class GhostofavmSend:
+    def __init__(self, app_client: algokit_utils.AppClient):
+        self.app_client = app_client
+
+    def blk_timestamp(
+        self,
+        args: tuple[int, int] | BlkTimestampArgs,
+        params: algokit_utils.CommonAppCallParams | None = None,
+        send_params: algokit_utils.SendParams | None = None
+    ) -> algokit_utils.SendAppTransactionResult[int]:
+        method_args = _parse_abi_args(args)
+        params = params or algokit_utils.CommonAppCallParams()
+        response = self.app_client.send.call(algokit_utils.AppClientMethodCallParams(**{
+            **dataclasses.asdict(params),
+            "method": "blkTimestamp(uint64,uint64)uint64",
+            "args": method_args,
+        }), send_params=send_params)
+        parsed_response = response
+        return typing.cast(algokit_utils.SendAppTransactionResult[int], parsed_response)
+
+    def blk_txn_counter(
+        self,
+        args: tuple[int, int] | BlkTxnCounterArgs,
+        params: algokit_utils.CommonAppCallParams | None = None,
+        send_params: algokit_utils.SendParams | None = None
+    ) -> algokit_utils.SendAppTransactionResult[int]:
+        method_args = _parse_abi_args(args)
+        params = params or algokit_utils.CommonAppCallParams()
+        response = self.app_client.send.call(algokit_utils.AppClientMethodCallParams(**{
+            **dataclasses.asdict(params),
+            "method": "blkTxnCounter(uint64,uint64)uint64",
+            "args": method_args,
+        }), send_params=send_params)
+        parsed_response = response
+        return typing.cast(algokit_utils.SendAppTransactionResult[int], parsed_response)
+
+    def blk_proposer(
+        self,
+        args: tuple[int, int] | BlkProposerArgs,
+        params: algokit_utils.CommonAppCallParams | None = None,
+        send_params: algokit_utils.SendParams | None = None
+    ) -> algokit_utils.SendAppTransactionResult[str]:
+        method_args = _parse_abi_args(args)
+        params = params or algokit_utils.CommonAppCallParams()
+        response = self.app_client.send.call(algokit_utils.AppClientMethodCallParams(**{
+            **dataclasses.asdict(params),
+            "method": "blkProposer(uint64,uint64)address",
+            "args": method_args,
+        }), send_params=send_params)
+        parsed_response = response
+        return typing.cast(algokit_utils.SendAppTransactionResult[str], parsed_response)
+
+    def blk_data(
+        self,
+        args: tuple[int, int] | BlkDataArgs,
+        params: algokit_utils.CommonAppCallParams | None = None,
+        send_params: algokit_utils.SendParams | None = None
+    ) -> algokit_utils.SendAppTransactionResult[BlkData]:
+        method_args = _parse_abi_args(args)
+        params = params or algokit_utils.CommonAppCallParams()
+        response = self.app_client.send.call(algokit_utils.AppClientMethodCallParams(**{
+            **dataclasses.asdict(params),
+            "method": "blkData(uint64,uint64)(uint64,uint64,uint64,address)",
+            "args": method_args,
+        }), send_params=send_params)
+        parsed_response = dataclasses.replace(response, abi_return=_init_dataclass(BlkData, typing.cast(dict, response.abi_return))) # type: ignore
+        return typing.cast(algokit_utils.SendAppTransactionResult[BlkData], parsed_response)
+
+    def acct_balance_data(
+        self,
+        args: tuple[list[str]] | AcctBalanceDataArgs,
+        params: algokit_utils.CommonAppCallParams | None = None,
+        send_params: algokit_utils.SendParams | None = None
+    ) -> algokit_utils.SendAppTransactionResult[AcctBalanceData]:
+        method_args = _parse_abi_args(args)
+        params = params or algokit_utils.CommonAppCallParams()
+        response = self.app_client.send.call(algokit_utils.AppClientMethodCallParams(**{
+            **dataclasses.asdict(params),
+            "method": "acctBalanceData(address[])(address,uint64,uint64)",
+            "args": method_args,
+        }), send_params=send_params)
+        parsed_response = dataclasses.replace(response, abi_return=_init_dataclass(AcctBalanceData, typing.cast(dict, response.abi_return))) # type: ignore
+        return typing.cast(algokit_utils.SendAppTransactionResult[AcctBalanceData], parsed_response)
+
+    def clear_state(
+        self,
+        params: algokit_utils.AppClientBareCallParams | None = None,
+        send_params: algokit_utils.SendParams | None = None
+    ) -> algokit_utils.SendAppTransactionResult[algokit_utils.ABIReturn]:
+        return self.app_client.send.bare.clear_state(
+            params,
+            send_params=send_params,
+        )
+
+
+class GhostofavmState:
+    """Methods to access state for the current Ghostofavm app"""
+
+    def __init__(self, app_client: algokit_utils.AppClient):
+        self.app_client = app_client
+
+class GhostofavmClient:
+    """Client for interacting with Ghostofavm smart contract"""
+
+    @typing.overload
+    def __init__(self, app_client: algokit_utils.AppClient) -> None: ...
+    
+    @typing.overload
+    def __init__(
+        self,
+        *,
+        algorand: _AlgoKitAlgorandClient,
+        app_id: int,
+        app_name: str | None = None,
+        default_sender: str | None = None,
+        default_signer: TransactionSigner | None = None,
+        approval_source_map: SourceMap | None = None,
+        clear_source_map: SourceMap | None = None,
+    ) -> None: ...
+
+    def __init__(
+        self,
+        app_client: algokit_utils.AppClient | None = None,
+        *,
+        algorand: _AlgoKitAlgorandClient | None = None,
+        app_id: int | None = None,
+        app_name: str | None = None,
+        default_sender: str | None = None,
+        default_signer: TransactionSigner | None = None,
+        approval_source_map: SourceMap | None = None,
+        clear_source_map: SourceMap | None = None,
+    ) -> None:
+        if app_client:
+            self.app_client = app_client
+        elif algorand and app_id:
+            self.app_client = algokit_utils.AppClient(
+                algokit_utils.AppClientParams(
+                    algorand=algorand,
+                    app_spec=APP_SPEC,
+                    app_id=app_id,
+                    app_name=app_name,
+                    default_sender=default_sender,
+                    default_signer=default_signer,
+                    approval_source_map=approval_source_map,
+                    clear_source_map=clear_source_map,
+                )
+            )
+        else:
+            raise ValueError("Either app_client or algorand and app_id must be provided")
+    
+        self.params = GhostofavmParams(self.app_client)
+        self.create_transaction = GhostofavmCreateTransactionParams(self.app_client)
+        self.send = GhostofavmSend(self.app_client)
+        self.state = GhostofavmState(self.app_client)
+
+    @staticmethod
+    def from_creator_and_name(
+        creator_address: str,
+        app_name: str,
+        algorand: _AlgoKitAlgorandClient,
+        default_sender: str | None = None,
+        default_signer: TransactionSigner | None = None,
+        approval_source_map: SourceMap | None = None,
+        clear_source_map: SourceMap | None = None,
+        ignore_cache: bool | None = None,
+        app_lookup_cache: algokit_utils.ApplicationLookup | None = None,
+    ) -> "GhostofavmClient":
+        return GhostofavmClient(
+            algokit_utils.AppClient.from_creator_and_name(
+                creator_address=creator_address,
+                app_name=app_name,
+                app_spec=APP_SPEC,
+                algorand=algorand,
+                default_sender=default_sender,
+                default_signer=default_signer,
+                approval_source_map=approval_source_map,
+                clear_source_map=clear_source_map,
+                ignore_cache=ignore_cache,
+                app_lookup_cache=app_lookup_cache,
+            )
+        )
+    
+    @staticmethod
+    def from_network(
+        algorand: _AlgoKitAlgorandClient,
+        app_name: str | None = None,
+        default_sender: str | None = None,
+        default_signer: TransactionSigner | None = None,
+        approval_source_map: SourceMap | None = None,
+        clear_source_map: SourceMap | None = None,
+    ) -> "GhostofavmClient":
+        return GhostofavmClient(
+            algokit_utils.AppClient.from_network(
+                app_spec=APP_SPEC,
+                algorand=algorand,
+                app_name=app_name,
+                default_sender=default_sender,
+                default_signer=default_signer,
+                approval_source_map=approval_source_map,
+                clear_source_map=clear_source_map,
+            )
+        )
+
+    @property
+    def app_id(self) -> int:
+        return self.app_client.app_id
+    
+    @property
+    def app_address(self) -> str:
+        return self.app_client.app_address
+    
+    @property
+    def app_name(self) -> str:
+        return self.app_client.app_name
+    
+    @property
+    def app_spec(self) -> algokit_utils.Arc56Contract:
+        return self.app_client.app_spec
+    
+    @property
+    def algorand(self) -> _AlgoKitAlgorandClient:
+        return self.app_client.algorand
+
+    def clone(
+        self,
+        app_name: str | None = None,
+        default_sender: str | None = None,
+        default_signer: TransactionSigner | None = None,
+        approval_source_map: SourceMap | None = None,
+        clear_source_map: SourceMap | None = None,
+    ) -> "GhostofavmClient":
+        return GhostofavmClient(
+            self.app_client.clone(
+                app_name=app_name,
+                default_sender=default_sender,
+                default_signer=default_signer,
+                approval_source_map=approval_source_map,
+                clear_source_map=clear_source_map,
+            )
+        )
+
+    def new_group(self) -> "GhostofavmComposer":
+        return GhostofavmComposer(self)
+
+    @typing.overload
+    def decode_return_value(
+        self,
+        method: typing.Literal["blkTimestamp(uint64,uint64)uint64"],
+        return_value: algokit_utils.ABIReturn | None
+    ) -> int | None: ...
+    @typing.overload
+    def decode_return_value(
+        self,
+        method: typing.Literal["blkTxnCounter(uint64,uint64)uint64"],
+        return_value: algokit_utils.ABIReturn | None
+    ) -> int | None: ...
+    @typing.overload
+    def decode_return_value(
+        self,
+        method: typing.Literal["blkProposer(uint64,uint64)address"],
+        return_value: algokit_utils.ABIReturn | None
+    ) -> str | None: ...
+    @typing.overload
+    def decode_return_value(
+        self,
+        method: typing.Literal["blkData(uint64,uint64)(uint64,uint64,uint64,address)"],
+        return_value: algokit_utils.ABIReturn | None
+    ) -> BlkData | None: ...
+    @typing.overload
+    def decode_return_value(
+        self,
+        method: typing.Literal["acctBalanceData(address[])(address,uint64,uint64)"],
+        return_value: algokit_utils.ABIReturn | None
+    ) -> AcctBalanceData | None: ...
+    @typing.overload
+    def decode_return_value(
+        self,
+        method: typing.Literal["blkTimestamp(uint64,uint64)uint64"],
+        return_value: algokit_utils.ABIReturn | None
+    ) -> int | None: ...
+    @typing.overload
+    def decode_return_value(
+        self,
+        method: typing.Literal["blkTxnCounter(uint64,uint64)uint64"],
+        return_value: algokit_utils.ABIReturn | None
+    ) -> int | None: ...
+    @typing.overload
+    def decode_return_value(
+        self,
+        method: typing.Literal["blkProposer(uint64,uint64)address"],
+        return_value: algokit_utils.ABIReturn | None
+    ) -> str | None: ...
+    @typing.overload
+    def decode_return_value(
+        self,
+        method: typing.Literal["blkData(uint64,uint64)(uint64,uint64,uint64,address)"],
+        return_value: algokit_utils.ABIReturn | None
+    ) -> BlkData | None: ...
+    @typing.overload
+    def decode_return_value(
+        self,
+        method: typing.Literal["acctBalanceData(address[])(address,uint64,uint64)"],
+        return_value: algokit_utils.ABIReturn | None
+    ) -> AcctBalanceData | None: ...
+    @typing.overload
+    def decode_return_value(
+        self,
+        method: str,
+        return_value: algokit_utils.ABIReturn | None
+    ) -> algokit_utils.ABIValue | algokit_utils.ABIStruct | None: ...
+
+    def decode_return_value(
+        self,
+        method: str,
+        return_value: algokit_utils.ABIReturn | None
+    ) -> algokit_utils.ABIValue | algokit_utils.ABIStruct | None | AcctBalanceData | BlkData | int | str:
+        """Decode ABI return value for the given method."""
+        if return_value is None:
+            return None
+    
+        arc56_method = self.app_spec.get_arc56_method(method)
+        decoded = return_value.get_arc56_value(arc56_method, self.app_spec.structs)
+    
+        # If method returns a struct, convert the dict to appropriate dataclass
+        if (arc56_method and
+            arc56_method.returns and
+            arc56_method.returns.struct and
+            isinstance(decoded, dict)):
+            struct_class = globals().get(arc56_method.returns.struct)
+            if struct_class:
+                return struct_class(**typing.cast(dict, decoded))
+        return decoded
+
+
+class GhostofavmComposer:
+    """Composer for creating transaction groups for Ghostofavm contract calls"""
+
+    def __init__(self, client: "GhostofavmClient"):
+        self.client = client
+        self._composer = client.algorand.new_group()
+        self._result_mappers: list[typing.Callable[[algokit_utils.ABIReturn | None], object] | None] = []
+
+    def blk_timestamp(
+        self,
+        args: tuple[int, int] | BlkTimestampArgs,
+        params: algokit_utils.CommonAppCallParams | None = None
+    ) -> "GhostofavmComposer":
+        self._composer.add_app_call_method_call(
+            self.client.params.blk_timestamp(
+                args=args,
+                params=params,
+            )
+        )
+        self._result_mappers.append(
+            lambda v: self.client.decode_return_value(
+                "blkTimestamp(uint64,uint64)uint64", v
+            )
+        )
+        return self
+
+    def blk_txn_counter(
+        self,
+        args: tuple[int, int] | BlkTxnCounterArgs,
+        params: algokit_utils.CommonAppCallParams | None = None
+    ) -> "GhostofavmComposer":
+        self._composer.add_app_call_method_call(
+            self.client.params.blk_txn_counter(
+                args=args,
+                params=params,
+            )
+        )
+        self._result_mappers.append(
+            lambda v: self.client.decode_return_value(
+                "blkTxnCounter(uint64,uint64)uint64", v
+            )
+        )
+        return self
+
+    def blk_proposer(
+        self,
+        args: tuple[int, int] | BlkProposerArgs,
+        params: algokit_utils.CommonAppCallParams | None = None
+    ) -> "GhostofavmComposer":
+        self._composer.add_app_call_method_call(
+            self.client.params.blk_proposer(
+                args=args,
+                params=params,
+            )
+        )
+        self._result_mappers.append(
+            lambda v: self.client.decode_return_value(
+                "blkProposer(uint64,uint64)address", v
+            )
+        )
+        return self
+
+    def blk_data(
+        self,
+        args: tuple[int, int] | BlkDataArgs,
+        params: algokit_utils.CommonAppCallParams | None = None
+    ) -> "GhostofavmComposer":
+        self._composer.add_app_call_method_call(
+            self.client.params.blk_data(
+                args=args,
+                params=params,
+            )
+        )
+        self._result_mappers.append(
+            lambda v: self.client.decode_return_value(
+                "blkData(uint64,uint64)(uint64,uint64,uint64,address)", v
+            )
+        )
+        return self
+
+    def acct_balance_data(
+        self,
+        args: tuple[list[str]] | AcctBalanceDataArgs,
+        params: algokit_utils.CommonAppCallParams | None = None
+    ) -> "GhostofavmComposer":
+        self._composer.add_app_call_method_call(
+            self.client.params.acct_balance_data(
+                args=args,
+                params=params,
+            )
+        )
+        self._result_mappers.append(
+            lambda v: self.client.decode_return_value(
+                "acctBalanceData(address[])(address,uint64,uint64)", v
+            )
+        )
+        return self
+
+    def clear_state(
+        self,
+        *,
+        args: list[bytes] | None = None,
+        params: algokit_utils.CommonAppCallParams | None = None,
+    ) -> "GhostofavmComposer":
+        params=params or algokit_utils.CommonAppCallParams()
+        self._composer.add_app_call(
+            self.client.params.clear_state(
+                algokit_utils.AppClientBareCallParams(
+                    **{
+                        **dataclasses.asdict(params),
+                        "args": args
+                    }
+                )
+            )
+        )
+        return self
+    
+    def add_transaction(
+        self, txn: Transaction, signer: TransactionSigner | None = None
+    ) -> "GhostofavmComposer":
+        self._composer.add_transaction(txn, signer)
+        return self
+    
+    def composer(self) -> algokit_utils.TransactionComposer:
+        return self._composer
+    
+    def simulate(
+        self,
+        allow_more_logs: bool | None = None,
+        allow_empty_signatures: bool | None = None,
+        allow_unnamed_resources: bool | None = None,
+        extra_opcode_budget: int | None = None,
+        exec_trace_config: SimulateTraceConfig | None = None,
+        simulation_round: int | None = None,
+        skip_signatures: bool | None = None,
+    ) -> algokit_utils.SendAtomicTransactionComposerResults:
+        return self._composer.simulate(
+            allow_more_logs=allow_more_logs,
+            allow_empty_signatures=allow_empty_signatures,
+            allow_unnamed_resources=allow_unnamed_resources,
+            extra_opcode_budget=extra_opcode_budget,
+            exec_trace_config=exec_trace_config,
+            simulation_round=simulation_round,
+            skip_signatures=skip_signatures,
+        )
+    
+    def send(
+        self,
+        send_params: algokit_utils.SendParams | None = None
+    ) -> algokit_utils.SendAtomicTransactionComposerResults:
+        return self._composer.send(send_params)

arc56_generated_d13co_ghostkit-1.2.2026072010/src/arc56_generated_d13co_ghostkit/__init__.py

@@ -0,0 +1 @@
+from . import Ghostofavm_a552bf7f as Ghostofavm_a552bf7f

arc56_generated_d13co_ghostkit-1.2.2026072010/state.json

@@ -0,0 +1,17 @@
+{
+  "contracts": {
+    "https://raw.githubusercontent.com/d13co/ghostkit/HEAD/examples/Ghostofavm.arc56.json": {
+      "class_name": "GhostofavmClient",
+      "content_sha256": "fdc1fa3706ad6b6f206540ba865238f330f1a529e23b7c90f59cbeddda20de97",
+      "file_slug": "Ghostofavm",
+      "generated_at": "2026-07-18T15:58:20.918435+00:00",
+      "hash8": "a552bf7f",
+      "py_sha256": "a91185d3a75b98a19c94c5e4e5b7c93a34739e3e45f2f6f1674b562db59f92f2"
+    }
+  },
+  "dist_name": "arc56-generated-d13co-ghostkit",
+  "generator_version": "2.2.0",
+  "increment": 2,
+  "template_hash": "e7cb5fa2fecdfde3f4cdfff941ff9299032493e9bd016b9cfc7c4a6c889246d5",
+  "version": "1.2.2026072010"
+}