You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 

318 lines
9.3 KiB

package prover
import (
"context"
"encoding/json"
"fmt"
"math/big"
"net/http"
"strings"
"time"
"github.com/dghubble/sling"
"github.com/hermeznetwork/hermez-node/common"
"github.com/hermeznetwork/tracerr"
)
// Proof TBD this type will be received from the proof server
type Proof struct {
PiA [2]*big.Int `json:"pi_a"`
PiB [3][2]*big.Int `json:"pi_b"`
PiC [2]*big.Int `json:"pi_c"`
Protocol string `json:"protocol"`
}
type bigInt big.Int
func (b *bigInt) UnmarshalText(text []byte) error {
_, ok := (*big.Int)(b).SetString(string(text), 10)
if !ok {
return fmt.Errorf("invalid big int: \"%v\"", string(text))
}
return nil
}
// UnmarshalJSON unmarshals the proof from a JSON encoded proof with the big
// ints as strings
func (p *Proof) UnmarshalJSON(data []byte) error {
proof := struct {
PiA [2]*bigInt `json:"pi_a"`
PiB [3][2]*bigInt `json:"pi_b"`
PiC [2]*bigInt `json:"pi_c"`
Protocol string `json:"protocol"`
}{}
if err := json.Unmarshal(data, &proof); err != nil {
return err
}
p.PiA[0] = (*big.Int)(proof.PiA[0])
p.PiA[1] = (*big.Int)(proof.PiA[1])
p.PiB[0][0] = (*big.Int)(proof.PiB[0][0])
p.PiB[0][1] = (*big.Int)(proof.PiB[0][1])
p.PiB[1][0] = (*big.Int)(proof.PiB[1][0])
p.PiB[1][1] = (*big.Int)(proof.PiB[1][1])
p.PiB[2][0] = (*big.Int)(proof.PiB[2][0])
p.PiB[2][1] = (*big.Int)(proof.PiB[2][1])
p.PiC[0] = (*big.Int)(proof.PiC[0])
p.PiC[1] = (*big.Int)(proof.PiC[1])
p.Protocol = proof.Protocol
return nil
}
// PublicInputs are the public inputs of the proof
type PublicInputs []*big.Int
// UnmarshalJSON unmarshals the JSON into the public inputs where the bigInts
// are in decimal as quoted strings
func (p *PublicInputs) UnmarshalJSON(data []byte) error {
pubInputs := []*bigInt{}
if err := json.Unmarshal(data, &pubInputs); err != nil {
return err
}
*p = make([]*big.Int, len(pubInputs))
for i, v := range pubInputs {
([]*big.Int)(*p)[i] = (*big.Int)(v)
}
return nil
}
// Client is the interface to a ServerProof that calculates zk proofs
type Client interface {
// Non-blocking
CalculateProof(ctx context.Context, zkInputs *common.ZKInputs) error
// Blocking. Returns the Proof and Public Data (public inputs)
GetProof(ctx context.Context) (*Proof, []*big.Int, error)
// Non-Blocking
Cancel(ctx context.Context) error
// Blocking
WaitReady(ctx context.Context) error
}
// StatusCode is the status string of the ProofServer
type StatusCode string
const (
// StatusCodeAborted means prover is ready to take new proof. Previous
// proof was aborted.
StatusCodeAborted StatusCode = "aborted"
// StatusCodeBusy means prover is busy computing proof.
StatusCodeBusy StatusCode = "busy"
// StatusCodeFailed means prover is ready to take new proof. Previous
// proof failed
StatusCodeFailed StatusCode = "failed"
// StatusCodeSuccess means prover is ready to take new proof. Previous
// proof succeeded
StatusCodeSuccess StatusCode = "success"
// StatusCodeUnverified means prover is ready to take new proof.
// Previous proof was unverified
StatusCodeUnverified StatusCode = "unverified"
// StatusCodeUninitialized means prover is not initialized
StatusCodeUninitialized StatusCode = "uninitialized"
// StatusCodeUndefined means prover is in an undefined state. Most
// likely is booting up. Keep trying
StatusCodeUndefined StatusCode = "undefined"
// StatusCodeInitializing means prover is initializing and not ready yet
StatusCodeInitializing StatusCode = "initializing"
// StatusCodeReady means prover initialized and ready to do first proof
StatusCodeReady StatusCode = "ready"
)
// IsReady returns true when the prover is ready
func (status StatusCode) IsReady() bool {
if status == StatusCodeAborted || status == StatusCodeFailed || status == StatusCodeSuccess ||
status == StatusCodeUnverified || status == StatusCodeReady {
return true
}
return false
}
// IsInitialized returns true when the prover is initialized
func (status StatusCode) IsInitialized() bool {
if status == StatusCodeUninitialized || status == StatusCodeUndefined ||
status == StatusCodeInitializing {
return false
}
return true
}
// Status is the return struct for the status API endpoint
type Status struct {
Status StatusCode `json:"status"`
Proof string `json:"proof"`
PubData string `json:"pubData"`
}
// ErrorServer is the return struct for an API error
type ErrorServer struct {
Status StatusCode `json:"status"`
Message string `json:"msg"`
}
// Error message for ErrorServer
func (e ErrorServer) Error() string {
return fmt.Sprintf("server proof status (%v): %v", e.Status, e.Message)
}
type apiMethod string
const (
// GET is an HTTP GET
GET apiMethod = "GET"
// POST is an HTTP POST with maybe JSON body
POST apiMethod = "POST"
)
// ProofServerClient contains the data related to a ProofServerClient
type ProofServerClient struct {
URL string
client *sling.Sling
pollInterval time.Duration
}
// NewProofServerClient creates a new ServerProof
func NewProofServerClient(URL string, pollInterval time.Duration) *ProofServerClient {
if URL[len(URL)-1] != '/' {
URL += "/"
}
client := sling.New().Base(URL)
return &ProofServerClient{URL: URL, client: client, pollInterval: pollInterval}
}
func (p *ProofServerClient) apiRequest(ctx context.Context, method apiMethod, path string,
body interface{}, ret interface{}) error {
path = strings.TrimPrefix(path, "/")
var errSrv ErrorServer
var req *http.Request
var err error
switch method {
case GET:
req, err = p.client.New().Get(path).Request()
case POST:
req, err = p.client.New().Post(path).BodyJSON(body).Request()
default:
return tracerr.Wrap(fmt.Errorf("invalid http method: %v", method))
}
if err != nil {
return tracerr.Wrap(err)
}
res, err := p.client.Do(req.WithContext(ctx), ret, &errSrv)
if err != nil {
return tracerr.Wrap(err)
}
defer res.Body.Close() //nolint:errcheck
if !(200 <= res.StatusCode && res.StatusCode < 300) {
return tracerr.Wrap(errSrv)
}
return nil
}
func (p *ProofServerClient) apiStatus(ctx context.Context) (*Status, error) {
var status Status
return &status, tracerr.Wrap(p.apiRequest(ctx, GET, "/status", nil, &status))
}
func (p *ProofServerClient) apiCancel(ctx context.Context) error {
return tracerr.Wrap(p.apiRequest(ctx, POST, "/cancel", nil, nil))
}
func (p *ProofServerClient) apiInput(ctx context.Context, zkInputs *common.ZKInputs) error {
return tracerr.Wrap(p.apiRequest(ctx, POST, "/input", zkInputs, nil))
}
// CalculateProof sends the *common.ZKInputs to the ServerProof to compute the
// Proof
func (p *ProofServerClient) CalculateProof(ctx context.Context, zkInputs *common.ZKInputs) error {
return tracerr.Wrap(p.apiInput(ctx, zkInputs))
}
// GetProof retreives the Proof and Public Data (public inputs) from the
// ServerProof, blocking until the proof is ready.
func (p *ProofServerClient) GetProof(ctx context.Context) (*Proof, []*big.Int, error) {
if err := p.WaitReady(ctx); err != nil {
return nil, nil, tracerr.Wrap(err)
}
status, err := p.apiStatus(ctx)
if err != nil {
return nil, nil, tracerr.Wrap(err)
}
if status.Status == StatusCodeSuccess {
var proof Proof
if err := json.Unmarshal([]byte(status.Proof), &proof); err != nil {
return nil, nil, tracerr.Wrap(err)
}
var pubInputs PublicInputs
if err := json.Unmarshal([]byte(status.PubData), &pubInputs); err != nil {
return nil, nil, tracerr.Wrap(err)
}
return &proof, pubInputs, nil
}
return nil, nil, fmt.Errorf("status != StatusCodeSuccess, status = %v", status.Status)
}
// Cancel cancels any current proof computation
func (p *ProofServerClient) Cancel(ctx context.Context) error {
return tracerr.Wrap(p.apiCancel(ctx))
}
// WaitReady waits until the serverProof is ready
func (p *ProofServerClient) WaitReady(ctx context.Context) error {
for {
status, err := p.apiStatus(ctx)
if err != nil {
return tracerr.Wrap(err)
}
if !status.Status.IsInitialized() {
return fmt.Errorf("Proof Server is not initialized")
}
if status.Status.IsReady() {
return nil
}
select {
case <-ctx.Done():
return tracerr.Wrap(common.ErrDone)
case <-time.After(p.pollInterval):
}
}
}
// MockClient is a mock ServerProof to be used in tests. It doesn't calculate anything
type MockClient struct {
}
// CalculateProof sends the *common.ZKInputs to the ServerProof to compute the
// Proof
func (p *MockClient) CalculateProof(ctx context.Context, zkInputs *common.ZKInputs) error {
return nil
}
// GetProof retreives the Proof from the ServerProof
func (p *MockClient) GetProof(ctx context.Context) (*Proof, []*big.Int, error) {
// Simulate a delay
select {
case <-time.After(500 * time.Millisecond): //nolint:gomnd
return &Proof{}, []*big.Int{big.NewInt(1234)}, nil //nolint:gomnd
case <-ctx.Done():
return nil, nil, tracerr.Wrap(common.ErrDone)
}
}
// Cancel cancels any current proof computation
func (p *MockClient) Cancel(ctx context.Context) error {
// Simulate a delay
select {
case <-time.After(80 * time.Millisecond): //nolint:gomnd
return nil
case <-ctx.Done():
return tracerr.Wrap(common.ErrDone)
}
}
// WaitReady waits until the prover is ready
func (p *MockClient) WaitReady(ctx context.Context) error {
// Simulate a delay
select {
case <-time.After(200 * time.Millisecond): //nolint:gomnd
return nil
case <-ctx.Done():
return tracerr.Wrap(common.ErrDone)
}
}