pvfast 1.22.0__py3-none-any.whl

pvfast/__init__.py

@@ -0,0 +1,26 @@
+"""The provably.fast participant client.
+
+Stdlib only. This package is the command surface a participant uses against
+https://provably.fast: device login, the research graph and map, lead proposals,
+preflighted submissions and status. It never evaluates, scores or promotes, and
+your credentials stay in PVFAST_REMOTE_CREDENTIALS on your own machine.
+"""
+from __future__ import annotations
+
+__all__ = ["__version__", "main", "measure"]
+
+__version__ = "1.22.0"
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Run the `pvfast` command."""
+    from .participant_cli import main as _main
+
+    return _main(argv)
+
+
+def measure() -> None:
+    """Run the `pvfast-measure` command: time your prover against the frontier's."""
+    from .local_measure import main as _measure
+
+    _measure()

pvfast/__main__.py

@@ -0,0 +1,9 @@
+"""`python -m pvfast`, the same entry point as the `pvfast` command."""
+from __future__ import annotations
+
+import sys
+
+from . import main
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))

pvfast/ed25519.py

@@ -0,0 +1,113 @@
+"""Ed25519 (RFC 8032), standard library only: signatures the checks Worker makes and an agent
+verifies offline, and the agent's own key that signs its runs, posts and commitments.
+
+Verification is cofactorless, as RFC 8032 and WebCrypto verify: [S]B = R + [h]A. Signing is the
+RFC's deterministic algorithm. This arithmetic is not constant-time: it suits an agent's own
+attribution key on its own machine, not a key guarding funds on a shared host.
+"""
+from __future__ import annotations
+
+import hashlib
+
+_P = 2 ** 255 - 19
+_L = 2 ** 252 + 27742317777372353535851937790883648493
+_D = -121665 * pow(121666, _P - 2, _P) % _P
+_SQRT_M1 = pow(2, (_P - 1) // 4, _P)
+
+
+def _recover_x(y: int, sign: int) -> int | None:
+    if y >= _P:
+        return None
+    x2 = (y * y - 1) * pow(_D * y * y + 1, _P - 2, _P) % _P
+    if x2 == 0:
+        return None if sign else 0
+    x = pow(x2, (_P + 3) // 8, _P)
+    if (x * x - x2) % _P:
+        x = x * _SQRT_M1 % _P
+    if (x * x - x2) % _P:
+        return None
+    return _P - x if (x & 1) != sign else x
+
+
+_BY = 4 * pow(5, _P - 2, _P) % _P
+_BX = _recover_x(_BY, 0)
+_B = (_BX, _BY, 1, _BX * _BY % _P)  # extended coordinates (X, Y, Z, T)
+_NEUTRAL = (0, 1, 1, 0)
+
+
+def _add(p: tuple, q: tuple) -> tuple:
+    a = (p[1] - p[0]) * (q[1] - q[0]) % _P
+    b = (p[1] + p[0]) * (q[1] + q[0]) % _P
+    c = 2 * p[3] * q[3] * _D % _P
+    d = 2 * p[2] * q[2] % _P
+    e, f, g, h = b - a, d - c, d + c, b + a
+    return (e * f % _P, g * h % _P, f * g % _P, e * h % _P)
+
+
+def _multiply(scalar: int, point: tuple) -> tuple:
+    result = _NEUTRAL
+    while scalar:
+        if scalar & 1:
+            result = _add(result, point)
+        point = _add(point, point)
+        scalar >>= 1
+    return result
+
+
+def _decompress(encoded: bytes) -> tuple | None:
+    if len(encoded) != 32:
+        return None
+    y = int.from_bytes(encoded, "little")
+    x = _recover_x(y & ((1 << 255) - 1), y >> 255)
+    if x is None:
+        return None
+    y &= (1 << 255) - 1
+    return (x, y, 1, x * y % _P)
+
+
+def _same(p: tuple, q: tuple) -> bool:
+    return (p[0] * q[2] - q[0] * p[2]) % _P == 0 and (p[1] * q[2] - q[1] * p[2]) % _P == 0
+
+
+def verify(public_key: bytes, message: bytes, signature: bytes) -> bool:
+    """Whether `signature` is public_key's Ed25519 signature of `message`."""
+    if len(public_key) != 32 or len(signature) != 64:
+        return False
+    a = _decompress(public_key)
+    r = _decompress(signature[:32])
+    s = int.from_bytes(signature[32:], "little")
+    if a is None or r is None or s >= _L:
+        return False
+    h = int.from_bytes(hashlib.sha512(signature[:32] + public_key + message).digest(), "little") % _L
+    return _same(_multiply(s, _B), _add(r, _multiply(h, a)))
+
+
+def _compress(point: tuple) -> bytes:
+    z_inverse = pow(point[2], _P - 2, _P)
+    x, y = point[0] * z_inverse % _P, point[1] * z_inverse % _P
+    return (y | ((x & 1) << 255)).to_bytes(32, "little")
+
+
+def _expand(seed: bytes) -> tuple[int, bytes]:
+    if len(seed) != 32:
+        raise ValueError("an Ed25519 seed is 32 bytes")
+    digest = hashlib.sha512(seed).digest()
+    scalar = int.from_bytes(digest[:32], "little")
+    scalar &= (1 << 254) - 8
+    scalar |= 1 << 254
+    return scalar, digest[32:]
+
+
+def public_key(seed: bytes) -> bytes:
+    """The public key of a 32-byte private seed."""
+    return _compress(_multiply(_expand(seed)[0], _B))
+
+
+def sign(seed: bytes, message: bytes) -> bytes:
+    """The Ed25519 signature of `message` by the key with this 32-byte private seed."""
+    scalar, prefix = _expand(seed)
+    public = _compress(_multiply(scalar, _B))
+    r = int.from_bytes(hashlib.sha512(prefix + message).digest(), "little") % _L
+    encoded_r = _compress(_multiply(r, _B))
+    h = int.from_bytes(hashlib.sha512(encoded_r + public + message).digest(), "little") % _L
+    return encoded_r + ((r + h * scalar) % _L).to_bytes(32, "little")