genlayer-test 0.4.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

{genlayer_test-0.4.0.dist-info → genlayer_test-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: genlayer-test
-Version: 0.4.0
+Version: 1.0.0
 Summary: GenLayer Testing Suite
 Author: GenLayer
 License-Expression: MIT
@@ -15,7 +15,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pytest
 Requires-Dist: setuptools>=77.0
-Requires-Dist: genlayer-py==0.6.1
+Requires-Dist: genlayer-py==0.7.1
 Requires-Dist: colorama>=0.4.6
 Requires-Dist: pyyaml
 Requires-Dist: python-dotenv
@@ -59,8 +59,8 @@ contract = factory.deploy(account=other_account)
 assert contract.account == other_account
 
 # Interact with the contract
-result = contract.get_value()  # Read method
-tx_receipt = contract.set_value(args=["new_value"])  # Write method
+result = contract.get_value().call()  # Read method
+tx_receipt = contract.set_value(args=["new_value"]).transact()  # Write method
 
 assert tx_execution_succeeded(tx_receipt)
 ```
@@ -320,7 +320,7 @@ def test_deployment():
 
 ### Read Methods
 
-Reading from the contract is straightforward:
+Reading from the contract requires calling `.call()` on the method:
 
 ```python
 from gltest import get_contract_factory
@@ -332,7 +332,7 @@ def test_read_methods():
     contract = factory.deploy()
 
     # Call a read-only method
-    result = contract.get_value(args=[])
+    result = contract.get_storage(args=[]).call()
     
     # Assert the result matches the initial value
     assert result == "initial_value"
@@ -340,7 +340,7 @@ def test_read_methods():
 
 ### Write Methods
 
-Writing to the contract requires transaction handling:
+Writing to the contract requires calling `.transact()` on the method. Method arguments are passed to the write method, while transaction parameters are passed to `.transact()`:
 
 ```python
 from gltest import get_contract_factory
@@ -354,6 +354,7 @@ def test_write_methods():
     # Call a write method with arguments
     tx_receipt = contract.update_storage(
         args=["new_value"],  # Method arguments
+    ).transact(
         value=0,  # Optional: amount of native currency to send
         consensus_max_rotations=3,  # Optional: max consensus rotations
         leader_only=False,  # Optional: whether to run only on leader
@@ -365,7 +366,7 @@ def test_write_methods():
     assert tx_execution_succeeded(tx_receipt)
     
     # Verify the value was updated
-    assert contract.get_storage() == "new_value"
+    assert contract.get_storage().call() == "new_value"
 ```
 
 ### Assertions
@@ -503,6 +504,50 @@ Fixtures help maintain clean, DRY test code by:
 - Ensuring consistent test environments
 - Managing resource cleanup automatically
 - Providing appropriate scoping for performance
+### Statistical Analysis with `.analyze()`
+
+The GenLayer Testing Suite provides a powerful `.analyze()` method for write operations that performs statistical analysis through multiple simulation runs. This is particularly useful for testing LLM-based contracts where outputs may vary:
+
+```python
+from gltest import get_contract_factory
+
+def test_analyze_method():
+    factory = get_contract_factory("LlmContract")
+    contract = factory.deploy()
+    
+    # Analyze a write method's behavior across multiple runs
+    analysis = contract.process_with_llm(args=["input_data"]).analyze(
+        provider="openai",           # LLM provider
+        model="gpt-4o",             # Model to use
+        runs=100,                   # Number of simulation runs (default: 100)
+        config=None,                # Optional: provider-specific config
+        plugin=None,                # Optional: plugin name
+        plugin_config=None,         # Optional: plugin configuration
+    )
+    
+    # Access analysis results
+    print(f"Method: {analysis.method}")
+    print(f"Success rate: {analysis.success_rate:.2f}%")
+    print(f"Reliability score: {analysis.reliability_score:.2f}%")
+    print(f"Unique states: {analysis.unique_states}")
+    print(f"Execution time: {analysis.execution_time:.1f}s")
+    
+    # The analysis returns a MethodStatsSummary object with:
+    # - method: The contract method name
+    # - args: Arguments passed to the method
+    # - total_runs: Total number of simulation runs
+    # - successful_runs: Number of successful executions
+    # - failed_runs: Number of failed executions
+    # - unique_states: Number of unique contract states observed
+    # - reliability_score: Percentage of runs with the most common state
+    # - execution_time: Total time for all simulations
+```
+
+The `.analyze()` method helps you:
+- Test non-deterministic contract methods
+- Measure consistency of LLM-based operations
+- Identify edge cases and failure patterns
+- Benchmark performance across multiple runs
 
 ## 📝 Best Practices
 
@@ -546,6 +591,7 @@ Fixtures help maintain clean, DRY test code by:
    ```python
    tx_receipt = contract.set_value(
        args=["new_value"],
+   ).transact(
        wait_interval=2,  # Increase wait interval between status checks
        wait_retries=20,  # Increase number of retry attempts
    )

genlayer_test-1.0.0.dist-info/RECORD

@@ -0,0 +1,75 @@
+genlayer_test-1.0.0.dist-info/licenses/LICENSE,sha256=che_H4vE0QUx3HvWrAa1_jDEVInift0U6VO15-QqEls,1064
+gltest/__init__.py,sha256=qoBV3IgDJr8uh9262XsWNMhi-ilkSgMqKVC9FVMk7cw,372
+gltest/accounts.py,sha256=HUmWguJMolggQaZNRPw-LGlRlQCjLLdUanKRowMv6pI,812
+gltest/assertions.py,sha256=0dEk0VxcHK4I7GZPHxJmz-2jaA60V499gOSR74rZbfM,1748
+gltest/clients.py,sha256=1dX6wmG3QCevQRLbSaFlHymZSb-sJ5aYwet1IoX2nbA,1554
+gltest/exceptions.py,sha256=deJPmrTe5gF33qkkKF2IVJY7lc_knI7Ql3N7jZ8aLZs,510
+gltest/fixtures.py,sha256=EJXmqcC3LD03v07mepacFl58lAdhbLj6bP5rtALYISk,2507
+gltest/logging.py,sha256=jAkHsuMm-AEx1Xu1srU6W-0YzTwXJB48mCK-OVzAiN4,342
+gltest/types.py,sha256=BODmwTr2gAUEiO9FjiuTiWwuKvXgo4xZWstQWNUfnlw,156
+gltest/artifacts/__init__.py,sha256=qTt3TE19gVNWnQLUlt5aDe4nNvJ2YJ1jzDkMmYIsCG0,194
+gltest/artifacts/contract.py,sha256=KChpmfjZod_0dVB8y-dvWz6IVm7QlIJsgG2ArtvVDaU,6457
+gltest/contracts/__init__.py,sha256=A9bvEtYOoqoHS8TLlFBfmNOnfwdsJPEf-AZuikagCHM,166
+gltest/contracts/contract.py,sha256=NGgciplaYINL_unJvLnOSWL4f8cNlHGMOEEbc6a1kw4,6402
+gltest/contracts/contract_factory.py,sha256=jjzxgsLW6AiQ4h8LcZwIzdq5Uqm-xkj_JZNhN0djijc,6691
+gltest/contracts/contract_functions.py,sha256=E-C9RnBkz3FeJRiswUaZbcDn4HRSWitsdwegSjX7E_Q,2089
+gltest/contracts/method_stats.py,sha256=zWWjvf7K5VC4yrHpDIR717VF7LYp1RaZ1Hr_RZvWxJA,5150
+gltest/contracts/stats_collector.py,sha256=fuCc8L8hd0tsVGzH4adtZWwPa7ORf0A0zR5Dt1w92Qk,9033
+gltest/contracts/utils.py,sha256=TTXgcXn9BuRIlKJrjwmU7R3l1IgXsXk2luM-r3lfbbg,296
+gltest/helpers/__init__.py,sha256=I7HiTu_H7_hP65zY6Wl02r-5eAMr2eZvqBVmusuQLX4,180
+gltest/helpers/fixture_snapshot.py,sha256=bMgvlEVQBGIQzj7NOyosXWlphI1H2C1o75Zo0C-kGfQ,1931
+gltest/helpers/take_snapshot.py,sha256=-QkaBvFG4ZsNKv_nCSEsy5Ze1pICOHxVhReSeQmZUlY,1276
+gltest_cli/logging.py,sha256=YRWIGwCJIkaB747oQvmS2tzF-B7zymdEMJznrlfyQYA,1245
+gltest_cli/main.py,sha256=Ti2-0Ev1x5_cM0D1UKqdgaDt80CDHEQGtdRne2qLm4M,53
+gltest_cli/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+gltest_cli/config/constants.py,sha256=3iSK337AeupyYl_6Sf8MR_o91XfLmul8m1rVmi3Fvmo,342
+gltest_cli/config/general.py,sha256=ezpoGsT8grO9zQH6RugV14b1GzeFt-htYToHQBJhNvY,186
+gltest_cli/config/plugin.py,sha256=gMK1xrkJ4G0ddCjKAFB7lEXecdvoZiwndwwI4Srn66w,4857
+gltest_cli/config/pytest_context.py,sha256=Ze8JSkrwMTCE8jIhpzU_71CEXg92SiEPvSgNTp-gbS4,243
+gltest_cli/config/types.py,sha256=w7KyINjM3_n4MYoRPfMBgudptjXjnSKPficAsqqSUTY,6344
+gltest_cli/config/user.py,sha256=VSS7llCUJc2GSIexdL73FqkLthdiECwmQONO3-WYi7o,8242
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/conftest.py,sha256=RKdoE5_zcMimeojAoA_GSFI9du4pMzMi1vZ1njtfoAs,28
+tests/examples/contracts/football_prediction_market.py,sha256=0Lm2x2F1DhmUP1fcfzGQAfc50tWFcaHliwyAzXIRFVw,3247
+tests/examples/contracts/intelligent_oracle.py,sha256=cZNGbjKMXY-pimVmPIKIlS963Gd3L1JAipq0VBR1J5Q,12360
+tests/examples/contracts/intelligent_oracle_factory.py,sha256=8lBEn3Atb0yUpXwlvnShlcRxCBTXCrrkoITDHWoWuHU,1499
+tests/examples/contracts/llm_erc20.py,sha256=pOvSUszCtC_f5yDX0tZnj494Ce10uESZ09JLLE8V67o,2534
+tests/examples/contracts/log_indexer.py,sha256=Nlf8XUt13ujam3k6hbbVrPHK-KJ366Csz1TBjc4P07g,1901
+tests/examples/contracts/multi_read_erc20.py,sha256=28qYqn191Ro3rP7YJtZwL6Sc7JDXTeh8_QoqvdVPdqM,864
+tests/examples/contracts/multi_tenant_storage.py,sha256=5F3MCKbzyHMFqLRT9hZNCd3RzjSJvAKVJwLFMeazwog,1906
+tests/examples/contracts/read_erc20.py,sha256=RgH269F0x482WuLLYcacBnZsGJjhgJp6sG_33cV6Z-w,454
+tests/examples/contracts/storage.py,sha256=3DD3qvzb0JkVcBtu240e5kaZWgkh-bu6YExqBUYvfaw,501
+tests/examples/contracts/user_storage.py,sha256=2W2Iv-hQZMkAaPl2RY_F-OeJpD4IlPxgWzN6e1bTkKE,649
+tests/examples/contracts/wizard_of_coin.py,sha256=Y8daPpoSKdM8wfbCPOIgEdpkLIA1ZMmeg6Hu5fBB-kU,1624
+tests/examples/contracts/multi_file_contract/__init__.py,sha256=CCdaK5p12GDf35hgbBWURNM5KUn6SWAcuyieTmZwVWE,548
+tests/examples/contracts/multi_file_contract/other.py,sha256=jHDtjUL3eAUgE6yOYKFw_RfAH7kIwk8CvxUjbWHNruk,236
+tests/examples/tests/test_football_prediction_market.py,sha256=f2hfDK76WrNJZtFkTPKoPRR6bkmFLEssnlwwltSnU9A,1111
+tests/examples/tests/test_intelligent_oracle_factory.py,sha256=wEcVAY0HHDf8oyVQ1kEY-2YfRJipkEJYooqW1wWwXls,8317
+tests/examples/tests/test_llm_erc20.py,sha256=zb5F_7NgvZXhvqL2nULwzuTT6LGDprSy0WgrdjY7pZc,2096
+tests/examples/tests/test_llm_erc20_analyze.py,sha256=ccWQenEOG-U4TJdu-0i-3qNM4xRRCHSr3Iwz7pxknws,1729
+tests/examples/tests/test_log_indexer.py,sha256=46AqL7qquNc9GX2wxFxVcQXLqruMnPmxXl1yeB0-KZ4,2869
+tests/examples/tests/test_multi_file_contract.py,sha256=ZC_zmEE-QtXZ1vxptFSWZw18fRZ5M3zqS7ZCZH1gIfc,569
+tests/examples/tests/test_multi_file_contract_legacy.py,sha256=UTI7Thc8Wg-lotH9JiB5hp9ba6O-yFy1Ss-yuhlgljA,584
+tests/examples/tests/test_multi_read_erc20.py,sha256=pSZUxoB33Z2EBtcvXxfUgwGSi_h7ryPoovkiNIfNAVQ,3713
+tests/examples/tests/test_multi_tenant_storage.py,sha256=TjxN9ks5Wd0QkIszFKNSveNBdJ-wOb7O-fNwGQauXeY,2825
+tests/examples/tests/test_read_erc20.py,sha256=vLGQwguaNnT497nSq-vt4LrXj4ehn5ZSgfPt0GVFoPc,1254
+tests/examples/tests/test_storage.py,sha256=y46nPjM-Jd9FVJmaNE29RPqamzxVwYtPPWE_GlXUsls,774
+tests/examples/tests/test_storage_legacy.py,sha256=STcoRKYP0JcwwNjFSTMpYGuOyXcw2DxGlemUivWp2B0,755
+tests/examples/tests/test_user_storage.py,sha256=wk0r0AXfKNgI7Eeyc8noNlJKvZBFXDbXTQE_u19XxBQ,2927
+tests/examples/tests/test_wizard_of_coin.py,sha256=AOQTanDsfZt9zIGkqZass_4BsGcVKTHzqRejN4KhSPI,854
+tests/gltest/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/gltest/artifact/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/gltest/artifact/test_contract_definition.py,sha256=6R8THNFKKpG7brULzp63vT1_pPd_JFNp3ZS08CJJWrg,3642
+tests/gltest/artifact/contracts/duplicate_ic_contract_1.py,sha256=bSWsUVjBy5cGtI72cjnkstsMzuUJbB3IG5JjTxOF-dc,500
+tests/gltest/artifact/contracts/duplicate_ic_contract_2.py,sha256=bSWsUVjBy5cGtI72cjnkstsMzuUJbB3IG5JjTxOF-dc,500
+tests/gltest/artifact/contracts/not_ic_contract.py,sha256=hQyGnYiiVceYdLI2WrvcFgPqzy1S4-YMb9FPhiHEGSA,510
+tests/gltest/assertions/test_assertions.py,sha256=qzVrOdOM4xYtIy1sFHVAD_-naDHOequ23tEN0MELh0k,10781
+tests/gltest_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/gltest_cli/config/test_general_config.py,sha256=T2haLj41-6tbEfybdXnEycIQQFNkdc_O07qmg_37dqM,5730
+tests/gltest_cli/config/test_plugin.py,sha256=GYY56VR39-uI2WXK-rlzTxB5Ui2h9f5oF_kO0iNljRo,5862
+tests/gltest_cli/config/test_user.py,sha256=40nEC-gM03Q86SnmJpkGfMRvKKtEkfx53qaGHj8XXGQ,13988
+genlayer_test-1.0.0.dist-info/METADATA,sha256=g1QNA8KP65HqSApiaNYcunHwz1Ch2IO_RIkFcbVk5Vo,24143
+genlayer_test-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+genlayer_test-1.0.0.dist-info/entry_points.txt,sha256=RWPcSArBpz_G4BYioh5L8Q8hyClRbSgzLimjcWMp-BQ,94
+genlayer_test-1.0.0.dist-info/top_level.txt,sha256=-qiGZxTRBytujzgVcKpxjvQ-WNeUDjXa59ceGMwMpko,24
+genlayer_test-1.0.0.dist-info/RECORD,,

gltest/__init__.py

@@ -1,14 +1,15 @@
-from gltest.glchain import (
-    create_account,
+from gltest.accounts import (
+    get_default_account,
+    get_accounts,
     create_accounts,
-    get_contract_factory,
+    create_account,
+)
+from gltest.clients import (
     get_gl_client,
-    get_accounts,
-    get_default_account,
 )
+from gltest.contracts import get_contract_factory
 
 __all__ = [
-    "find_contract_definition",
     "create_account",
     "create_accounts",
     "get_contract_factory",

gltest/{glchain/client.py → clients.py}

@@ -1,6 +1,6 @@
 from genlayer_py.chains import localnet
 from genlayer_py import create_client
-from .account import get_default_account
+from gltest.accounts import get_default_account
 from functools import lru_cache
 from gltest_cli.config.general import get_general_config
 

gltest/contracts/__init__.py

@@ -0,0 +1,4 @@
+from .contract import Contract
+from .contract_factory import ContractFactory, get_contract_factory
+
+__all__ = ["Contract", "ContractFactory", "get_contract_factory"]

gltest/contracts/contract.py

@@ -0,0 +1,193 @@
+import types
+from eth_account.signers.local import LocalAccount
+from dataclasses import dataclass
+from gltest.clients import get_gl_client
+from gltest.types import CalldataEncodable, GenLayerTransaction, TransactionStatus
+from typing import List, Any, Optional, Dict, Callable
+from gltest_cli.config.general import get_general_config
+from .contract_functions import ContractFunction
+from .stats_collector import StatsCollector, SimulationConfig
+
+
+def read_contract_wrapper(
+    self,
+    method_name: str,
+    args: Optional[List[CalldataEncodable]] = None,
+) -> Any:
+    """
+    Wrapper to the contract read method.
+    """
+
+    def call_method():
+        client = get_gl_client()
+        return client.read_contract(
+            address=self.address,
+            function_name=method_name,
+            account=self.account,
+            args=args,
+        )
+
+    return ContractFunction(
+        method_name=method_name,
+        read_only=True,
+        call_method=call_method,
+    )
+
+
+def write_contract_wrapper(
+    self,
+    method_name: str,
+    args: Optional[List[CalldataEncodable]] = None,
+) -> GenLayerTransaction:
+    """
+    Wrapper to the contract write method.
+    """
+
+    def transact_method(
+        value: int = 0,
+        consensus_max_rotations: Optional[int] = None,
+        leader_only: bool = False,
+        wait_transaction_status: TransactionStatus = TransactionStatus.FINALIZED,
+        wait_interval: Optional[int] = None,
+        wait_retries: Optional[int] = None,
+        wait_triggered_transactions: bool = True,
+        wait_triggered_transactions_status: TransactionStatus = TransactionStatus.FINALIZED,
+    ):
+        """
+        Transact the contract method.
+        """
+        general_config = get_general_config()
+        actual_wait_interval = (
+            wait_interval
+            if wait_interval is not None
+            else general_config.get_default_wait_interval()
+        )
+        actual_wait_retries = (
+            wait_retries
+            if wait_retries is not None
+            else general_config.get_default_wait_retries()
+        )
+        client = get_gl_client()
+        tx_hash = client.write_contract(
+            address=self.address,
+            function_name=method_name,
+            account=self.account,
+            value=value,
+            consensus_max_rotations=consensus_max_rotations,
+            leader_only=leader_only,
+            args=args,
+        )
+        receipt = client.wait_for_transaction_receipt(
+            transaction_hash=tx_hash,
+            status=wait_transaction_status,
+            interval=actual_wait_interval,
+            retries=actual_wait_retries,
+        )
+        if wait_triggered_transactions:
+            triggered_transactions = receipt["triggered_transactions"]
+            for triggered_transaction in triggered_transactions:
+                client.wait_for_transaction_receipt(
+                    transaction_hash=triggered_transaction,
+                    status=wait_triggered_transactions_status,
+                    interval=actual_wait_interval,
+                    retries=actual_wait_retries,
+                )
+        return receipt
+
+    def analyze_method(
+        provider: str,
+        model: str,
+        config: Optional[Dict[str, Any]] = None,
+        plugin: Optional[str] = None,
+        plugin_config: Optional[Dict[str, Any]] = None,
+        runs: int = 100,
+    ):
+        """
+        Analyze the contract method using StatsCollector.
+        """
+        collector = StatsCollector(
+            contract_address=self.address,
+            method_name=method_name,
+            account=self.account,
+            args=args,
+        )
+        sim_config = SimulationConfig(
+            provider=provider,
+            model=model,
+            config=config,
+            plugin=plugin,
+            plugin_config=plugin_config,
+        )
+        sim_results = collector.run_simulations(sim_config, runs)
+        return collector.analyze_results(sim_results, runs, sim_config)
+
+    return ContractFunction(
+        method_name=method_name,
+        read_only=False,
+        transact_method=transact_method,
+        analyze_method=analyze_method,
+    )
+
+
+def contract_function_factory(method_name: str, read_only: bool) -> Callable:
+    """
+    Create a function that interacts with a specific contract method.
+    """
+    if read_only:
+        return lambda self, args=None: read_contract_wrapper(self, method_name, args)
+    return lambda self, args=None: write_contract_wrapper(self, method_name, args)
+
+
+@dataclass
+class Contract:
+    """
+    Class to interact with a contract, its methods
+    are implemented dynamically at build time.
+    """
+
+    address: str
+    account: Optional[LocalAccount] = None
+    _schema: Optional[Dict[str, Any]] = None
+
+    @classmethod
+    def new(
+        cls,
+        address: str,
+        schema: Dict[str, Any],
+        account: Optional[LocalAccount] = None,
+    ) -> "Contract":
+        """
+        Build the methods from the schema.
+        """
+        if not isinstance(schema, dict) or "methods" not in schema:
+            raise ValueError("Invalid schema: must contain 'methods' field")
+        instance = cls(address=address, _schema=schema, account=account)
+        instance._build_methods_from_schema()
+        return instance
+
+    def _build_methods_from_schema(self):
+        """
+        Build the methods from the schema.
+        """
+        if self._schema is None:
+            raise ValueError("No schema provided")
+        for method_name, method_info in self._schema["methods"].items():
+            if not isinstance(method_info, dict) or "readonly" not in method_info:
+                raise ValueError(
+                    f"Invalid method info for '{method_name}': must contain 'readonly' field"
+                )
+            method_func = contract_function_factory(
+                method_name, method_info["readonly"]
+            )
+            bound_method = types.MethodType(method_func, self)
+            setattr(self, method_name, bound_method)
+
+    def connect(self, account: LocalAccount) -> "Contract":
+        """
+        Create a new instance of the contract with the same methods and a different account.
+        """
+        new_contract = self.__class__(
+            address=self.address, account=account, _schema=self._schema
+        )
+        new_contract._build_methods_from_schema()
+        return new_contract

gltest/{glchain/contract.py → contracts/contract_factory.py}

@@ -1,145 +1,27 @@
+from dataclasses import dataclass
+from typing import Type, Union, Optional, List, Any
+from pathlib import Path
 from eth_typing import (
     Address,
     ChecksumAddress,
 )
 from eth_account.signers.local import LocalAccount
-from typing import Union
-from pathlib import Path
-from dataclasses import dataclass
 from gltest.artifacts import (
     find_contract_definition_from_name,
     find_contract_definition_from_path,
 )
+from gltest.clients import (
+    get_gl_client,
+    get_gl_hosted_studio_client,
+    get_local_client,
+)
+from .contract import Contract
+from gltest.logging import logger
+from gltest.types import TransactionStatus
 from gltest.assertions import tx_execution_failed
 from gltest.exceptions import DeploymentError
-from .client import get_gl_client, get_gl_hosted_studio_client, get_local_client
-from gltest.types import CalldataEncodable, GenLayerTransaction, TransactionStatus
-from typing import List, Any, Type, Optional, Dict, Callable
-import types
 from gltest_cli.config.general import get_general_config
-from gltest_cli.logging import logger
-
-
-@dataclass
-class Contract:
-    """
-    Class to interact with a contract, its methods
-    are implemented dynamically at build time.
-    """
-
-    address: str
-    account: Optional[LocalAccount] = None
-    _schema: Optional[Dict[str, Any]] = None
-
-    @classmethod
-    def new(
-        cls,
-        address: str,
-        schema: Dict[str, Any],
-        account: Optional[LocalAccount] = None,
-    ) -> "Contract":
-        """
-        Build the methods from the schema.
-        """
-        if not isinstance(schema, dict) or "methods" not in schema:
-            raise ValueError("Invalid schema: must contain 'methods' field")
-        instance = cls(address=address, _schema=schema, account=account)
-        instance._build_methods_from_schema()
-        return instance
-
-    def _build_methods_from_schema(self):
-        if self._schema is None:
-            raise ValueError("No schema provided")
-        for method_name, method_info in self._schema["methods"].items():
-            if not isinstance(method_info, dict) or "readonly" not in method_info:
-                raise ValueError(
-                    f"Invalid method info for '{method_name}': must contain 'readonly' field"
-                )
-            method_func = self.contract_method_factory(
-                method_name, method_info["readonly"]
-            )
-            bound_method = types.MethodType(method_func, self)
-            setattr(self, method_name, bound_method)
-
-    def connect(self, account: LocalAccount) -> "Contract":
-        """
-        Create a new instance of the contract with the same methods and a different account.
-        """
-        new_contract = self.__class__(
-            address=self.address, account=account, _schema=self._schema
-        )
-        new_contract._build_methods_from_schema()
-        return new_contract
 
-    @staticmethod
-    def contract_method_factory(method_name: str, read_only: bool) -> Callable:
-        """
-        Create a function that interacts with a specific contract method.
-        """
-
-        def read_contract_wrapper(
-            self,
-            args: Optional[List[CalldataEncodable]] = None,
-        ) -> Any:
-            """
-            Wrapper to the contract read method.
-            """
-            client = get_gl_client()
-            return client.read_contract(
-                address=self.address,
-                function_name=method_name,
-                account=self.account,
-                args=args,
-            )
-
-        def write_contract_wrapper(
-            self,
-            args: Optional[List[CalldataEncodable]] = None,
-            value: int = 0,
-            consensus_max_rotations: Optional[int] = None,
-            leader_only: bool = False,
-            wait_transaction_status: TransactionStatus = TransactionStatus.FINALIZED,
-            wait_interval: Optional[int] = None,
-            wait_retries: Optional[int] = None,
-            wait_triggered_transactions: bool = True,
-            wait_triggered_transactions_status: TransactionStatus = TransactionStatus.FINALIZED,
-        ) -> GenLayerTransaction:
-            """
-            Wrapper to the contract write method.
-            """
-            general_config = get_general_config()
-            if wait_interval is None:
-                wait_interval = general_config.get_default_wait_interval()
-            if wait_retries is None:
-                wait_retries = general_config.get_default_wait_retries()
-            client = get_gl_client()
-            tx_hash = client.write_contract(
-                address=self.address,
-                function_name=method_name,
-                account=self.account,
-                value=value,
-                consensus_max_rotations=consensus_max_rotations,
-                leader_only=leader_only,
-                args=args,
-            )
-            receipt = client.wait_for_transaction_receipt(
-                transaction_hash=tx_hash,
-                status=wait_transaction_status,
-                interval=wait_interval,
-                retries=wait_retries,
-            )
-            if wait_triggered_transactions:
-                triggered_transactions = receipt["triggered_transactions"]
-                for triggered_transaction in triggered_transactions:
-                    client.wait_for_transaction_receipt(
-                        transaction_hash=triggered_transaction,
-                        status=wait_triggered_transactions_status,
-                        interval=wait_interval,
-                        retries=wait_retries,
-                    )
-            return receipt
-
-        return read_contract_wrapper if read_only else write_contract_wrapper
 
 
 @dataclass
@@ -184,17 +66,17 @@ class ContractFactory:
         """Attempts to get the contract schema using multiple clients in a fallback pattern.
 
         This method tries to get the contract schema in the following order:
-        1. Hosted studio client
-        2. Local client
-        3. Regular client
+        1. Default client
+        2. Hosted studio client
+        3. Local client
 
         Returns:
             Optional[Dict[str, Any]]: The contract schema if successful, None if all attempts fail.
         """
         clients = (
+            ("default", get_gl_client()),
             ("hosted studio", get_gl_hosted_studio_client()),
             ("local", get_local_client()),
-            ("default", get_gl_client()),
         )
         for label, client in clients:
             try:
@@ -216,7 +98,7 @@ class ContractFactory:
         schema = self._get_schema_with_fallback()
         if schema is None:
             raise ValueError(
-                "Failed to get schema from all clients (hosted studio, local, and regular)"
+                "Failed to get schema from all clients (default, hosted studio, and local)"
             )
 
         return Contract.new(address=contract_address, schema=schema, account=account)
@@ -273,7 +155,7 @@ class ContractFactory:
             schema = self._get_schema_with_fallback()
             if schema is None:
                 raise ValueError(
-                    "Failed to get schema from all clients (hosted studio, local, and regular)"
+                    "Failed to get schema from all clients (default, hosted studio, and local)"
                 )
 
             return Contract.new(