Browse Source
Advance coordinator implementation
- Common - Move ErrTODO and ErrDone to common for usage where needed. - Coordinator - Move prover types to prover package - Handle reorgs, stopping the pipeline when necessary - Handle ethereum transaction errors by stopping the pipeline - In case of ethereum transaction revert, check for known revert causes (more revert causes can be added to handle more cases) - Fix skipped transactions in TxManager confirmation logic - Cancel and wait for provers to be ready - Connect L2DB to: - purge l2txs due to timeout - mark l2txs at the different states - Connect HistoryDB to query L1UserTxs to forge in an L1Batch - L2DB - Skip update functions when the input slices have no values (to avoid a query with no values that results in an SQL error) - StateDB - In LocalStateDB, fix Reset when mt == nil - Prover (new package) - Rename the interface to Prover - Rename the mock struct to Mock - Extend Prover interface methods to provide everything required by the coordinator - Begin implementing required http client code to interact with server proof (not tested) - Synchronizer: - Add LastForgeL1TxsNum to Stats - Test/Client - Update Auction logic to track slots in which there's no forge during the time before the deadline (following the solidity implementation)feature/sql-semaphore1
Eduard S
4 years ago
14 changed files with 735 additions and 270 deletions
Split View
Diff Options
-
+16 -1common/errors.go
-
+6 -0common/ethauction.go
-
+4 -7coordinator/batch.go
-
+207 -120coordinator/coordinator.go
-
+83 -19coordinator/coordinator_test.go
-
+0 -90coordinator/proofpool.go
-
+38 -0coordinator/proverspool.go
-
+14 -2db/l2db/l2db.go
-
+8 -5db/statedb/statedb.go
-
+5 -4eth/auction.go
-
+4 -2node/node.go
-
+291 -0prover/prover.go
-
+21 -6synchronizer/synchronizer.go
-
+38 -14test/ethclient.go
@ -1,90 +0,0 @@ |
|||
package coordinator |
|||
|
|||
import ( |
|||
"context" |
|||
"time" |
|||
|
|||
"github.com/hermeznetwork/hermez-node/common" |
|||
"github.com/hermeznetwork/hermez-node/log" |
|||
"github.com/hermeznetwork/tracerr" |
|||
) |
|||
|
|||
// ServerProofInterface is the interface to a ServerProof that calculates zk proofs
|
|||
type ServerProofInterface interface { |
|||
CalculateProof(zkInputs *common.ZKInputs) error |
|||
GetProof(ctx context.Context) (*Proof, error) |
|||
} |
|||
|
|||
// ServerProof contains the data related to a ServerProof
|
|||
type ServerProof struct { |
|||
// TODO
|
|||
URL string |
|||
Available bool |
|||
} |
|||
|
|||
// NewServerProof creates a new ServerProof
|
|||
func NewServerProof(URL string) *ServerProof { |
|||
return &ServerProof{URL: URL} |
|||
} |
|||
|
|||
// CalculateProof sends the *common.ZKInputs to the ServerProof to compute the
|
|||
// Proof
|
|||
func (p *ServerProof) CalculateProof(zkInputs *common.ZKInputs) error { |
|||
log.Error("TODO") |
|||
return tracerr.Wrap(errTODO) |
|||
} |
|||
|
|||
// GetProof retreives the Proof from the ServerProof
|
|||
func (p *ServerProof) GetProof(ctx context.Context) (*Proof, error) { |
|||
log.Error("TODO") |
|||
return nil, tracerr.Wrap(errTODO) |
|||
} |
|||
|
|||
// ServerProofMock is a mock ServerProof to be used in tests. It doesn't calculate anything
|
|||
type ServerProofMock struct { |
|||
} |
|||
|
|||
// CalculateProof sends the *common.ZKInputs to the ServerProof to compute the
|
|||
// Proof
|
|||
func (p *ServerProofMock) CalculateProof(zkInputs *common.ZKInputs) error { |
|||
return nil |
|||
} |
|||
|
|||
// GetProof retreives the Proof from the ServerProof
|
|||
func (p *ServerProofMock) GetProof(ctx context.Context) (*Proof, error) { |
|||
// Simulate a delay
|
|||
select { |
|||
case <-time.After(200 * time.Millisecond): //nolint:gomnd
|
|||
return &Proof{}, nil |
|||
case <-ctx.Done(): |
|||
return nil, tracerr.Wrap(ErrDone) |
|||
} |
|||
} |
|||
|
|||
// ServerProofPool contains the multiple ServerProof
|
|||
type ServerProofPool struct { |
|||
pool chan ServerProofInterface |
|||
} |
|||
|
|||
// NewServerProofPool creates a new pool of ServerProofs.
|
|||
func NewServerProofPool(maxServerProofs int) *ServerProofPool { |
|||
return &ServerProofPool{ |
|||
pool: make(chan ServerProofInterface, maxServerProofs), |
|||
} |
|||
} |
|||
|
|||
// Add a ServerProof to the pool
|
|||
func (p *ServerProofPool) Add(serverProof ServerProofInterface) { |
|||
p.pool <- serverProof |
|||
} |
|||
|
|||
// Get returns the next available ServerProof
|
|||
func (p *ServerProofPool) Get(ctx context.Context) (ServerProofInterface, error) { |
|||
select { |
|||
case <-ctx.Done(): |
|||
log.Info("ServerProofPool.Get done") |
|||
return nil, tracerr.Wrap(ErrDone) |
|||
case serverProof := <-p.pool: |
|||
return serverProof, nil |
|||
} |
|||
} |
|||
@ -0,0 +1,38 @@ |
|||
package coordinator |
|||
|
|||
import ( |
|||
"context" |
|||
|
|||
"github.com/hermeznetwork/hermez-node/common" |
|||
"github.com/hermeznetwork/hermez-node/log" |
|||
"github.com/hermeznetwork/hermez-node/prover" |
|||
"github.com/hermeznetwork/tracerr" |
|||
) |
|||
|
|||
// ProversPool contains the multiple prover clients
|
|||
type ProversPool struct { |
|||
pool chan prover.Client |
|||
} |
|||
|
|||
// NewProversPool creates a new pool of provers.
|
|||
func NewProversPool(maxServerProofs int) *ProversPool { |
|||
return &ProversPool{ |
|||
pool: make(chan prover.Client, maxServerProofs), |
|||
} |
|||
} |
|||
|
|||
// Add a prover to the pool
|
|||
func (p *ProversPool) Add(serverProof prover.Client) { |
|||
p.pool <- serverProof |
|||
} |
|||
|
|||
// Get returns the next available prover
|
|||
func (p *ProversPool) Get(ctx context.Context) (prover.Client, error) { |
|||
select { |
|||
case <-ctx.Done(): |
|||
log.Info("ServerProofPool.Get done") |
|||
return nil, tracerr.Wrap(common.ErrDone) |
|||
case serverProof := <-p.pool: |
|||
return serverProof, nil |
|||
} |
|||
} |
|||
@ -0,0 +1,291 @@ |
|||
package prover |
|||
|
|||
import ( |
|||
"bytes" |
|||
"context" |
|||
"encoding/json" |
|||
"fmt" |
|||
"io" |
|||
"mime/multipart" |
|||
"net/http" |
|||
"strings" |
|||
"time" |
|||
|
|||
"github.com/dghubble/sling" |
|||
"github.com/hermeznetwork/hermez-node/common" |
|||
"github.com/hermeznetwork/hermez-node/log" |
|||
"github.com/hermeznetwork/tracerr" |
|||
) |
|||
|
|||
// Proof TBD this type will be received from the proof server
|
|||
type Proof struct { |
|||
} |
|||
|
|||
// Client is the interface to a ServerProof that calculates zk proofs
|
|||
type Client interface { |
|||
// Non-blocking
|
|||
CalculateProof(zkInputs *common.ZKInputs) error |
|||
// Blocking
|
|||
GetProof(ctx context.Context) (*Proof, 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" |
|||
// POSTFILE is an HTTP POST with a form file
|
|||
POSTFILE apiMethod = "POSTFILE" |
|||
) |
|||
|
|||
// ProofServerClient contains the data related to a ProofServerClient
|
|||
type ProofServerClient struct { |
|||
URL string |
|||
client *sling.Sling |
|||
} |
|||
|
|||
// NewProofServerClient creates a new ServerProof
|
|||
func NewProofServerClient(URL string) *ProofServerClient { |
|||
if URL[len(URL)-1] != '/' { |
|||
URL += "/" |
|||
} |
|||
client := sling.New().Base(URL) |
|||
return &ProofServerClient{URL: URL, client: client} |
|||
} |
|||
|
|||
//nolint:unused
|
|||
type formFileProvider struct { |
|||
writer *multipart.Writer |
|||
body []byte |
|||
} |
|||
|
|||
//nolint:unused
|
|||
func newFormFileProvider(payload interface{}) (*formFileProvider, error) { |
|||
body := new(bytes.Buffer) |
|||
writer := multipart.NewWriter(body) |
|||
part, err := writer.CreateFormFile("file", "file.json") |
|||
if err != nil { |
|||
return nil, tracerr.Wrap(err) |
|||
} |
|||
if err := json.NewEncoder(part).Encode(payload); err != nil { |
|||
return nil, tracerr.Wrap(err) |
|||
} |
|||
if err := writer.Close(); err != nil { |
|||
return nil, tracerr.Wrap(err) |
|||
} |
|||
return &formFileProvider{ |
|||
writer: writer, |
|||
body: body.Bytes(), |
|||
}, nil |
|||
} |
|||
|
|||
func (p formFileProvider) ContentType() string { |
|||
return p.writer.FormDataContentType() |
|||
} |
|||
|
|||
func (p formFileProvider) Body() (io.Reader, error) { |
|||
return bytes.NewReader(p.body), nil |
|||
} |
|||
|
|||
//nolint:unused
|
|||
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() |
|||
case POSTFILE: |
|||
provider, err := newFormFileProvider(body) |
|||
if err != nil { |
|||
return tracerr.Wrap(err) |
|||
} |
|||
req, err = p.client.New().Post(path).BodyProvider(provider).Request() |
|||
if err != nil { |
|||
return tracerr.Wrap(err) |
|||
} |
|||
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 |
|||
} |
|||
|
|||
//nolint:unused
|
|||
func (p *ProofServerClient) apiStatus(ctx context.Context) (*Status, error) { |
|||
var status Status |
|||
if err := p.apiRequest(ctx, GET, "/status", nil, &status); err != nil { |
|||
return nil, tracerr.Wrap(err) |
|||
} |
|||
return &status, nil |
|||
} |
|||
|
|||
//nolint:unused
|
|||
func (p *ProofServerClient) apiCancel(ctx context.Context) error { |
|||
if err := p.apiRequest(ctx, POST, "/cancel", nil, nil); err != nil { |
|||
return tracerr.Wrap(err) |
|||
} |
|||
return nil |
|||
} |
|||
|
|||
//nolint:unused
|
|||
func (p *ProofServerClient) apiInput(ctx context.Context, zkInputs *common.ZKInputs) error { |
|||
if err := p.apiRequest(ctx, POSTFILE, "/input", zkInputs, nil); err != nil { |
|||
return tracerr.Wrap(err) |
|||
} |
|||
return nil |
|||
} |
|||
|
|||
// CalculateProof sends the *common.ZKInputs to the ServerProof to compute the
|
|||
// Proof
|
|||
func (p *ProofServerClient) CalculateProof(zkInputs *common.ZKInputs) error { |
|||
log.Error("TODO") |
|||
return tracerr.Wrap(common.ErrTODO) |
|||
} |
|||
|
|||
// GetProof retreives the Proof from the ServerProof, blocking until the proof
|
|||
// is ready.
|
|||
func (p *ProofServerClient) GetProof(ctx context.Context) (*Proof, error) { |
|||
log.Error("TODO") |
|||
return nil, tracerr.Wrap(common.ErrTODO) |
|||
} |
|||
|
|||
// Cancel cancels any current proof computation
|
|||
func (p *ProofServerClient) Cancel(ctx context.Context) error { |
|||
log.Error("TODO") |
|||
return tracerr.Wrap(common.ErrTODO) |
|||
} |
|||
|
|||
// WaitReady waits until the serverProof is ready
|
|||
func (p *ProofServerClient) WaitReady(ctx context.Context) error { |
|||
log.Error("TODO") |
|||
return tracerr.Wrap(common.ErrTODO) |
|||
} |
|||
|
|||
// 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(zkInputs *common.ZKInputs) error { |
|||
return nil |
|||
} |
|||
|
|||
// GetProof retreives the Proof from the ServerProof
|
|||
func (p *MockClient) GetProof(ctx context.Context) (*Proof, error) { |
|||
// Simulate a delay
|
|||
select { |
|||
case <-time.After(500 * time.Millisecond): //nolint:gomnd
|
|||
return &Proof{}, nil |
|||
case <-ctx.Done(): |
|||
return 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) |
|||
} |
|||
} |
|||