Merge pull request #2504 from oasislabs/kostko/feature/rt-registration

Roothash processing fees

.changelog/2504.breaking.md

@@ -0,0 +1,9 @@
+Charge gas for runtime transactions and suspend runtimes which do not pay periodic maintenance fees.
+
+This introduces gas fees for submitting roothash commitments from runtime nodes. Since periodic
+maintenance work must be performed on each epoch transition (e.g., electing runtime committees),
+fees for that maintenance are paid by any nodes that register to perform work for a specific
+runtime. Fees are pre-paid for the number of epochs a node registers for.
+
+If the maintenance fees are not paid, the runtime gets suspended (so periodic work is not needed)
+and must be resumed by registering nodes.

go/Makefile

@@ -52,7 +52,7 @@ fmt:
 # Lint.
 lint:
 	@$(ECHO) "$(CYAN)*** Running Go linters...$(OFF)"
-	@env -u GOPATH golangci-lint run
+	@env -u GOPATH golangci-lint run --deadline 2m
 
 # Test.
 test:

go/common/crypto/signature/signature.go

@@ -222,6 +222,11 @@ func (r RawSignature) String() string {
 	return string(data)
 }
 
+// Equal compares vs another public key for equality.
+func (r RawSignature) Equal(cmp RawSignature) bool {
+	return bytes.Equal(r[:], cmp[:])
+}
+
 // MarshalBinary encodes a signature into binary form.
 func (r RawSignature) MarshalBinary() (data []byte, err error) {
 	data = append([]byte{}, r[:]...)
@@ -279,6 +284,17 @@ type Signature struct {
 	Signature RawSignature `json:"signature"`
 }
 
+// Equal compares vs another signature for equality.
+func (s *Signature) Equal(cmp *Signature) bool {
+	if !s.PublicKey.Equal(cmp.PublicKey) {
+		return false
+	}
+	if !s.Signature.Equal(cmp.Signature) {
+		return false
+	}
+	return true
+}
+
 // Sign generates a signature with the private key over the context and
 // message.
 func Sign(signer Signer, context Context, message []byte) (*Signature, error) {

go/consensus/tendermint/abci/context.go

@@ -218,7 +218,9 @@ func (sc *StateCheckpoint) Rollback() {
 	if sc.ctx == nil {
 		return
 	}
-	sc.ctx.State().ImmutableTree = &sc.ImmutableTree
+	st := sc.ctx.State()
+	st.Rollback()
+	st.ImmutableTree = &sc.ImmutableTree
 }
 
 // BlockContextKey is an interface for a block context key.

go/consensus/tendermint/apps/beacon/beacon.go

@@ -122,7 +122,7 @@ func (app *beaconApplication) onBeaconEpochChange(ctx *abci.Context, epoch epoch
 	case true:
 		// UNSAFE/DEBUG - Deterministic beacon.
 		entropyCtx = debugEntropyCtx
-		entropy = []byte("If you change this, you will fuck up the byzantine tests!!")
+		entropy = []byte("If you change this, you will fuck up the byzantine tests!!!")
 	}
 
 	b := getBeacon(epoch, entropyCtx, entropy)

go/consensus/tendermint/apps/registry/genesis.go

@@ -75,6 +75,25 @@ func (app *registryApplication) InitChain(ctx *abci.Context, request types.Reque
 			}
 		}
 	}
+	for _, v := range st.SuspendedRuntimes {
+		app.logger.Debug("InitChain: Registering genesis suspended runtime",
+			"runtime_owner", v.Signature.PublicKey,
+		)
+		if err := app.registerRuntime(ctx, state, v); err != nil {
+			app.logger.Error("InitChain: failed to register runtime",
+				"err", err,
+				"runtime", v,
+			)
+			return errors.Wrap(err, "registry: genesis suspended runtime registration failure")
+		}
+		var rt registry.Runtime
+		if err := cbor.Unmarshal(v.Blob, &rt); err != nil {
+			return errors.Wrap(err, "registry: malformed genesis suspended runtime")
+		}
+		if err := state.SuspendRuntime(rt.ID); err != nil {
+			return errors.Wrap(err, "registry: failed to suspend runtime at genesis")
+		}
+	}
 	for _, v := range st.Nodes {
 		app.logger.Debug("InitChain: Registering genesis node",
 			"node_owner", v.Signature.PublicKey,
@@ -120,6 +139,10 @@ func (rq *registryQuerier) Genesis(ctx context.Context) (*registry.Genesis, erro
 	if err != nil {
 		return nil, err
 	}
+	suspendedRuntimes, err := rq.state.SuspendedRuntimes()
+	if err != nil {
+		return nil, err
+	}
 	signedNodes, err := rq.state.SignedNodes()
 	if err != nil {
 		return nil, err
@@ -149,11 +172,12 @@ func (rq *registryQuerier) Genesis(ctx context.Context) (*registry.Genesis, erro
 	}
 
 	gen := registry.Genesis{
-		Parameters:   *params,
-		Entities:     signedEntities,
-		Runtimes:     signedRuntimes,
-		Nodes:        validatorNodes,
-		NodeStatuses: nodeStatuses,
+		Parameters:        *params,
+		Entities:          signedEntities,
+		Runtimes:          signedRuntimes,
+		SuspendedRuntimes: suspendedRuntimes,
+		Nodes:             validatorNodes,
+		NodeStatuses:      nodeStatuses,
 	}
 	return &gen, nil
 }