pythsol 0.1.0__py3-none-any.whl

pythsol/testing/__init__.py

@@ -0,0 +1,12 @@
+"""Pytest helpers for programs built by PythSol.
+
+Importing this package does not import the compiler. The plugin does, when a
+test asks for the ``program`` fixture.
+"""
+
+from __future__ import annotations
+
+__all__ = ["DEFAULT_PROGRAM_ID"]
+
+#: Program id the LiteSVM fixture loads, unless ``PYTHSOL_PROGRAM_ID`` is set.
+DEFAULT_PROGRAM_ID = "F1x3Lz3Nn3jvrUWM65uwGFPzFGuCB5GMUksMiNGxiKgU"

pythsol/testing/plugin.py

@@ -0,0 +1,437 @@
+"""Pytest plugin: ``svm``, ``program``, ``payer``, ``accounts``, and ``send``.
+
+``pythsol test`` sets ``PYTHSOL_TEST_SO``, ``PYTHSOL_TEST_CLIENT``, and
+``PYTHSOL_TEST_SOURCE``. A test then calls instructions by keyword:
+
+```python
+def test_increment(program, payer):
+    opened = program.initialize(authority=payer)
+    counter = opened.account("counter")
+    program.increment(authority=payer, counter=counter, by=5)
+    assert program.fetch("Counter", counter)["count"] == 5
+```
+
+``Init`` accounts and a ``bump`` argument are filled in. The signer must be a
+keypair. Failures raise with the program logs, including ``(file.py:line)``.
+"""
+
+from __future__ import annotations
+
+import importlib.util
+import os
+import re
+from collections.abc import Iterator
+from contextlib import contextmanager
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from pythsol.testing import DEFAULT_PROGRAM_ID
+
+FAUCET_LAMPORTS = 50_000_000
+
+_CUSTOM = re.compile(r"Custom\((\d+)\)")
+_HEX = re.compile(r"custom program error: 0x([0-9a-fA-F]+)")
+_CU = re.compile(r"consumed (\d+) of")
+_SOLDERS: dict[str, Any] = {}
+
+
+def pytest_configure(config: pytest.Config) -> None:
+    """Register the marker used by template tests."""
+    config.addinivalue_line("markers", "pythsol: test drives a PythSol program in LiteSVM")
+
+
+@dataclass(frozen=True)
+class PythsolTarget:
+    """A built program the fixtures load."""
+
+    source: Path
+    so: Path
+    client: Path
+    program_id: str = DEFAULT_PROGRAM_ID
+
+
+@dataclass
+class CallResult:
+    """One ``send``: logs, compute units, and the accounts the call used."""
+
+    ok: bool
+    logs: list[str]
+    compute_units: int | None
+    error_code: int | None
+    accounts: dict[str, Any] = field(default_factory=dict)
+
+    def account(self, name: str) -> Any:
+        """Pubkey passed for the account parameter ``name``."""
+        if name not in self.accounts:
+            known = ", ".join(sorted(self.accounts))
+            raise KeyError(f"no account {name!r} on this call ({known})")
+        return self.accounts[name]
+
+
+class ProgramFailed(AssertionError):  # noqa: N818
+    """The instruction returned an error and the test did not expect one."""
+
+
+def _solders() -> dict[str, Any]:
+    if _SOLDERS:
+        return _SOLDERS
+    from solders.keypair import Keypair
+    from solders.litesvm import LiteSVM
+    from solders.message import Message
+    from solders.pubkey import Pubkey
+    from solders.transaction import Transaction
+    from solders.transaction_metadata import FailedTransactionMetadata
+
+    _SOLDERS.update(
+        {
+            "Keypair": Keypair,
+            "LiteSVM": LiteSVM,
+            "Message": Message,
+            "Pubkey": Pubkey,
+            "Transaction": Transaction,
+            "Failed": FailedTransactionMetadata,
+        }
+    )
+    return _SOLDERS
+
+
+def _need_solders() -> None:
+    try:
+        _solders()
+    except ImportError:
+        if os.environ.get("PYTHSOL_TEST_SO"):
+            pytest.fail("solders is required for pythsol test; pip install 'pythsol[test]'")
+        pytest.skip("solders is not installed")
+
+
+def _is_keypair(value: object) -> bool:
+    return callable(getattr(value, "pubkey", None)) and callable(
+        getattr(value, "sign_message", None)
+    )
+
+
+def _as_pubkey(value: Any) -> Any:
+    pubkey = getattr(value, "pubkey", None)
+    if callable(pubkey):
+        return pubkey()
+    return value
+
+
+def _logs(result: Any) -> list[str]:
+    try:
+        logs = getattr(result, "logs", None)
+        if callable(logs):
+            logs = logs()
+        else:
+            meta = getattr(result, "meta", None)
+            meta = meta() if callable(meta) else meta
+            logs = getattr(meta, "logs", None)
+            logs = logs() if callable(logs) else logs
+        return [str(entry) for entry in (logs or [])]
+    except Exception:
+        return []
+
+
+def _failed(result: Any) -> bool:
+    if isinstance(result, _solders()["Failed"]):
+        return True
+    err = getattr(result, "err", None)
+    if callable(err):
+        err = err()
+    return err is not None
+
+
+def _error_code(result: Any) -> int | None:
+    err = getattr(result, "err", None)
+    if err is None:
+        return None
+    if callable(err):
+        err = err()
+    if err is None:
+        return None
+    text = str(err)
+    digits = _CUSTOM.search(text)
+    if digits:
+        return int(digits.group(1), 10)
+    hexa = _HEX.search(text)
+    if hexa:
+        return int(hexa.group(1), 16)
+    return None
+
+
+def _compute_units(result: Any, logs: list[str]) -> int | None:
+    meta = getattr(result, "meta", None)
+    if callable(meta):
+        try:
+            meta = meta()
+        except Exception:
+            meta = None
+    for obj in (result, meta):
+        if obj is None:
+            continue
+        for attr in ("compute_units_consumed", "compute_units"):
+            value = getattr(obj, attr, None)
+            if callable(value):
+                try:
+                    value = value()
+                except Exception:
+                    continue
+            if isinstance(value, int):
+                return value
+    for line in logs:
+        match = _CU.search(line)
+        if match:
+            return int(match.group(1))
+    return None
+
+
+def _load_client(path: Path) -> Any:
+    spec = importlib.util.spec_from_file_location(f"pythsol_client_{path.stem}_{id(path)}", path)
+    if spec is None or spec.loader is None:
+        raise RuntimeError(f"cannot load client {path}")
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    return module
+
+
+class LoadedProgram:
+    """One LiteSVM plus the generated client for a built program."""
+
+    def __init__(self, svm: Any, payer: Any, target: PythsolTarget) -> None:
+        from pythsol.compiler.model import ProgramModel
+        from pythsol.compiler.modules import read_sibling_modules
+        from pythsol.compiler.pipeline import emit_program
+
+        text = target.source.read_text(encoding="utf-8")
+        modules, module_files = read_sibling_modules(target.source)
+        generated = emit_program(
+            text,
+            target.source,
+            modules=modules,
+            module_files=module_files,
+        )
+        if not generated.ok or generated.generated is None:
+            rendered = "\n".join(item.render() for item in generated.diagnostics)
+            pytest.fail(f"program did not check:\n{rendered}")
+        model: ProgramModel = generated.generated
+        self.svm = svm
+        self.payer = payer
+        self.target = target
+        self.model = model
+        self.name = model.name
+        self.client = _load_client(target.client)
+        self.program_id = _solders()["Pubkey"].from_string(target.program_id)
+        self.addresses: dict[str, Any] = {}
+        self.instruction_names = tuple(instr.snake_name for instr in model.instructions)
+        self._errors = {err.name: err.code for err in model.errors}
+        self._expect: int | None = None
+        self._last: CallResult | None = None
+
+    def keypair(self) -> Any:
+        """A new funded keypair on this LiteSVM."""
+        kp = _solders()["Keypair"]()
+        self.svm.airdrop(kp.pubkey(), FAUCET_LAMPORTS)
+        return kp
+
+    def fetch(self, account: str, address: Any) -> dict[str, Any]:
+        """Decode ``account`` at ``address`` with the generated client."""
+        from pythsol.compiler.model import snake_case
+
+        found = self.svm.get_account(address)
+        if found is None or not bytes(found.data):
+            raise AssertionError(f"{account} at {address} is empty")
+        fn = getattr(self.client, f"decode_{snake_case(account)}")
+        decoded: dict[str, Any] = fn(bytes(found.data))
+        return decoded
+
+    def send_ix(self, ix: Any, signers: list[Any]) -> CallResult:
+        """Send a solders instruction. ``signers[0]`` pays the fee."""
+        if not signers:
+            raise TypeError("send needs at least one signer")
+        expire = getattr(self.svm, "expire_blockhash", None)
+        if callable(expire):
+            expire()
+        blockhash = self.svm.latest_blockhash()
+        message = _solders()["Message"].new_with_blockhash([ix], signers[0].pubkey(), blockhash)
+        tx = _solders()["Transaction"](signers, message, blockhash)
+        raw = self.svm.send_transaction(tx)
+        return self._result(raw, {})
+
+    @contextmanager
+    def expect_error(self, name: str | int) -> Iterator[None]:
+        """Fail unless the next instruction returns this custom error."""
+        expected = name if isinstance(name, int) else self._resolve_error(name)
+        if self._expect is not None:
+            raise RuntimeError("expect_error cannot be nested")
+        self._expect = expected
+        self._last = None
+        try:
+            yield
+        except Exception:
+            raise
+        else:
+            last = self._last
+            got = None if last is None else last.error_code
+            logs = "" if last is None else "\n".join(last.logs)
+            if last is None or last.ok or last.error_code != expected:
+                raise AssertionError(f"expected error {name} ({expected}), got {got}\n{logs}")
+        finally:
+            self._expect = None
+
+    def __getattr__(self, name: str) -> Any:
+        instr = self._instruction(name)
+        if instr is None:
+            raise AttributeError(name)
+
+        def call(**kwargs: Any) -> CallResult:
+            return self._invoke(instr, kwargs)
+
+        return call
+
+    def _instruction(self, name: str) -> Any:
+        for instr in self.model.instructions:
+            if instr.name == name or instr.snake_name == name:
+                return instr
+        return None
+
+    def _resolve_error(self, name: str) -> int:
+        if name in self._errors:
+            return self._errors[name]
+        for err_name, code in self._errors.items():
+            if name == err_name or name.endswith("." + err_name):
+                return code
+        known = ", ".join(sorted(self._errors))
+        raise KeyError(f"unknown error {name!r} ({known})")
+
+    def _invoke(self, instr: Any, kwargs: dict[str, Any]) -> CallResult:
+        from pythsol.compiler.model import snake_case
+
+        account_names = {param.name for param in instr.account_params}
+        data_names = {param.name for param in instr.data_params}
+        unknown = set(kwargs) - account_names - data_names
+        if unknown:
+            raise TypeError(f"unknown argument {sorted(unknown)[0]}")
+        pubkeys: dict[str, Any] = {}
+        signers: list[Any] = []
+        seen: set[str] = set()
+        bumps: list[int] = []
+        used: dict[str, Any] = {}
+        for param in instr.account_params:
+            if param.name in kwargs:
+                value = kwargs[param.name]
+                if param.kind == "signer" and not _is_keypair(value):
+                    raise TypeError(f"{param.name} must be a keypair")
+                if _is_keypair(value) and param.kind == "signer":
+                    identity = str(value.pubkey())
+                    if identity not in seen:
+                        seen.add(identity)
+                        signers.append(value)
+                pubkey = _as_pubkey(value)
+            elif param.is_init or param.seed:
+                seed = param.seed or snake_case(param.account)
+                pubkey, bump = _solders()["Pubkey"].find_program_address(
+                    [seed.encode()],
+                    self.program_id,
+                )
+                bumps.append(int(bump))
+            else:
+                raise TypeError(f"missing account {param.name}")
+            pubkeys[param.name] = pubkey
+            used[param.name] = pubkey
+        values: list[Any] = []
+        for param in instr.data_params:
+            if param.name in kwargs:
+                value = kwargs[param.name]
+                values.append(_as_pubkey(value) if _is_keypair(value) else value)
+            elif param.name == "bump" and len(bumps) == 1:
+                values.append(bumps[0])
+            else:
+                raise TypeError(f"missing argument {param.name}")
+        if not signers:
+            raise TypeError("pass a keypair for the signer")
+        fn = getattr(self.client, instr.snake_name)
+        ix = fn(self.program_id, *[pubkeys[param.name] for param in instr.account_params], *values)
+        raw = self._send_raw(ix, signers)
+        result = self._result(raw, used)
+        self.addresses.update(used)
+        self._last = result
+        if not result.ok and self._expect is None:
+            raise ProgramFailed(self._failure_text(result))
+        return result
+
+    def _send_raw(self, ix: Any, signers: list[Any]) -> Any:
+        expire = getattr(self.svm, "expire_blockhash", None)
+        if callable(expire):
+            expire()
+        blockhash = self.svm.latest_blockhash()
+        message = _solders()["Message"].new_with_blockhash([ix], signers[0].pubkey(), blockhash)
+        tx = _solders()["Transaction"](signers, message, blockhash)
+        return self.svm.send_transaction(tx)
+
+    def _result(self, raw: Any, accounts: dict[str, Any]) -> CallResult:
+        logs = _logs(raw)
+        ok = not _failed(raw)
+        return CallResult(
+            ok=ok,
+            logs=logs,
+            compute_units=_compute_units(raw, logs),
+            error_code=None if ok else _error_code(raw),
+            accounts=dict(accounts),
+        )
+
+    def _failure_text(self, result: CallResult) -> str:
+        body = "\n".join(result.logs)
+        return f"program failed with {result.error_code}\n{body}"
+
+
+@pytest.fixture(scope="module")
+def pythsol_target() -> PythsolTarget:
+    """Built artifacts. ``pythsol test`` sets the environment this reads."""
+    so = os.environ.get("PYTHSOL_TEST_SO")
+    source = os.environ.get("PYTHSOL_TEST_SOURCE")
+    client = os.environ.get("PYTHSOL_TEST_CLIENT")
+    if not so or not source or not client:
+        pytest.skip("PYTHSOL_TEST_SO is not set; run pythsol test")
+    program_id = os.environ.get("PYTHSOL_PROGRAM_ID") or DEFAULT_PROGRAM_ID
+    return PythsolTarget(Path(source), Path(so), Path(client), program_id)
+
+
+@pytest.fixture
+def svm(pythsol_target: PythsolTarget) -> Any:
+    """A fresh LiteSVM with the program loaded."""
+    _need_solders()
+    vm = _solders()["LiteSVM"]()
+    program_id = _solders()["Pubkey"].from_string(pythsol_target.program_id)
+    vm.add_program(program_id, pythsol_target.so.read_bytes())
+    return vm
+
+
+@pytest.fixture
+def payer(svm: Any) -> Any:
+    """A funded fee-payer keypair."""
+    _need_solders()
+    kp = _solders()["Keypair"]()
+    svm.airdrop(kp.pubkey(), FAUCET_LAMPORTS)
+    return kp
+
+
+@pytest.fixture
+def program(svm: Any, payer: Any, pythsol_target: PythsolTarget) -> LoadedProgram:
+    """Instruction helpers bound to ``svm``."""
+    _need_solders()
+    return LoadedProgram(svm, payer, pythsol_target)
+
+
+@pytest.fixture
+def accounts(program: LoadedProgram) -> dict[str, Any]:
+    """Account name to pubkey, filled in as instructions run."""
+    return program.addresses
+
+
+@pytest.fixture
+def send(program: LoadedProgram) -> Any:
+    """``send(ix, signers)`` for a hand-built instruction."""
+    return program.send_ix

