def post_initialize(self):
n_copybits = 4
n_outbits = 3
z1 = VPIntfClient.vpmsg_vector( [ util.random_felem() for _ in range(0, n_outbits) ])
z1 = chr(Defs.P_RECV_Z1) + z1[1:]
z2 = VPIntfClient.vpmsg_vector( [ util.random_felem() for _ in range(0, n_copybits) ])
z2 = chr(Defs.P_RECV_Z2) + z2[1:]
self.enqueue(z1)
self.enqueue(z2)
def post_initialize(self):
n_copybits = 4
n_copies = 1 << n_copybits
n_inbits = 3
n_inputs = 1 << n_inbits
n_gates = 8
z2v = VPIntfClient.vpmsg_vector([ util.random_felem() for _ in range(0, 2 * n_copybits) ], Defs.P_RECV_Z2VALS)
z1x = VPIntfClient.vpmsg_vector([ util.random_felem() for _ in range(0, n_gates) ], Defs.P_RECV_Z1CHI)
lvs = VPIntfClient.vpmsg_vector([ util.random_felem() for _ in range(0, n_copies * n_inputs)], Defs.P_RECV_LAYVALS)
self.enqueue(z2v)
self.enqueue(z1x)
self.enqueue(lvs)
def post_initialize(self):
n_inbits = 3
n_copybits = 4
n_inputs = 1 << n_inbits
n_copies = 1 << n_copybits
inputs = VPIntfClient.vpmsg_vector([ util.random_felem() for _ in range(0, n_copies * n_inputs) ], Defs.V_RECV_INPUTS)
expect = VPIntfClient.vpmsg_vector([ util.random_felem() ], Defs.V_RECV_EXPECT)
z1v = VPIntfClient.vpmsg_vector([ util.random_felem() for _ in range(0, n_inbits) ], Defs.V_RECV_Z1)
z2v = VPIntfClient.vpmsg_vector([ util.random_felem() for _ in range(0, n_copybits) ], Defs.V_RECV_Z2)
self.enqueue(inputs)
self.enqueue(expect)
self.enqueue(z1v)
self.enqueue(z2v)
def post_initialize(self):
n_outbits = 3
n_copybits = 4
n_outputs = 1 << n_outbits
n_copies = 1 << n_copybits
outputs = VPIntfClient.vpmsg_vector([ util.random_felem() for _ in range(0, n_copies * n_outputs) ], Defs.V_RECV_OUTPUTS)
self.enqueue(outputs)
def post_initialize(self):
n_muxsel = 1
n_outbits = 3
n_copybits = 4
n_coeffs = 4
muxsels = VPIntfClient.vpmsg_bitvector(util.random_bitvec(n_muxsel), Defs.V_RECV_MUXSEL)
expect = VPIntfClient.vpmsg_vector([ util.random_felem() ], Defs.V_RECV_EXPECT)
z1v = VPIntfClient.vpmsg_vector([ util.random_felem() for _ in range(0, n_outbits) ], Defs.V_RECV_Z1)
z2v = VPIntfClient.vpmsg_vector([ util.random_felem() for _ in range(0, n_copybits) ], Defs.V_RECV_Z2)
coeff = VPIntfClient.vpmsg_vector([ util.random_felem() for _ in range(0, n_coeffs) ], Defs.V_RECV_COEFFS)
self.enqueue(muxsels)
self.enqueue(expect)
self.enqueue(z1v)
self.enqueue(z2v)
self.enqueue(coeff)
def post_initialize(self):
n_copies = 16
n_inputs = 8
n_muxsel = 1
muxsels = VPIntfClient.vpmsg_bitvector(util.random_bitvec(n_muxsel))
muxsels = chr(Defs.P_RECV_MUXSEL) + muxsels[1:]
inputs = VPIntfClient.vpmsg_vector([ util.random_felem() for _ in range(0, n_copies * n_inputs) ])
inputs = chr(Defs.P_RECV_LAYVALS) + inputs[1:]
self.enqueue(muxsels)
self.enqueue(inputs)
def start_computation(cls):
cls.restart_computation()
muxsel = cls.server_info.muxsels
inputs = cls.server_info.inputs
if muxsel is None:
muxsel = VPIntfClient.vpmsg_bitvector(util.random_bitvec(cls.n_muxsel))
cls.server_info.muxsels = muxsel
else:
assert len(muxsel) == cls.n_muxsel, "Wrong number of muxsel bits supplied"
muxsel = VPIntfClient.vpmsg_bitvector(muxsel)
if inputs is None:
if cls.i_values is None:
ivals = [ util.random_felem() for _ in range(0, cls.n_copies * cls.n_inputs) ]
else:
ivals = [ x if x is not None else util.random_felem() for x in cls.i_values * cls.n_copies ]
cls.server_info.inputs = ivals
inputs = VPIntfClient.vpmsg_vector(ivals)
else:
assert len(inputs) == cls.n_copies * cls.n_inputs, "Wrong number of inputs supplied"
ivals = inputs
inputs = VPIntfClient.vpmsg_vector(inputs)
if cls.debug_prv is not None:
dv_ivals = cls.unflatten(ivals, True)
cls.debug_prv.set_inputs(dv_ivals)
# muxsels to all verifier layers
muxsel = chr(Defs.V_RECV_MUXSEL) + muxsel[1:]
for lay in cls.Verifier.layers:
lay.enqueue(muxsel)
# muxsels to all prover and computation layers
muxsel = chr(Defs.P_RECV_MUXSEL) + muxsel[1:]
for lay in cls.Computation.layers:
lay.enqueue(muxsel)
for lay in cls.Prover.layers:
lay.enqueue(muxsel)
# inputs to P circuit computation and top P layer
inputs = chr(Defs.P_RECV_LAYVALS) + inputs[1:]
cls.Computation.layers[cls.n_layers - 1].enqueue(inputs)
cls.Prover.layers[cls.n_layers - 1].enqueue(inputs)
# inputs to V input layer
inputs = chr(Defs.V_RECV_INPUTS) + inputs[1:]
cls.Verifier.inputs.enqueue(inputs)
# if we're running the ckt in software, do it now
if cls.sw_ckt is not None:
for (idx, lcnts) in enumerate(reversed(cls.sw_ckt.get_counts())):
nextcnt = [ lcnts[0], lcnts[1], 0, cls.n_cpar * lcnts[2], cls.n_cpar * lcnts[3], 0 ]
cls.Computation.layers[idx].counts.append(nextcnt)
(ckt_outputs, lay_outputs) = cls.sw_ckt.run(cls.unflatten(ivals, False), False)
cls.server_info.outputs = cls.flatten(ckt_outputs)
outmsg = VPIntfClient.vpmsg_vector(cls.server_info.outputs, Defs.V_RECV_OUTPUTS)
cls.Verifier.outputs.enqueue(outmsg)
for (idx, vals) in enumerate(reversed(lay_outputs[1:])):
laymsg = VPIntfClient.vpmsg_vector(cls.flatten(vals), Defs.P_RECV_LAYVALS)
cls.Prover.layers[idx].enqueue(laymsg)
def do_handle(self):
msg = self.dequeue()
print len(msg), ':', msg, '\n'
coeff = VPIntfClient.vpmsg_vector([ util.random_felem() for _ in range(0, 4) ], Defs.V_RECV_COEFFS)
self.enqueue(coeff)
def do_handle(self):
msg = self.dequeue()
print len(msg), ':', msg, '\n'
tau = VPIntfClient.vpmsg_vector([ util.random_felem() ], Defs.P_RECV_TAU)
self.enqueue(tau)
