foundry integration

Author: bbyalcinkaya

README.md

@@ -46,7 +46,7 @@ Example contract with `init` function:
 ```rust
 #[public]
 impl TestCounter {
-    pub fn init(&mut self, counter: Address) {
+    pub fn setUp(&mut self, counter: Address) {
         self.counter.set(counter);
     }
     // ...
@@ -65,7 +65,7 @@ Example `skribe.json` file for the contract above:
 
 #### Test functions
 
-Test functions must start with the `test_` prefix and return either `bool` or `()`. A panic or a `false` result is
+Test functions must start with the `test_` prefix and return `()`. A panic is
 considered a test failure. Skribe automatically discovers these test functions and runs them with randomized input
 values as part of the fuzzing process.
 
@@ -76,11 +76,11 @@ Example test function:
 impl TestCounter {
     // ...
 
-    pub fn test_call_set_get_number(&mut self, x: U256) -> bool {
+    pub fn test_call_set_get_number(&mut self, x: U256) {
         let counter = ICounter::new(self.counter.get());
         counter.set_number(Call::new_in(self), x).unwrap();
 
-        counter.number(self).unwrap() == x
+        assert_eq!(counter.number(self).unwrap(), x)
     }
 }
 ```

src/skribe/__main__.py

@@ -29,7 +29,11 @@ def _exec_build(dir_path: Path | None) -> None:
     dir_path = Path.cwd() if dir_path is None else dir_path
 
     skribe = Skribe(concrete_definition)
-    skribe.build_stylus_contract(contract_dir=dir_path)
+
+    if (dir_path / 'foundry.toml').exists():
+        skribe.build_foundry_contract(contract_dir=dir_path)
+    else:
+        skribe.build_stylus_contract(contract_dir=dir_path)
 
     exit(0)
 

src/skribe/contract.py

@@ -8,132 +8,119 @@
 
 from eth_abi.tools._strategies import get_abi_strategy
 from hypothesis import strategies
-from pyk.utils import run_process
+from kontrol.solc_to_k import Contract as EVMContract
+from kontrol.solc_to_k import contract_name_with_path, method_sig_from_abi
+from pyk.kast.inner import KSort
+from pyk.utils import run_process, single
 
-from .simulation import call_data
+from skribe.simulation import call_data
 
 if TYPE_CHECKING:
 
     from hypothesis.strategies import SearchStrategy
 
 
-@dataclass(frozen=True)
-class ContractBinding:
-    """Represents one of the function bindings for a Stylus contract."""
+type Method = EVMContract.Method
 
-    name: str
-    inputs: tuple[str, ...]
-    outputs: tuple[str, ...]
 
-    @staticmethod
-    def from_dict(d: dict[str, Any]) -> ContractBinding:
-        name = d['name']
-        inputs = tuple(inp['type'] for inp in d['inputs'])
-        outputs = tuple(out['type'] for out in d['outputs'])
-        return ContractBinding(name, inputs, outputs)
+@dataclass
+class StylusContract:
+    contract_path: Path
+    _cargo_bin: Path
 
-    @cached_property
-    def strategy(self) -> SearchStrategy[bytes]:
-        input_strategies = (get_abi_strategy(arg) for arg in self.inputs)
-        tuple_strategy = strategies.tuples(*input_strategies)
-
-        encoder = partial(call_data, self.name, self.inputs)
-        return tuple_strategy.map(encoder)
+    def __init__(self, cargo_bin: Path, contract_dir: Path):
+        self.contract_path = contract_dir.resolve()
+        self._cargo_bin = cargo_bin
 
     @cached_property
-    def is_test(self) -> bool:
-        return self.name.startswith('test')
+    def name_with_path(self) -> str:
+        return contract_name_with_path(str(self.contract_path), self._name)
 
     @cached_property
-    def arity(self) -> int:
-        return len(self.inputs)
-
+    def manifest_path(self) -> Path:
+        return self.contract_path / 'Cargo.toml'
 
-@dataclass(frozen=True)
-class ContractMetadata:
-    manifest_path: Path
-    name: str
-    bindings: tuple[ContractBinding, ...]
-    target_dir: Path
+    @cached_property
+    def manifest(self) -> dict[str, Any]:
+        return json.loads(
+            run_process(
+                [
+                    str(self._cargo_bin),
+                    'metadata',
+                    '--no-deps',
+                    '--manifest-path',
+                    str(self.manifest_path),
+                    '--format-version',
+                    '1',
+                ],
+                check=True,
+            ).stdout
+        )
 
     @cached_property
-    def wasm_target_dir(self) -> Path:
-        return (self.target_dir / 'wasm32-unknown-unknown' / 'release').resolve()
+    def contract_package(self) -> dict[str, Any]:
+        return single(p for p in self.manifest['packages'] if Path(p['manifest_path']) == self.manifest_path)
 
     @cached_property
-    def wasm_path(self) -> Path:
-        wasm_file_name = self.name.replace('-', '_') + '.wasm'
-        wasm_path = self.wasm_target_dir / wasm_file_name
-        return wasm_path.resolve()
+    def _name(self) -> str:
+        return self.contract_package['name']
 
     @cached_property
-    def init_func(self) -> ContractBinding | None:
-        for b in self.bindings:
-            if b.name == 'init':
-                return b
-        return None
+    def abi(self) -> list[dict[str, Any]]:
+        proc_res = run_process(
+            [str(self._cargo_bin), 'stylus', 'export-abi', '--json'],
+            cwd=self.contract_path,
+            check=True,
+        )
+        json_output = proc_res.stdout.split('\n', 3)[3]  # remove the headers
+        return json.loads(json_output)
 
     @cached_property
