Allow for querying proofs and remove broadcasting

[poszu]

Implements necessary poet changes for spacemeshos/pm#173

Closes #167
Closes #168
Closes #169

Notable changes:

• Service reports produced proofs via a channel instead of broadcasting them. The proofs are then picked up by consumers:

  • in a poet server case, the consumer is a database actor that serializes and persists them
  • in tests, the test is a consumer directly

• removed the last Mutex from the Service struct. The actor event loop is now synchonous (started via Service::Run()). It doesn't spawn a goroutine and finishes when the context is cancelled. It made the shutdown logic redundant.

• split server startup into:

  • creation: server::New(), where it configures itself and binds ports to listen on
  • start: Server::Start, where it actually starts to process incoming requests

  It allows writing tests that run on random ports and obtain ports the server listens on, which lets run parallel tests.

• Submit() GRPC returns duration till the end of the round that the challenge was submitted to. It gives two benefits for the node:

  • it can easily verify if the resulting proof will be valuable for it (if it ends on time). It might not be if it missed the registration window,
  • it knows when to query for the proof

[countvonzero]

some high level questions first to get the context. thanks for your patience.

[countvonzero]

i still finds this multiple rounds logic confusing. would appreciate (for future reviews) that we get rid of it if we know poet is not doing multiple rounds at the same time.

[countvonzero]

would printing err.Error() here be more informative for debugging?

[poszu]

The GRPC interceptor already prints requests and responses here 😉:

poet/server/server.go

Lines 174 to 191 in c2c2e82

	func loggerInterceptor() func(ctx context.Context, req any, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (any, error) {
	return func(ctx context.Context, req any, info *grpc.UnaryServerInfo, handler grpc.UnaryHandler) (any, error) {
	peer, _ := peer.FromContext(ctx)
	logger := log.AppLog.WithName(info.FullMethod).WithFields(log.Field(zap.Stringer("request_id", uuid.New())))
	ctx = logging.NewContext(ctx, logger)
	if msg, ok := req.(fmt.Stringer); ok {
	logger.With().Debug("new GRPC", log.Field(zap.Stringer("from", peer.Addr)), log.Field(zap.Stringer("message", msg)))
	}
	resp, err := handler(ctx, req)
	if err != nil {
	logger.With().Info("FAILURE", log.Err(err))
	}
	return resp, err
	}
	}

The returned error will be visible in logs printed there.