def test_backward_compatibility_py_evm(): from py_ecc import optimized_bn128 as bn128 from py_ecc.optimized_bn128 import ( FQP, FQ2, ) FQ = bn128.FQ p1 = (FQ(0), FQ(0), FQ(1)) bn128.is_on_curve(p1, bn128.b)
def polyhash(key, nonce, message, round_consts=None): r""" This construction uses two `n`-bit keys, `k` and `k'` it operates on message of bitlength `L = t * n`. It starts by splitting the input message `x` into `t` blocks of bitlength `n` denoted `x_i`. The `x_i`, `k` and `k'` are represented as elements of `GF(p)` The authentication function `g_{k,k'}(x)` is then defined as: g_{k,k'}(x) = k' + \sum_{i=0}^t (x_i+c_i) * k^i Where: * `x` is the message * `x_i` is a segment of the message * `c_i` is an optional round constant * `k'` is the nonce * `k` is the key """ if isinstance(message, (str, bytes)): if isinstance(message, str): message = message.encode('utf-8') message = bytes_to_field_elements(message) if round_consts and len(message) != round_consts: raise RuntimeError("Round consts must be the same length as message") k = None res = FQ(nonce) for i, x_i in enumerate(message): rhs = FQ(x_i) if round_consts: rhs += round_consts[i] if k is not None: rhs *= k k *= k else: k = FQ(key) res += rhs return res
def _load_g1_point(point): """Unserialize a G1 point, from Ethereum hex encoded 0x...""" if len(point) != 2: raise RuntimeError("Invalid G1 point - not 2 vals", point) out = tuple(FQ(_filter_int(_)) for _ in point) if not bn128.is_on_curve(out, bn128.b): raise ValueError("Invalid G1 point - not on curve", out) return out
def ecAdd(p1: Point, p2: Point) -> Point: p1 = FQ(p1[0]), FQ(p1[1]) p2 = FQ(p2[0]), FQ(p2[1]) return fq2point(add(p1, p2))
def ecMul(p: Point, x: int) -> Point: pt = FQ(p[0]), FQ(p[1]) return fq2point(multiply(pt, x))
def get_monitor_parameters(self, address): parameters = self.contract.functions.getMonitorParameters(address).call() target = parameters[:2] shuffle = parameters[2:4] index = parameters[4] return (FQ(target[0]), FQ(target[1])), (FQ(shuffle[0]), FQ(shuffle[1])), index