genlayer-test 0.4.1__py3-none-any.whl → 2.0.0__py3-none-any.whl

{genlayer_test-0.4.1.dist-info → genlayer_test-2.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: genlayer-test
-Version: 0.4.1
+Version: 2.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.2
 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)
 ```
@@ -114,6 +114,7 @@ networks:
 
   localnet:  # Local development network configuration
     url: "http://127.0.0.1:4000/api"
+    leader_only: false  # Set to true to run all contracts in leader-only mode by default
 
   testnet_asimov:  # Test network configuration
     id: 4221
@@ -125,6 +126,7 @@ networks:
 
 paths:
   contracts: "contracts"  # Path to your contracts directory
+  artifacts: "artifacts" # Path to your artifacts directory
 
 environment: .env  # Path to your environment file containing private keys and other secrets
 ```
@@ -137,12 +139,14 @@ Key configuration sections:
      - `url`: The RPC endpoint for the network
      - `id`: Chain ID
      - `accounts`: List of account private keys (using environment variables)
+     - `leader_only`: Leader only mode
    - Special case for `localnet`:
      - If a network is named `localnet`, missing fields will be filled with default values
      - For all other network names, `id`, `url`, and `accounts` are required fields
 
 2. **Paths**: Define important directory paths
    - `contracts`: Location of your contract files
+   - `artifacts`: Location of your artifacts files (analysis results will be stored here)
 
 3. **Environment**: Path to your `.env` file containing sensitive information like private keys
 
@@ -231,6 +235,20 @@ def test_with_mocked_llm(setup_validators):
 
 Note: This feature is only available when running tests on localnet.
 
+11. Run tests with leader-only mode enabled
+```bash
+$ gltest --leader-only
+```
+The `--leader-only` flag configures all contract deployments and write operations to run only on the leader node. This is useful for:
+- Faster test execution by avoiding consensus
+- Testing specific leader-only scenarios
+- Development and debugging purposes
+- Reducing computational overhead in test environments
+
+When this flag is enabled, all contracts deployed and all write transactions will automatically use leader-only mode, regardless of individual method parameters.
+
+**Note:** Leader-only mode is only available for studio-based networks (localhost, 127.0.0.1, *.genlayer.com, *.genlayerlabs.com). When enabled on other networks, it will have no effect and a warning will be logged.
+
 ## 🚀 Key Features
 
 - **Pytest Integration** – Extends pytest to support intelligent contract testing, making it familiar and easy to adopt.
@@ -251,8 +269,9 @@ Before diving into the examples, let's understand the basic project structure:
 genlayer-example/
 ├── contracts/              # Contract definitions
 │   └── storage.py          # Example storage contract
-└── test/                   # Test files
-    └── test_contract.py    # Contract test cases
+├── test/                   # Test files
+│   └── test_contract.py    # Contract test cases
+└── gltest.config.yaml      # Configuration file
 ```
 
 ### Storage Contract Example
@@ -311,7 +330,6 @@ def test_deployment():
         args=["initial_value"],  # Constructor arguments
         account=get_default_account(),  # Account to deploy from
         consensus_max_rotations=3,  # Optional: max consensus rotations
-        leader_only=False,  # Optional: whether to run only on leader
     )
     
     # Contract is now deployed and ready to use
@@ -320,7 +338,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 +350,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 +358,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,9 +372,9 @@ 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
         wait_interval=1,  # Optional: seconds between status checks
         wait_retries=10,  # Optional: max number of retries
     )
@@ -365,7 +383,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 +521,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 +608,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
    )
@@ -558,13 +621,11 @@ Fixtures help maintain clean, DRY test code by:
    # Try with increased consensus parameters
    contract = factory.deploy(
        consensus_max_rotations=5,  # Increase number of consensus rotations
-       leader_only=True,  # Try leader-only mode for faster execution
    )
    
    # For critical operations, use more conservative settings
    contract = factory.deploy(
        consensus_max_rotations=10,  # More rotations for better reliability
-       leader_only=False,  # Full consensus for better security
        wait_interval=3,  # Longer wait between checks
        wait_retries=30  # More retries for consensus
    )

genlayer_test-2.0.0.dist-info/RECORD

@@ -0,0 +1,76 @@
+genlayer_test-2.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=cYr5B5Sy-YRtEk6PvlLGkRy1X0cwf1EmsCHb6xPL-Rw,6524
+gltest/contracts/contract_factory.py,sha256=4xoODlCu2jHh3Z2e6OmWWnAiXT99yFu_7DhVvCUbKZE,6812
+gltest/contracts/contract_functions.py,sha256=Dpgu9rUSMrczBgNSlEaZ47RUpKzV8vucnc6OyxExMnM,2017
+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=zWNEJWjywI-T5B5Bc-8OyrGt7rUVlpNP8zrlsORhVgw,5412
+gltest_cli/config/pytest_context.py,sha256=Ze8JSkrwMTCE8jIhpzU_71CEXg92SiEPvSgNTp-gbS4,243
+gltest_cli/config/types.py,sha256=KDAA_vNqI7o_sYMj21ks3WaIXGrbLVb76E17TSlWUwI,7241
+gltest_cli/config/user.py,sha256=WNX_Wi2eJpjW0UstQuQiDjzRpOIOwx9iiXOx4ntt93U,8759
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/conftest.py,sha256=RKdoE5_zcMimeojAoA_GSFI9du4pMzMi1vZ1njtfoAs,28
+tests/examples/contracts/football_prediction_market.py,sha256=9xwU8f3q73Hae-ByHy_wauhMPLRnLZd4XKNrClnjOJM,3248
+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_config_integration.py,sha256=vPTzr3_h9UMw7m72HogBJE2ZPhRduXoLSq18Z7FoCWQ,10105
+tests/gltest_cli/config/test_general_config.py,sha256=UHtSwVnso-ZwNtYM0Z4v2sCLKwyrVbHlk6b1leVfV84,14703
+tests/gltest_cli/config/test_plugin.py,sha256=87kJpSYcWbNuKDqfc_jiN7hoRnFkMEnOOTINwuXKBY0,7981
+tests/gltest_cli/config/test_user.py,sha256=JxR655oUFoM9quWQO68CVPKRpT0TMpzS3bF6j6NWyT4,14401
+genlayer_test-2.0.0.dist-info/METADATA,sha256=ykgDxxVQ0p5XRRShD6ke9amrhH4o7MacAQsUya0r5Ts,24978
+genlayer_test-2.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+genlayer_test-2.0.0.dist-info/entry_points.txt,sha256=RWPcSArBpz_G4BYioh5L8Q8hyClRbSgzLimjcWMp-BQ,94
+genlayer_test-2.0.0.dist-info/top_level.txt,sha256=-qiGZxTRBytujzgVcKpxjvQ-WNeUDjXa59ceGMwMpko,24
+genlayer_test-2.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,197 @@
+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,
+        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()
+        )
+        leader_only = (
+            general_config.get_leader_only()
+            if general_config.check_studio_based_rpc()
+            else False
+        )
+        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