Implement spendoutputs JSON-RPC method

This method provides greater coin control when creating and sending
transactions.  Rather than the wallet performing UTXO selection on its own,
only the specified inputs and outputs (with the exception of wallet change)
will be used.

This is intended to be a more ergonomic and easier to use alternative to the
raw transaction RPCs (createrawtransaction, signrawtransaction, and
sendrawtransaction).

Author: jrick

internal/rpc/jsonrpc/methods.go

@@ -55,9 +55,9 @@ import (
 
 // API version constants
 const (
-	jsonrpcSemverString = "9.1.0"
+	jsonrpcSemverString = "9.2.0"
 	jsonrpcSemverMajor  = 9
-	jsonrpcSemverMinor  = 1
+	jsonrpcSemverMinor  = 2
 	jsonrpcSemverPatch  = 0
 )
 
@@ -170,6 +170,7 @@ var handlers = map[string]handler{
 	"signmessage":               {fn: (*Server).signMessage},
 	"signrawtransaction":        {fn: (*Server).signRawTransaction},
 	"signrawtransactions":       {fn: (*Server).signRawTransactions},
+	"spendoutputs":              {fn: (*Server).spendOutputs},
 	"stakepooluserinfo":         {fn: (*Server).stakePoolUserInfo},
 	"sweepaccount":              {fn: (*Server).sweepAccount},
 	"syncstatus":                {fn: (*Server).syncStatus},
@@ -4180,6 +4181,168 @@ func (s *Server) rescanWallet(ctx context.Context, icmd any) (any, error) {
 	return nil, err
 }
 
+// spendOutputsInputSource creates an input source from a wallet and a list of
+// outputs to be spent.  Only the provided outputs will be returned by the
+// source, without any other input selection.
+func spendOutputsInputSource(ctx context.Context, w *wallet.Wallet,
+	account string, inputs []*wire.TxIn) (txauthor.InputSource, error) {
+
+	params := w.ChainParams()
+
+	detail := new(txauthor.InputDetail)
+	detail.Inputs = inputs
+	detail.Scripts = make([][]byte, len(inputs))
+	detail.RedeemScriptSizes = make([]int, len(inputs))
+	for i, in := range inputs {
+		prevOut, err := w.FetchOutput(ctx, &in.PreviousOutPoint)
+		if err != nil {
+			return nil, err
+		}
+		detail.Amount += dcrutil.Amount(prevOut.Value)
+		detail.Scripts[i] = prevOut.PkScript
+		st, addrs := stdscript.ExtractAddrs(prevOut.Version,
+			prevOut.PkScript, params)
+		var addr stdaddr.Address
+		var redeemScriptSize int
+		switch st {
+		case stdscript.STPubKeyHashEcdsaSecp256k1:
+			addr = addrs[0]
+			redeemScriptSize = txsizes.RedeemP2PKHInputSize
+		default:
+			// XXX: don't assume P2PKH, support other script types
+			return nil, errors.E("unsupport address type")
+		}
+		ka, err := w.KnownAddress(ctx, addr)
+		if err != nil {
+			return nil, err
+		}
+		if ka.AccountName() != account {
+			err := errors.Errorf("output address of %v does not "+
+				"belong to account %q", &in.PreviousOutPoint,
+				account)
+			return nil, errors.E(errors.Invalid, err)
+		}
+		detail.RedeemScriptSizes[i] = redeemScriptSize
+	}
+
+	fn := func(target dcrutil.Amount) (*txauthor.InputDetail, error) {
+		return detail, nil
+	}
+	return fn, nil
+}
+
+type accountChangeSource struct {
+	ctx     context.Context
+	wallet  *wallet.Wallet
+	account uint32
+	addr    stdaddr.Address
+}
+
+func (a *accountChangeSource) Script() (script []byte, version uint16, err error) {
+	if a.addr == nil {
+		addr, err := a.wallet.NewChangeAddress(a.ctx, a.account)
+		if err != nil {
+			return nil, 0, err
+		}
+		a.addr = addr
+	}
+
+	version, script = a.addr.PaymentScript()
+	return
+}
+
+func (a *accountChangeSource) ScriptSize() int {
+	// XXX: shouldn't assume P2PKH
+	return txsizes.P2PKHOutputSize
+}
+
+// spendOutputs creates, signs and publishes a transaction that spends the
+// specified outputs belonging to an account, pays a list of address/amount
+// pairs, with any change returned to the specified account.
+func (s *Server) spendOutputs(ctx context.Context, icmd any) (any, error) {
+	cmd := icmd.(*types.SpendOutputsCmd)
+	w, ok := s.walletLoader.LoadedWallet()
+	if !ok {
+		return nil, errUnloadedWallet
+	}
+	n, err := w.NetworkBackend()
+	if err != nil {
+		return nil, err
+	}
+
+	params := w.ChainParams()
+
+	account, err := w.AccountNumber(ctx, cmd.Account)
+	if err != nil {
+		return nil, err
+	}
+
+	inputs := make([]*wire.TxIn, 0, len(cmd.PreviousOutpoints))
+	outputs := make([]*wire.TxOut, 0, len(cmd.Outputs))
+	for _, outpointStr := range cmd.PreviousOutpoints {
+		op, err := parseOutpoint(outpointStr)
+		if err != nil {
+			return nil, rpcError(dcrjson.ErrRPCInvalidParameter, err)
+		}
+		inputs = append(inputs, wire.NewTxIn(op, wire.NullValueIn, nil))
+	}
+	for _, output := range cmd.Outputs {
+		addr, err := stdaddr.DecodeAddress(output.Address, params)
+		if err != nil {
+			return nil, err
+		}
+		amount, err := dcrutil.NewAmount(output.Amount)
+		if err != nil {
+			return nil, rpcError(dcrjson.ErrRPCInvalidParameter, err)
+		}
+		scriptVersion, script := addr.PaymentScript()
+		txOut := wire.NewTxOut(int64(amount), script)
+		txOut.Version = scriptVersion
+		outputs = append(outputs, txOut)
+	}
+	wallet.Shuffle(len(inputs), func(i, j int) {
+		inputs[i], inputs[j] = inputs[j], inputs[i]
+	})
+	wallet.Shuffle(len(outputs), func(i, j int) {
+		outputs[i], outputs[j] = outputs[j], outputs[i]
+	})
+
+	inputSource, err := spendOutputsInputSource(ctx, w, cmd.Account,
+		inputs)
+	if err != nil {
+		return nil, err
+	}
+
+	changeSource := &accountChangeSource{
+		ctx:     ctx,
+		wallet:  w,
+		account: account,
+	}
+
+	secretsSource, err := w.SecretsSource()
+	if err != nil {
+		return nil, err
+	}
+	defer secretsSource.Close()
+
+	atx, err := txauthor.NewUnsignedTransaction(outputs, w.RelayFee(),
+		inputSource, changeSource, params.MaxTxSize)
+	if err != nil {
+		return nil, err
+	}
+	atx.RandomizeChangePosition()
+	err = atx.AddAllInputScripts(secretsSource)
+	if err != nil {
+		return nil, err
+	}
+
+	hash, err := w.PublishTransaction(ctx, atx.Tx, n)
+	if err != nil {
+		return nil, err
+	}
+	return hash.String(), nil
+}
+
 // stakePoolUserInfo returns the ticket information for a given user from the
 // stake pool.
 func (s *Server) stakePoolUserInfo(ctx context.Context, icmd any) (any, error) {

internal/rpc/jsonrpc/rpcserverhelp.go

@@ -869,6 +869,16 @@ var helpDescsEnUS = map[string]string{
 	"signedtransaction-sent":            "Tells if the transaction was sent.",
 	"signedtransaction-signingresult":   "Success or failure of signing.",
 
+	// SpendOutputsCmd help.
+	"spendoutputs--synopsis": "Create, sign, and publish a transaction spending the specified wallet outputs, and paying an array of address/amount pairs.\n" +
+		"Outputs must belong to the specified account, and change (if needed) is returned to an internal address of the same account.",
+	"spendoutputs-account":           "Account of specified previous outpoints, and account used to return change",
+	"spendoutputs-previousoutpoints": `Array of outpoints in string encoding ("hash:index")`,
+	"spendoutputs-outputs":           "Array of JSON objects, each specifying an address string and amount",
+	"spendoutputs--result0":          "The published transaction hash",
+	"addressamountpair-address":      "Address to pay",
+	"addressamountpair-amount":       "Amount to pay the address",
+
 	// StakePoolUserInfoCmd help.
 	"stakepooluserinfo--synopsis": "Get user info for stakepool",
 	"stakepooluserinfo-user":      "The id of the user to be looked up",

internal/rpchelp/helpdescs_en_US.go

@@ -90,8 +90,8 @@ var Methods = []struct {
 	{"lockunspent", returnsBool},
 	{"mixaccount", nil},
 	{"mixoutput", nil},
-	{"purchaseticket", returnsString},
 	{"processunmanagedticket", nil},
+	{"purchaseticket", returnsString},
 	{"redeemmultisigout", []any{(*types.RedeemMultiSigOutResult)(nil)}},
 	{"redeemmultisigouts", []any{(*types.RedeemMultiSigOutResult)(nil)}},
 	{"renameaccount", nil},
@@ -112,6 +112,7 @@ var Methods = []struct {
 	{"signmessage", returnsString},
 	{"signrawtransaction", []any{(*types.SignRawTransactionResult)(nil)}},
 	{"signrawtransactions", []any{(*types.SignRawTransactionsResult)(nil)}},
+	{"spendoutputs", returnsString},
 	{"stakepooluserinfo", []any{(*types.StakePoolUserInfoResult)(nil)}},
 	{"sweepaccount", []any{(*types.SweepAccountResult)(nil)}},
 	{"syncstatus", []any{(*types.SyncStatusResult)(nil)}},

internal/rpchelp/methods.go

@@ -1206,14 +1206,29 @@ type ProcessUnmanagedTicketCmd struct {
 	TicketHash *string
 }
 
-type registeredMethod struct {
-	method string
-	cmd    any
+// GetCoinjoinsByAcctCmd defines the getcoinjoinsbyaccount JSON-RPC command arguments.
+type GetCoinjoinsByAcctCmd struct{}
+
+// SpendOutputsCmd defines the spendoutputs JSON-RPC command arguments.
+type SpendOutputsCmd struct {
+	Account           string
+	PreviousOutpoints []string
+	Outputs           []AddressAmountPair
 }
 
-type GetCoinjoinsByAcctCmd struct{}
+// AddressAmountPair represents a JSON object defining an address and an
+// amount.
+type AddressAmountPair struct {
+	Address string  `json:"address"`
+	Amount  float64 `json:"amount"`
+}
 
 func init() {
+	type registeredMethod struct {
+		method string
+		cmd    any
+	}
+
 	// Wallet-specific methods
 	register := []registeredMethod{
 		{"abandontransaction", (*AbandonTransactionCmd)(nil)},
@@ -1289,6 +1304,7 @@ func init() {
 		{"signmessage", (*SignMessageCmd)(nil)},
 		{"signrawtransaction", (*SignRawTransactionCmd)(nil)},
 		{"signrawtransactions", (*SignRawTransactionsCmd)(nil)},
+		{"spendoutputs", (*SpendOutputsCmd)(nil)},
 		{"stakepooluserinfo", (*StakePoolUserInfoCmd)(nil)},
 		{"sweepaccount", (*SweepAccountCmd)(nil)},
 		{"syncstatus", (*SyncStatusCmd)(nil)},

rpc/jsonrpc/types/methods.go

@@ -199,6 +199,62 @@ func (s *secretSource) GetScript(addr stdaddr.Address) ([]byte, error) {
 	return s.Manager.RedeemScript(s.addrmgrNs, addr)
 }
 
+// SecretsSource is an implementation of txauthor.SecretsSource querying the
+// wallet's address manager.
+//
+// The Close method must be called after the SecretsSource usage is over.
+type SecretsSource struct {
+	wallet    *Wallet
+	dbtx      walletdb.ReadTx
+	doneFuncs []func()
+}
+
+// SecretsSource returns a txauthor.SecretsSource implementor using the wallet
+// as the backing store for keys and scripts.
+func (w *Wallet) SecretsSource() (*SecretsSource, error) {
+	dbtx, err := w.db.BeginReadTx()
+	if err != nil {
+		return nil, err
+	}
+	return &SecretsSource{wallet: w, dbtx: dbtx}, nil
+}
+
+// ChainParams returns the chain parameters.
+func (s *SecretsSource) ChainParams() *chaincfg.Params {
+	return s.wallet.chainParams
+}
+
+// GetKey provides the private key associated with an address.
+func (s *SecretsSource) GetKey(addr stdaddr.Address) (key []byte, sigType dcrec.SignatureType, compressed bool, err error) {
+	addrmgrNs := s.dbtx.ReadBucket(waddrmgrNamespaceKey)
+	privKey, done, err := s.wallet.manager.PrivateKey(addrmgrNs, addr)
+	if err != nil {
+		return
+	}
+	s.doneFuncs = append(s.doneFuncs, done)
+	return privKey.Serialize(), dcrec.STEcdsaSecp256k1, true, nil
+}
+
+// GetScript provides the redeem script for a P2SH address.
+func (s *SecretsSource) GetScript(addr stdaddr.Address) ([]byte, error) {
+	addrmgrNs := s.dbtx.ReadBucket(waddrmgrNamespaceKey)
+	return s.wallet.manager.RedeemScript(addrmgrNs, addr)
+}
+
+// Close finishes the SecretsSource usage by releasing all secret key material
+// and closing the underlying database transaction.
+func (s *SecretsSource) Close() error {
+	for _, f := range s.doneFuncs {
+		f()
+	}
+	s.doneFuncs = nil
+	err := s.dbtx.Rollback()
+	if err == nil {
+		s.dbtx = nil
+	}
+	return err
+}
+
 // CreatedTx holds the state of a newly-created transaction and the change
 // output (if one was added).
 type CreatedTx struct {

wallet/createtx.go

@@ -45,3 +45,8 @@ func shuffle(n int, swap func(i, j int)) {
 		swap(int(i), int(j))
 	}
 }
+
+// Shuffle cryptographically shuffles a total of n items.
+func Shuffle(n int, swap func(i, j int)) {
+	shuffle(n, swap)
+}