mirror of
https://github.com/status-im/c-kzg-4844.git
synced 2025-01-19 14:43:06 +00:00
104 lines
2.5 KiB
Python
104 lines
2.5 KiB
Python
import atexit
|
|
import ckzg
|
|
|
|
def int_from_uint64s(digits):
|
|
"""Convert a 4-tuple of base64 digits to the int it denotes"""
|
|
res, mult = 0, 1
|
|
for x in digits:
|
|
res += mult * x
|
|
mult *= 2 ** 64
|
|
return res
|
|
|
|
def eval_poly(coeffs, x):
|
|
"""Evaluate a polynomial represented by a sequence of coefficients"""
|
|
res, mult = 0, 1
|
|
for c in coeffs:
|
|
res += mult * c
|
|
mult *= x
|
|
return res
|
|
|
|
# Make some elements to be used as coefficients
|
|
|
|
c1 = ckzg.fr_from_uint64s((12,13,0,0))
|
|
c2 = ckzg.fr_from_uint64(2)
|
|
c3 = ckzg.fr_from_uint64s((1,0,0,0))
|
|
c4 = ckzg.fr_sub(c2, c3)
|
|
|
|
# A few sanity checks
|
|
|
|
assert ckzg.fr_is_one(c4)
|
|
|
|
assert ckzg.fr_equal(c3, c4)
|
|
|
|
# Create an array of the coefficients
|
|
|
|
coeffs = [c1, c2, c3, c4]
|
|
cfa = ckzg.frArray(len(coeffs))
|
|
for i, c in enumerate(coeffs):
|
|
cfa[i] = c
|
|
|
|
# Build the polynomial
|
|
|
|
ret, pptr = ckzg.new_poly_with_coeffs(cfa.cast(), len(coeffs))
|
|
assert ret == 0
|
|
|
|
# Check one of its coefficients is as expected
|
|
|
|
p = ckzg.polyp_frompointer(pptr).value()
|
|
assert p.length == 4
|
|
|
|
pcoeffs = ckzg.frArray_frompointer(p.coeffs)
|
|
assert ckzg.fr_to_uint64s(pcoeffs[1]) == (2, 0, 0, 0)
|
|
|
|
# Build a trusted setup with an arbitrary secret s
|
|
# and max scale 4 (so 16 secret values)
|
|
|
|
max_scale = 4
|
|
|
|
ret, fs = ckzg.new_fft_settings(max_scale)
|
|
assert ret == 0
|
|
|
|
secret_s = ckzg.blst_scalar_from_uint64((29,3,1,4))
|
|
|
|
num_secrets = 2 ** max_scale
|
|
|
|
g1s = ckzg.g1Array(num_secrets)
|
|
g2s = ckzg.g2Array(num_secrets)
|
|
|
|
ckzg.generate_trusted_setup(g1s.cast(), g2s.cast(), secret_s, num_secrets)
|
|
|
|
ret, ks = ckzg.new_kzg_settings(g1s.cast(), g2s.cast(), num_secrets, fs)
|
|
assert ret == 0
|
|
|
|
# Compute the Lagrange form of our polynomial in this setup
|
|
|
|
ret, p_l = ckzg.new_poly_l_from_poly(p, ks)
|
|
assert ret == 0
|
|
|
|
# Check some evaluations at the point 2
|
|
# First, that Lagrange and coefficient form evaluations agree
|
|
|
|
ret, y_l = ckzg.eval_poly_l(p_l, c2, fs)
|
|
assert ret == 0
|
|
|
|
y = ckzg.eval_poly(p, c2)
|
|
assert ckzg.fr_equal(y, y_l)
|
|
|
|
# And that this agrees with a naive Python evaluation
|
|
|
|
py_coeffs = [int_from_uint64s(ckzg.fr_to_uint64s(c)) for c in coeffs]
|
|
|
|
y_p = eval_poly(py_coeffs, int_from_uint64s(ckzg.fr_to_uint64s(c2)))
|
|
assert int_from_uint64s(ckzg.fr_to_uint64s(y)) == y_p
|
|
|
|
print("All tests passed.")
|
|
|
|
# We need to manually free the C allocated arrays
|
|
# Use atexit so this file can be loaded interactively before freeing
|
|
def cleanup():
|
|
ckzg.free_poly(pptr)
|
|
ckzg.free_poly_l(p_l)
|
|
ckzg.free_fft_settings(fs)
|
|
ckzg.free_kzg_settings(ks)
|
|
atexit.register(cleanup)
|