pythsol-0.1.0.dist-info/METADATA

@@ -0,0 +1,178 @@
+Metadata-Version: 2.5
+Name: pythsol
+Version: 0.1.0
+Summary: PythSol: write Solana programs in a typed Python subset, compiled to native SBF.
+Project-URL: Homepage, https://github.com/PythSol/pythsol
+Project-URL: Repository, https://github.com/PythSol/pythsol
+Project-URL: Issues, https://github.com/PythSol/pythsol/issues
+Project-URL: Changelog, https://github.com/PythSol/pythsol/blob/main/CHANGELOG.md
+Author: PythSol contributors
+License-Expression: Apache-2.0
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Requires-Dist: click>=8.1
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: hatchling>=1.24; extra == 'dev'
+Requires-Dist: mypy>=1.10; extra == 'dev'
+Requires-Dist: pyright>=1.1.350; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Provides-Extra: test
+Requires-Dist: pytest-cov>=4; extra == 'test'
+Requires-Dist: pytest>=8; extra == 'test'
+Requires-Dist: solana>=0.41; extra == 'test'
+Requires-Dist: solders<0.30,>=0.27; extra == 'test'
+Description-Content-Type: text/markdown
+
+# PythSol
+
+Write Solana programs in **typed Python**, compiled to native SBF bytecode — no Rust on your machine.
+
+> **Status: compiler through SPL token CPI, plus the local CLI.** `pythsol check`
+> type-checks a typed Python subset. `pythsol build` compiles it to a native
+> SBF `.so`, an Anchor-style IDL, and a solders client. A second build of the
+> same C prints `cache hit (skipped clang)`. `pythsol test` runs pytest against
+> LiteSVM. The counter and ledger examples run there, and so do a one-byte
+> `@enum` gate, a fixed-width `Option[u64]` note, a `FixedString[8]` label, a
+> till whose fee is an inlined helper, a spot account whose `Point` is packed
+> inline, a vault whose PDA seed, has-one, address, owner, and close are
+> checked by the program, a bell that `emit`s a fixed-width event, a pay
+> instruction whose `system_transfer` moves lamports, and a token move whose
+> `token_transfer`, `token2022_transfer`, and `ata_create` CPIs run against
+> the programs LiteSVM already loads. A program may split across sibling
+> modules (`from acct import Counter`); those files are parsed and are never
+> imported or executed.
+> `pythsol serve` can also compile that program to a `.so` on your machine
+> when the SBF tools are installed.
+> `Vec[T, N]` is a fixed-capacity list. A data enum is a tag plus one
+> reserved scalar (`Fill: u64`), so later fields stay put. A
+> `system_transfer` from a program PDA moves lamports directly. Still ahead:
+> unbounded `Vec[T]`, in-browser SBF compile, and translated docs. Host the
+> static site from `web/docs/dist` after `npm run build`. Host the full
+> playground (check + emit + compile) with Docker — see
+> `docs/guides/hosting.md` (also `/v1/compile` behind `--allow-compile`).
+> Without that flag a public server checks and emits only. The checklist is
+> `docs/STATUS.md`. This tree is version 0.1.0 and is not a release.
+
+Source of truth: `docs/spec/PRD.md` (scope) + `docs/spec/TRD.md` (how).
+When possible ADRs under `docs/decisions/` record every assumption that was validated.
+
+```python
+from pythsol import (
+    Init, Mut, ProgramError, Pubkey, Signer, account, error, instruction, require, u64, u8,
+)
+
+@account
+class Counter:
+    authority: Pubkey
+    count: u64
+    bump: u8
+
+@error
+class CounterError(ProgramError):
+    Unauthorized = 100
+    Overflow = 101
+
+@instruction
+def increment(authority: Signer, counter: Mut[Counter], by: u64) -> None:
+    require(counter.authority == authority.key, CounterError.Unauthorized)
+    counter.count += by   # overflow-checked
+```
+
+## Install
+
+```bash
+pip install -e ".[test]"  # developer install, with pytest and solders
+pip install pythsol       # compiler and CLI only (when published)
+```
+
+`pythsol test` needs the `test` extra. Until you reinstall the editable package,
+the pytest plugin is not on the entry-point list. `pythsol test` still loads it
+with `PYTEST_DISABLE_PLUGIN_AUTOLOAD=1` and `-p pythsol.testing.plugin`.
+
+## CLI
+
+```bash
+pythsol doctor            # check toolchain, Python, RPC
+pythsol init app --template counter   # or ledger, vault, escrow
+pythsol check counter.py  # full front-end type check; exit 1 with PSxxxx diagnostics
+pythsol check --json counter.py
+pythsol idl counter.py    # Anchor-style IDL, no SBF toolchain
+pythsol build counter.py  # native SBF .so + IDL + client + manifest
+pythsol test              # build, then pytest on LiteSVM
+pythsol client counter.py -o client.py
+pythsol cpi counter.py -o cpi.py      # off-chain builders; not an on-chain invoke
+pythsol port idl.json -o sketch.py    # skeleton with pass bodies
+pythsol deploy --dry-run --so prog.so # prints solana program deploy; mainnet needs --yes
+pythsol faucet --amount 1             # devnet only, at most 5 SOL
+pythsol wallet new --outfile id.json  # secret stays off the terminal unless --show-secret
+pythsol verify --left a.so --right b.so   # exit 0 match, exit 3 mismatch
+pythsol profile --logs run.log        # reads "consumed N of" lines already in the log
+pythsol idl-publish --address <ID> --dry-run
+pythsol serve                         # loopback playground, 127.0.0.1:8765
+pythsol docs                          # offline command list
+pysol doctor                          # `pysol` is the spec-draft alias of the same CLI
+```
+
+## Build
+
+`pythsol build programs/counter.py` emits `target/pythsol/counter/`:
+
+| file            | contents                                                      |
+|-----------------|---------------------------------------------------------------|
+| `counter.c`            | auditable C generated from your program (never hand-edited) |
+| `counter.so`           | the SBF ELF deployed on-chain                               |
+| `counter.json`         | Anchor-style legacy IDL                                     |
+| `counter_client.py`    | solders `Instruction` builders and account decoders         |
+| `manifest.json`        | sha256 of c/idl/so/client, toolchain info, and `cache` (`hit`, `miss`, or `off`) |
+
+On-chain guarantees: `require()` failures log `(file:line)` and return
+`6000 + index`; integer arithmetic never wraps (checked ops abort with 1009/1010);
+`Init` accounts are PDAs created through a System-program CPI with your seeds.
+The binary ABI conventions are pinned in
+[ADR-0010](docs/decisions/ADR-0010-runtime-abi-and-input-layout.md).
+
+## Phases
+
+| Phase | Deliverable | Status |
+|---|---|---|
+| 0 | monorepo skeleton, ADRs, CI, license, name spike | **done** |
+| 1 | SBF toolchain locator + doctor, C→SBF spike, LiteSVM spike | **done** |
+| 2 | parse/subset/type-check front-end, `pythsol check`, 40+ negative fixtures | **done** |
+| 3 | ProgramModel, IDL, C runtime/emitter, `pythsol build`, LiteSVM acceptance | **done** |
+| 4 | if/while/for, casts, full integer widths, `FixedArray`, checked expressions | **done** |
+| 5 | Python client (`*_client.py`, solders) | **done** |
+| 6 | `pythsol test`, pytest plugin, build cache, wallet, faucet, deploy, `pysol.toml` | **done** |
+| 7 | Starlight scaffold and light tokens (`web/docs`, `web/shared-tokens`) | **done** (live at `/docs`; no Lighthouse run) |
+| 8 | `pythsol serve` loopback check, emit, and compile | **live check/emit** (hosted compile pending Render) |
+| 9 | gallery of the six examples, `pythsol port`, migration and contributor notes | **partial** (six examples, not twenty) |
+| 10 | `verify`, `profile`, `idl-publish`, `cpi`, VS Code diagnostics | **partial** (no audit, no CU gate) |
+| 11 | docs translations, a second IR, in-browser SBF | **not scheduled** |
+| … | unit enums (`@enum`, `match`) | **done** |
+| … | fixed-width `Option[T]` (tag + reserved value) | **done** |
+| … | fixed-width `FixedString[N]` (`u32` length + reserved bytes) | **done** |
+| … | plain helpers (inlined, not instructions) | **done** |
+| … | nested `@struct` (fixed width, inline, no discriminator) | **done** |
+| … | constraints `Seeds` / `HasOne` / `Address` / `Owner` / `CloseTo` | **done** |
+| … | alias refusal peels constraint wrappers | **done** |
+| … | `@event` and `emit` (fixed-width log) | **done** |
+| … | `system_transfer` (System program CPI) | **done** |
+| … | SPL Token, Token-2022, and ATA CPIs | **done** |
+| … | multi-file programs (sibling modules, parsed not executed) | **done** |
+| … | `Vec[T, N]`, fixed-width data enums, PDA lamport move | **done** |
+| … | hosted playground deploy configs (Docker/Fly/Render, `--allow-compile`) | **done** |
+| … | browser-side devnet deploy button | later |
+| … | unbounded `Vec[T]`, in-browser WASM clang | later |
+
+## License
+
+Apache-2.0. See [LICENSE](./LICENSE) and [docs/decisions/ADR-0002](docs/decisions/ADR-0002-license.md).