astreum 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

astreum/crypto/quadratic_form.py

@@ -0,0 +1,123 @@
+import math
+
+
+def extended_gcd(a: int, b: int) -> tuple[int, int, int]:
+    """
+    Return (g, x, y) such that a*x + b*y = g = gcd(a, b).
+    """
+    if b == 0:
+        return (a, 1, 0)
+    g, x1, y1 = extended_gcd(b, a % b)
+    return (g, y1, x1 - (a // b) * y1)
+
+
+def modinv(a: int, m: int) -> int:
+    """
+    Return modular inverse of a mod m.
+    """
+    g, x, _ = extended_gcd(a, m)
+    if g != 1:
+        raise ValueError(f"No modular inverse for {a} modulo {m}")
+    return x % m
+
+
+def is_reduced(q: 'QuadraticForm') -> bool:
+    """
+    Check if the form q is in reduced (Gauss) form:
+      |b| <= a <= c, and if a == c then b >= 0.
+    """
+    return abs(q.b) <= q.a <= q.c and not (q.a == q.c and q.b < 0)
+
+
+def is_primitive(a: int, b: int, c: int) -> bool:
+    """
+    Check if the form coefficients are coprime: gcd(a, b, c) == 1.
+    """
+    return math.gcd(math.gcd(a, b), c) == 1
+
+
+class QuadraticForm:
+    """
+    Represents the binary quadratic form ax^2 + bxy + cy^2 with discriminant D,
+    stored in reduced, primitive form.
+    """
+
+    def __init__(self, a: int, b: int, c: int, D: int):
+        if b*b - 4*a*c != D:
+            raise ValueError(f"Discriminant mismatch: b^2 - 4ac = {b*b - 4*a*c}, expected {D}")
+        if not is_primitive(a, b, c):
+            raise ValueError("Form coefficients are not coprime (not primitive)")
+        self.a = a
+        self.b = b
+        self.c = c
+        self.D = D
+
+    def reduce(self) -> 'QuadraticForm':
+        """
+        Perform Gauss reduction until the form is reduced.
+        """
+        while not is_reduced(self):
+            self._gauss_step()
+        return self
+
+    def _gauss_step(self) -> None:
+        """
+        One iteration of Gauss reduction on the current form.
+        """
+        a, b, c = self.a, self.b, self.c
+        # Compute m = round(b / (2a)) using integer arithmetic
+        sign = 1 if b >= 0 else -1
+        m = (b + sign * a) // (2 * a)
+        # Update b and c
+        b_new = b - 2 * m * a
+        c_new = m * m * a - m * b + c
+        # Assign back
+        self.b = b_new
+        self.c = c_new
+        # Swap if needed to ensure a <= c and proper sign
+        if a > self.c or (a == self.c and self.b < 0):
+            self.a, self.b, self.c = self.c, -self.b, a
+
+    def __mul__(self, other: 'QuadraticForm') -> 'QuadraticForm':
+        """
+        Dirichlet (NUCOMP) composition of two forms of the same discriminant.
+        """
+        if self.D != other.D:
+            raise ValueError("Cannot compose forms with different discriminants")
+        a1, b1, c1 = self.a, self.b, self.c
+        a2, b2, c2 = other.a, other.b, other.c
+        D = self.D
+        # Compute g = gcd(a1, a2, (b1 + b2)//2)
+        k = (b1 + b2) // 2
+        g = math.gcd(math.gcd(a1, a2), k)
+        a1p = a1 // g
+        a2p = a2 // g
+        # Solve m * a1p ≡ (b2 - b1)//2 mod a2p
+        diff = (b2 - b1) // 2
+        inv = modinv(a1p, a2p)
+        m = (diff * inv) % a2p
+        # Compute composed coefficients
+        b3 = b1 + 2 * m * a1
+        a3 = a1 * a2p
+        c3 = (b3 * b3 - D) // (4 * a3)
+        return QuadraticForm(a3, b3, c3, D).reduce()
+
+    def to_bytes(self) -> bytes:
+        """
+        Serialize this form to bytes (a and b, big-endian, fixed width).
+        """
+        # Width: enough to hold |D| bitlength / 8 rounded up
+        width = (self.D.bit_length() + 15) // 8
+        return self.a.to_bytes(width, 'big', signed=True) + \
+               self.b.to_bytes(width, 'big', signed=True)
+
+    @classmethod
+    def from_bytes(cls, data: bytes, D: int) -> 'QuadraticForm':
+        """
+        Deserialize bytes back into a QuadraticForm for discriminant D.
+        """
+        width = len(data) // 2
+        a = int.from_bytes(data[:width], 'big', signed=True)
+        b = int.from_bytes(data[width:], 'big', signed=True)
+        c = (b*b - D) // (4 * a)
+        return cls(a, b, c, D).reduce()

astreum/crypto/wesolowski.py

@@ -0,0 +1,154 @@
+import hashlib
+from typing import Tuple
+from quadratic_form import QuadraticForm
+
+# --- Helper functions ---------------------------------------------------
+
+def hash_to_int(*args: bytes) -> int:
+    """
+    Hash the concatenation of args (bytes) to a large integer using SHA-256.
+    """
+    h = hashlib.sha256()
+    for b in args:
+        h.update(b)
+    return int.from_bytes(h.digest(), 'big')
+
+# --- Class-group VDF functions using QuadraticForm ----------------------
+
+def group_mul(x: QuadraticForm, y: QuadraticForm) -> QuadraticForm:
+    """
+    Compose two class-group elements via QuadraticForm multiplication.
+    """
+    return (x * y)
+
+
+def identity(D: int) -> QuadraticForm:
+    """
+    Return the identity element of the class group for discriminant D.
+    """
+    # For D ≡ 1 mod 4, identity form is (1, 1, (1-D)//4)
+    b0 = 1
+    c0 = (b0*b0 - D) // 4
+    return QuadraticForm(1, b0, c0, D)
+
+
+def class_group_square(x: QuadraticForm) -> QuadraticForm:
+    """
+    One sequential squaring step in the class group.
+    """
+    return group_mul(x, x)
+
+
+def group_exp(x: QuadraticForm, exponent: int) -> QuadraticForm:
+    """
+    Fast exponentiation in the class group by repeated squaring.
+    """
+    result = identity(x.D)
+    base = x
+    e = exponent
+    while e > 0:
+        if e & 1:
+            result = group_mul(result, base)
+        base = group_mul(base, base)
+        e >>= 1
+    return result
+
+# --- Wesolowski proof and verify ----------------------------------------
+
+def compute_wesolowski_proof(
+    x0: QuadraticForm,
+    y: QuadraticForm,
+    T: int
+) -> QuadraticForm:
+    """
+    Compute the Wesolowski proof π for VDF evaluation:
+    Solve 2^T = c * q + r, where
+      c = hash(x0 || y || T)
+    Return π = x0^q in the class group.
+    """
+    # Derive challenge c
+    h_bytes = serialize(x0) + serialize(y) + T.to_bytes((T.bit_length()+7)//8, 'big')
+    c = hash_to_int(h_bytes)
+    # Divide exponent
+    two_T = 1 << T
+    q, r = divmod(two_T, c)
+    # π = x0^q
+    return group_exp(x0, q)
+
+
+def verify_wesolowski_proof(
+    x0: QuadraticForm,
+    y: QuadraticForm,
+    pi: QuadraticForm,
+    T: int
+) -> bool:
+    """
+    Verify π satisfies: π^c * x0^r == y.
+    """
+    h_bytes = serialize(x0) + serialize(y) + T.to_bytes((T.bit_length()+7)//8, 'big')
+    c = hash_to_int(h_bytes)
+    two_T = 1 << T
+    q, r = divmod(two_T, c)
+    lhs = group_mul(group_exp(pi, c), group_exp(x0, r))
+    return lhs == y
+
+# --- Serialization helpers ----------------------------------------------
+
+def serialize(x: QuadraticForm) -> bytes:
+    """
+    Serialize a QuadraticForm to bytes.
+    """
+    return x.to_bytes()
+
+
+def deserialize(data: bytes, D: int) -> QuadraticForm:
+    """
+    Deserialize bytes into a QuadraticForm of discriminant D.
+    """
+    return QuadraticForm.from_bytes(data, D)
+
+# --- Public VDF API -----------------------------------------------------
+
+def generate(
+    old_output: bytes,
+    T: int,
+    D: int
+) -> Tuple[bytes, bytes]:
+    """
+    Evaluate the VDF by sequentially squaring the previous output 'T' times,
+    then produce a Wesolowski proof.
+
+    Returns:
+      new_output : serialized new VDF output (y)
+      proof      : serialized proof (π)
+    """
+    # Decode previous output
+    x0 = deserialize(old_output, D)
+    # Sequential squarings
+    x = x0
+    for _ in range(T):
+        x = class_group_square(x)
+    # Serialize output
+    y_bytes = serialize(x)
+    # Compute proof
+    pi = compute_wesolowski_proof(x0, x, T)
+    proof_bytes = serialize(pi)
+    return y_bytes, proof_bytes
+
+
+def verify(
+    old_output: bytes,
+    new_output: bytes,
+    proof: bytes,
+    T: int,
+    D: int
+) -> bool:
+    """
+    Verify the Wesolowski VDF proof.
+
+    Returns True if valid, False otherwise.
+    """
+    x0 = deserialize(old_output, D)
+    y  = deserialize(new_output, D)
+    pi = deserialize(proof, D)
+    return verify_wesolowski_proof(x0, y, pi, T)

astreum/node.py

@@ -289,23 +289,39 @@ class Expr:
             return f'(error "{self.message}" in {self.origin})'
 
 class Env:
-    def __init__(self, parent_id: uuid.UUID = None):
-        self.data: Dict[str, Expr] = {}
-        self.parent_id = parent_id
-
-    def put(self, name: str, value: Expr):
+    def __init__(
+        self,
+        data: Optional[Dict[str, Expr]] = None,
+        parent_id: Optional[uuid.UUID] = None,
+        max_exprs: Optional[int] = 8,
+    ):
+        self.data: Dict[str, Expr] = data if data is not None else {}
+        self.parent_id: Optional[uuid.UUID] = parent_id
+        self.max_exprs: Optional[int] = max_exprs
+
+    def put(self, name: str, value: Expr) -> None:
+        if (
+            self.max_exprs is not None
+            and name not in self.data
+            and len(self.data) >= self.max_exprs
+        ):
+            raise RuntimeError(
+                f"environment full: {len(self.data)} ≥ max_exprs={self.max_exprs}"
+            )
         self.data[name] = value
 
     def get(self, name: str) -> Optional[Expr]:
-        if name in self.data:
-            return self.data[name]
-        elif self.parent is not None:
-            return self.parent.get(name)
-        else:
-            return None
+        return self.data.get(name)
+
+    def pop(self, name: str) -> Optional[Expr]:
+        return self.data.pop(name, None)
 
-    def __repr__(self):
-        return f"Env({self.data})"
+    def __repr__(self) -> str:
+        return (
+            f"Env(size={len(self.data)}, "
+            f"max_exprs={self.max_exprs}, "
+            f"parent_id={self.parent_id})"
+        )
 
 
 class Node:
@@ -706,14 +722,19 @@ class Node:
             self.environments[env_id] = Env(parent_id=parent_id)
         return env_id
     
-    def machine_get_or_create_environment(self, env_id: Optional[uuid.UUID] = None, parent_id: Optional[uuid.UUID] = None) -> uuid.UUID:
+    def machine_get_or_create_environment(
+        self,
+        env_id: Optional[uuid.UUID] = None,
+        parent_id: Optional[uuid.UUID] = None,
+        max_exprs: Optional[int] = None
+    ) -> uuid.UUID:
         with self.machine_environments_lock:
             if env_id is not None and env_id in self.environments:
                 return env_id
             new_id = env_id if env_id is not None else uuid.uuid4()
             while new_id in self.environments:
                 new_id = uuid.uuid4()
-            self.environments[new_id] = Env(parent_id=parent_id)
+            self.environments[new_id] = Env(parent_id=parent_id, max_exprs=max_exprs)
             return new_id
 
     def machine_delete_environment(self, env_id: uuid.UUID) -> bool:
@@ -911,120 +932,90 @@ class Node:
                 #         env=env,
                 #     )
 
-                # Integer
+                # Integer arithmetic primitives
                 elif first.value == "+":
                     args = expr.elements[1:]
-                    if len(args) == 0:
-                        return Expr.Error(message="'+' expects at least 1 argument", origin=expr)
-                    evaluated_args = []
-                    for arg in args:
-                        val = self.machine_expr_eval(env_id==env_id, expr=arg)
-                        if isinstance(val, Expr.Error):
-                            return val
-                        evaluated_args.append(val)
-                    if not all(isinstance(val, Expr.Integer) for val in evaluated_args):
-                        offending = next(val for val in evaluated_args if not isinstance(val, Expr.Integer))
-                        return Expr.Error(message="'+' only accepts integer operands", origin=offending)
-                    result = sum(val.value for val in evaluated_args)
+                    if not args:
+                        return Expr.Error("'+' expects at least 1 argument", origin=expr)
+                    vals = [self.machine_expr_eval(env_id=env_id, expr=a) for a in args]
+                    for v in vals:
+                        if isinstance(v, Expr.Error): return v
+                        if not isinstance(v, Expr.Integer):
+                            return Expr.Error("'+' only accepts integer operands", origin=v)
+                    return Expr.Integer(abs(vals[0].value) if len(vals) == 1
+                                        else sum(v.value for v in vals))
+
+                elif first.value == "-":
+                    args = expr.elements[1:]
+                    if not args:
+                        return Expr.Error("'-' expects at least 1 argument", origin=expr)
+                    vals = [self.machine_expr_eval(env_id=env_id, expr=a) for a in args]
+                    for v in vals:
+                        if isinstance(v, Expr.Error): return v
+                        if not isinstance(v, Expr.Integer):
+                            return Expr.Error("'-' only accepts integer operands", origin=v)
+                    if len(vals) == 1:
+                        return Expr.Integer(-vals[0].value)
+                    result = vals[0].value
+                    for v in vals[1:]:
+                        result -= v.value
                     return Expr.Integer(result)
-                
-                # # Subtraction
-                # elif first.value == "-":
-                #     evaluated_args = [self.evaluate_expression(arg, env) for arg in expr.elements[1:]]
-
-                #     # Check for non-integer arguments
-                #     if not all(isinstance(arg, Expr.Integer) for arg in evaluated_args):
-                #         return Expr.Error(
-                #             category="TypeError",
-                #             message="All arguments to - must be integers"
-                #         )
-                    
-                #     # With only one argument, negate it
-                #     if len(evaluated_args) == 1:
-                #         return Expr.Integer(-evaluated_args[0].value)
-                    
-                #     # With multiple arguments, subtract all from the first
-                #     result = evaluated_args[0].value
-                #     for arg in evaluated_args[1:]:
-                #         result -= arg.value
-                    
-                #     return Expr.Integer(result)
-                
-                # # Multiplication
-                # elif first.value == "*":
-                #     evaluated_args = [self.evaluate_expression(arg, env) for arg in expr.elements[1:]]
 
-                #     # Check for non-integer arguments
-                #     if not all(isinstance(arg, Expr.Integer) for arg in evaluated_args):
-                #         return Expr.Error(
-                #             category="TypeError",
-                #             message="All arguments to * must be integers"
-                #         )
-                    
-                #     # Multiply all values
-                #     result = 1
-                #     for arg in evaluated_args:
-                #         result *= arg.value
-                    
-                #     return Expr.Integer(result)
-                
-                # # Division (integer division)
-                # elif first.value == "/":
-                #     evaluated_args = [self.evaluate_expression(arg, env) for arg in expr.elements[1:]]
-
-                #     # Check for non-integer arguments
-                #     if not all(isinstance(arg, Expr.Integer) for arg in evaluated_args):
-                #         return Expr.Error(
-                #             category="TypeError",
-                #             message="All arguments to / must be integers"
-                #         )
-                    
-                #     # Need exactly two arguments
-                #     if len(evaluated_args) != 2:
-                #         return Expr.Error(
-                #             category="ArgumentError",
-                #             message="The / operation requires exactly two arguments"
-                #         )
-                    
-                #     dividend = evaluated_args[0].value
-                #     divisor = evaluated_args[1].value
-                    
-                #     if divisor == 0:
-                #         return Expr.Error(
-                #             category="DivisionError",
-                #             message="Division by zero"
-                #         )
-                    
-                #     return Expr.Integer(dividend // divisor)  # Integer division
-                
-                # # Remainder (modulo)
-                # elif first.value == "%":
-                #     evaluated_args = [self.evaluate_expression(arg, env) for arg in expr.elements[1:]]
+                elif first.value == "/":
+                    args = expr.elements[1:]
+                    if len(args) < 2:
+                        return Expr.Error("'/' expects at least 2 arguments", origin=expr)
+                    vals = [self.machine_expr_eval(env_id=env_id, expr=a) for a in args]
+                    for v in vals:
+                        if isinstance(v, Expr.Error): return v
+                        if not isinstance(v, Expr.Integer):
+                            return Expr.Error("'/' only accepts integer operands", origin=v)
+                    result = vals[0].value
+                    for v in vals[1:]:
+                        if v.value == 0:
+                            return Expr.Error("division by zero", origin=v)
+                        if result % v.value:
+                            return Expr.Error("non-exact division", origin=expr)
+                        result //= v.value
+                    return Expr.Integer(result)
 
-                #     # Check for non-integer arguments
-                #     if not all(isinstance(arg, Expr.Integer) for arg in evaluated_args):
-                #         return Expr.Error(
-                #             category="TypeError",
-                #             message="All arguments to % must be integers"
-                #         )
-                    
-                #     # Need exactly two arguments
-                #     if len(evaluated_args) != 2:
-                #         return Expr.Error(
-                #             category="ArgumentError",
-                #             message="The % operation requires exactly two arguments"
-                #         )
-                    
-                #     dividend = evaluated_args[0].value
-                #     divisor = evaluated_args[1].value
-                    
-                #     if divisor == 0:
-                #         return Expr.Error(
-                #             category="DivisionError",
-                #             message="Modulo by zero"
-                #         )
-                    
-                #     return Expr.Integer(dividend % divisor)
+                elif first.value == "%":
+                    if len(expr.elements) != 3:
+                        return Expr.Error("'%' expects exactly 2 arguments", origin=expr)
+                    a = self.machine_expr_eval(env_id=env_id, expr=expr.elements[1])
+                    b = self.machine_expr_eval(env_id=env_id, expr=expr.elements[2])
+                    for v in (a, b):
+                        if isinstance(v, Expr.Error): return v
+                        if not isinstance(v, Expr.Integer):
+                            return Expr.Error("'%' only accepts integer operands", origin=v)
+                    if b.value == 0:
+                        return Expr.Error("division by zero", origin=expr.elements[2])
+                    return Expr.Integer(a.value % b.value)
+
+                elif first.value in ("=", "!=", ">", "<", ">=", "<="):
+                    args = expr.elements[1:]
+                    if len(args) != 2:
+                        return Expr.Error(f"'{first.value}' expects exactly 2 arguments", origin=expr)
+
+                    left  = self.machine_expr_eval(env_id=env_id, expr=args[0])
+                    right = self.machine_expr_eval(env_id=env_id, expr=args[1])
+
+                    for v in (left, right):
+                        if isinstance(v, Expr.Error):
+                            return v
+                        if not isinstance(v, Expr.Integer):
+                            return Expr.Error(f"'{first.value}' only accepts integer operands", origin=v)
+
+                    a, b = left.value, right.value
+                    match first.value:
+                        case "=":   res = a == b
+                        case "!=":  res = a != b
+                        case ">":   res = a >  b
+                        case "<":   res = a <  b
+                        case ">=":  res = a >= b
+                        case "<=":  res = a <= b
+
+                    return Expr.Boolean(res)
 
             else:
                 evaluated_elements = [self.machine_expr_eval(env_id=env_id, expr=e) for e in expr.elements]

{astreum-0.2.6.dist-info → astreum-0.2.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: astreum
-Version: 0.2.6
+Version: 0.2.8
 Summary: Python library to interact with the Astreum blockchain and its Lispeum virtual machine.
 Author-email: "Roy R. O. Okello" <roy@stelar.xyz>
 Project-URL: Homepage, https://github.com/astreum/lib

{astreum-0.2.6.dist-info → astreum-0.2.8.dist-info}/RECORD

@@ -1,18 +1,20 @@
 astreum/__init__.py,sha256=y2Ok3EY_FstcmlVASr80lGR_0w-dH-SXDCCQFmL6uwA,28
 astreum/format.py,sha256=X4tG5GGPweNCE54bHYkLFiuLTbmpy5upO_s1Cef-MGA,2711
-astreum/node.py,sha256=dlgnGmVq5zn3XNcGr5CjWniOpBSkqvgrenOY4IJxiGc,46383
+astreum/node.py,sha256=SswYgBq6-iJyD6dWbo3nf0_QrjNl_KifPSJsFMJ2z1Q,45941
 astreum/_node/__init__.py,sha256=7yz1YHo0DCUgUQvJf75qdUo_ocl5-XZRU-Vc2NhcvJs,18639
 astreum/_node/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/_node/storage/merkle.py,sha256=XCQBrHbwI0FuPTCUwHOy-Kva3uWbvCdw_-13hRPf1UI,10219
 astreum/_node/storage/patricia.py,sha256=tynxn_qETCU9X7yJdeh_0GHpC8Pzcoq4CWrSZlMUeRc,11546
 astreum/crypto/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 astreum/crypto/ed25519.py,sha256=FRnvlN0kZlxn4j-sJKl-C9tqiz_0z4LZyXLj3KIj1TQ,1760
+astreum/crypto/quadratic_form.py,sha256=pJgbORey2NTWbQNhdyvrjy_6yjORudQ67jBz2ScHptg,4037
+astreum/crypto/wesolowski.py,sha256=FDAX82L5cceR6DGTtUO57ZhcxpBNiskGrnLWnd_3BSw,4084
 astreum/crypto/x25519.py,sha256=i29v4BmwKRcbz9E7NKqFDQyxzFtJUqN0St9jd7GS1uA,1137
 astreum/lispeum/__init__.py,sha256=K-NDzIjtIsXzC9X7lnYvlvIaVxjFcY7WNsgLIE3DH3U,58
 astreum/lispeum/parser.py,sha256=jQRzZYvBuSg8t_bxsbt1-WcHaR_LPveHNX7Qlxhaw-M,1165
 astreum/lispeum/tokenizer.py,sha256=J-I7MEd0r2ZoVqxvRPlu-Afe2ZdM0tKXXhf1R4SxYTo,1429
-astreum-0.2.6.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
-astreum-0.2.6.dist-info/METADATA,sha256=NRBQqKmoHeFm5VY4HpBUmPlfmlVjrFAV4ax3NvBvJx0,5453
-astreum-0.2.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-astreum-0.2.6.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
-astreum-0.2.6.dist-info/RECORD,,
+astreum-0.2.8.dist-info/licenses/LICENSE,sha256=gYBvRDP-cPLmTyJhvZ346QkrYW_eleke4Z2Yyyu43eQ,1089
+astreum-0.2.8.dist-info/METADATA,sha256=mXlFwukobFtoWXDbgQOr__JH_9xnTfMWoginX-KoR7k,5453
+astreum-0.2.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+astreum-0.2.8.dist-info/top_level.txt,sha256=1EG1GmkOk3NPmUA98FZNdKouhRyget-KiFiMk0i2Uz0,8
+astreum-0.2.8.dist-info/RECORD,,