Fix compatibility with latest development dcrd

dcrd's JSON-RPC version received a major version bump for the removal
of several RPCs related to querying expired and missed tickets.  With
the activation of DCP0009 and the revocations of all older unspent
tickets, these methods are no longer needed by the wallet.

The "revoked" status for getstakeinfo is no longer used, and instead,
a status of "expired" or "missed" is used (which also implies that the
ticket has been revoked).  For this subtle breaking change,
dcrwallet's JSON-RPC API version also receives a major bump.

Author: jrick

chain/sync.go

@@ -25,7 +25,7 @@ import (
 	"golang.org/x/sync/errgroup"
 )
 
-var requiredAPIVersion = semver{Major: 7, Minor: 0, Patch: 0}
+var requiredAPIVersion = semver{Major: 8, Minor: 0, Patch: 0}
 
 // Syncer implements wallet synchronization services by processing
 // notifications from a dcrd JSON-RPC server.
@@ -533,10 +533,6 @@ func (s *Syncer) Run(ctx context.Context) (err error) {
 	if err != nil {
 		return err
 	}
-	err = s.rpc.Call(ctx, "rebroadcastmissed", nil)
-	if err != nil {
-		return err
-	}
 
 	log.Infof("Blockchain sync completed, wallet ready for general usage.")
 

internal/rpc/jsonrpc/methods.go

@@ -54,9 +54,9 @@ import (
 
 // API version constants
 const (
-	jsonrpcSemverString = "8.9.0"
-	jsonrpcSemverMajor  = 8
-	jsonrpcSemverMinor  = 9
+	jsonrpcSemverString = "9.0.0"
+	jsonrpcSemverMajor  = 9
+	jsonrpcSemverMinor  = 0
 	jsonrpcSemverPatch  = 0
 )
 

rpc/client/dcrd/calls.go

@@ -88,15 +88,17 @@ func (r *RPC) ExistsLiveTicket(ctx context.Context, ticket *chainhash.Hash) (boo
 	return exists, err
 }
 
-// ExistsLiveExpiredTickets returns bitsets identifying whether each ticket
-// is currently live or expired.
-func (r *RPC) ExistsLiveExpiredTickets(ctx context.Context, tickets []*chainhash.Hash) (live, expired bitset.Bytes, err error) {
+// ExistsLiveExpiredTickets returns bitsets identifying whether each ticket is
+// currently live or expired.  Following the activation of DCP0009, this method
+// will never return any expired tickets.
+//
+// Deprecated: Use ExistsLiveTickets instead.
+func (r *RPC) ExistsLiveExpiredTickets(ctx context.Context, tickets []*chainhash.Hash) (live, _ bitset.Bytes, err error) {
 	const op errors.Op = "dcrd.ExistsLiveExpiredTickets"
 	// Reuse the single json.RawMessage for both calls
 	ticketArray, _ := json.Marshal(hashSliceToStrings(tickets))
-	errs := make(chan error, 2)
+	errs := make(chan error, 1)
 	go func() { errs <- exists(ctx, r, "existslivetickets", &live, ticketArray) }()
-	go func() { errs <- exists(ctx, r, "existsexpiredtickets", &expired, ticketArray) }()
 	for i := 0; i < cap(errs); i++ {
 		if e := <-errs; err == nil && e != nil {
 			// Must only return after all exists calls are
@@ -109,19 +111,11 @@ func (r *RPC) ExistsLiveExpiredTickets(ctx context.Context, tickets []*chainhash
 	return
 }
 
-// ExistsExpiredMissedTickets returns bitsets identifying whether each ticket
-// is currently expired or missed.
-func (r *RPC) ExistsExpiredMissedTickets(ctx context.Context, tickets []*chainhash.Hash) (expired, missed bitset.Bytes, err error) {
-	const op errors.Op = "dcrd.ExistsExpiredMissedTickets"
-	ticketArray, _ := json.Marshal(hashSliceToStrings(tickets))
-	errs := make(chan error, 2)
-	go func() { errs <- exists(ctx, r, "existsexpiredtickets", &expired, ticketArray) }()
-	go func() { errs <- exists(ctx, r, "existsmissedtickets", &missed, ticketArray) }()
-	for i := 0; i < cap(errs); i++ {
-		if e := <-errs; err == nil && e != nil {
-			err = errors.E(op, e)
-		}
-	}
+// ExistsExpiredMissedTckets no longer performs any RPC as there should never be
+// unspent expired or missed tickets after the activation of DCP0009.
+//
+// Deprecated: this method will be removed in the next major version.
+func (r *RPC) ExistsExpiredMissedTickets(ctx context.Context, tickets []*chainhash.Hash) (_, _ bitset.Bytes, _ error) {
 	return
 }
 

rpc/client/dcrd/notifications.go

@@ -67,6 +67,9 @@ func RelevantTxAccepted(params json.RawMessage) (tx *wire.MsgTx, err error) {
 
 // MissedTickets extracts the missed ticket hashes from the parameters of a
 // spentandmissedtickets JSON-RPC notification.
+//
+// Deprecated: The missedtickets notification was removed from dcrd and this
+// function will be removed in the next major version.
 func MissedTickets(params json.RawMessage) (missed []*chainhash.Hash, err error) {
 	// Parameters (array):
 	// 0: Block hash (reversed hex)

wallet/tickets.go

@@ -6,11 +6,9 @@ package wallet
 
 import (
 	"context"
-	"time"
 
 	"decred.org/dcrwallet/v2/errors"
 	"decred.org/dcrwallet/v2/rpc/client/dcrd"
-	"decred.org/dcrwallet/v2/wallet/udb"
 	"decred.org/dcrwallet/v2/wallet/walletdb"
 	"github.com/decred/dcrd/blockchain/stake/v4"
 	"github.com/decred/dcrd/chaincfg/chainhash"
@@ -226,105 +224,11 @@ func (w *Wallet) TicketHashesForVotingAddress(ctx context.Context, votingAddr st
 	return ticketHashes, nil
 }
 
-// RevokeTickets creates and sends revocation transactions for any unrevoked
-// missed and expired tickets.  The wallet must be unlocked to generate any
-// revocations.
+// RevokeTickets no longer revokes any tickets since revocations are now
+// automatically created per DCP0009.
+//
+// Deprecated: this method will be removed in the next major version.
 func (w *Wallet) RevokeTickets(ctx context.Context, rpcCaller Caller) error {
-	const op errors.Op = "wallet.RevokeTickets"
-
-	var ticketHashes []chainhash.Hash
-	err := walletdb.View(ctx, w.db, func(dbtx walletdb.ReadTx) error {
-		var err error
-		_, tipHeight := w.txStore.MainChainTip(dbtx)
-		ticketHashes, err = w.txStore.UnspentTickets(dbtx, tipHeight, false)
-		return err
-	})
-	if err != nil {
-		return errors.E(op, err)
-	}
-
-	ticketHashPtrs := make([]*chainhash.Hash, len(ticketHashes))
-	for i := range ticketHashes {
-		ticketHashPtrs[i] = &ticketHashes[i]
-	}
-	rpc := dcrd.New(rpcCaller)
-	expired, missed, err := rpc.ExistsExpiredMissedTickets(ctx, ticketHashPtrs)
-	if err != nil {
-		return errors.E(op, err)
-	}
-	revokableTickets := make([]*chainhash.Hash, 0, len(ticketHashes))
-	for i, p := range ticketHashPtrs {
-		if !(expired.Get(i) || missed.Get(i)) {
-			continue
-		}
-		revokableTickets = append(revokableTickets, p)
-	}
-	feePerKb := w.RelayFee()
-	revocations := make([]*wire.MsgTx, 0, len(revokableTickets))
-	err = walletdb.View(ctx, w.db, func(dbtx walletdb.ReadTx) error {
-		for _, ticketHash := range revokableTickets {
-			addrmgrNs := dbtx.ReadBucket(waddrmgrNamespaceKey)
-			txmgrNs := dbtx.ReadBucket(wtxmgrNamespaceKey)
-			ticketPurchase, err := w.txStore.Tx(txmgrNs, ticketHash)
-			if err != nil {
-				return err
-			}
-
-			// Don't create revocations when this wallet doesn't have voting
-			// authority or the private key to revoke.
-			owned, haveKey, err := w.hasVotingAuthority(addrmgrNs, ticketPurchase)
-			if err != nil {
-				return err
-			}
-			if !(owned && haveKey) {
-				continue
-			}
-
-			revocation, err := createUnsignedRevocation(ticketHash,
-				ticketPurchase, feePerKb, w.chainParams)
-			if err != nil {
-				return err
-			}
-			err = w.signRevocation(addrmgrNs, ticketPurchase, revocation)
-			if err != nil {
-				return err
-			}
-			revocations = append(revocations, revocation)
-		}
-		return nil
-	})
-	if err != nil {
-		return errors.E(op, err)
-	}
-
-	for i, revocation := range revocations {
-		rec, err := udb.NewTxRecordFromMsgTx(revocation, time.Now())
-		if err != nil {
-			return errors.E(op, err)
-		}
-		var watch []wire.OutPoint
-		//w.lockedOutpointMu intentionally not locked.
-		err = walletdb.Update(ctx, w.db, func(dbtx walletdb.ReadWriteTx) error {
-			// Could be more efficient by avoiding processTransaction, as we
-			// know it is a revocation.
-			watch, err = w.processTransactionRecord(ctx, dbtx, rec, nil, nil)
-			if err != nil {
-				return errors.E(op, err)
-			}
-			return rpc.PublishTransaction(ctx, revocation)
-		})
-		if err != nil {
-			return errors.E(op, err)
-		}
-
-		log.Infof("Revoked ticket %v with revocation %v", revokableTickets[i],
-			&rec.Hash)
-		err = rpc.LoadTxFilter(ctx, false, nil, watch)
-		if err != nil {
-			log.Errorf("Failed to watch outpoints: %v", err)
-		}
-	}
-
 	return nil
 }
 

wallet/wallet.go

@@ -2923,6 +2923,9 @@ const (
 	TicketStatusUnspent // unspent
 
 	// TicketStatusRevoked any ticket that has been previously revoked.
+	//
+	// Deprecated: The ticket status will be either missed or expired
+	// instead.  There are no more unrevoked missed/expired tickets.
 	TicketStatusRevoked // revoked
 )
 
@@ -2956,31 +2959,17 @@ func makeTicketSummary(ctx context.Context, rpc *dcrd.RPC, dbtx walletdb.ReadTx,
 		case stake.TxTypeSSGen:
 			summary.Status = TicketStatusVoted
 		case stake.TxTypeSSRtx:
-			summary.Status = TicketStatusRevoked
-		}
-		return summary
-	}
-
-	if rpc != nil && summary.Status == TicketStatusLive {
-		// In RPC mode, find if unspent ticket was expired or missed.
-		hashes := []*chainhash.Hash{&details.Ticket.Hash}
-		live, expired, err := rpc.ExistsLiveExpiredTickets(ctx, hashes)
-		switch {
-		case err != nil:
-			log.Errorf("Unable to check if ticket was live "+
-				"for ticket status: %v", &details.Ticket.Hash)
-			summary.Status = TicketStatusUnknown
-		case expired.Get(0):
-			summary.Status = TicketStatusExpired
-		case !live.Get(0):
-			summary.Status = TicketStatusMissed
-		}
-	} else if rpc == nil {
-		// In SPV mode, use expired status when the ticket is certainly
-		// past the expiry period (even though it is possible that the
-		// ticket was missed rather than expiring).
-		if ticketExpired(w.chainParams, ticketHeight, tipHeight) {
-			summary.Status = TicketStatusExpired
+			params := w.chainParams
+			ticketHeight := details.Ticket.Block.Height
+			revocationHeight := details.Spender.Block.Height
+			expired := revocationHeight-ticketHeight >=
+				int32(params.TicketExpiryBlocks())+
+					int32(params.TicketMaturity)
+			if expired {
+				summary.Status = TicketStatusExpired
+			} else {
+				summary.Status = TicketStatusMissed
+			}
 		}
 	}