Merge branch 'dev'

Author: ademolahh

.gitmodules

@@ -1,3 +1,6 @@
 [submodule "lib/forge-std"]
 	path = lib/forge-std
 	url = https://github.com/foundry-rs/forge-std
+[submodule "lib/solady"]
+	path = lib/solady
+	url = https://github.com/vectorized/solady

Makefile

@@ -0,0 +1,20 @@
+tree:
+	@python3 convert_trees.py test/unit
+
+gen:
+	@python3 convert_trees.py test/unit
+	@find test/unit -type f -name "*.tree" \
+		! -size 0c \
+		! -exec test -f "$$(dirname "{}")/$$(basename "{}" .tree).t.sol" \; \
+		-exec sh -c 'if grep -q "[A-Za-z]" "$$1"; then bulloak scaffold -S -w -s 0.8.30 "$$1"; fi' _ {} \;
+
+check:
+	@python3 convert_trees.py test/unit
+	@bulloak check test/unit
+
+fix:
+	@python3 convert_trees.py test/unit
+	@find test/unit -type f -name "*.tree" -exec bulloak check --fix {} \;
+
+coverage:
+	@forge coverage --report lcov

README.md

@@ -1,66 +1,68 @@
-## Foundry
 
-**Foundry is a blazing fast, portable and modular toolkit for Ethereum application development written in Rust.**
+# Lending & Borrowing Protocol
 
-Foundry consists of:
+ZToken Protocol is a modular lending and borrowing system built with Foundry. It supports ERC20 and native-asset markets, interest rate modeling, and collateralized lending mechanics.
 
-- **Forge**: Ethereum testing framework (like Truffle, Hardhat and DappTools).
-- **Cast**: Swiss army knife for interacting with EVM smart contracts, sending transactions and getting chain data.
-- **Anvil**: Local Ethereum node, akin to Ganache, Hardhat Network.
-- **Chisel**: Fast, utilitarian, and verbose solidity REPL.
+## Overview
 
-## Documentation
+Core contracts live in `src/` and are composed around a base ZToken implementation with ERC20 and native-asset market variants plus collateral and liquidation management.
 
-https://book.getfoundry.sh/
+## Contracts
 
-## Usage
+- `ZToken` – Base interest-bearing token
+- `ZErc20` / `ZNative` – ERC20 and native-asset market implementations
+- `CollateralManager` – Collateral deposits, limits, and liquidation flows
+- `LiquidationManger` – Liquidation execution logic
+- `ZTokenFactory` – Market deployment and setup
 
-### Build
+## Repo Layout
 
-```shell
-$ forge build
-```
+- `src/` – Solidity contracts
+- `src/interfaces/` – External interfaces
+- `src/libraries/` – Math and helpers
+- `test/` – Foundry tests
+- `script/` – Deployment / utility scripts
+- `docs/` – mdBook documentation
 
-### Test
+## Quickstart
 
-```shell
-$ forge test
-```
+```zsh
+# Install dependencies
+forge install
 
-### Format
-
-```shell
-$ forge fmt
+# Build contracts
+forge build
 ```
 
-### Gas Snapshots
+## Make Targets
 
-```shell
-$ forge snapshot
-```
+```zsh
+# Convert bulloak trees for unit tests
+make tree
 
-### Anvil
+# Generate scaffolds for missing test files
+make gen
 
-```shell
-$ anvil
-```
+# Check test trees
+make check
 
-### Deploy
+# Auto-fix tree check issues
+make fix
 
-```shell
-$ forge script script/Counter.s.sol:CounterScript --rpc-url <your_rpc_url> --private-key <your_private_key>
+# Coverage report
+make coverage
 ```
 
-### Cast
+## Documentation
+
+The mdBook source lives in `docs/`. To build and serve locally:
 
