wayfinder-paths 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

wayfinder_paths/strategies/stablecoin_yield_strategy/README.md

@@ -1,7 +1,6 @@
 # Stablecoin Yield Strategy
 
 - Entrypoint: `strategies.stablecoin_yield_strategy.strategy.StablecoinYieldStrategy`
-- Manifest: `manifest.yaml`
 - Examples: `examples.json`
 - Tests: `test_strategy.py`
 
@@ -87,10 +86,4 @@ poetry run python wayfinder_paths/run_strategy.py stablecoin_yield_strategy --ac
 poetry run python wayfinder_paths/run_strategy.py stablecoin_yield_strategy --action update --config $(pwd)/config.json
 ```
 
-You can also load the manifest explicitly:
-
-```bash
-poetry run python wayfinder_paths/run_strategy.py --manifest wayfinder_paths/strategies/stablecoin_yield_strategy/manifest.yaml --action status --config $(pwd)/config.json
-```
-
 Wallet addresses are auto-populated from `wallets.json` when you run `wayfinder_paths/scripts/make_wallets.py`. Set `NETWORK=testnet` in `config.json` to dry-run operations against mocked services.

wayfinder_paths/strategies/stablecoin_yield_strategy/strategy.py

@@ -74,7 +74,7 @@ class StablecoinYieldStrategy(Strategy):
         gas_threshold=GAS_MAXIMUM * GAS_SAFETY_FRACTION,
         # risk indicators
         volatility=Volatility.LOW,
-        volatility_description_short=(
+        volatility_description=(
             "Capital sits in Base stablecoin lending pools, so price swings are minimal."
         ),
         directionality=Directionality.MARKET_NEUTRAL,

wayfinder_paths/templates/adapter/README.md

@@ -8,16 +8,15 @@ Adapters expose protocol-specific capabilities to strategies. They should be thi
    ```
    cp -r wayfinder_paths/templates/adapter wayfinder_paths/adapters/my_adapter
    ```
-2. Rename `MyAdapter` in `adapter.py` and update `manifest.yaml` so the `entrypoint` matches (`adapters.my_adapter.adapter.MyAdapter`).
-3. Declare the capabilities your adapter will provide and list any client dependencies (e.g., `PoolClient`, `LedgerClient`).
-4. Implement the public methods that fulfill those capabilities.
+2. Rename `MyAdapter` in `adapter.py` to match your adapter's purpose.
+3. Implement the public methods that provide your adapter's capabilities.
+4. Add tests in `test_adapter.py`.
 
 ## Layout
 
 ```
 my_adapter/
 ├── adapter.py          # Adapter implementation
-├── manifest.yaml       # Entrypoint + capabilities + dependency list
 ├── examples.json       # Example payloads (optional but encouraged)
 ├── test_adapter.py     # Pytest smoke tests
 └── README.md           # Adapter-specific notes
@@ -57,21 +56,6 @@ class MyAdapter(BaseAdapter):
 
 Your adapter should return `(success, payload)` tuples for every operation, just like the built-in adapters do.
 
-## Manifest
-
-Every adapter needs a manifest describing its import path, declared capabilities, and runtime dependencies.
-
-```yaml
-schema_version: "0.1"
-entrypoint: "adapters.my_adapter.adapter.MyAdapter"
-capabilities:
-  - "pool.read"
-dependencies:
-  - "PoolClient"
-```
-
-The `dependencies` list is informational today but helps reviewers understand which core clients you rely on.
-
 ## Testing
 
 `test_adapter.py` should cover the public methods you expose. Patch out remote clients with `unittest.mock.AsyncMock` so tests run offline.
@@ -99,7 +83,7 @@ async def test_get_pools():
 
 ## Best practices
 
-- Capabilities listed in `manifest.yaml` must correspond to methods you implement.
 - Keep adapters stateless and idempotent—strategies may reuse instances across operations.
 - Use `self.logger` for contextual logging (BaseAdapter has already bound the adapter name).
-- Raise `NotImplementedError` for manifest capabilities you intentionally do not support yet.
+- Return `(success, payload)` tuples consistently for all operations.
+- Raise `NotImplementedError` for capabilities you intentionally do not support yet.

wayfinder_paths/templates/adapter/adapter.py