-    def has_init(self) -> bool:
-        return self.init_func is not None
+    def methods(self) -> tuple[Method, ...]:
+        return tuple(
+            EVMContract.Method(
+                msig=method_sig_from_abi(method_abi, True),
+                id=0,
+                abi=method_abi,
+                ast=None,
+                contract_name_with_path='',
+                contract_digest='',
+                contract_storage_digest='',
+                sort=KSort(f'{EVMContract.escaped(self.name_with_path, "S2K")}Method'),
+                devdoc=None,
+                function_calls=None,
+            )
+            for method_abi in self.abi
+            if method_abi['type'] == 'function'
+        )
 
     @cached_property
-    def test_functions(self) -> tuple[ContractBinding, ...]:
-        return tuple(b for b in self.bindings if b.is_test)
-
-    def typecheck(self) -> None:
-        for b in self.bindings:
-            if b.name == 'init':
-                no_output = not b.outputs
-                only_address = all(i == 'address' for i in b.inputs)
-                if no_output and only_address:
-                    continue
-            if not b.is_test:
-                continue
-            if not b.outputs:
-                continue
-            if b.outputs == ('bool',):
-                continue
-
-            raise TypeError(f'Invalid type: {b.name}{b.inputs} -> {b.outputs}')
-
-
-def read_contract_bindings(cargo_bin: Path, contract_dir: Path) -> tuple[ContractBinding, ...]:
-    """Reads a stylus wasm contract, and returns a list of the function bindings for it."""
-    proc_res = run_process(
-        [str(cargo_bin), 'stylus', 'export-abi', '--json'],
-        cwd=contract_dir,
-        check=True,
-    )
-    json_output = proc_res.stdout.split('\n', 3)[3]  # remove the headers
-    bindings_list = json.loads(json_output)
-
-    return tuple(
-        ContractBinding.from_dict(binding_dict) for binding_dict in bindings_list if binding_dict['type'] == 'function'
-    )
-
-
-def read_contract_metadata(cargo_bin: Path, contract_dir: Path) -> ContractMetadata:
-    manifest_path = (contract_dir / 'Cargo.toml').resolve()
-    proc_res = run_process(
-        [str(cargo_bin), 'metadata', '--no-deps', '--manifest-path', str(manifest_path), '--format-version', '1'],
-        check=True,
-    )
-    manifest = json.loads(proc_res.stdout)
-
-    # filter out other packages in the workspace and get the one that matches the contract
-    contract_package = [p for p in manifest['packages'] if Path(p['manifest_path']) == manifest_path][0]
-    name = contract_package['name']
-    target_dir = Path(manifest['target_directory']).resolve()
-
-    bindings = read_contract_bindings(cargo_bin, contract_dir)
-
-    res = ContractMetadata(
-        manifest_path=manifest_path,
-        name=name,
-        bindings=bindings,
-        target_dir=target_dir,
-    )
-    res.typecheck()
-
-    return res
+    def deployed_bytecode(self) -> bytes:
+        wasm_file_name = self._name.replace('-', '_') + '.wasm'
+        wasm_path = Path(self.manifest['target_directory']) / 'wasm32-unknown-unknown' / 'release' / wasm_file_name
+        return wasm_path.read_bytes()
+
+
+type ArbitrumContract = EVMContract | StylusContract
+
+
+def setup_method(c: ArbitrumContract) -> Method | None:
+    for m in c.methods:
+        if m.name == 'setUp':
+            return m
+    return None
+
+
+def is_foundry_test(ctr: EVMContract) -> bool:
+    if ctr.is_test_contract:
+        for m in ctr.methods:
+            if m.is_test:
+                return True
+    return False
+
+
+def argument_strategy(m: Method) -> SearchStrategy[bytes]:
+    input_strategies = (get_abi_strategy(arg) for arg in m.arg_types)
+    tuple_strategy = strategies.tuples(*input_strategies)
+    encoder = partial(call_data, m.name, m.arg_types)
+    return tuple_strategy.map(encoder)

src/skribe/kdist/plugin.py

@@ -5,6 +5,7 @@
 from typing import TYPE_CHECKING
 
 from kevm_pyk.kompile import KompileTarget, kevm_kompile
+from kontrol.kdist.utils import KSRC_DIR as FOUNDRY_KSRC_DIR
 from pyk.kbuild.utils import k_version
 from pyk.kdist.api import Target
 
@@ -72,7 +73,7 @@ def context(self) -> dict[str, str]:
             'main_file': src_dir / 'stylus-semantics/skribe.md',
             'main_module': 'SKRIBE',
             'syntax_module': 'SKRIBE-SYNTAX',
-            'includes': [src_dir],
+            'includes': [src_dir, FOUNDRY_KSRC_DIR],
         },
     ),
 }

src/skribe/progress.py

@@ -9,13 +9,13 @@
 
     from rich.progress import TaskID
 
-    from .contract import ContractBinding
+    from .contract import Method
 
 
 class FuzzProgress(Progress):
     fuzz_tasks: list[FuzzTask]
 
-    def __init__(self, bindings: Iterable[ContractBinding], max_examples: int):
+    def __init__(self, bindings: Iterable[Method], max_examples: int):
         super().__init__(
             TextColumn('[progress.description]{task.description}'),
             BarColumn(),
@@ -33,11 +33,11 @@ def __init__(self, bindings: Iterable[ContractBinding], max_examples: int):
 
 
 class FuzzTask:
-    binding: ContractBinding
+    binding: Method
     task_id: TaskID
     progress: FuzzProgress
 
-    def __init__(self, binding: ContractBinding, task_id: TaskID, progress: FuzzProgress):
+    def __init__(self, binding: Method, task_id: TaskID, progress: FuzzProgress):
         self.binding = binding
         self.task_id = task_id
         self.progress = progress