tapgarden: propogate taptree sibling for batch key

Author: jharveyb

tapgarden/batch.go

@@ -6,6 +6,7 @@ import (
 	"time"
 
 	"github.com/btcsuite/btcd/btcec/v2"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
 	"github.com/btcsuite/btcd/txscript"
 	"github.com/lightninglabs/taproot-assets/asset"
 	"github.com/lightninglabs/taproot-assets/commitment"
@@ -67,6 +68,10 @@ type MintingBatch struct {
 	// to commit to the Taproot Asset commitment above.
 	mintingPubKey *btcec.PublicKey
 
+	// tapSibling is an optional root hash of a tapscript tree that will be
+	// used with the taprootAssetScriptRoot to construct the mintingPubKey.
+	tapSibling *chainhash.Hash
+
 	// taprootAssetScriptRoot is the root hash of the Taproot Asset
 	// commitment. If this is nil, then the mintingPubKey will be as well.
 	taprootAssetScriptRoot []byte
@@ -104,7 +109,9 @@ func (m *MintingBatch) validateGroupAnchor(s *Seedling) error {
 
 // MintingOutputKey derives the output key that once mined, will commit to the
 // Taproot asset root, thereby creating the set of included assets.
-func (m *MintingBatch) MintingOutputKey() (*btcec.PublicKey, []byte, error) {
+func (m *MintingBatch) MintingOutputKey(sibling *commitment.TapscriptPreimage) (
+	*btcec.PublicKey, []byte, error) {
+
 	if m.mintingPubKey != nil {
 		return m.mintingPubKey, m.taprootAssetScriptRoot, nil
 	}
@@ -113,7 +120,21 @@ func (m *MintingBatch) MintingOutputKey() (*btcec.PublicKey, []byte, error) {
 		return nil, nil, fmt.Errorf("no asset commitment present")
 	}
 
-	taprootAssetScriptRoot := m.RootAssetCommitment.TapscriptRoot(nil)
+	var (
+		siblingHash *chainhash.Hash
+		err         error
+	)
+
+	if sibling != nil {
+		siblingHash, err = sibling.TapHash()
+		if err != nil {
+			return nil, nil, err
+		}
+	}
+
+	taprootAssetScriptRoot := m.RootAssetCommitment.TapscriptRoot(
+		siblingHash,
+	)
 
 	m.taprootAssetScriptRoot = taprootAssetScriptRoot[:]
 	m.mintingPubKey = txscript.ComputeTaprootOutputKey(
@@ -125,8 +146,10 @@ func (m *MintingBatch) MintingOutputKey() (*btcec.PublicKey, []byte, error) {
 
 // genesisScript returns the script that should be placed in the minting output
 // within the genesis transaction.
-func (m *MintingBatch) genesisScript() ([]byte, error) {
-	mintingOutputKey, _, err := m.MintingOutputKey()
+func (m *MintingBatch) genesisScript(sibling *commitment.TapscriptPreimage) (
+	[]byte, error) {
+
+	mintingOutputKey, _, err := m.MintingOutputKey(sibling)
 	if err != nil {
 		return nil, err
 	}
@@ -149,3 +172,18 @@ func (m *MintingBatch) State() BatchState {
 func (m *MintingBatch) UpdateState(state BatchState) {
 	m.batchState.Store(uint32(state))
 }
+
+// TapSibling returns the optional tapscript sibling for the batch, which is a
+// root hash of a tapscript tree.
+func (m *MintingBatch) TapSibling() []byte {
+	if m.tapSibling == nil {
+		return nil
+	}
+
+	return m.tapSibling.CloneBytes()
+}
+
+// UpdateTapSibling updates the optional tapscript sibling for the batch.
+func (m *MintingBatch) UpdateTapSibling(sibling *chainhash.Hash) {
+	m.tapSibling = sibling
+}

tapgarden/caretaker.go

@@ -679,10 +679,28 @@ func (b *BatchCaretaker) stateStep(currentState BatchState) (BatchState, error)
 
 		b.cfg.Batch.RootAssetCommitment = tapCommitment
 
+		// Fetch the optional Tapscript sibling for this batch, and
+		// convert it to a TapscriptPreimage.
+		var batchSibling *commitment.TapscriptPreimage
+		if b.cfg.Batch.tapSibling != nil {
+			tapSibling, err := b.cfg.TreeStore.LoadTapscriptTree(
+				ctx, *b.cfg.Batch.tapSibling,
+			)
+			if err != nil {
+				return 0, err
+			}
+
+			batchSibling, err = commitment.
+				NewPreimageFromTapscriptTreeNodes(*tapSibling)
+			if err != nil {
+				return 0, err
+			}
+		}
+
 		// With the commitment Taproot Asset root SMT constructed, we'll
 		// map that into the tapscript root we'll insert into the
 		// genesis transaction.
-		genesisScript, err := b.cfg.Batch.genesisScript()
+		genesisScript, err := b.cfg.Batch.genesisScript(batchSibling)
 		if err != nil {
 			return 0, fmt.Errorf("unable to create genesis "+
 				"script: %w", err)
@@ -776,18 +794,51 @@ func (b *BatchCaretaker) stateStep(currentState BatchState) (BatchState, error)
 
 		// At this point we have a fully signed PSBT packet which'll
 		// create our set of assets once mined. We'll write this to
-		// disk, then import the public key into the wallet.
+		// disk, then import the public key into the wallet. The sibling
+		// here can always be nil as we'll fetch the output key computed
+		// previously in BatchStateFrozen.
 		//
 		// TODO(roasbeef): re-run during the broadcast phase to ensure
 		// it's fully imported?
-		mintingOutputKey, tapRoot, err := b.cfg.Batch.MintingOutputKey()
+		mintingOutputKey, merkleRoot, err := b.cfg.Batch.
+			MintingOutputKey(nil)
 		if err != nil {
 			return 0, err
 		}
+
+		// To spend this output in the future, we must also commit the
+		// Taproot Asset commitment root and batch tapscript sibling.
+		tapCommitmentRoot := b.cfg.Batch.RootAssetCommitment.
+			TapscriptRoot(nil)
+
+		// Fetch the optional Tapscript sibling for this batch, and
+		// encode it to bytes.
+		var siblingBytes []byte
+		if b.cfg.Batch.tapSibling != nil {
+			tapSibling, err := b.cfg.TreeStore.LoadTapscriptTree(
+				ctx, *b.cfg.Batch.tapSibling,
+			)
+			if err != nil {
+				return 0, err
+			}
+
+			batchSibling, err := commitment.
+				NewPreimageFromTapscriptTreeNodes(*tapSibling)
+			if err != nil {
+				return 0, err
+			}
+
+			siblingBytes, _, err = commitment.
+				MaybeEncodeTapscriptPreimage(batchSibling)
+			if err != nil {
+				return 0, err
+			}
+		}
+
 		err = b.cfg.Log.CommitSignedGenesisTx(
 			ctx, b.cfg.Batch.BatchKey.PubKey,
 			b.cfg.Batch.GenesisPacket, b.anchorOutputIndex,
-			tapRoot,
+			merkleRoot, tapCommitmentRoot[:], siblingBytes,
 		)
 		if err != nil {
 			return 0, fmt.Errorf("unable to commit genesis "+
@@ -976,6 +1027,24 @@ func (b *BatchCaretaker) stateStep(currentState BatchState) (BatchState, error)
 		groupVerifier := GenGroupVerifier(ctx, b.cfg.Log)
 		groupAnchorVerifier := GenGroupAnchorVerifier(ctx, b.cfg.Log)
 
+		// Fetch the optional tapscript sibling for this batch, which
+		// is needed to construct valid inclusion proofs.
+		var batchSibling *commitment.TapscriptPreimage
+		if b.cfg.Batch.tapSibling != nil {
+			tapSibling, err := b.cfg.TreeStore.LoadTapscriptTree(
+				ctx, *b.cfg.Batch.tapSibling,
+			)
+			if err != nil {
+				return 0, err
+			}
+
+			batchSibling, err = commitment.
+				NewPreimageFromTapscriptTreeNodes(*tapSibling)
+			if err != nil {
+				return 0, err
+			}
+		}
+
 		// Now that the minting transaction has been confirmed, we'll
 		// need to create the series of proof file blobs for each of
 		// the assets. In case the lnd wallet creates a P2TR change
@@ -990,6 +1059,7 @@ func (b *BatchCaretaker) stateStep(currentState BatchState) (BatchState, error)
 				TxIndex:          int(confInfo.TxIndex),
 				OutputIndex:      int(b.anchorOutputIndex),
 				InternalKey:      b.cfg.Batch.BatchKey.PubKey,
+				TapscriptSibling: batchSibling,
 				TaprootAssetRoot: batchCommitment,
 			},
 			GenesisPoint: extractGenesisOutpoint(
@@ -1011,6 +1081,7 @@ func (b *BatchCaretaker) stateStep(currentState BatchState) (BatchState, error)
 			baseProof, headerVerifier, groupVerifier,
 			groupAnchorVerifier,
 			proof.WithAssetMetaReveals(b.cfg.Batch.AssetMetas),
+			proof.WithSiblingPreimage(batchSibling),
 		)
 		if err != nil {
 			return 0, fmt.Errorf("unable to construct minting "+

tapgarden/mock.go

@@ -633,3 +633,42 @@ func (m *MockProofWatcher) DefaultUpdateCallback() proof.UpdateCallback {
 		return nil
 	}
 }
+
+type FallibleTapscriptTreeMgr struct {
+	store               MintingStore
+	FailLoad, FailStore bool
+}
+
+func (mgr FallibleTapscriptTreeMgr) DeleteTapscriptTree(ctx context.Context,
+	rootHash chainhash.Hash) error {
+
+	return mgr.store.DeleteTapscriptTree(ctx, rootHash)
+}
+
+func (mgr FallibleTapscriptTreeMgr) LoadTapscriptTree(ctx context.Context,
+	rootHash chainhash.Hash) (*asset.TapscriptTreeNodes, error) {
+
+	if mgr.FailLoad {
+		return nil, fmt.Errorf("failed to load tapscript tree")
+	}
+
+	return mgr.store.LoadTapscriptTree(ctx, rootHash)
+}
+
+func (mgr FallibleTapscriptTreeMgr) StoreTapscriptTree(ctx context.Context,
+	treeNodes asset.TapscriptTreeNodes) (*chainhash.Hash, error) {
+
+	if mgr.FailStore {
+		return nil, fmt.Errorf("unable to store tapscript tree")
+	}
+
+	return mgr.store.StoreTapscriptTree(ctx, treeNodes)
+}
+
+func NewFallibleTapscriptTreeMgr(store MintingStore) FallibleTapscriptTreeMgr {
+	return FallibleTapscriptTreeMgr{
+		store: store,
+	}
+}
+
+var _ asset.TapscriptTreeManager = (*FallibleTapscriptTreeMgr)(nil)

tapgarden/planter_test.go

@@ -66,6 +66,8 @@ type mintingTestHarness struct {
 
 	store tapgarden.MintingStore
 
+	treeStore *tapgarden.FallibleTapscriptTreeMgr
+
 	keyRing *tapgarden.MockKeyRing
 
 	genSigner *tapgarden.MockGenSigner
@@ -96,10 +98,12 @@ func newMintingTestHarness(t *testing.T, store tapgarden.MintingStore,
 
 	keyRing := tapgarden.NewMockKeyRing()
 	genSigner := tapgarden.NewMockGenSigner(keyRing)
+	treeMgr := tapgarden.NewFallibleTapscriptTreeMgr(store)
 
 	return &mintingTestHarness{
 		T:            t,
 		store:        store,
+		treeStore:    &treeMgr,
 		ticker:       ticker.NewForce(interval),
 		wallet:       tapgarden.NewMockWalletAnchor(),
 		chain:        tapgarden.NewMockChainBridge(),
@@ -126,6 +130,7 @@ func (t *mintingTestHarness) refreshChainPlanter() {
 			Wallet:       t.wallet,
 			ChainBridge:  t.chain,
 			Log:          t.store,
+			TreeStore:    t.treeStore,
 			KeyRing:      t.keyRing,
 			GenSigner:    t.genSigner,
 			GenTxBuilder: t.genTxBuilder,
@@ -277,7 +282,7 @@ func (t *mintingTestHarness) assertFinalizeBatch(wg *sync.WaitGroup,
 // progressCaretaker uses the mock interfaces to progress a caretaker from start
 // to TX confirmation.
 func (t *mintingTestHarness) progressCaretaker(
-	seedlings []*tapgarden.Seedling) func() {
+	seedlings []*tapgarden.Seedling, batchSibling *chainhash.Hash) func() {
 
 	// Assert that the caretaker has requested a genesis TX to be funded.
 	_ = t.assertGenesisTxFunded()
@@ -295,7 +300,7 @@ func (t *mintingTestHarness) progressCaretaker(
 
 	// We should now transition to the next state where we'll attempt to
 	// sign this PSBT packet generated above.
-	t.assertGenesisPsbtFinalized()
+	t.assertGenesisPsbtFinalized(batchSibling)
 
 	// With the PSBT packet finalized for the caretaker, we should now
 	// receive a request to publish a transaction followed by a
@@ -626,7 +631,9 @@ func (t *mintingTestHarness) assertSeedlingsMatchSprouts(
 
 // assertGenesisPsbtFinalized asserts that a request to finalize the genesis
 // transaction has been requested by a caretaker.
-func (t *mintingTestHarness) assertGenesisPsbtFinalized() {
+func (t *mintingTestHarness) assertGenesisPsbtFinalized(
+	sibling *chainhash.Hash) {
+
 	t.Helper()
 
 	// Ensure that a request to finalize the PSBt has come across.
@@ -650,7 +657,7 @@ func (t *mintingTestHarness) assertGenesisPsbtFinalized() {
 
 	// The minting key of the batch should match the public key
 	// that was inserted into the wallet.
-	batchKey, _, err := pendingBatch.MintingOutputKey()
+	batchKey, _, err := pendingBatch.MintingOutputKey(sibling)
 	require.NoError(t, err)
 
 	importedKey, err := fn.RecvOrTimeout(
@@ -791,7 +798,7 @@ func testBasicAssetCreation(t *mintingTestHarness) {
 
 	// We should now transition to the next state where we'll attempt to
 	// sign this PSBT packet generated above.
-	t.assertGenesisPsbtFinalized()
+	t.assertGenesisPsbtFinalized(nil)
 
 	// With the PSBT packet finalized for the caretaker, we should now
 	// receive a request to publish a transaction followed by a
@@ -893,7 +900,7 @@ func testMintingTicker(t *mintingTestHarness) {
 
 	// We should now transition to the next state where we'll attempt to
 	// sign this PSBT packet generated above.
-	t.assertGenesisPsbtFinalized()
+	t.assertGenesisPsbtFinalized(nil)
 
 	// With the PSBT packet finalized for the caretaker, we should now
 	// receive a request to publish a transaction followed by a
@@ -1029,7 +1036,7 @@ func testMintingCancelFinalize(t *mintingTestHarness) {
 
 	// We should now transition to the next state where we'll attempt to
 	// sign this PSBT packet generated above.
-	t.assertGenesisPsbtFinalized()
+	t.assertGenesisPsbtFinalized(nil)
 
 	// With the PSBT packet finalized for the caretaker, we should now
 	// receive a request to publish a transaction followed by a
@@ -1137,7 +1144,7 @@ func testFinalizeBatch(t *mintingTestHarness) {
 	t.finalizeBatch(&wg, respChan)
 	batchCount++
 
-	_ = t.progressCaretaker(seedlings)
+	_ = t.progressCaretaker(seedlings, nil)
 	caretakerCount++
 
 	t.assertFinalizeBatch(&wg, respChan, "")
@@ -1161,7 +1168,7 @@ func testFinalizeBatch(t *mintingTestHarness) {
 	t.finalizeBatch(&wg, respChan)
 	batchCount++
 
-	sendConfNtfn := t.progressCaretaker(seedlings)
+	sendConfNtfn := t.progressCaretaker(seedlings, nil)
 	caretakerCount++
 
 	// Trigger the confirmation event, which should cause the caretaker to
@@ -1191,7 +1198,7 @@ func testFinalizeBatch(t *mintingTestHarness) {
 	t.finalizeBatch(&wg, respChan)
 	batchCount++
 
-	sendConfNtfn = t.progressCaretaker(seedlings)
+	sendConfNtfn = t.progressCaretaker(seedlings, nil)
 	sendConfNtfn()
 
 	t.assertFinalizeBatch(&wg, respChan, "")