-```shell
-$ cast <subcommand>
+```zsh
+mdbook build docs
+mdbook serve docs -p 3000
 ```
 
-### Help
+## Notes
 
-```shell
-$ forge --help
-$ anvil --help
-$ cast --help
-```
+- Contract docs in `docs/src/src/` are generated from the Solidity sources.
+- Use `foundry.toml` for compiler and remapping configuration.

convert_trees.py

@@ -0,0 +1,104 @@
+import os
+import sys
+
+ASCII_SIGNS = ("├──", "└──", "│")
+
+def is_ascii_tree_line(line: str) -> bool:
+    """Return True if the line is already part of an ASCII tree."""
+    return line.strip().startswith(ASCII_SIGNS)
+
+def parse_tree(lines):
+    """Build a nested tree structure based on '#' indentation."""
+    tree = []
+    stack = [(-1, tree)]
+    for line in lines:
+        if not line.strip():
+            continue
+        level = line.count('#')
+        text = line.replace('#', '').strip()
+        while level <= stack[-1][0]:
+            stack.pop()
+        node = {"text": text, "children": []}
+        stack[-1][1].append(node)
+        stack.append((level, node["children"]))
+    return tree
+
+def render_ascii(nodes, prefix=""):
+    """Recursively render tree nodes as ASCII."""
+    lines = []
+    for i, node in enumerate(nodes):
+        connector = "└── " if i == len(nodes) - 1 else "├── "
+        lines.append(prefix + connector + node["text"])
+        if node["children"]:
+            extension = "    " if i == len(nodes) - 1 else "│   "
+            lines.extend(render_ascii(node["children"], prefix + extension))
+    return lines
+
+def convert_section(section_lines):
+    """Convert only the #-based part of one section into ASCII."""
+    if not section_lines:
+        return section_lines
+
+    header = section_lines[0].strip()
+    body = [l for l in section_lines[1:] if l.strip().startswith("#")]
+    if not body:
+        # nothing to convert
+        return section_lines
+
+    tree = parse_tree(body)
+    ascii_tree = render_ascii(tree)
+    return [header] + ascii_tree + [""]
+
+def convert_file(filepath):
+    """Convert only unformatted (#-based) sections in a .tree file."""
+    with open(filepath, "r", encoding="utf-8") as f:
+        raw = [line.rstrip("\n") for line in f.readlines()]
+
+    # If the entire file is already ASCII, skip it.
+    if all(is_ascii_tree_line(l) or not l.strip() or "::" in l for l in raw):
+        print(f"Skipped (already formatted): {filepath}")
+        return
+
+    new_content = []
+    current_section = []
+
+    def flush_section():
+        if current_section:
+            if any("#" in l for l in current_section):
+                new_content.extend(convert_section(current_section))
+            else:
+                new_content.extend(current_section)
+            current_section.clear()
+
+    for line in raw:
+        if "::" in line and not line.strip().startswith("#"):
+            flush_section()
+            current_section.append(line)
+        else:
+            current_section.append(line)
+    flush_section()
+
+    with open(filepath, "w", encoding="utf-8") as f:
+        f.write("\n".join(new_content).strip() + "\n")
+
+    print(f"Updated: {filepath}")
+
+def convert_all(folder):
+    """Convert all .tree files recursively."""
+    for root, _, files in os.walk(folder):
+        for file in files:
+            if file.endswith(".tree"):
+                convert_file(os.path.join(root, file))
+    print("\\Incremental conversion complete!")
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: python3 convert_trees_incremental_fixed.py <path/to/folder>")
+        sys.exit(1)
+
+    folder = sys.argv[1]
+    if not os.path.isdir(folder):
+        print("Invalid folder path.")
+        sys.exit(1)
+
+    convert_all(folder)

foundry.lock

@@ -4,5 +4,11 @@
       "name": "v1.11.0",
       "rev": "8e40513d678f392f398620b3ef2b418648b33e89"
     }
+  },
+  "lib/solady": {
+    "tag": {
+      "name": "v0.1.26",
+      "rev": "acd959aa4bd04720d640bf4e6a5c71037510cc4b"
+    }
   }
 }

images/contract-interaction.png

@@ -31,3 +31,4 @@ graph TD
     AM --> AN[Borrower Redeems Collateral]
     AN --> AO[Exit]
     AL -->|Continue Borrowing| AG
+