Merge branch 'psbt'

Author: benma

.golangci.yml

@@ -120,6 +120,7 @@ linters:
     - predeclared
     - tenv
     - recvcheck
+    - godot
   disable-all: false
 
 issues:

backend/accounts.go

@@ -1063,14 +1063,14 @@ func (backend *Backend) createAndAddAccount(coin coinpkg.Coin, persistedConfig *
 
 	// This function is passed as a callback to the BTC account constructor. It is called when the
 	// keystore needs to determine whether an address belongs to an account on its same keystore.
-	getAddressCallback := func(askingAccount *btc.Account, scriptHashHex blockchain.ScriptHashHex) (*addresses.AccountAddress, bool, error) {
+	getAddressCallback := func(coinCode coinpkg.Code, scriptHashHex blockchain.ScriptHashHex) (*addresses.AccountAddress, error) {
 		accountsByKeystore, err := backend.AccountsByKeystore()
 		if err != nil {
-			return nil, false, err
+			return nil, err
 		}
 		rootFingerprint, err := backend.keystore.RootFingerprint()
 		if err != nil {
-			return nil, false, err
+			return nil, err
 		}
 		for _, account := range accountsByKeystore[hex.EncodeToString(rootFingerprint)] {
 			// This only makes sense for BTC accounts.
@@ -1079,14 +1079,14 @@ func (backend *Backend) createAndAddAccount(coin coinpkg.Coin, persistedConfig *
 				continue
 			}
 			// Only return an address if the coin codes match.
-			if btcAccount.Coin().Code() != askingAccount.Coin().Code() {
+			if btcAccount.Coin().Code() != coinCode {
 				continue
 			}
 			if address := btcAccount.GetAddress(scriptHashHex); address != nil {
-				return address, askingAccount == btcAccount, nil
+				return address, nil
 			}
 		}
-		return nil, false, nil
+		return nil, nil
 	}
 
 	switch specificCoin := coin.(type) {

backend/accounts_test.go

@@ -1491,7 +1491,7 @@ func TestKeystoresBalance(t *testing.T) {
 	b := newBackend(t, testnetDisabled, regtestDisabled)
 	defer b.Close()
 
-	b.makeBtcAccount = func(config *accounts.AccountConfig, coin *btc.Coin, gapLimits *types.GapLimits, getAddress func(*btc.Account, blockchain.ScriptHashHex) (*addresses.AccountAddress, bool, error), log *logrus.Entry) accounts.Interface {
+	b.makeBtcAccount = func(config *accounts.AccountConfig, coin *btc.Coin, gapLimits *types.GapLimits, getAddress func(coinpkg.Code, blockchain.ScriptHashHex) (*addresses.AccountAddress, error), log *logrus.Entry) accounts.Interface {
 		accountMock := MockBtcAccount(t, config, coin, gapLimits, log)
 		accountMock.BalanceFunc = func() (*accounts.Balance, error) {
 			return accounts.NewBalance(coinpkg.NewAmountFromInt64(1e8), coinpkg.NewAmountFromInt64(0)), nil
@@ -1561,7 +1561,7 @@ func TestCoinsTotalBalance(t *testing.T) {
 	b := newBackend(t, testnetDisabled, regtestDisabled)
 	defer b.Close()
 
-	b.makeBtcAccount = func(config *accounts.AccountConfig, coin *btc.Coin, gapLimits *types.GapLimits, getAddress func(*btc.Account, blockchain.ScriptHashHex) (*addresses.AccountAddress, bool, error), log *logrus.Entry) accounts.Interface {
+	b.makeBtcAccount = func(config *accounts.AccountConfig, coin *btc.Coin, gapLimits *types.GapLimits, getAddress func(coinpkg.Code, blockchain.ScriptHashHex) (*addresses.AccountAddress, error), log *logrus.Entry) accounts.Interface {
 		accountMock := MockBtcAccount(t, config, coin, gapLimits, log)
 		accountMock.BalanceFunc = func() (*accounts.Balance, error) {
 			return accounts.NewBalance(coinpkg.NewAmountFromInt64(1e8), coinpkg.NewAmountFromInt64(0)), nil
@@ -1622,7 +1622,7 @@ func TestAccountsFiatAndCoinBalance(t *testing.T) {
 	b := newBackend(t, testnetDisabled, regtestDisabled)
 	defer b.Close()
 
-	b.makeBtcAccount = func(config *accounts.AccountConfig, coin *btc.Coin, gapLimits *types.GapLimits, getAddress func(*btc.Account, blockchain.ScriptHashHex) (*addresses.AccountAddress, bool, error), log *logrus.Entry) accounts.Interface {
+	b.makeBtcAccount = func(config *accounts.AccountConfig, coin *btc.Coin, gapLimits *types.GapLimits, getAddress func(coinpkg.Code, blockchain.ScriptHashHex) (*addresses.AccountAddress, error), log *logrus.Entry) accounts.Interface {
 		accountMock := MockBtcAccount(t, config, coin, gapLimits, log)
 		accountMock.BalanceFunc = func() (*accounts.Balance, error) {
 			return accounts.NewBalance(coinpkg.NewAmountFromInt64(1e8), coinpkg.NewAmountFromInt64(0)), nil

backend/backend.go

@@ -229,7 +229,7 @@ type Backend struct {
 
 	// makeBtcAccount creates a BTC account. In production this is `btc.NewAccount`, but can be
 	// overridden in unit tests for mocking.
-	makeBtcAccount func(*accounts.AccountConfig, *btc.Coin, *types.GapLimits, func(*btc.Account, blockchain.ScriptHashHex) (*addresses.AccountAddress, bool, error), *logrus.Entry) accounts.Interface
+	makeBtcAccount func(*accounts.AccountConfig, *btc.Coin, *types.GapLimits, func(coinpkg.Code, blockchain.ScriptHashHex) (*addresses.AccountAddress, error), *logrus.Entry) accounts.Interface
 	// makeEthAccount creates an ETH account. In production this is `eth.NewAccount`, but can be
 	// overridden in unit tests for mocking.
 	makeEthAccount func(*accounts.AccountConfig, *eth.Coin, *http.Client, *logrus.Entry) accounts.Interface
@@ -298,7 +298,7 @@ func NewBackend(arguments *arguments.Arguments, environment Environment) (*Backe
 		coins:    map[coinpkg.Code]coinpkg.Coin{},
 		accounts: []accounts.Interface{},
 		aopp:     AOPP{State: aoppStateInactive},
-		makeBtcAccount: func(config *accounts.AccountConfig, coin *btc.Coin, gapLimits *types.GapLimits, getAddress func(*btc.Account, blockchain.ScriptHashHex) (*addresses.AccountAddress, bool, error), log *logrus.Entry) accounts.Interface {
+		makeBtcAccount: func(config *accounts.AccountConfig, coin *btc.Coin, gapLimits *types.GapLimits, getAddress func(coinpkg.Code, blockchain.ScriptHashHex) (*addresses.AccountAddress, error), log *logrus.Entry) accounts.Interface {
 			return btc.NewAccount(config, coin, gapLimits, getAddress, log, hclient)
 		},
 		makeEthAccount: func(config *accounts.AccountConfig, coin *eth.Coin, httpClient *http.Client, log *logrus.Entry) accounts.Interface {

backend/backend_test.go

@@ -281,7 +281,7 @@ func newBackend(t *testing.T, testing, regtest bool) *Backend {
 	}
 	b.ratesUpdater.SetCoingeckoURL("unused") // avoid hitting real API
 
-	b.makeBtcAccount = func(config *accounts.AccountConfig, coin *btc.Coin, gapLimits *types.GapLimits, getAddress func(*btc.Account, blockchain.ScriptHashHex) (*addresses.AccountAddress, bool, error), log *logrus.Entry) accounts.Interface {
+	b.makeBtcAccount = func(config *accounts.AccountConfig, coin *btc.Coin, gapLimits *types.GapLimits, getAddress func(coinpkg.Code, blockchain.ScriptHashHex) (*addresses.AccountAddress, error), log *logrus.Entry) accounts.Interface {
 		return MockBtcAccount(t, config, coin, gapLimits, log)
 	}
 	b.makeEthAccount = func(config *accounts.AccountConfig, coin *eth.Coin, httpClient *http.Client, log *logrus.Entry) accounts.Interface {

backend/coins/btc/account.go

@@ -122,7 +122,7 @@ type Account struct {
 	httpClient *http.Client
 
 	// getAddressFromSameKeystore is a function that retrieves an address from any account on the same keystore as this one.
-	getAddressFromSameKeystore func(*Account, blockchain.ScriptHashHex) (*addresses.AccountAddress, bool, error)
+	getAddressFromSameKeystore func(coin.Code, blockchain.ScriptHashHex) (*addresses.AccountAddress, error)
 }
 
 // NewAccount creates a new account.
@@ -133,7 +133,7 @@ func NewAccount(
 	config *accounts.AccountConfig,
 	coin *Coin,
 	forceGapLimits *types.GapLimits,
-	getAddressFromSameKeystore func(*Account, blockchain.ScriptHashHex) (*addresses.AccountAddress, bool, error),
+	getAddressFromSameKeystore func(coin.Code, blockchain.ScriptHashHex) (*addresses.AccountAddress, error),
 	log *logrus.Entry,
 	httpClient *http.Client,
 ) *Account {

backend/coins/btc/addresses/address.go

@@ -21,13 +21,11 @@ import (
 	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/coins/btc/types"
 	ourbtcutil "github.com/BitBoxSwiss/bitbox-wallet-app/backend/coins/btc/util"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/signing"
-	"github.com/BitBoxSwiss/bitbox-wallet-app/util/errp"
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/btcsuite/btcd/btcec/v2/schnorr"
 	"github.com/btcsuite/btcd/btcutil"
 	"github.com/btcsuite/btcd/chaincfg"
 	"github.com/btcsuite/btcd/txscript"
-	"github.com/btcsuite/btcd/wire"
 	"github.com/sirupsen/logrus"
 )
 
@@ -38,12 +36,13 @@ type AccountAddress struct {
 
 	// AccountConfiguration is the account level configuration from which this address was derived.
 	AccountConfiguration *signing.Configuration
-	// publicKey is the public key of a single-sig address.
-	publicKey  *btcec.PublicKey
+	// PublicKey is the public key of a single-sig address.
+	PublicKey  *btcec.PublicKey
 	Derivation types.Derivation
 
-	// redeemScript stores the redeem script of a BIP16 P2SH output or nil if address type is P2PKH.
-	redeemScript []byte
+	// redeemScript stores the redeem script of a BIP16 P2SH output or nil if address type is not
+	// P2SH.
+	RedeemScript []byte
 
 	log *logrus.Entry
 }
@@ -116,9 +115,9 @@ func NewAccountAddress(
 	return &AccountAddress{
 		Address:              address,
 		AccountConfiguration: accountConfiguration,
-		publicKey:            publicKey,
+		PublicKey:            publicKey,
 		Derivation:           derivation,
-		redeemScript:         redeemScript,
+		RedeemScript:         redeemScript,
 		log:                  log,
 	}
 }
@@ -128,23 +127,6 @@ func (address *AccountAddress) ID() string {
 	return string(address.PubkeyScriptHashHex())
 }
 
-// BIP352Pubkey returns the pubkey used for silent payments:
-// - 33 byte compressed public key for p2pkh, p2wpkh, p2wpkh-p2sh.
-// - 32 byte x-only public key for p2tr
-// See https://github.com/bitcoin/bips/blob/master/bip-0352.mediawiki#user-content-Inputs_For_Shared_Secret_Derivation.
-func (address *AccountAddress) BIP352Pubkey() ([]byte, error) {
-	publicKey := address.publicKey
-	switch address.AccountConfiguration.ScriptType() {
-	case signing.ScriptTypeP2PKH, signing.ScriptTypeP2WPKHP2SH, signing.ScriptTypeP2WPKH:
-		return publicKey.SerializeCompressed(), nil
-	case signing.ScriptTypeP2TR:
-		outputKey := txscript.ComputeTaprootKeyNoScript(publicKey)
-		return schnorr.SerializePubKey(outputKey), nil
-	default:
-		return nil, errp.New("unsupported script type for silent payments")
-	}
-}
-
 // EncodeForHumans implements accounts.Address.
 func (address *AccountAddress) EncodeForHumans() string {
 	return address.EncodeAddress()
@@ -180,59 +162,11 @@ func (address *AccountAddress) ScriptForHashToSign() (bool, []byte) {
 	case signing.ScriptTypeP2PKH:
 		return false, address.PubkeyScript()
 	case signing.ScriptTypeP2WPKHP2SH:
-		return true, address.redeemScript
+		return true, address.RedeemScript
 	case signing.ScriptTypeP2WPKH:
 		return true, address.PubkeyScript()
 	default:
 		address.log.Panic("Unrecognized address type.")
 	}
 	panic("The end of the function cannot be reached.")
 }
-
-// SignatureScript returns the signature script (and witness) needed to spend from this address.
-// The signatures have to be provided in the order of the configuration (and some can be nil).
-func (address *AccountAddress) SignatureScript(
-	signature types.Signature,
-) ([]byte, wire.TxWitness) {
-	publicKey := address.publicKey
-	switch address.AccountConfiguration.ScriptType() {
-	case signing.ScriptTypeP2PKH:
-		signatureScript, err := txscript.NewScriptBuilder().
-			AddData(append(signature.SerializeDER(), byte(txscript.SigHashAll))).
-			AddData(publicKey.SerializeCompressed()).
-			Script()
-		if err != nil {
-			address.log.WithError(err).Panic("Failed to build signature script for P2PKH.")
-		}
-		return signatureScript, nil
-	case signing.ScriptTypeP2WPKHP2SH:
-		signatureScript, err := txscript.NewScriptBuilder().
-			AddData(address.redeemScript).
-			Script()
-		if err != nil {
-			address.log.WithError(err).Panic("Failed to build segwit signature script.")
-		}
-		txWitness := wire.TxWitness{
-			append(signature.SerializeDER(), byte(txscript.SigHashAll)),
-			publicKey.SerializeCompressed(),
-		}
-		return signatureScript, txWitness
-	case signing.ScriptTypeP2WPKH:
-		txWitness := wire.TxWitness{
-			append(signature.SerializeDER(), byte(txscript.SigHashAll)),
-			publicKey.SerializeCompressed(),
-		}
-		return []byte{}, txWitness
-	case signing.ScriptTypeP2TR:
-		// We assume SIGHASH_DEFAULT, which defaults to SIGHASH_ALL without needing to explicitly
-		// append it to the signature. See:
-		// https://github.com/bitcoin/bips/blob/97e02b2223b21753acefa813a4e59dbb6e849e77/bip-0341.mediawiki#taproot-key-path-spending-signature-validation
-		txWitness := wire.TxWitness{
-			signature.SerializeCompact(),
-		}
-		return []byte{}, txWitness
-	default:
-		address.log.Panic("Unrecognized address type.")
-	}
-	panic("The end of the function cannot be reached.")
-}

backend/coins/btc/addresses/address_export_test.go

@@ -143,7 +143,7 @@ func (s *addressChainTestSuite) TestEnsureAddresses() {
 	s.Require().Len(newAddresses, s.gapLimit)
 	for index, address := range newAddresses {
 		s.Require().Equal(uint32(index), address.AbsoluteKeypath().ToUInt32()[1])
-		s.Require().Equal(getPubKey(index), address.TstPublicKey())
+		s.Require().Equal(getPubKey(index), address.PublicKey)
 	}
 	// Address statuses are still the same, so calling it again won't produce more addresses.
 	addrs, err := s.addresses.EnsureAddresses()

backend/coins/btc/addresses/addresschain_test.go

@@ -28,6 +28,7 @@ import (
 	"github.com/BitBoxSwiss/bitbox-wallet-app/backend/signing"
 	"github.com/BitBoxSwiss/bitbox-wallet-app/util/errp"
 	"github.com/btcsuite/btcd/btcutil"
+	"github.com/btcsuite/btcd/btcutil/psbt"
 	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/txscript"
 	"github.com/btcsuite/btcd/wire"
@@ -49,8 +50,7 @@ type TxProposal struct {
 	// Amount is the amount that is sent out. The fee is not included and is deducted on top.
 	Amount btcutil.Amount
 	// Fee is the mining fee used.
-	Fee         btcutil.Amount
-	Transaction *wire.MsgTx
+	Fee btcutil.Amount
 	// ChangeAddress is the address of the wallet to which the change of the transaction is sent.
 	ChangeAddress   *addresses.AccountAddress
 	PreviousOutputs PreviousOutputs
@@ -60,11 +60,12 @@ type TxProposal struct {
 	SilentPaymentAddress string
 	// OutIndex is the index of the output we send to.
 	OutIndex int
+	Psbt     *psbt.Packet
 }
 
 // SigHashes computes the hashes cache to speed up per-input sighash computations.
 func (txProposal *TxProposal) SigHashes() *txscript.TxSigHashes {
-	return txscript.NewTxSigHashes(txProposal.Transaction, txProposal.PreviousOutputs)
+	return txscript.NewTxSigHashes(txProposal.Psbt.UnsignedTx, txProposal.PreviousOutputs)
 }
 
 // Total is amount+fee.
@@ -209,15 +210,19 @@ func NewTxSpendAll(
 	log.WithField("fee", maxRequiredFee).Debug("Preparing transaction to spend all outputs")
 
 	setRBF(coin, unsignedTransaction)
+	psbt, err := psbt.NewFromUnsignedTx(unsignedTransaction)
+	if err != nil {
+		return nil, err
+	}
 	return &TxProposal{
 		Coin:                 coin,
 		Amount:               btcutil.Amount(output.Value),
 		Fee:                  maxRequiredFee,
-		Transaction:          unsignedTransaction,
 		PreviousOutputs:      spendableOutputs,
 		SilentPaymentAddress: outputInfo.silentPaymentAddress,
 		// Only one output in send-all
 		OutIndex: 0,
+		Psbt:     psbt,
 	}, nil
 }
 
@@ -307,15 +312,20 @@ func NewTx(
 		}
 
 		setRBF(coin, unsignedTransaction)
+		psbt, err := psbt.NewFromUnsignedTx(unsignedTransaction)
+		if err != nil {
+			return nil, err
+		}
+
 		return &TxProposal{
 			Coin:                 coin,
 			Amount:               targetAmount,
 			Fee:                  finalFee,
-			Transaction:          unsignedTransaction,
 			ChangeAddress:        changeAddress,
 			PreviousOutputs:      previousOutputs,
 			SilentPaymentAddress: outputInfo.silentPaymentAddress,
 			OutIndex:             outIndex,
+			Psbt:                 psbt,
 		}, nil
 	}
 }