@@ -6,8 +6,7 @@ from wayfinder_paths.core.adapters.BaseAdapter import BaseAdapter
 class MyAdapter(BaseAdapter):
     """
     Template adapter for a protocol/exchange integration.
-    Copy this folder, rename it (e.g., my_adapter), update manifest entrypoint,
-    and implement the capabilities your manifest declares.
+    Copy this folder, rename it (e.g., my_adapter), and implement your adapter methods.
     """
 
     adapter_type: str = "MY_ADAPTER"

wayfinder_paths/templates/adapter/test_adapter.py

@@ -40,7 +40,7 @@ class TestMyAdapter:
         assert isinstance(ok, bool)
 
     def test_capabilities(self, adapter):
-        """Test adapter capabilities match manifest"""
+        """Test adapter capabilities"""
         assert hasattr(adapter, "adapter_type")
 
     @pytest.mark.asyncio

wayfinder_paths/templates/strategy/README.md

@@ -1,6 +1,6 @@
 # Strategy Template
 
-This template provides the scaffolding for a new strategy. It mirrors the structure in `wayfinder_paths/strategies/...` and wires into the runner via a manifest.
+This template provides the scaffolding for a new strategy. It mirrors the structure in `wayfinder_paths/strategies/...`.
 
 ## Quick Start
 
@@ -8,7 +8,7 @@ This template provides the scaffolding for a new strategy. It mirrors the struct
    ```
    cp -r wayfinder_paths/templates/strategy wayfinder_paths/strategies/my_strategy
    ```
-2. Rename the class in `strategy.py` and update `manifest.yaml` so `entrypoint` points to your new module (for example `strategies.my_strategy.strategy.MyStrategy`).
+2. Rename the class in `strategy.py` to match your strategy name.
 3. Fill out `examples.json` with sample CLI invocations and `test_strategy.py` with at least one smoke test.
 4. Implement the required strategy methods (`deposit`, `update`, `_status`, optionally override `withdraw`).
 
@@ -17,7 +17,6 @@ This template provides the scaffolding for a new strategy. It mirrors the struct
 ```
 my_strategy/
 ├── strategy.py          # Strategy implementation
-├── manifest.yaml        # Entrypoint + adapter requirements + policy
 ├── examples.json        # Example CLI payloads
 ├── test_strategy.py     # Pytest-based smoke tests
 └── README.md            # Strategy-specific documentation
@@ -98,22 +97,6 @@ class MyStrategy(Strategy):
         }
 ```
 
-## Manifest configuration
-
-Your `manifest.yaml` should define:
-
-```yaml
-schema_version: "0.1"
-entrypoint: "strategies.my_strategy.strategy.MyStrategy"
-permissions:
-  policy: "(wallet.id == 'FORMAT_WALLET_ID') && (eth.tx.to == '0x...')"
-adapters:
-  - name: "BALANCE"
-    capabilities: ["wallet_read", "wallet_transfer"]
-  - name: "POOL"
-    capabilities: ["pool.read", "pool.analytics"]
-```
-
 ## Testing
 
 `test_strategy.py` should cover at least deposit/update/status. Use `pytest.mark.asyncio` and patch adapters or services as needed.
@@ -149,5 +132,5 @@ poetry run python wayfinder_paths/run_strategy.py my_strategy --action status --
 
 - Return `(success: bool, message: str)` tuples from `deposit`/`update`.
 - Always populate `portfolio_value`, `net_deposit`, and `strategy_status` keys in `_status`.
-- Use the adapters declared in `manifest.yaml`—they are injected via `register_adapters`.
-- Keep on-chain permissions tight by scoping the manifest policy to the strategy wallet and expected contracts.
+- Register adapters via `register_adapters` in your `__init__` method.
+- Keep strategy logic clear and well-documented.

wayfinder_paths/tests/test_smoke_manifest.py

@@ -14,6 +14,16 @@ class FakeAdapter(BaseAdapter):
         return {"asset": asset, "amount": 100}
 
 
+class FakeLedgerAdapter(BaseAdapter):
+    adapter_type = "LEDGER"
+
+    async def connect(self) -> bool:
+        return True
+
+    async def record_strategy_snapshot(self, **kwargs):
+        pass
+
+
 class FakeStrategy(Strategy):
     name = "Fake Strategy"
 
