Merge pull request #6207 from oasisprotocol/peternose/trivial/deprecate-get-signer-nonce

go/consensus/api: Deprecate GetSignerNonce

Author: peternose

.changelog/6207.trivial.md

@@ -159,6 +159,8 @@ type Backend interface {
 
 	// GetSignerNonce returns the nonce that should be used by the given
 	// signer for transmitting the next transaction.
+	//
+	// Deprecated: Use staking backend instead.
 	GetSignerNonce(ctx context.Context, req *GetSignerNonceRequest) (uint64, error)
 
 	// GetTransactions returns a list of all transactions contained within a

go/consensus/api/api.go

@@ -51,7 +51,7 @@ type SubmissionManager interface {
 }
 
 type submissionManager struct {
-	consensus      Backend
+	consensus      Services
 	priceDiscovery PriceDiscovery
 	maxFee         quantity.Quantity
 
@@ -77,7 +77,7 @@ func (m *submissionManager) EstimateGasAndSetFee(ctx context.Context, signer sig
 		gas transaction.Gas
 		err error
 	)
-	gas, err = m.consensus.EstimateGas(ctx, &EstimateGasRequest{Signer: signer.Public(), Transaction: tx})
+	gas, err = m.consensus.Core().EstimateGas(ctx, &EstimateGasRequest{Signer: signer.Public(), Transaction: tx})
 	if err != nil {
 		return fmt.Errorf("failed to estimate gas: %w", err)
 	}
@@ -118,14 +118,14 @@ func (m *submissionManager) getSignerNonce(ctx context.Context, signerAddr staki
 	nonce, ok := m.nonces[signerAddr]
 	if !ok {
 		// Query latest nonce when one is not available.
-		var err error
-		nonce, err = m.consensus.GetSignerNonce(ctx, &GetSignerNonceRequest{
-			AccountAddress: signerAddr,
-			Height:         HeightLatest,
+		account, err := m.consensus.Staking().Account(ctx, &staking.OwnerQuery{
+			Height: HeightLatest,
+			Owner:  signerAddr,
 		})
 		if err != nil {
 			return 0, err
 		}
+		nonce = account.General.Nonce
 	}
 
 	m.nonces[signerAddr] = nonce + 1
@@ -171,9 +171,9 @@ func (m *submissionManager) signAndSubmitTx(ctx context.Context, signer signatur
 
 	var proof *transaction.Proof
 	if withProof {
-		proof, err = m.consensus.SubmitTxWithProof(ctx, sigTx)
+		proof, err = m.consensus.Core().SubmitTxWithProof(ctx, sigTx)
 	} else {
-		err = m.consensus.SubmitTx(ctx, sigTx)
+		err = m.consensus.Core().SubmitTx(ctx, sigTx)
 	}
 	if err != nil {
 		// If the transaction check fails (which cannot be determined from
@@ -236,7 +236,7 @@ func (m *submissionManager) SignAndSubmitTxWithProof(ctx context.Context, signer
 }
 
 // NewSubmissionManager creates a new transaction submission manager.
-func NewSubmissionManager(consensus Backend, priceDiscovery PriceDiscovery, maxFee uint64) SubmissionManager {
+func NewSubmissionManager(consensus Services, priceDiscovery PriceDiscovery, maxFee uint64) SubmissionManager {
 	sm := &submissionManager{
 		consensus:      consensus,
 		priceDiscovery: priceDiscovery,

go/consensus/api/submission.go

@@ -131,7 +131,7 @@ func ConsensusImplementationTests(t *testing.T, consensus api.Backend) {
 	})
 	require.NoError(err, "EstimateGas")
 
-	nonce, err := consensus.GetSignerNonce(ctx, &api.GetSignerNonceRequest{
+	nonce, err := consensus.GetSignerNonce(ctx, &api.GetSignerNonceRequest{ //nolint:staticcheck
 		AccountAddress: staking.NewAddress(
 			signature.NewPublicKey("badfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"),
 		),

go/consensus/tests/tester.go

@@ -104,7 +104,7 @@ func doRun(cmd *cobra.Command, _ []string) error {
 	if err != nil {
 		return fmt.Errorf("failed to create submission manager: %w", err)
 	}
-	sm := consensusAPI.NewSubmissionManager(consensus.Core(), pd, 0)
+	sm := consensusAPI.NewSubmissionManager(consensus, pd, 0)
 
 	// Wait for sync before transferring control to the workload.
 	ncc := api.NewNodeControllerClient(conn)

go/oasis-node/cmd/debug/txsource/txsource.go

@@ -220,13 +220,14 @@ func (r *registration) Run( // nolint: gocyclo
 	// XXX: currently entities are only registered at start. Could also
 	// periodically register new entities.
 	for i := range entityAccs {
-		entityAccs[i].reckonedNonce, err = consensus.Core().GetSignerNonce(ctx, &consensusAPI.GetSignerNonceRequest{
-			AccountAddress: entityAccs[i].address,
-			Height:         consensusAPI.HeightLatest,
+		account, err := consensus.Staking().Account(ctx, &staking.OwnerQuery{
+			Height: consensusAPI.HeightLatest,
+			Owner:  entityAccs[i].address,
 		})
 		if err != nil {
-			return fmt.Errorf("GetSignerNonce error: %w", err)
+			return fmt.Errorf("failed to query account: %w", err)
 		}
+		entityAccs[i].reckonedNonce = account.General.Nonce
 
 		ent := &entity.Entity{
 			Versioned: cbor.NewVersioned(entity.LatestDescriptorVersion),
@@ -245,16 +246,15 @@ func (r *registration) Run( // nolint: gocyclo
 			}
 			nodeDesc := getNodeDesc(rng, ident, entityAccs[i].signer.Public(), r.ns)
 
-			var nodeAccNonce uint64
 			nodeAccAddress := staking.NewAddress(ident.NodeSigner.Public())
-			nodeAccNonce, err = consensus.Core().GetSignerNonce(ctx, &consensusAPI.GetSignerNonceRequest{
-				AccountAddress: nodeAccAddress,
-				Height:         consensusAPI.HeightLatest,
+			account, err := consensus.Staking().Account(ctx, &staking.OwnerQuery{
+				Height: consensusAPI.HeightLatest,
+				Owner:  nodeAccAddress,
 			})
 			if err != nil {
-				return fmt.Errorf("GetSignerNonce error for accout %s: %w", nodeAccAddress, err)
+				return fmt.Errorf("failed to query account %s: %w", nodeAccAddress, err)
 			}
-
+			nodeAccNonce := account.General.Nonce
 			entityAccs[i].nodeIdentities = append(entityAccs[i].nodeIdentities, &nodeAcc{ident, nodeDesc, nodeAccNonce})
 			ent.Nodes = append(ent.Nodes, ident.NodeSigner.Public())
 

go/oasis-node/cmd/debug/txsource/workload/registration.go

@@ -12,16 +12,13 @@ import (
 	"strconv"
 
 	beacon "github.com/oasisprotocol/oasis-core/go/beacon/api"
-	"github.com/oasisprotocol/oasis-core/go/common/crypto/signature"
-	"github.com/oasisprotocol/oasis-core/go/common/entity"
 	consensus "github.com/oasisprotocol/oasis-core/go/consensus/api"
 	"github.com/oasisprotocol/oasis-core/go/consensus/api/transaction"
 	governance "github.com/oasisprotocol/oasis-core/go/governance/api"
 	"github.com/oasisprotocol/oasis-core/go/oasis-test-runner/env"
 	"github.com/oasisprotocol/oasis-core/go/oasis-test-runner/oasis"
 	"github.com/oasisprotocol/oasis-core/go/oasis-test-runner/oasis/cli"
 	registry "github.com/oasisprotocol/oasis-core/go/registry/api"
-	staking "github.com/oasisprotocol/oasis-core/go/staking/api"
 )
 
 // TrustRoot is a consensus trust root.
@@ -99,36 +96,6 @@ func (sc *Scenario) TrustRoot(ctx context.Context) (*TrustRoot, error) {
 	}, nil
 }
 
-// TestEntityNonce returns the nonce of the test entity.
-func (sc *Scenario) TestEntityNonce(ctx context.Context) (uint64, error) {
-	ent, _, err := entity.TestEntity()
-	if err != nil {
-		return 0, err
-	}
-	return sc.EntityNonce(ctx, ent)
-}
-
-// EntityNonce returns the nonce of the specified entity.
-func (sc *Scenario) EntityNonce(ctx context.Context, ent *entity.Entity) (uint64, error) {
-	addr := staking.NewAddress(ent.ID)
-	return sc.Net.ClientController().Consensus.GetSignerNonce(ctx, &consensus.GetSignerNonceRequest{
-		Height:         consensus.HeightLatest,
-		AccountAddress: addr,
-	})
-}
-
-// EntityNonceByID returns the nonce of the specified entity.
-func (sc *Scenario) EntityNonceByID(ctx context.Context, id signature.PublicKey) (uint64, error) {
-	ent, err := sc.Net.ClientController().Registry.GetEntity(ctx, &registry.IDQuery{
-		Height: consensus.HeightLatest,
-		ID:     id,
-	})
-	if err != nil {
-		return 0, err
-	}
-	return sc.EntityNonce(ctx, ent)
-}
-
 // ExportedGenesisFiles gathers exported genesis files and ensures all exported genesis files match.
 func (sc *Scenario) ExportedGenesisFiles(skipCompute bool) ([]string, error) {
 	dumpGlob := "genesis-*.json"

go/oasis-test-runner/scenario/e2e/helpers_consensus.go

@@ -169,7 +169,7 @@ func (sc *archiveAPI) testArchiveAPI(ctx context.Context, archiveCtrl *oasis.Con
 	}
 
 	sc.Logger.Info("testing GetSignerNonce")
-	_, err = archiveCtrl.Consensus.GetSignerNonce(ctx, &consensusAPI.GetSignerNonceRequest{})
+	_, err = archiveCtrl.Consensus.GetSignerNonce(ctx, &consensusAPI.GetSignerNonceRequest{}) //nolint:staticcheck
 	if err != consensusAPI.ErrUnsupported {
 		return fmt.Errorf("archive node GetSignerNonce should fail with unsupported")
 	}

go/oasis-test-runner/scenario/e2e/runtime/archive_api.go

@@ -204,13 +204,14 @@ func (sc *kmRotationFailureImpl) extendKeymanagerRegistrations(ctx context.Conte
 		if err != nil {
 			return err
 		}
-		nonce, err := sc.Net.Controller().Consensus.GetSignerNonce(ctx, &consensus.GetSignerNonceRequest{
-			AccountAddress: staking.NewAddress(identity.NodeSigner.Public()),
-			Height:         consensus.HeightLatest,
+		account, err := sc.Net.Controller().Staking.Account(ctx, &staking.OwnerQuery{
+			Height: consensus.HeightLatest,
+			Owner:  staking.NewAddress(identity.NodeSigner.Public()),
 		})
 		if err != nil {
 			return err
 		}
+		nonce := account.General.Nonce
 		tx := registry.NewRegisterNodeTx(nonce, &transaction.Fee{Gas: 50000}, sigNode)
 		sigTx, err := transaction.Sign(identity.NodeSigner, tx)
 		if err != nil {

go/oasis-test-runner/scenario/e2e/runtime/keymanager_rotation_failure.go

@@ -337,6 +337,12 @@ func (nt *nodeTracker) Nodes(nodes []signature.PublicKey) map[core.PeerID]signat
 }
 
 func (nt *nodeTracker) trackKeymanagerNodes(ctx context.Context) {
+	select {
+	case <-nt.consensus.Synced():
+	case <-ctx.Done():
+		return
+	}
+
 	stCh, stSub, err := nt.consensus.KeyManager().Secrets().WatchStatuses(ctx)
 	if err != nil {
 		nt.logger.Error("failed to watch key manager secrets statuses",