arc56-generated-ansar-e2fd235e 1.2.2026072010__tar.gz

arc56_generated_ansar_e2fd235e-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_ansar_e2fd235e-1.2.2026072010/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.5
+Name: arc56-generated-ansar_e2fd235e
+Version: 1.2.2026072010
+Summary: Generated ARC-56 Algorand smart-contract clients for ansaria11/Hackathon.
+Project-URL: Homepage, https://github.com/scholtz/Arc56Registry
+Project-URL: Repository, https://github.com/scholtz/Arc56Registry
+Author: ansaria11
+Keywords: Hackathon,algorand,ansaria11,arc56,avm,generated-client,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-ansar_e2fd235e
+
+Auto-generated typed Algorand smart-contract clients for **[ansaria11/Hackathon](https://github.com/ansaria11/Hackathon)**,
+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-ansar_e2fd235e
+```
+
+## 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_ansar_e2fd235e import HackathonContract_6b34a24a
+
+algorand = AlgorandClient.mainnet()
+client = HackathonContract_6b34a24a.HackathonContractClient(
+    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 |
+| --- | --- | --- |
+| `HackathonContract_6b34a24a` | `HackathonContractClient` | [https://raw.githubusercontent.com/ansaria11/Hackathon/HEAD/projects/Hackathon-contracts/smart_contracts/artifacts/hackathon_contract/HackathonContract.arc56.json](https://raw.githubusercontent.com/ansaria11/Hackathon/HEAD/projects/Hackathon-contracts/smart_contracts/artifacts/hackathon_contract/HackathonContract.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_ansar_e2fd235e-1.2.2026072010/README.md

@@ -0,0 +1,60 @@
+# arc56-generated-ansar_e2fd235e
+
+Auto-generated typed Algorand smart-contract clients for **[ansaria11/Hackathon](https://github.com/ansaria11/Hackathon)**,
+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-ansar_e2fd235e
+```
+
+## 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_ansar_e2fd235e import HackathonContract_6b34a24a
+
+algorand = AlgorandClient.mainnet()
+client = HackathonContract_6b34a24a.HackathonContractClient(
+    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 |
+| --- | --- | --- |
+| `HackathonContract_6b34a24a` | `HackathonContractClient` | [https://raw.githubusercontent.com/ansaria11/Hackathon/HEAD/projects/Hackathon-contracts/smart_contracts/artifacts/hackathon_contract/HackathonContract.arc56.json](https://raw.githubusercontent.com/ansaria11/Hackathon/HEAD/projects/Hackathon-contracts/smart_contracts/artifacts/hackathon_contract/HackathonContract.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_ansar_e2fd235e-1.2.2026072010/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "arc56-generated-ansar_e2fd235e"
+version = "1.2.2026072010"
+description = "Generated ARC-56 Algorand smart-contract clients for ansaria11/Hackathon."
+readme = "README.md"
+requires-python = ">=3.10"
+authors = [{ name = "ansaria11" }]
+keywords = ["algorand", "arc56", "avm", "smart-contract", "generated-client", "ansaria11", "Hackathon"]
+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_ansar_e2fd235e"]

arc56_generated_ansar_e2fd235e-1.2.2026072010/src/arc56_generated_ansar_e2fd235e/HackathonContract_6b34a24a.py

@@ -0,0 +1,427 @@
+# 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": ["NoOp"]}, "methods": [{"actions": {"call": ["NoOp"], "create": []}, "args": [{"type": "string", "name": "name"}], "name": "hello", "returns": {"type": "string"}, "events": [], "readonly": false, "recommendations": {}}], "name": "HackathonContract", "state": {"keys": {"box": {}, "global": {}, "local": {}}, "maps": {"box": {}, "global": {}, "local": {}}, "schema": {"global": {"bytes": 0, "ints": 0}, "local": {"bytes": 0, "ints": 0}}}, "structs": {}, "events": [], "networks": {}, "sourceInfo": {"approval": {"pcOffsetMethod": "none", "sourceInfo": [{"pc": [25], "errorMessage": "OnCompletion is not NoOp"}, {"pc": [66], "errorMessage": "can only call when creating"}, {"pc": [28], "errorMessage": "can only call when not creating"}]}, "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, kw_only=True)
+class HelloArgs:
+    """Dataclass for hello arguments"""
+    name: str
+
+    @property
+    def abi_method_signature(self) -> str:
+        return "hello(string)string"
+
+
+class HackathonContractParams:
+    def __init__(self, app_client: algokit_utils.AppClient):
+        self.app_client = app_client
+
+    def hello(
+        self,
+        args: tuple[str] | HelloArgs,
+        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": "hello(string)string",
+            "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 HackathonContractCreateTransactionParams:
+    def __init__(self, app_client: algokit_utils.AppClient):
+        self.app_client = app_client
+
+    def hello(
+        self,
+        args: tuple[str] | HelloArgs,
+        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": "hello(string)string",
+            "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 HackathonContractSend:
+    def __init__(self, app_client: algokit_utils.AppClient):
+        self.app_client = app_client
+
+    def hello(
+        self,
+        args: tuple[str] | HelloArgs,
+        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": "hello(string)string",
+            "args": method_args,
+        }), send_params=send_params)
+        parsed_response = response
+        return typing.cast(algokit_utils.SendAppTransactionResult[str], 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 HackathonContractState:
+    """Methods to access state for the current HackathonContract app"""
+
+    def __init__(self, app_client: algokit_utils.AppClient):
+        self.app_client = app_client
+
+class HackathonContractClient:
+    """Client for interacting with HackathonContract 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 = HackathonContractParams(self.app_client)
+        self.create_transaction = HackathonContractCreateTransactionParams(self.app_client)
+        self.send = HackathonContractSend(self.app_client)
+        self.state = HackathonContractState(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,
+    ) -> "HackathonContractClient":
+        return HackathonContractClient(
+            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,
+    ) -> "HackathonContractClient":
+        return HackathonContractClient(
+            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,
+    ) -> "HackathonContractClient":
+        return HackathonContractClient(
+            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) -> "HackathonContractComposer":
+        return HackathonContractComposer(self)
+
+    @typing.overload
+    def decode_return_value(
+        self,
+        method: typing.Literal["hello(string)string"],
+        return_value: algokit_utils.ABIReturn | None
+    ) -> str | 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 | 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 HackathonContractComposer:
+    """Composer for creating transaction groups for HackathonContract contract calls"""
+
+    def __init__(self, client: "HackathonContractClient"):
+        self.client = client
+        self._composer = client.algorand.new_group()
+        self._result_mappers: list[typing.Callable[[algokit_utils.ABIReturn | None], object] | None] = []
+
+    def hello(
+        self,
+        args: tuple[str] | HelloArgs,
+        params: algokit_utils.CommonAppCallParams | None = None
+    ) -> "HackathonContractComposer":
+        self._composer.add_app_call_method_call(
+            self.client.params.hello(
+                args=args,
+                params=params,
+            )
+        )
+        self._result_mappers.append(
+            lambda v: self.client.decode_return_value(
+                "hello(string)string", v
+            )
+        )
+        return self
+
+    def clear_state(
+        self,
+        *,
+        args: list[bytes] | None = None,
+        params: algokit_utils.CommonAppCallParams | None = None,
+    ) -> "HackathonContractComposer":
+        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
+    ) -> "HackathonContractComposer":
+        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_ansar_e2fd235e-1.2.2026072010/src/arc56_generated_ansar_e2fd235e/__init__.py

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

arc56_generated_ansar_e2fd235e-1.2.2026072010/src/arc56_generated_ansaria11_hackathon/HackathonContract_6b34a24a.py

@@ -0,0 +1,427 @@
+# 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": ["NoOp"]}, "methods": [{"actions": {"call": ["NoOp"], "create": []}, "args": [{"type": "string", "name": "name"}], "name": "hello", "returns": {"type": "string"}, "events": [], "readonly": false, "recommendations": {}}], "name": "HackathonContract", "state": {"keys": {"box": {}, "global": {}, "local": {}}, "maps": {"box": {}, "global": {}, "local": {}}, "schema": {"global": {"bytes": 0, "ints": 0}, "local": {"bytes": 0, "ints": 0}}}, "structs": {}, "events": [], "networks": {}, "sourceInfo": {"approval": {"pcOffsetMethod": "none", "sourceInfo": [{"pc": [25], "errorMessage": "OnCompletion is not NoOp"}, {"pc": [66], "errorMessage": "can only call when creating"}, {"pc": [28], "errorMessage": "can only call when not creating"}]}, "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, kw_only=True)
+class HelloArgs:
+    """Dataclass for hello arguments"""
+    name: str
+
+    @property
+    def abi_method_signature(self) -> str:
+        return "hello(string)string"
+
+
+class HackathonContractParams:
+    def __init__(self, app_client: algokit_utils.AppClient):
+        self.app_client = app_client
+
+    def hello(
+        self,
+        args: tuple[str] | HelloArgs,
+        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": "hello(string)string",
+            "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 HackathonContractCreateTransactionParams:
+    def __init__(self, app_client: algokit_utils.AppClient):
+        self.app_client = app_client
+
+    def hello(
+        self,
+        args: tuple[str] | HelloArgs,
+        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": "hello(string)string",
+            "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 HackathonContractSend:
+    def __init__(self, app_client: algokit_utils.AppClient):
+        self.app_client = app_client
+
+    def hello(
+        self,
+        args: tuple[str] | HelloArgs,
+        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": "hello(string)string",
+            "args": method_args,
+        }), send_params=send_params)
+        parsed_response = response
+        return typing.cast(algokit_utils.SendAppTransactionResult[str], 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 HackathonContractState:
+    """Methods to access state for the current HackathonContract app"""
+
+    def __init__(self, app_client: algokit_utils.AppClient):
+        self.app_client = app_client
+
+class HackathonContractClient:
+    """Client for interacting with HackathonContract 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 = HackathonContractParams(self.app_client)
+        self.create_transaction = HackathonContractCreateTransactionParams(self.app_client)
+        self.send = HackathonContractSend(self.app_client)
+        self.state = HackathonContractState(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,
+    ) -> "HackathonContractClient":
+        return HackathonContractClient(
+            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,
+    ) -> "HackathonContractClient":
+        return HackathonContractClient(
+            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,
+    ) -> "HackathonContractClient":
+        return HackathonContractClient(
+            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) -> "HackathonContractComposer":
+        return HackathonContractComposer(self)
+
+    @typing.overload
+    def decode_return_value(
+        self,
+        method: typing.Literal["hello(string)string"],
+        return_value: algokit_utils.ABIReturn | None
+    ) -> str | 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 | 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 HackathonContractComposer:
+    """Composer for creating transaction groups for HackathonContract contract calls"""
+
+    def __init__(self, client: "HackathonContractClient"):
+        self.client = client
+        self._composer = client.algorand.new_group()
+        self._result_mappers: list[typing.Callable[[algokit_utils.ABIReturn | None], object] | None] = []
+
+    def hello(
+        self,
+        args: tuple[str] | HelloArgs,
+        params: algokit_utils.CommonAppCallParams | None = None
+    ) -> "HackathonContractComposer":
+        self._composer.add_app_call_method_call(
+            self.client.params.hello(
+                args=args,
+                params=params,
+            )
+        )
+        self._result_mappers.append(
+            lambda v: self.client.decode_return_value(
+                "hello(string)string", v
+            )
+        )
+        return self
+
+    def clear_state(
+        self,
+        *,
+        args: list[bytes] | None = None,
+        params: algokit_utils.CommonAppCallParams | None = None,
+    ) -> "HackathonContractComposer":
+        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
+    ) -> "HackathonContractComposer":
+        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_ansar_e2fd235e-1.2.2026072010/src/arc56_generated_ansaria11_hackathon/__init__.py

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

arc56_generated_ansar_e2fd235e-1.2.2026072010/state.json

@@ -0,0 +1,17 @@
+{
+  "contracts": {
+    "https://raw.githubusercontent.com/ansaria11/Hackathon/HEAD/projects/Hackathon-contracts/smart_contracts/artifacts/hackathon_contract/HackathonContract.arc56.json": {
+      "class_name": "HackathonContractClient",
+      "content_sha256": "0783df5dc5b8ccd42c872d1eb1467fe5bb4dce29f019151afb86885362eb04dc",
+      "file_slug": "HackathonContract",
+      "generated_at": "2026-07-18T15:56:43.391946+00:00",
+      "hash8": "6b34a24a",
+      "py_sha256": "0fb81b2112692d406772fdf0628bec23153e750582b2aaa9b50a6ed129ea4195"
+    }
+  },
+  "dist_name": "arc56-generated-ansar_e2fd235e",
+  "generator_version": "2.2.0",
+  "increment": 2,
+  "template_hash": "e7cb5fa2fecdfde3f4cdfff941ff9299032493e9bd016b9cfc7c4a6c889246d5",
+  "version": "1.2.2026072010"
+}