@@ -26,7 +36,7 @@ class FakeStrategy(Strategy):
     async def withdraw(self, amount: float = 0) -> StatusTuple:
         return (True, "withdrew")
 
-    async def status(self) -> StatusDict:
+    async def _status(self) -> StatusDict:
         return {"total_earned": 0.0, "strategy_status": {"ok": True}}
 
     @staticmethod
@@ -36,8 +46,13 @@ class FakeStrategy(Strategy):
 
 @pytest.mark.asyncio
 async def test_smoke_deposit_update_withdraw_status():
-    s = FakeStrategy()
+    s = FakeStrategy(
+        config={
+            "strategy_wallet": {"address": "0x1234567890123456789012345678901234567890"}
+        }
+    )
     s.register_adapters([FakeAdapter("fake")])
+    s.ledger_adapter = FakeLedgerAdapter("ledger")
     ok, msg = await s.deposit(amount=1)
     assert ok
     ok, msg = await s.update()

{wayfinder_paths-0.1.9.dist-info → wayfinder_paths-0.1.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wayfinder-paths
-Version: 0.1.9
+Version: 0.1.11
 Summary: Wayfinder Path: strategies and adapters
 Author: Wayfinder
 Author-email: dev@wayfinder.ai
@@ -47,6 +47,9 @@ poetry install
 just create-wallets
 # Or manually: poetry run python wayfinder_paths/scripts/make_wallets.py -n 1
 
+# To test a specific strategy
+just create-wallet stablecoin_yield_strategy
+
 # Copy and configure
 cp wayfinder_paths/config.example.json config.json
 # Edit config.json with your Wayfinder credentials
@@ -72,7 +75,6 @@ wayfinder_paths/
 │   ├── adapters/                 # Your exchange/protocol integrations (community contributions)
 │   │   ├── balance_adapter/
 │   │   │   ├── adapter.py        # Adapter implementation
-│   │   │   ├── manifest.yaml     # Adapter manifest (caps, entrypoint)
 │   │   │   ├── examples.json     # Example inputs for smoke
 │   │   │   ├── README.md         # Local notes
 │   │   │   └── test_adapter.py   # Local smoke test
@@ -81,7 +83,6 @@ wayfinder_paths/
 │   ├── strategies/               # Your trading strategies (community contributions)
 │   │   ├── stablecoin_yield_strategy/
 │   │   │   ├── strategy.py       # Strategy implementation
-│   │   │   ├── manifest.yaml     # Strategy manifest
 │   │   │   ├── examples.json     # Example inputs
 │   │   │   ├── README.md         # Local notes
 │   │   │   └── test_strategy.py  # Local smoke test
@@ -108,10 +109,9 @@ We welcome contributions! This is an open-source project where community members
 3. **Copy a template** to get started:
    - **For adapters**: Copy `wayfinder_paths/templates/adapter/` to `wayfinder_paths/adapters/my_adapter/`
    - **For strategies**: Copy `wayfinder_paths/templates/strategy/` to `wayfinder_paths/strategies/my_strategy/`
-4. **Customize** the template (rename classes, update manifest, implement methods)
+4. **Customize** the template (rename classes, implement methods)
 5. **Test your code** thoroughly using the provided test framework
-6. **Validate manifests**: Run `just validate-manifests`
-7. **Submit a Pull Request** with a clear description of your changes
+6. **Submit a Pull Request** with a clear description of your changes
 
 ### What You Can Contribute
 
@@ -125,29 +125,18 @@ We welcome contributions! This is an open-source project where community members
 
 - **Start from the template**: Copy `wayfinder_paths/templates/adapter/` as a starting point
 - Extend `BaseAdapter` from `wayfinder_paths/core/adapters/BaseAdapter.py`
-- Create a `manifest.yaml` (template at `wayfinder_paths/templates/adapter/manifest.yaml`) with:
-  - `entrypoint`: Full import path to your adapter class
-  - `capabilities`: List of capabilities your adapter provides
-  - `dependencies`: List of required client classes (e.g., `PoolClient`, `TokenClient`)
-- Implement methods that fulfill the declared capabilities
+- Implement your adapter methods
 - Add comprehensive tests in `test_adapter.py`
 - Include usage examples in `examples.json`
 - Document your adapter in `README.md`
-- Validate your manifest: `just validate-manifests`
 
 #### For Strategies
 
 - **Start from the template**: Use `just create-strategy "Strategy Name"` to create a new strategy with its own wallet, or copy `wayfinder_paths/templates/strategy/` manually
 - Extend `Strategy` from `wayfinder_paths/core/strategies/Strategy.py`
-- Create a `manifest.yaml` (template at `wayfinder_paths/templates/strategy/manifest.yaml`) with:
-  - `entrypoint`: Full import path to your strategy class
-  - `name`: Strategy directory name (used for wallet lookup)
-  - `permissions.policy`: Security policy for transaction permissions
-  - `adapters`: List of required adapters and their capabilities
 - Implement required methods: `deposit()`, `update()`, `status()`, `withdraw()`
 - Include test cases in `test_strategy.py`
 - Add example configurations in `examples.json`
-- Validate your manifest: `just validate-manifests`
 
 #### General Guidelines
 
@@ -183,10 +172,7 @@ cp -r wayfinder_paths/templates/strategy wayfinder_paths/strategies/my_strategy
 
 # 5. Customize the template (see template README.md files for details)
 
-# 6. Validate your manifest
-just validate-manifests
-
-# 7. Run tests
+# 6. Run tests
 poetry run pytest -k smoke -v
 
 # Or test your specific contribution
@@ -211,7 +197,7 @@ The platform uses a unified client system for all API interactions. Clients are
 ### Clients vs Adapters
 
 - **Clients**: Low-level, reusable service wrappers that talk to networks and external APIs. They handle auth, headers, retries, and response parsing, and expose generic capabilities (e.g., token info, tx building). Examples: `TokenClient`, `WalletClient`.
-- **Adapters**: Strategy-facing integrations for a specific exchange/protocol. They compose one or more clients to implement a manifest of capabilities (e.g., `supply`, `borrow`, `place_order`). Adapters encapsulate protocol-specific semantics and raise `NotImplementedError` for unsupported ops.
+- **Adapters**: Strategy-facing integrations for a specific exchange/protocol. They compose one or more clients to implement a set of capabilities (e.g., `supply`, `borrow`, `place_order`). Adapters encapsulate protocol-specific semantics and raise `NotImplementedError` for unsupported ops.
 
 Recommended usage:
 
@@ -221,168 +207,6 @@ Recommended usage:
 
 Data flow: `Strategy` → `Adapter` → `Client(s)` → network/API.
 
-### Manifests
-
-Every adapter and strategy requires a `manifest.yaml` file that declares its metadata, capabilities, and dependencies. Manifests are validated automatically in CI/CD and serve as the **single source of truth** for what each component can do.
-
-#### Adapter Manifests
-
-Adapter manifests declare the capabilities an adapter provides and the clients it depends on.
-
-**Template:** Copy `wayfinder_paths/templates/adapter/manifest.yaml` as a starting point.
-
-**Schema:**
-
-```yaml
-schema_version: "0.1"
-entrypoint: "adapters.my_adapter.adapter.MyAdapter"
-capabilities:
-  - "pool.read"
-  - "pool.analytics"
-dependencies:
-  - "PoolClient"
-  - "TokenClient"
-```
-
-**Fields:**
-
-- `schema_version`: Manifest schema version (currently `"0.1"`)
-- `entrypoint`: Full Python import path to the adapter class (required)
-- `capabilities`: List of abstract capabilities this adapter provides (required, non-empty)
-- `dependencies`: List of client class names from `core.clients` that this adapter requires (required, non-empty)
-
-**Example** (`wayfinder_paths/adapters/pool_adapter/manifest.yaml`):
-
-```yaml
-schema_version: "0.1"
-entrypoint: "adapters.pool_adapter.adapter.PoolAdapter"
-capabilities:
-  - "pool.read"
-  - "pool.analytics"
-  - "pool.discovery"
-  - "llama.data"
-  - "pool.reports"
-dependencies:
-  - "PoolClient"
-```
-
-#### Strategy Manifests
-
-Strategy manifests declare permissions and required adapters with their capabilities.
-
-**Template:** Copy `wayfinder_paths/templates/strategy/manifest.yaml` as a starting point.
-
-**Schema:**
-
-```yaml
-schema_version: "0.1"
-entrypoint: "strategies.my_strategy.strategy.MyStrategy"
-permissions:
-  policy: "(wallet.id == 'FORMAT_WALLET_ID') && (eth.tx.to == '0x...')"
-adapters:
-  - name: "POOL"
-    capabilities: ["pool.read", "pool.analytics"]
-  - name: "BRAP"
-    capabilities: ["swap.quote", "swap.execute"]
-```
-
-**Fields:**
-
-- `schema_version`: Manifest schema version (currently `"0.1"`)
-- `entrypoint`: Full Python import path to the strategy class (required)
-- `name`: Strategy directory name (optional, used for wallet lookup - defaults to directory name)
-- `permissions.policy`: Security policy string that defines transaction permissions (required, non-empty)
-- `adapters`: List of required adapters with their names and needed capabilities (required, non-empty)
-  - `name`: Adapter type identifier (e.g., "POOL", "BRAP")
-  - `capabilities`: List of capabilities required from this adapter
-
-**Example** (`wayfinder_paths/strategies/stablecoin_yield_strategy/manifest.yaml`):
-
-```yaml
-schema_version: "0.1"
-entrypoint: "strategies.stablecoin_yield_strategy.strategy.StablecoinYieldStrategy"
-permissions:
-  policy: "(wallet.id == 'FORMAT_WALLET_ID') && ((eth.tx.data[0..10] == '0x095ea7b3' && eth.tx.data[34..74] == 'f75584ef6673ad213a685a1b58cc0330b8ea22cf') || (eth.tx.to == '0xF75584eF6673aD213a685a1B58Cc0330B8eA22Cf'))"
-adapters:
-  - name: "BALANCE"
-    capabilities: ["wallet_read", "wallet_transfer"]
-  - name: "POOL"
-    capabilities: ["pool.read", "pool.analytics"]
-  - name: "BRAP"
-    capabilities: ["swap.quote", "swap.execute"]
-```
-
-#### Manifest Validation
-
-Manifests are automatically validated to ensure:
-
-- Schema compliance (all required fields present, correct types)
-- Entrypoint classes exist and are importable
-- Dependencies are valid client classes
-- Permissions policies are non-empty
-
-**Validate locally:**
-
-```bash
-# Validate all manifests
-just validate-manifests
-
-# Or manually
-PYTHONPATH=wayfinder_paths poetry run python wayfinder_paths/scripts/validate_manifests.py
-```
-
-Validation runs automatically in CI/CD on every PR and push to main. All manifests must be valid before merging.
-
-**How Validation Works:**
-
-The `validate_manifests.py` script performs multi-stage validation:
-
-1. **Schema Validation** (via Pydantic models):
-   - Loads YAML file and validates against `AdapterManifest` or `StrategyManifest` schema
-   - Checks required fields, types, and basic constraints (e.g., capabilities cannot be empty)
-   - Validates entrypoint format (must be full import path like `"adapters.pool_adapter.adapter.PoolAdapter"`)
-
-2. **Entrypoint Verification**:
-   - **For Adapters**: Imports the entrypoint class and verifies it's a subclass of `BaseAdapter`
-   - **For Strategies**: Imports the entrypoint class and verifies it's a subclass of `Strategy`
-   - Uses Python's `__import__()` to dynamically import the module and class
-   - Catches import errors, missing classes, and type mismatches
-
-3. **Dependency Verification** (adapters only):
-   - Validates that all declared dependencies (e.g., `PoolClient`, `TokenClient`) exist in `core.clients`
-   - Attempts to import each dependency as `core.clients.{DepName}`
-
-4. **Permissions Validation** (strategies only):
-   - Validated by Pydantic: ensures `permissions.policy` exists and is non-empty
-   - Policy syntax is not parsed/validated (assumed to be valid at runtime)
-
-**Validation Flow:**
-
-```
-For each manifest file:
-  1. Load YAML → Parse with Pydantic (schema validation)
-  2. Import entrypoint class → Verify inheritance (entrypoint validation)
-  3. For adapters: Import dependencies → Verify they exist (dependency validation)
-  4. Collect all errors → Report results
-```
-
-The script automatically discovers all manifests by scanning:
-
-- `wayfinder_paths/adapters/*/manifest.yaml` for adapter manifests
-- `wayfinder_paths/strategies/*/manifest.yaml` for strategy manifests
-
-All errors are collected and reported at the end, with the script exiting with code 1 if any validation fails.
-
-#### Capabilities
-
-Capabilities are abstract operation identifiers (e.g., `"pool.read"`, `"swap.execute"`) declared in manifests. They represent what operations an adapter can perform, not specific method names. The manifest is the **single source of truth** for capabilities—they are not duplicated in code.
-
-When creating an adapter:
-
-1. Declare capabilities in your `manifest.yaml`
-2. Implement methods that fulfill those capabilities
-3. Capabilities are validated at manifest validation time (entrypoint must be importable)
-
 ### Configuration
 
 Configuration is split between:
@@ -473,7 +297,7 @@ class MyAdapter(BaseAdapter):
         self.pool_client = PoolClient()
 
     async def connect(self) -> bool:
-        """No-op for read-only adapters, but kept for manifest compatibility."""
+        """No-op for read-only adapters, but kept for interface consistency."""
         return True
 
     async def get_pools(self, pool_ids: list[str]):
@@ -546,6 +370,54 @@ class MyStrategy(Strategy):
         }
 ```
 
+### Built-in Strategies
+
+The following strategies are available and can be run using the CLI:
+
+| Strategy                          | Description                 | Chain    |
+| --------------------------------- | --------------------------- | -------- |
+| `basis_trading_strategy`          | Delta-neutral basis trading | -        |
+| `hyperlend_stable_yield_strategy` | Stable yield on HyperLend   | HyperEVM |
+| `moonwell_wsteth_loop_strategy`   | Leveraged wstETH yield loop | Base     |
+
+#### Running Strategies
+
+```bash
+# Check strategy status
+poetry run python wayfinder_paths/scripts/run_strategy.py \
+  --strategy moonwell_wsteth_loop_strategy \
+  --main-wallet-label main \
+  --strategy-wallet-label moonwell_wsteth_loop_strategy \
+  status
+
+# Deposit funds (USDC amount, optional ETH for gas)
+poetry run python wayfinder_paths/scripts/run_strategy.py \
+  --strategy moonwell_wsteth_loop_strategy \
+  --main-wallet-label main \
+  --strategy-wallet-label moonwell_wsteth_loop_strategy \
+  deposit --usdc 100 --eth 0.01
+
+# Run periodic update
+poetry run python wayfinder_paths/scripts/run_strategy.py \
+  --strategy moonwell_wsteth_loop_strategy \
+  --main-wallet-label main \
+  --strategy-wallet-label moonwell_wsteth_loop_strategy \
+  update
+
+# Withdraw funds (omit --amount for full withdrawal)
+poetry run python wayfinder_paths/scripts/run_strategy.py \
+  --strategy moonwell_wsteth_loop_strategy \
+  --main-wallet-label main \
+  --strategy-wallet-label moonwell_wsteth_loop_strategy \
+  withdraw --amount 50
+
+# Run in simulation mode (no real transactions)
+poetry run python wayfinder_paths/scripts/run_strategy.py \
+  --strategy moonwell_wsteth_loop_strategy \
+  --simulation \
+  status
+```
+
 ### Built-in adapters
 
 - **BALANCE (BalanceAdapter)**: wraps `WalletClient`/`TokenClient` to read wallet, token, and pool balances and now orchestrates transfers between the main/strategy wallets with ledger bookkeeping. Requires a `Web3Service` so it can share the same wallet provider as the strategy.
@@ -554,8 +426,9 @@ class MyStrategy(Strategy):
 - **LEDGER (LedgerAdapter)**: records deposits, withdrawals, custom operations, and cashflows via `LedgerClient`, and can read strategy transaction summaries.
 - **TOKEN (TokenAdapter)**: lightweight wrapper around `TokenClient` for token metadata, live price snapshots, and gas token lookups.
 - **HYPERLEND (HyperlendAdapter)**: connects to `HyperlendClient` for lending/supply caps inside the HyperLend strategy.
+- **MOONWELL (MoonwellAdapter)**: interfaces with Moonwell protocol on Base for lending, borrowing, collateral management, and WELL rewards.
 
-Each strategy manifest declares which adapters it needs and which capabilities it consumes. Adapters must implement the behavior promised in their manifest (or raise `NotImplementedError` if invoked outside the manifest contract).
+Strategies register the adapters they need in their `__init__` method. Adapters implement their specific capabilities and raise `NotImplementedError` for unsupported operations.
 
 ## 🧪 Testing