alberta-buck-core 0.1.0__tar.gz

alberta_buck_core-0.1.0/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: alberta-buck-core
+Version: 0.1.0
+Summary: Alberta Buck core platform (Python): the ChainSession API over anvil/testnets/pyrevm with expectation journaling, and the Foundry artifact loader
+Author-email: Perry Kundert <perry@dominionrnd.com>
+License-Expression: CAL-1.0
+Project-URL: Homepage, https://github.com/alberta-buck/alberta-buck
+Project-URL: Bug Tracker, https://github.com/alberta-buck/alberta-buck/issues
+Keywords: ethereum,stablecoin,simulation,web3
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: web3>=7
+Requires-Dist: alberta-buck-contracts>=0.1.0
+Provides-Extra: kernel
+Requires-Dist: alberta-buck-kernel>=0.1.0; extra == "kernel"
+
+# alberta-buck-core
+
+The Python side of the Alberta Buck platform: one testing API over every
+EVM backend, with expectation checking and journaling.
+
+- **`Web3Session`** -- the ChainSession API. Send, call and deploy against
+  anvil, a public testnet, or in-process pyrevm with the same code. Every
+  state-changing operation declares whether it is expected to succeed or
+  revert, so expectation mismatches are first-class results rather than
+  surprises.
+- **Journal** -- an append-only JSONL record of every operation: tag, op,
+  sender, expectation, outcome, gas, tx hash, block, error. Journals are
+  auditable, diffable across backends *and across languages* (the
+  JavaScript platform writes the same schema), and replayable.
+- **`load_artifact`** -- contract artifacts from a repo checkout's `out/`
+  when there is one, falling back to the installed
+  [`alberta-buck-contracts`](https://pypi.org/project/alberta-buck-contracts/)
+  otherwise, so an installed package can deploy a world with no checkout.
+
+## Install
+
+```sh
+pip install alberta-buck-core
+```
+
+The distribution is prefixed; the import is not:
+
+```python
+from buck_core import Web3Session, Expect, load_artifact
+```
+
+## The compiled kernels are optional
+
+`buck_core.buck_math`, `buck_core.buck_identity`, `buck_core.buck_wallet`
+and `buck_core.buck_registry` are shims that delegate to
+[`alberta-buck-kernel`](https://pypi.org/project/alberta-buck-kernel/) when
+it is installed. This package is deliberately a pure-Python wheel: keeping
+the binaries out means depending on the session API does not drag a
+per-platform wheel matrix behind it.
+
+In a repo checkout the built `.so` sits beside the shim and CPython prefers
+the extension, so a freshly rebuilt kernel takes effect immediately.
+
+## Status
+
+0.1.0, prototype. Unaudited software for a monetary system, published so
+the simulation and identity work can be reproduced and built on.
+
+## Licence
+
+CAL-1.0 (Cryptographic Autonomy License v1.0). Beyond the usual copyleft,
+CAL requires that anyone you provide this software's functionality to
+receives their own data and is not locked out of it by cryptographic or
+technical means. See
+[LICENSING.md](https://github.com/alberta-buck/alberta-buck/blob/master/LICENSING.md).
+
+Repository: <https://github.com/alberta-buck/alberta-buck>

alberta_buck_core-0.1.0/README.md

@@ -0,0 +1,57 @@
+# alberta-buck-core
+
+The Python side of the Alberta Buck platform: one testing API over every
+EVM backend, with expectation checking and journaling.
+
+- **`Web3Session`** -- the ChainSession API. Send, call and deploy against
+  anvil, a public testnet, or in-process pyrevm with the same code. Every
+  state-changing operation declares whether it is expected to succeed or
+  revert, so expectation mismatches are first-class results rather than
+  surprises.
+- **Journal** -- an append-only JSONL record of every operation: tag, op,
+  sender, expectation, outcome, gas, tx hash, block, error. Journals are
+  auditable, diffable across backends *and across languages* (the
+  JavaScript platform writes the same schema), and replayable.
+- **`load_artifact`** -- contract artifacts from a repo checkout's `out/`
+  when there is one, falling back to the installed
+  [`alberta-buck-contracts`](https://pypi.org/project/alberta-buck-contracts/)
+  otherwise, so an installed package can deploy a world with no checkout.
+
+## Install
+
+```sh
+pip install alberta-buck-core
+```
+
+The distribution is prefixed; the import is not:
+
+```python
+from buck_core import Web3Session, Expect, load_artifact
+```
+
+## The compiled kernels are optional
+
+`buck_core.buck_math`, `buck_core.buck_identity`, `buck_core.buck_wallet`
+and `buck_core.buck_registry` are shims that delegate to
+[`alberta-buck-kernel`](https://pypi.org/project/alberta-buck-kernel/) when
+it is installed. This package is deliberately a pure-Python wheel: keeping
+the binaries out means depending on the session API does not drag a
+per-platform wheel matrix behind it.
+
+In a repo checkout the built `.so` sits beside the shim and CPython prefers
+the extension, so a freshly rebuilt kernel takes effect immediately.
+
+## Status
+
+0.1.0, prototype. Unaudited software for a monetary system, published so
+the simulation and identity work can be reproduced and built on.
+
+## Licence
+
+CAL-1.0 (Cryptographic Autonomy License v1.0). Beyond the usual copyleft,
+CAL requires that anyone you provide this software's functionality to
+receives their own data and is not locked out of it by cryptographic or
+technical means. See
+[LICENSING.md](https://github.com/alberta-buck/alberta-buck/blob/master/LICENSING.md).
+
+Repository: <https://github.com/alberta-buck/alberta-buck>

alberta_buck_core-0.1.0/alberta_buck_core.egg-info/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: alberta-buck-core
+Version: 0.1.0
+Summary: Alberta Buck core platform (Python): the ChainSession API over anvil/testnets/pyrevm with expectation journaling, and the Foundry artifact loader
+Author-email: Perry Kundert <perry@dominionrnd.com>
+License-Expression: CAL-1.0
+Project-URL: Homepage, https://github.com/alberta-buck/alberta-buck
+Project-URL: Bug Tracker, https://github.com/alberta-buck/alberta-buck/issues
+Keywords: ethereum,stablecoin,simulation,web3
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: web3>=7
+Requires-Dist: alberta-buck-contracts>=0.1.0
+Provides-Extra: kernel
+Requires-Dist: alberta-buck-kernel>=0.1.0; extra == "kernel"
+
+# alberta-buck-core
+
+The Python side of the Alberta Buck platform: one testing API over every
+EVM backend, with expectation checking and journaling.
+
+- **`Web3Session`** -- the ChainSession API. Send, call and deploy against
+  anvil, a public testnet, or in-process pyrevm with the same code. Every
+  state-changing operation declares whether it is expected to succeed or
+  revert, so expectation mismatches are first-class results rather than
+  surprises.
+- **Journal** -- an append-only JSONL record of every operation: tag, op,
+  sender, expectation, outcome, gas, tx hash, block, error. Journals are
+  auditable, diffable across backends *and across languages* (the
+  JavaScript platform writes the same schema), and replayable.
+- **`load_artifact`** -- contract artifacts from a repo checkout's `out/`
+  when there is one, falling back to the installed
+  [`alberta-buck-contracts`](https://pypi.org/project/alberta-buck-contracts/)
+  otherwise, so an installed package can deploy a world with no checkout.
+
+## Install
+
+```sh
+pip install alberta-buck-core
+```
+
+The distribution is prefixed; the import is not:
+
+```python
+from buck_core import Web3Session, Expect, load_artifact
+```
+
+## The compiled kernels are optional
+
+`buck_core.buck_math`, `buck_core.buck_identity`, `buck_core.buck_wallet`
+and `buck_core.buck_registry` are shims that delegate to
+[`alberta-buck-kernel`](https://pypi.org/project/alberta-buck-kernel/) when
+it is installed. This package is deliberately a pure-Python wheel: keeping
+the binaries out means depending on the session API does not drag a
+per-platform wheel matrix behind it.
+
+In a repo checkout the built `.so` sits beside the shim and CPython prefers
+the extension, so a freshly rebuilt kernel takes effect immediately.
+
+## Status
+
+0.1.0, prototype. Unaudited software for a monetary system, published so
+the simulation and identity work can be reproduced and built on.
+
+## Licence
+
+CAL-1.0 (Cryptographic Autonomy License v1.0). Beyond the usual copyleft,
+CAL requires that anyone you provide this software's functionality to
+receives their own data and is not locked out of it by cryptographic or
+technical means. See
+[LICENSING.md](https://github.com/alberta-buck/alberta-buck/blob/master/LICENSING.md).
+
+Repository: <https://github.com/alberta-buck/alberta-buck>

alberta_buck_core-0.1.0/alberta_buck_core.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+README.md
+pyproject.toml
+alberta_buck_core.egg-info/PKG-INFO
+alberta_buck_core.egg-info/SOURCES.txt
+alberta_buck_core.egg-info/dependency_links.txt
+alberta_buck_core.egg-info/requires.txt
+alberta_buck_core.egg-info/top_level.txt
+buck_core/__init__.py
+buck_core/artifacts.py
+buck_core/buck_identity.py
+buck_core/buck_math.py
+buck_core/buck_registry.py
+buck_core/buck_wallet.py
+buck_core/session.py
+tests/test_identity_vectors.py
+tests/test_journal_fixture.py
+tests/test_math_vectors.py
+tests/test_registry_vectors.py
+tests/test_session.py
+tests/test_wallet_vectors.py

alberta_buck_core-0.1.0/alberta_buck_core.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

alberta_buck_core-0.1.0/alberta_buck_core.egg-info/requires.txt

@@ -0,0 +1,5 @@
+web3>=7
+alberta-buck-contracts>=0.1.0
+
+[kernel]
+alberta-buck-kernel>=0.1.0

alberta_buck_core-0.1.0/alberta_buck_core.egg-info/top_level.txt

@@ -0,0 +1 @@
+buck_core

alberta_buck_core-0.1.0/buck_core/__init__.py

@@ -0,0 +1,19 @@
+"""Alberta Buck core platform (Python).
+
+See alberta-buck-platform.org for the architecture.  Layer 1 lives here
+today: the ChainSession API (buck_core.session) and the Foundry artifact
+helpers (buck_core.artifacts).  Layer 2 kernels (buck-math, buck-identity)
+arrive as PyO3 bindings re-exported from this package.
+
+Dependency rule: buck_core never imports alberta_buck.
+"""
+
+from buck_core.artifacts import load_artifact, repo_root
+from buck_core.session import (
+    CALL_GAS, DEPLOY_GAS, Expect, Journal, Web3Session,
+)
+
+__all__ = [
+    "CALL_GAS", "DEPLOY_GAS", "Expect", "Journal", "Web3Session",
+    "load_artifact", "repo_root",
+]

alberta_buck_core-0.1.0/buck_core/artifacts.py

@@ -0,0 +1,68 @@
+"""Foundry artifact + repo-checkout helpers.
+
+Lifted verbatim from alberta_buck/sim/chain.py (which now re-exports these
+names) so that core never imports alberta_buck; see alberta-buck-platform.org.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+
+
+def repo_root() -> Path:
+    """The repository checkout root -- needed for the Foundry artifacts
+    (out/) and contract sources the live-EVM helpers consume.
+
+    Resolution order: the ``ALBERTA_BUCK_REPO`` env var; walking up from this
+    file (a repo checkout / editable install); walking up from the cwd (a
+    venv-installed package run from inside the repo).  ``foundry.toml`` is
+    the marker.  Raises FileNotFoundError when no repo is reachable -- the
+    fixture-only paths (package data) do not need one.
+    """
+    env = os.environ.get("ALBERTA_BUCK_REPO")
+    candidates = ([Path(env)] if env else []) + [
+        Path(__file__).resolve(), Path.cwd().resolve()]
+    for start in candidates:
+        for p in (start, *start.parents):
+            if (p / "foundry.toml").exists():
+                return p
+    raise FileNotFoundError(
+        "alberta-buck repo root not found (looked for foundry.toml from "
+        f"{[str(c) for c in candidates]}); set ALBERTA_BUCK_REPO or run "
+        "from inside the repo checkout")
+
+
+def load_artifact(name: str, sol_file: str | None = None) -> tuple[list, str]:
+    """Return (abi, bytecode) for a contract.
+
+    Resolution order:
+
+    1. ``out/<sol_file or name>.sol/<name>.json`` in a repo checkout -- the
+       developer path, unchanged: a freshly built artifact always wins, so
+       editing a contract and rebuilding takes effect immediately.
+    2. the installed ``alberta-buck-contracts`` package.
+
+    The fallback is what lets a pip-installed ``alberta_buck`` deploy a
+    world at all: ``repo_root()`` raises ``FileNotFoundError`` when no
+    ``foundry.toml`` is reachable, so without it an installed package could
+    import fine and then fail on its first deploy (see
+    alberta-buck-deployment.org, P2.5).
+    """
+    try:
+        f = repo_root() / "out" / f"{sol_file or name}.sol" / f"{name}.json"
+        art = json.loads(f.read_text())
+        return art["abi"], art["bytecode"]["object"]
+    except (FileNotFoundError, OSError):
+        pass
+
+    try:
+        import buck_contracts
+    except ImportError:
+        raise FileNotFoundError(
+            f"no artifact for {name}: not in a repo checkout with out/ built "
+            f"(run `make build`), and alberta-buck-contracts is not installed "
+            f"(pip install alberta-buck-contracts)") from None
+
+    return buck_contracts.artifact(name)

alberta_buck_core-0.1.0/buck_core/buck_identity.py

@@ -0,0 +1,20 @@
+"""Compatibility shim: ``buck_core.buck_identity`` -> ``buck_kernel.buck_identity``.
+
+The compiled kernels moved out of this package so that alberta-buck-core
+can be a pure-Python wheel -- otherwise every consumer of the session and
+journal API would drag the whole Rust wheel matrix behind it.  They now
+ship separately as alberta-buck-kernel.
+
+Callers keep saying ``import buck_core.buck_identity``.  In a repo checkout the
+built ``buck_identity.so`` sits beside this file and CPython prefers the
+extension, so a freshly rebuilt kernel wins.  Installed from wheels there
+is no .so here and this shim delegates.  When alberta-buck-kernel is not
+installed the ImportError is exactly what the backend selector in
+alberta_buck.wallet._kernel expects: it falls back to pure Python.
+"""
+
+import sys
+
+from buck_kernel import buck_identity as _mod
+
+sys.modules[__name__] = _mod

alberta_buck_core-0.1.0/buck_core/buck_math.py

@@ -0,0 +1,20 @@
+"""Compatibility shim: ``buck_core.buck_math`` -> ``buck_kernel.buck_math``.
+
+The compiled kernels moved out of this package so that alberta-buck-core
+can be a pure-Python wheel -- otherwise every consumer of the session and
+journal API would drag the whole Rust wheel matrix behind it.  They now
+ship separately as alberta-buck-kernel.
+
+Callers keep saying ``import buck_core.buck_math``.  In a repo checkout the
+built ``buck_math.so`` sits beside this file and CPython prefers the
+extension, so a freshly rebuilt kernel wins.  Installed from wheels there
+is no .so here and this shim delegates.  When alberta-buck-kernel is not
+installed the ImportError is exactly what the backend selector in
+alberta_buck.wallet._kernel expects: it falls back to pure Python.
+"""
+
+import sys
+
+from buck_kernel import buck_math as _mod
+
+sys.modules[__name__] = _mod

alberta_buck_core-0.1.0/buck_core/buck_registry.py

@@ -0,0 +1,20 @@
+"""Compatibility shim: ``buck_core.buck_registry`` -> ``buck_kernel.buck_registry``.
+
+The compiled kernels moved out of this package so that alberta-buck-core
+can be a pure-Python wheel -- otherwise every consumer of the session and
+journal API would drag the whole Rust wheel matrix behind it.  They now
+ship separately as alberta-buck-kernel.
+
+Callers keep saying ``import buck_core.buck_registry``.  In a repo checkout the
+built ``buck_registry.so`` sits beside this file and CPython prefers the
+extension, so a freshly rebuilt kernel wins.  Installed from wheels there
+is no .so here and this shim delegates.  When alberta-buck-kernel is not
+installed the ImportError is exactly what the backend selector in
+alberta_buck.wallet._kernel expects: it falls back to pure Python.
+"""
+
+import sys
+
+from buck_kernel import buck_registry as _mod
+
+sys.modules[__name__] = _mod

alberta_buck_core-0.1.0/buck_core/buck_wallet.py

@@ -0,0 +1,20 @@
+"""Compatibility shim: ``buck_core.buck_wallet`` -> ``buck_kernel.buck_wallet``.
+
+The compiled kernels moved out of this package so that alberta-buck-core
+can be a pure-Python wheel -- otherwise every consumer of the session and
+journal API would drag the whole Rust wheel matrix behind it.  They now
+ship separately as alberta-buck-kernel.
+
+Callers keep saying ``import buck_core.buck_wallet``.  In a repo checkout the
+built ``buck_wallet.so`` sits beside this file and CPython prefers the
+extension, so a freshly rebuilt kernel wins.  Installed from wheels there
+is no .so here and this shim delegates.  When alberta-buck-kernel is not
+installed the ImportError is exactly what the backend selector in
+alberta_buck.wallet._kernel expects: it falls back to pure Python.
+"""
+
+import sys
+
+from buck_kernel import buck_wallet as _mod
+
+sys.modules[__name__] = _mod