x402aff 0.1.0__tar.gz

x402aff-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aeon Inc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

x402aff-0.1.0/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: x402aff
+Version: 0.1.0
+Summary: Builder-code affiliation for x402 sellers - route each payment to a per-(seller, builder) 0xSplits split.
+License: MIT
+Project-URL: Homepage, https://github.com/MiroShark/x402aff
+Project-URL: Repository, https://github.com/MiroShark/x402aff
+Project-URL: Documentation, https://github.com/MiroShark/x402aff/blob/main/docs/INTEGRATION.md
+Project-URL: Issues, https://github.com/MiroShark/x402aff/issues
+Keywords: x402,builder-codes,0xsplits,base,affiliation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Office/Business :: Financial
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28
+Requires-Dist: cbor2>=5.4
+Provides-Extra: cdp
+Requires-Dist: cdp-sdk>=1.0; extra == "cdp"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Dynamic: license-file
+
+# x402aff - Python
+
+The x402aff kit (Python): an installable `x402aff` package with the one-object
+[`Affiliation`](./x402aff/affiliation.py) facade on top. This is the
+implementation validated end-to-end on Base mainnet.
+
+## Install
+
+```bash
+pip install x402aff                  # from PyPI
+pip install 'x402aff[cdp]'           # with the CDP discovery extra
+```
+
+Or from a checkout / straight from git, to track unreleased changes:
+
+```bash
+pip install ./python                 # from a clone, at the repo root
+pip install '.[cdp]'                 # from inside python/, with the CDP extra
+pip install 'x402aff[cdp] @ git+https://github.com/MiroShark/x402aff@main#subdirectory=python'
+```
+
+The `cdp` extra adds `cdp-sdk`, needed only for the CDP-index discovery path
+(`monitor`, `aff.scan()` / `pending()` / `splits_payload()`). Without it the
+request-time `payTo` and payout-calldata paths work fine.
+
+Vendoring instead of installing works too - copy `python/x402aff/` into your
+project as a subpackage; the modules import each other relatively, so nothing
+needs rewriting and none of the generic names (`split`, `monitor`, `resolver`)
+leak into your top-level namespace.
+
+## Use
+
+```python
+from x402aff import Affiliation
+
+aff = Affiliation(app_code="bc_yourcode", seller_payout="0xYourWallet")
+
+# on your x402 route:
+#   pay_to=aff.pay_to           per-request split, from the X-Builder-Code header
+#   extensions=aff.extensions   declares your app code `a`
+
+# release payouts, later (permissionless):
+calls, balance = aff.release("bc_alice")
+```
+
+Full integration guide (money path, trust model, wiring, caveats):
+[`../docs/INTEGRATION.md`](../docs/INTEGRATION.md). The TypeScript port lives in
+[`../ts/`](../ts) and resolves the identical split address.
+
+## Modules
+
+| File | Role |
+|------|------|
+| `__init__.py` | The package's public surface (`from x402aff import Affiliation`, …). |
+| `affiliation.py` | **Start here.** The `Affiliation` facade wrapping everything below. |
+| `builder_code.py` | Declare `a`; decode `a`/`s`/`w` off a settle tx. |
+| `resolver.py` | Builder code → registered payout address (one `eth_call`). |
+| `split.py` | Builder code + price → the split plan (recipients + bps). |
+| `push_split.py` | The plan → 0xSplits calldata + counterfactual address. |
+| `payto.py` | Request-time `payTo` resolver. Cached, never raises. |
+| `distribute.py` | The (deploy + distribute) calldata to release a funded split. |
+| `monitor.py` | Which splits hold distributable funds (via CDP's index). |
+| `buyer_client.py` | Buyer-side extension that attaches `s` (via `marked_service_codes`). |
+| `cdp_sql.py` · `queries.sql` | CDP SQL API client + attribution queries. |
+
+## Develop
+
+```bash
+pip install -e '.[cdp,dev]'   # editable install with the CDP + test extras
+pytest                        # runs tests/ against the x402aff package
+```

x402aff-0.1.0/README.md

@@ -0,0 +1,71 @@
+# x402aff - Python
+
+The x402aff kit (Python): an installable `x402aff` package with the one-object
+[`Affiliation`](./x402aff/affiliation.py) facade on top. This is the
+implementation validated end-to-end on Base mainnet.
+
+## Install
+
+```bash
+pip install x402aff                  # from PyPI
+pip install 'x402aff[cdp]'           # with the CDP discovery extra
+```
+
+Or from a checkout / straight from git, to track unreleased changes:
+
+```bash
+pip install ./python                 # from a clone, at the repo root
+pip install '.[cdp]'                 # from inside python/, with the CDP extra
+pip install 'x402aff[cdp] @ git+https://github.com/MiroShark/x402aff@main#subdirectory=python'
+```
+
+The `cdp` extra adds `cdp-sdk`, needed only for the CDP-index discovery path
+(`monitor`, `aff.scan()` / `pending()` / `splits_payload()`). Without it the
+request-time `payTo` and payout-calldata paths work fine.
+
+Vendoring instead of installing works too - copy `python/x402aff/` into your
+project as a subpackage; the modules import each other relatively, so nothing
+needs rewriting and none of the generic names (`split`, `monitor`, `resolver`)
+leak into your top-level namespace.
+
+## Use
+
+```python
+from x402aff import Affiliation
+
+aff = Affiliation(app_code="bc_yourcode", seller_payout="0xYourWallet")
+
+# on your x402 route:
+#   pay_to=aff.pay_to           per-request split, from the X-Builder-Code header
+#   extensions=aff.extensions   declares your app code `a`
+
+# release payouts, later (permissionless):
+calls, balance = aff.release("bc_alice")
+```
+
+Full integration guide (money path, trust model, wiring, caveats):
+[`../docs/INTEGRATION.md`](../docs/INTEGRATION.md). The TypeScript port lives in
+[`../ts/`](../ts) and resolves the identical split address.
+
+## Modules
+
+| File | Role |
+|------|------|
+| `__init__.py` | The package's public surface (`from x402aff import Affiliation`, …). |
+| `affiliation.py` | **Start here.** The `Affiliation` facade wrapping everything below. |
+| `builder_code.py` | Declare `a`; decode `a`/`s`/`w` off a settle tx. |
+| `resolver.py` | Builder code → registered payout address (one `eth_call`). |
+| `split.py` | Builder code + price → the split plan (recipients + bps). |
+| `push_split.py` | The plan → 0xSplits calldata + counterfactual address. |
+| `payto.py` | Request-time `payTo` resolver. Cached, never raises. |
+| `distribute.py` | The (deploy + distribute) calldata to release a funded split. |
+| `monitor.py` | Which splits hold distributable funds (via CDP's index). |
+| `buyer_client.py` | Buyer-side extension that attaches `s` (via `marked_service_codes`). |
+| `cdp_sql.py` · `queries.sql` | CDP SQL API client + attribution queries. |
+
+## Develop
+
+```bash
+pip install -e '.[cdp,dev]'   # editable install with the CDP + test extras
+pytest                        # runs tests/ against the x402aff package
+```

x402aff-0.1.0/pyproject.toml

@@ -0,0 +1,50 @@
+[build-system]
+requires = ["setuptools>=64"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "x402aff"
+version = "0.1.0"
+description = "Builder-code affiliation for x402 sellers - route each payment to a per-(seller, builder) 0xSplits split."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+keywords = ["x402", "builder-codes", "0xsplits", "base", "affiliation"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: Office/Business :: Financial",
+    "Topic :: Software Development :: Libraries",
+    "Typing :: Typed",
+]
+dependencies = [
+    "requests>=2.28",
+    "cbor2>=5.4",
+]
+
+[project.optional-dependencies]
+# Discovery via the CDP SQL API: monitor.py, Affiliation.scan/pending/splits_payload.
+cdp = ["cdp-sdk>=1.0"]
+dev = ["pytest>=7.0"]
+
+[project.urls]
+Homepage = "https://github.com/MiroShark/x402aff"
+Repository = "https://github.com/MiroShark/x402aff"
+Documentation = "https://github.com/MiroShark/x402aff/blob/main/docs/INTEGRATION.md"
+Issues = "https://github.com/MiroShark/x402aff/issues"
+
+[tool.setuptools]
+packages = ["x402aff"]
+
+[tool.setuptools.package-data]
+# Ship the reference queries alongside the code they document, and the PEP 561
+# marker so a consumer's type checker sees the annotations.
+x402aff = ["queries.sql", "py.typed"]
+
+[tool.pytest.ini_options]
+pythonpath = ["."]
+testpaths = ["tests"]
+addopts = "-q"

x402aff-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

x402aff-0.1.0/tests/test_affiliation.py

@@ -0,0 +1,219 @@
+"""Tests for the Affiliation facade (affiliation.py) - no network.
+
+Resolution is monkeypatched so these run offline; they check the facade wires the
+underlying modules together correctly and keeps its safe-fallback contract.
+
+    pytest test_affiliation.py -q
+"""
+from __future__ import annotations
+
+import asyncio
+
+import pytest
+
+from x402aff import distribute, push_split, resolver
+from x402aff.affiliation import Affiliation
+from x402aff.builder_code import declare_builder_code
+
+SELLER = "0x2222222222222222222222222222222222222222"
+BUILDER = "0x1111111111111111111111111111111111111111"
+SPLIT = "0x3773000000000000000000000000000000002e38"
+
+
+class _FakeAdapter:
+    def __init__(self, value):
+        self._value = value
+
+    def get_header(self, name):
+        return self._value
+
+
+class _FakeCtx:
+    """Looks like an x402 HTTPRequestContext for header extraction."""
+
+    def __init__(self, value):
+        self.adapter = _FakeAdapter(value)
+
+
+def _aff(**kw) -> Affiliation:
+    Affiliation.clear_cache()  # payto._CACHE is process-global; isolate each test
+    return Affiliation(app_code="bc_seller", seller_payout=SELLER, **kw)
+
+
+# ── construction ──────────────────────────────────────────────────────────────
+
+def test_requires_app_code_and_seller():
+    import pytest
+
+    with pytest.raises(ValueError):
+        Affiliation(app_code="", seller_payout=SELLER)
+    with pytest.raises(ValueError):
+        Affiliation(app_code="bc_seller", seller_payout="")
+
+
+def test_extensions_declares_app_code():
+    aff = _aff()
+    assert aff.extensions == declare_builder_code("bc_seller")
+    assert aff.extensions["builder-code"]["info"]["a"] == "bc_seller"
+
+
+def test_custom_share_sets_effective_share():
+    assert _aff()._share == push_split.BUILDER_SHARE_BPS
+    assert _aff(builder_share_bps=2500)._share == 2500
+
+
+# ── code extraction from every source shape ───────────────────────────────────
+
+def test_code_from_raw_string_takes_primary():
+    assert _aff()._code_from("bc_alice,bc_bob") == "bc_alice"
+
+
+def test_code_from_headers_mapping():
+    aff = _aff()
+    assert aff._code_from({Affiliation.HEADER: "bc_alice"}) == "bc_alice"
+
+
+def test_code_from_x402_context():
+    aff = _aff()
+    assert aff._code_from(_FakeCtx("bc_alice")) == "bc_alice"
+    assert aff._code_from(_FakeCtx(None)) is None
+
+
+def test_code_from_none():
+    assert _aff()._code_from(None) is None
+
+
+# ── safe fallback: no/empty code → seller, no network ─────────────────────────
+
+def test_no_code_falls_back_to_seller():
+    aff = _aff()
+    pt = aff.resolve(None)
+    assert pt.address == SELLER
+    assert pt.attributed is False
+    assert aff.pay_to_for(None) == SELLER
+    assert aff.pay_to_for({Affiliation.HEADER: ""}) == SELLER
+
+
+def test_pay_to_async_callback_no_code():
+    aff = _aff()
+    addr = asyncio.run(aff.pay_to(_FakeCtx(None)))
+    assert addr == SELLER
+
+
+# ── attributed path (resolution monkeypatched) ────────────────────────────────
+
+def _patch_registered(monkeypatch, *, deployed=False, balance=0):
+    monkeypatch.setattr(
+        resolver, "resolve",
+        lambda code, **kw: {"code": code, "registered": True,
+                            "owner": BUILDER, "payout_address": BUILDER},
+    )
+    monkeypatch.setattr(
+        push_split, "predict_split_address",
+        lambda plan, **kw: (SPLIT, deployed),
+    )
+    monkeypatch.setattr(
+        distribute, "split_balance_units",
+        lambda addr, **kw: balance,
+    )
+
+
+def test_resolve_registered_code_routes_to_split(monkeypatch):
+    _patch_registered(monkeypatch)
+    aff = _aff()
+    pt = aff.resolve(_FakeCtx("bc_alice"))
+    assert pt.address == SPLIT
+    assert pt.attributed is True
+    # 10% builder / 90% seller in the plan
+    assert pt.plan.has_builder is True
+    assert dict(pt.plan.recipients)[BUILDER] == push_split.BUILDER_SHARE_BPS
+
+
+def test_pay_to_async_callback_registered(monkeypatch):
+    _patch_registered(monkeypatch)
+    aff = _aff()
+    addr = asyncio.run(aff.pay_to(_FakeCtx("bc_alice")))
+    assert addr == SPLIT
+
+
+def test_balance_reads_split(monkeypatch):
+    _patch_registered(monkeypatch, balance=12_400_000)
+    assert _aff().balance("bc_alice") == 12_400_000
+
+
+def test_balance_zero_when_unattributed(monkeypatch):
+    monkeypatch.setattr(resolver, "resolve",
+                        lambda code, **kw: {"registered": False, "payout_address": None})
+    assert _aff().balance("bc_alice") == 0
+
+
+def test_release_builds_deploy_and_distribute(monkeypatch):
+    _patch_registered(monkeypatch, deployed=False, balance=12_400_000)
+    calls, balance = _aff().release("bc_alice")
+    assert balance == 12_400_000
+    steps = [c.step for c in calls]
+    assert steps == ["deploy_split", "distribute"]  # not deployed → both legs
+
+
+def test_release_skips_deploy_when_already_deployed(monkeypatch):
+    _patch_registered(monkeypatch, deployed=True, balance=5_000_000)
+    calls, _ = _aff().release("bc_alice")
+    assert [c.step for c in calls] == ["distribute"]
+
+
+def test_splits_payload_shapes_rows_and_filters_marker(monkeypatch):
+    from x402aff import monitor
+
+    _patch_registered(monkeypatch, deployed=False, balance=1_000_000)
+    # Discovery is CDP-backed; stub it. The shared marker rides along as a
+    # "builder" and must be dropped; the app code + facilitator are already
+    # filtered by discover_builder_codes.
+    monkeypatch.setattr(monitor, "discover_builder_codes",
+                        lambda app_code, **kw: ["bc_alice", "x402aff"])
+
+    payload = _aff().splits_payload()
+    assert payload["configured"] is True
+    assert payload["marker"] == "x402aff"
+    assert payload["count"] == 1  # the marker row is dropped
+    s = payload["splits"][0]
+    assert s["payTo"] == SPLIT
+    assert s["sellerCode"] == "bc_seller"
+    assert s["builderCode"] == "bc_alice"
+    assert s["balanceUnits"] == "1000000"
+    assert s["deployed"] is False
+    assert s["claimable"] is True
+    assert [c["step"] for c in s["calls"]] == ["deploy_split", "distribute"]
+
+
+def test_splits_payload_makes_no_base_events_query(monkeypatch):
+    """Regression: the per-split payments/received rollup joined base.events and
+    tripped the CDP SQL API's leaf-scan limit (400) on every call - see
+    queries.sql #5b. splits_payload must issue no such query, and must not
+    resurrect the fields that only that query could populate."""
+    from x402aff import monitor
+
+    _patch_registered(monkeypatch, deployed=False, balance=1_000_000)
+    monkeypatch.setattr(monitor, "discover_builder_codes",
+                        lambda app_code, **kw: ["bc_alice"])
+    # Any CDP SQL beyond the stubbed discovery is a reintroduced rollup.
+    monkeypatch.setattr(monitor.cdp_sql, "run_query",
+                        lambda *a, **kw: pytest.fail("splits_payload ran an unexpected CDP query"))
+
+    s = _aff().splits_payload()["splits"][0]
+    assert "payments" not in s
+    assert "receivedUnits" not in s
+    assert not hasattr(monitor, "discover_split_rollup")
+
+
+def test_resolve_failure_falls_back_and_logs(monkeypatch, caplog):
+    def _boom(code, **kw):
+        raise RuntimeError("RPC 429")
+
+    monkeypatch.setattr(resolver, "resolve", _boom)
+    aff = _aff()
+    with caplog.at_level("WARNING", logger="affiliation"):
+        pt = aff.resolve(_FakeCtx("bc_alice"))
+    assert pt.address == SELLER          # never raises - payment still works
+    assert pt.attributed is False
+    assert pt.error is not None
+    assert any("resolve failed" in r.message for r in caplog.records)

x402aff-0.1.0/tests/test_builder_code.py

@@ -0,0 +1,134 @@
+"""Tests for the declare + decode helpers.
+
+Run:  pip install cbor2 pytest && pytest test_builder_code.py
+
+These prove the wire shape and the on-chain suffix round-trip. They do NOT prove
+real on-chain attribution - that needs a real Base-mainnet settlement verified
+against the calldata suffix (see README → Verify).
+"""
+import pytest
+
+from x402aff.builder_code import (
+    AFFILIATION_MARKER,
+    BUILDER_CODE_KEY,
+    ERC_8021_MARKER,
+    declare_builder_code,
+    marked_service_codes,
+    normalize_builder_code,
+    normalize_service_codes,
+    parse_builder_code_suffix,
+)
+
+# --- declare_builder_code: the "declare it" step ------------------------------
+
+def test_declares_app_code_under_correct_key():
+    ext = declare_builder_code("bc_yourcode")
+    assert set(ext) == {BUILDER_CODE_KEY}
+    assert ext[BUILDER_CODE_KEY]["info"] == {"a": "bc_yourcode"}
+    schema = ext[BUILDER_CODE_KEY]["schema"]
+    assert set(schema["properties"]) == {"a", "w", "s"}
+    assert schema["additionalProperties"] is False
+
+
+def test_strips_whitespace():
+    assert declare_builder_code("  bc_yourcode  ")[BUILDER_CODE_KEY]["info"]["a"] == "bc_yourcode"
+
+
+@pytest.mark.parametrize("bad", ["", "BC_UPPER", "bc-dash", "x" * 33, "bc code"])
+def test_rejects_malformed_codes(bad):
+    with pytest.raises(ValueError):
+        declare_builder_code(bad)
+
+
+# --- normalizers: sanitize codes read off the wire ----------------------------
+
+def test_normalize_builder_code_accepts_and_trims():
+    assert normalize_builder_code("  bc_abc12345  ") == "bc_abc12345"
+
+
+@pytest.mark.parametrize("bad", ["", "BC_UPPER", "bc-dash", "x" * 33, None, 123, ["bc_x"]])
+def test_normalize_builder_code_rejects(bad):
+    assert normalize_builder_code(bad) is None  # never raises
+
+
+def test_normalize_service_codes_list_joins_valid():
+    assert normalize_service_codes(["bc_one", "bc_two"]) == "bc_one,bc_two"
+
+
+def test_normalize_service_codes_accepts_bare_string():
+    assert normalize_service_codes("bc_abc12345") == "bc_abc12345"
+
+
+def test_normalize_service_codes_dedupes_and_drops_invalid():
+    assert normalize_service_codes(["bc_one", "BC_BAD", "bc_one", "bc_two"]) == "bc_one,bc_two"
+
+
+@pytest.mark.parametrize("empty", [None, [], ["BAD!"], "not a code", [""]])
+def test_normalize_service_codes_empty_to_none(empty):
+    assert normalize_service_codes(empty) is None
+
+
+# --- marked_service_codes: the buyer-side `s` -------------------------------
+
+def test_marked_service_codes_appends_the_shared_marker():
+    assert marked_service_codes("bc_yourcode") == ["bc_yourcode", AFFILIATION_MARKER]
+
+
+def test_marked_service_codes_keeps_the_real_code_primary():
+    # The split pays the FIRST code, so the marker must never lead.
+    assert marked_service_codes("bc_yourcode")[0] == "bc_yourcode"
+
+
+def test_marked_service_codes_never_duplicates_the_marker():
+    assert marked_service_codes(AFFILIATION_MARKER) == [AFFILIATION_MARKER]
+
+
+def test_buyer_extension_stamps_exactly_marked_service_codes():
+    """The extension must not re-implement the rule - one source of truth."""
+    from x402aff.buyer_client import BuilderCodeClientExtension
+
+    class _Payload:
+        extensions = None
+
+        def model_copy(self, *, update):
+            return update["extensions"]
+
+    stamped = BuilderCodeClientExtension("bc_yourcode").enrich_payment_payload(_Payload(), None)
+    assert stamped["builder-code"]["info"]["s"] == marked_service_codes("bc_yourcode")
+
+
+# --- parse_builder_code_suffix: the "recover w from chain" step ---------------
+
+def _make_suffix(**codes) -> bytes:
+    """Build a Schema 2 suffix the way the facilitator does."""
+    import cbor2
+
+    cbor = cbor2.dumps(codes)
+    return cbor + len(cbor).to_bytes(2, "big") + bytes([2]) + ERC_8021_MARKER
+
+
+def test_parse_recovers_app_and_wallet_codes():
+    suffix = _make_suffix(a="bc_yourcode", w="cdp_facil1")
+    calldata = "0x" + ("ab" * 120) + suffix.hex()
+    assert parse_builder_code_suffix(calldata) == {"a": "bc_yourcode", "w": "cdp_facil1"}
+
+
+def test_parse_recovers_service_codes_array():
+    suffix = _make_suffix(s=["bc_client1", "bc_client2"])
+    assert parse_builder_code_suffix(("00" * 40) + suffix.hex()) == {"s": ["bc_client1", "bc_client2"]}
+
+
+def test_parse_all_three_fields():
+    suffix = _make_suffix(a="bc_app", w="cdp_facil1", s=["bc_client"])
+    assert parse_builder_code_suffix("0x" + suffix.hex()) == {
+        "a": "bc_app", "w": "cdp_facil1", "s": ["bc_client"]
+    }
+
+
+@pytest.mark.parametrize("calldata", ["0xa9059cbb" + "00" * 60, "0x", "0xdeadbeef", "not hex", ""])
+def test_parse_no_suffix_returns_none(calldata):
+    assert parse_builder_code_suffix(calldata) is None
+
+
+def test_parse_accepts_raw_bytes():
+    assert parse_builder_code_suffix(b"\x00\x00" + _make_suffix(w="cdp_facil1")) == {"w": "cdp_facil1"}