tapgarden: large scale hardening

asset/asset.go

@@ -348,6 +348,17 @@ func (g Genesis) TagHash() [sha256.Size]byte {
 	return sha256.Sum256([]byte(g.Tag))
 }
 
+// Copy returns a deep copy of *Genesis. Every field is value-typed
+// (OutPoint, string, fixed-size array, scalars), so a struct value
+// copy is itself a deep copy. Returns nil if g is nil.
+func (g *Genesis) Copy() *Genesis {
+	if g == nil {
+		return nil
+	}
+	cpy := *g
+	return &cpy
+}
+
 // ID serves as a unique identifier of an asset, resulting from:
 //
 //	sha256(genesisOutPoint || sha256(tag) || sha256(metadata) ||
@@ -1165,6 +1176,18 @@ func (a *AssetGroup) IsGroupAnchor() (bool, error) {
 	return a.GroupKey.IsGroupAnchor(a.Genesis.ID())
 }
 
+// Copy returns a deep copy of *AssetGroup. The embedded *Genesis and
+// *GroupKey are both cloned independently. Returns nil if a is nil.
+func (a *AssetGroup) Copy() *AssetGroup {
+	if a == nil {
+		return nil
+	}
+	return &AssetGroup{
+		Genesis:  a.Genesis.Copy(),
+		GroupKey: a.GroupKey.Copy(),
+	}
+}
+
 // ExternalKey represents an external key used for deriving and managing
 // hierarchical deterministic (HD) wallet addresses according to BIP-86.
 type ExternalKey struct {
@@ -1246,6 +1269,22 @@ func (e *ExternalKey) PubKey() (btcec.PublicKey, error) {
 	return *pubKey, nil
 }
 
+// Copy returns a deep copy of an ExternalKey. The DerivationPath
+// slice is duplicated; the embedded hdkeychain.ExtendedKey is value-
+// copied (its internal byte slices are private and never mutated
+// externally, so shared references are safe in practice).
+func (e ExternalKey) Copy() ExternalKey {
+	out := ExternalKey{
+		XPub:              e.XPub,
+		MasterFingerprint: e.MasterFingerprint,
+	}
+	if e.DerivationPath != nil {
+		out.DerivationPath = make([]uint32, len(e.DerivationPath))
+		copy(out.DerivationPath, e.DerivationPath)
+	}
+	return out
+}
+
 // EqualKeyDescriptors returns true if the two key descriptors are equal.
 func EqualKeyDescriptors(a, o keychain.KeyDescriptor) bool {
 	if a.KeyLocator != o.KeyLocator {
@@ -1259,6 +1298,29 @@ func EqualKeyDescriptors(a, o keychain.KeyDescriptor) bool {
 	return a.PubKey.IsEqual(o.PubKey)
 }
 
+// CopyPubKey clones a btcec.PublicKey by value-copying its underlying
+// secp256k1 struct (two FieldVal coordinates -- entirely value-typed).
+// Returns nil if pk is nil. Free function since btcec.PublicKey is a
+// foreign type we cannot add methods to.
+func CopyPubKey(pk *btcec.PublicKey) *btcec.PublicKey {
+	if pk == nil {
+		return nil
+	}
+	cpy := *pk
+	return &cpy
+}
+
+// CopyKeyDescriptor returns a KeyDescriptor whose PubKey points to a
+// fresh PublicKey value. KeyLocator is two uint32 fields and copied
+// trivially. Free function since keychain.KeyDescriptor is a foreign
+// type we cannot add methods to.
+func CopyKeyDescriptor(kd keychain.KeyDescriptor) keychain.KeyDescriptor {
+	return keychain.KeyDescriptor{
+		KeyLocator: kd.KeyLocator,
+		PubKey:     CopyPubKey(kd.PubKey),
+	}
+}
+
 // ScriptKeyDerivationMethod is the method used to derive the script key of an
 // asset send output from the recipient's internal key and the asset ID of
 // the output. This is used to ensure that the script keys are unique for each
@@ -1354,6 +1416,20 @@ func (ts *TweakedScriptKey) IsEqual(other *TweakedScriptKey) bool {
 	return EqualKeyDescriptors(ts.RawKey, other.RawKey)
 }
 
+// Copy returns a deep copy of *TweakedScriptKey: the raw key
+// descriptor is cloned and the tweak bytes are duplicated. Returns
+// nil if ts is nil.
+func (ts *TweakedScriptKey) Copy() *TweakedScriptKey {
+	if ts == nil {
+		return nil
+	}
+	return &TweakedScriptKey{
+		RawKey: CopyKeyDescriptor(ts.RawKey),
+		Tweak:  bytes.Clone(ts.Tweak),
+		Type:   ts.Type,
+	}
+}
+
 // ScriptKey represents a tweaked Taproot output key encumbering the different
 // ways an asset can be spent.
 type ScriptKey struct {
@@ -1400,6 +1476,15 @@ func (s *ScriptKey) IsEqual(otherScriptKey *ScriptKey) bool {
 	return s.PubKey.IsEqual(otherScriptKey.PubKey)
 }
 
+// Copy returns a deep copy of ScriptKey: the tweaked sub-key is
+// cloned and the pubkey is value-copied.
+func (s ScriptKey) Copy() ScriptKey {
+	return ScriptKey{
+		PubKey:           CopyPubKey(s.PubKey),
+		TweakedScriptKey: s.TweakedScriptKey.Copy(),
+	}
+}
+
 // DeclaredAsKnown returns true if this script key has either been derived by
 // the local wallet or was explicitly declared to be known by using the
 // DeclareScriptKey RPC. Knowing the key conceptually means the key belongs to

asset/group_key.go

@@ -124,6 +124,29 @@ func (g *GroupKey) IsGroupAnchor(assetID ID) (bool, error) {
 	return expectedGroupPubKey.IsEqual(derivedGroupPubKey), nil
 }
 
+// Copy returns a deep copy of *GroupKey: all slice/witness
+// substructure is cloned and the embedded key descriptor is rebuilt.
+// Returns nil if g is nil.
+func (g *GroupKey) Copy() *GroupKey {
+	if g == nil {
+		return nil
+	}
+	out := &GroupKey{
+		Version:             g.Version,
+		RawKey:              CopyKeyDescriptor(g.RawKey),
+		GroupPubKey:         g.GroupPubKey,
+		TapscriptRoot:       bytes.Clone(g.TapscriptRoot),
+		CustomTapscriptRoot: g.CustomTapscriptRoot,
+	}
+	if g.Witness != nil {
+		out.Witness = make(wire.TxWitness, len(g.Witness))
+		for i, w := range g.Witness {
+			out.Witness[i] = bytes.Clone(w)
+		}
+	}
+	return out
+}
+
 // GroupKeyRequest contains the essential fields used to derive a group key.
 type GroupKeyRequest struct {
 	// Version is the version of the group key construction.

backup/rehydrate.go

@@ -10,7 +10,7 @@ import (
 )
 
 // ChainQuerier is the interface needed to fetch blockchain data during proof
-// rehydration. The tapgarden.ChainBridge interface satisfies this.
+// rehydration. The tapnode.ChainBridge interface satisfies this.
 type ChainQuerier interface {
 	// GetBlockByHeight returns a full block given its height.
 	GetBlockByHeight(ctx context.Context,

cmd/tapd/main.go

@@ -35,6 +35,19 @@ func main() {
 		os.Exit(0)
 	}
 
+	// If the operator has invoked tapd in one-shot repair mode, run
+	// the requested repair against the database and exit before
+	// constructing the full server. The repair tool opens the DB
+	// with migrations skipped, so it can recover a legacy DB whose
+	// state would otherwise block a migration from applying.
+	if cfg.Repair != nil && cfg.Repair.CancelDuplicateBatches {
+		if err := tapcfg.RunRepairTool(cfg, cfgLogger); err != nil {
+			_, _ = fmt.Fprintln(os.Stderr, err)
+			os.Exit(1)
+		}
+		os.Exit(0)
+	}
+
 	// Enable http profiling server if requested.
 	if cfg.Profile != "" {
 		go func() {

itest/sign_finalize_psbt_test.go

@@ -0,0 +1,90 @@
+package itest
+
+import (
+	"bytes"
+	"context"
+
+	"github.com/btcsuite/btcd/btcutil"
+	"github.com/btcsuite/btcd/btcutil/psbt"
+	"github.com/btcsuite/btcd/txscript"
+	"github.com/btcsuite/btcd/wire"
+	"github.com/lightninglabs/taproot-assets/lndservices"
+	"github.com/lightningnetwork/lnd/lnwallet/chainfee"
+	"github.com/stretchr/testify/require"
+)
+
+// testSignAndFinalizePsbtDeterministic pins the assumption that
+// Wallet.SignAndFinalizePsbt produces byte-identical output when invoked
+// twice on the same unsigned PSBT. The minting caretaker's Committed
+// branch relies on this on restart: a crash after sign-and-finalize but
+// before persisting the signed PSBT causes the next run to re-sign the
+// same unsigned PSBT loaded from disk, and we expect the resulting
+// signed bytes to match. lnd uses BIP-340 RFC-6979 deterministic
+// Schnorr nonces, so this should hold, but it is load-bearing for
+// idempotent restart semantics and worth verifying directly.
+func testSignAndFinalizePsbtDeterministic(t *harnessTest) {
+	ctxb := context.Background()
+	ctx, cancel := context.WithCancel(ctxb)
+	defer cancel()
+
+	lndClient, err := t.newLndClient(t.tapd.cfg.LndNode)
+	require.NoError(t.t, err)
+	defer lndClient.Close()
+
+	walletAnchor := lndservices.NewLndRpcWalletAnchor(
+		&lndClient.LndServices,
+	)
+
+	// Build a minimal unsigned tx with one P2TR-shaped dummy output;
+	// lnd will fund it by adding a wallet input and a change output.
+	dummyScript := append(
+		[]byte{txscript.OP_1, txscript.OP_DATA_32},
+		bytes.Repeat([]byte{0x00}, 32)...,
+	)
+	tx := wire.NewMsgTx(2)
+	tx.AddTxOut(&wire.TxOut{
+		Value:    int64(btcutil.Amount(1000)),
+		PkScript: dummyScript,
+	})
+
+	unsignedPkt, err := psbt.NewFromUnsignedTx(tx)
+	require.NoError(t.t, err)
+
+	fundedPkt, err := walletAnchor.FundPsbt(
+		ctx, unsignedPkt, 1, chainfee.SatPerKWeight(3000), -1,
+	)
+	require.NoError(t.t, err)
+
+	// SignAndFinalizePsbt mutates the input, so each call gets its
+	// own deep-cloned copy of the unsigned-but-funded PSBT. Round-
+	// tripping through Serialize/NewFromRawBytes is the cleanest way
+	// to get an independent value.
+	clonePsbt := func(p *psbt.Packet) *psbt.Packet {
+		var buf bytes.Buffer
+		require.NoError(t.t, p.Serialize(&buf))
+		clone, err := psbt.NewFromRawBytes(
+			bytes.NewReader(buf.Bytes()), false,
+		)
+		require.NoError(t.t, err)
+		return clone
+	}
+
+	signed1, err := walletAnchor.SignAndFinalizePsbt(
+		ctx, clonePsbt(fundedPkt.Pkt),
+	)
+	require.NoError(t.t, err)
+
+	signed2, err := walletAnchor.SignAndFinalizePsbt(
+		ctx, clonePsbt(fundedPkt.Pkt),
+	)
+	require.NoError(t.t, err)
+
+	var buf1, buf2 bytes.Buffer
+	require.NoError(t.t, signed1.Serialize(&buf1))
+	require.NoError(t.t, signed2.Serialize(&buf2))
+
+	require.Equal(t.t, buf1.Bytes(), buf2.Bytes(),
+		"SignAndFinalizePsbt must produce byte-identical output "+
+			"for the same unsigned input; the minting caretaker "+
+			"restart path relies on this")
+}

itest/supply_commit_test.go

@@ -18,7 +18,6 @@ import (
 	"github.com/lightninglabs/taproot-assets/mssmt"
 	"github.com/lightninglabs/taproot-assets/proof"
 	"github.com/lightninglabs/taproot-assets/rpcserver"
-	"github.com/lightninglabs/taproot-assets/tapgarden"
 	"github.com/lightninglabs/taproot-assets/taprpc"
 	"github.com/lightninglabs/taproot-assets/taprpc/mintrpc"
 	unirpc "github.com/lightninglabs/taproot-assets/taprpc/universerpc"
@@ -65,7 +64,7 @@ func assertAnchorTxPreCommitOut(
 	)
 	require.NoError(t.t, err)
 
-	expectedTxOut, err := tapgarden.PreCommitTxOut(*delegationKey)
+	expectedTxOut, err := supplycommit.PreCommitTxOut(*delegationKey)
 	require.NoError(t.t, err)
 
 	// The pre-commitment output should be present in the anchor tx exactly

itest/test_list_on_test.go

@@ -53,6 +53,10 @@ var allTestCases = []*testCase{
 		name: "mint external group key chantools",
 		test: testMintExternalGroupKeyChantools,
 	},
+	{
+		name: "sign and finalize psbt deterministic",
+		test: testSignAndFinalizePsbtDeterministic,
+	},
 	{
 		name: "mint asset decimal display",
 		test: testMintAssetWithDecimalDisplayMetaField,

lndservices/chain_bridge.go

@@ -14,7 +14,7 @@ import (
 	"github.com/lightninglabs/taproot-assets/fn"
 	"github.com/lightninglabs/taproot-assets/proof"
 	"github.com/lightninglabs/taproot-assets/tapdb"
-	"github.com/lightninglabs/taproot-assets/tapgarden"
+	"github.com/lightninglabs/taproot-assets/tapnode"
 	"github.com/lightningnetwork/lnd/chainntnfs"
 	"github.com/lightningnetwork/lnd/lnwallet/chainfee"
 )
@@ -31,7 +31,7 @@ var (
 	errTxNotFound = fmt.Errorf("transaction not found in proof file")
 )
 
-// LndRpcChainBridge is an implementation of the tapgarden.ChainBridge
+// LndRpcChainBridge is an implementation of the tapnode.ChainBridge
 // interface backed by an active remote lnd node.
 type LndRpcChainBridge struct {
 	// lnd is the active lnd services client.
@@ -371,22 +371,22 @@ func (l *LndRpcChainBridge) GenProofChainLookup(
 }
 
 // A compile time assertion to ensure LndRpcChainBridge meets the
-// tapgarden.ChainBridge interface.
-var _ tapgarden.ChainBridge = (*LndRpcChainBridge)(nil)
+// tapnode.ChainBridge interface.
+var _ tapnode.ChainBridge = (*LndRpcChainBridge)(nil)
 
 // ProofChainLookup is an implementation of the asset.ChainLookup interface
 // that uses a proof file to look up block height information of previous inputs
 // while validating proofs.
 type ProofChainLookup struct {
-	chainBridge tapgarden.ChainBridge
+	chainBridge tapnode.ChainBridge
 
 	assetStore *tapdb.AssetStore
 
 	proofFile *proof.File
 }
 
 // NewProofChainLookup creates a new ProofChainLookup instance.
-func NewProofChainLookup(chainBridge tapgarden.ChainBridge,
+func NewProofChainLookup(chainBridge tapnode.ChainBridge,
 	assetStore *tapdb.AssetStore, proofFile *proof.File) *ProofChainLookup {
 
 	return &ProofChainLookup{

lndservices/key_ring.go

@@ -8,7 +8,7 @@ import (
 	"github.com/btcsuite/btcd/btcec/v2"
 	"github.com/lightninglabs/lndclient"
 	"github.com/lightninglabs/taproot-assets/asset"
-	"github.com/lightninglabs/taproot-assets/tapgarden"
+	"github.com/lightninglabs/taproot-assets/tapnode"
 	"github.com/lightningnetwork/lnd/keychain"
 )
 
@@ -108,5 +108,5 @@ func (l *LndRpcKeyRing) DeriveSharedKey(ctx context.Context,
 }
 
 // A compile time assertion to ensure LndRpcKeyRing meets the
-// tapgarden.KeyRing interface.
-var _ tapgarden.KeyRing = (*LndRpcKeyRing)(nil)
+// tapnode.KeyRing interface.
+var _ tapnode.KeyRing = (*LndRpcKeyRing)(nil)

lndservices/wallet_anchor.go

@@ -14,7 +14,7 @@ import (
 	"github.com/lightninglabs/lndclient"
 	"github.com/lightninglabs/taproot-assets/fn"
 	"github.com/lightninglabs/taproot-assets/tapfreighter"
-	"github.com/lightninglabs/taproot-assets/tapgarden"
+	"github.com/lightninglabs/taproot-assets/tapnode"
 	"github.com/lightninglabs/taproot-assets/tapsend"
 	"github.com/lightningnetwork/lnd/lnrpc/walletrpc"
 	"github.com/lightningnetwork/lnd/lnwallet"
@@ -28,7 +28,7 @@ import (
 // useful in high fee environments where we'd otherwise fail to fund the psbt.
 const DefaultPsbtMaxFeeRatio = 0.75
 
-// LndRpcWalletAnchor is an implementation of the tapgarden.WalletAnchor
+// LndRpcWalletAnchor is an implementation of the tapnode.WalletAnchor
 // interfaced backed by an active remote lnd node.
 type LndRpcWalletAnchor struct {
 	lnd *lndclient.LndServices
@@ -275,7 +275,7 @@ func (l *LndRpcWalletAnchor) MinRelayFee(
 }
 
 // A compile time assertion to ensure LndRpcWalletAnchor meets the
-// tapgarden.WalletAnchor interface.
-var _ tapgarden.WalletAnchor = (*LndRpcWalletAnchor)(nil)
+// tapnode.WalletAnchor interface.
+var _ tapnode.WalletAnchor = (*LndRpcWalletAnchor)(nil)
 
 var _ tapfreighter.WalletAnchor = (*LndRpcWalletAnchor)(nil)