txscript: recognize P2A witness program during script execution

diff --git a/txscript/engine.go b/txscript/engine.go
index 95bc55f..9ce3a9f 100644
--- a/txscript/engine.go
+++ b/txscript/engine.go
@@ -542,6 +542,13 @@ func (vm *Engine) isWitnessVersionActive(version uint) bool {
 	return vm.witnessProgram != nil && uint(vm.witnessVersion) == version
 }
 
+// IsPayToAnchorWitnessProgram returns true if the witness version and program
+// correspond to a pay-to-anchor output.
+func IsPayToAnchorWitnessProgram(witnessVersion int, witnessProgram []byte) bool {
+	return witnessVersion == 1 && len(witnessProgram) == 2 &&
+		bytes.Equal(witnessProgram, []byte{0x4e, 0x73})
+}
+
 // witnessProgramAcceptStack collapses the data stack down to a single element
 // for witness programs that succeed without inner script execution. The
 // running pkScript must have left a truthy top item; the stack is then reduced
@@ -795,18 +802,30 @@ func (vm *Engine) verifyWitnessProgram(witness wire.TxWitness) error {
 			vm.SetStack(witness[:len(witness)-2])
 		}
 
+	// Pay-to-anchor (P2A) outputs are special anyone-can-spend outputs.
+	// They only work as native witness programs, not wrapped in P2SH.
+	case IsPayToAnchorWitnessProgram(
+		vm.witnessVersion, vm.witnessProgram,
+	) && !vm.bip16:
+		// P2A spending always succeeds regardless of witness content.
+		if err := vm.witnessProgramAcceptStack(); err != nil {
+			return err
+		}
+
 	case vm.hasFlag(ScriptVerifyDiscourageUpgradeableWitnessProgram):
 		errStr := fmt.Sprintf("new witness program versions "+
 			"invalid: %v", vm.witnessProgram)
 
-		return scriptError(ErrDiscourageUpgradableWitnessProgram, errStr)
+		return scriptError(
+			ErrDiscourageUpgradableWitnessProgram, errStr,
+		)
+
 	default:
 		if err := vm.witnessProgramAcceptStack(); err != nil {
 			return err
 		}
 	}
 
-	// TODO(roasbeef): other sanity checks here
 	switch {
 
 	// In addition to the normal script element size limits, taproot also
@@ -933,8 +952,10 @@ func (vm *Engine) CheckErrorCondition(finalScript bool) error {
 	cleanStackActive := vm.hasFlag(ScriptVerifyCleanStack) || vm.taprootCtx != nil
 	if finalScript && cleanStackActive && vm.dstack.Depth() != 1 {
 
-		str := fmt.Sprintf("stack must contain exactly one item (contains %d)",
-			vm.dstack.Depth())
+		str := fmt.Sprintf(
+			"stack must contain exactly one item (contains %d)",
+			vm.dstack.Depth(),
+		)
 		return scriptError(ErrCleanStack, str)
 	} else if vm.dstack.Depth() < 1 {
 		return scriptError(ErrEmptyStack,
diff --git a/txscript/engine_p2a_test.go b/txscript/engine_p2a_test.go
new file mode 100644
index 0000000..7d2b227
--- /dev/null
+++ b/txscript/engine_p2a_test.go
@@ -0,0 +1,105 @@
+package txscript
+
+import (
+	"testing"
+
+	"github.com/btcsuite/btcd/wire"
+	"github.com/stretchr/testify/require"
+)
+
+// TestP2ASpending tests that pay-to-anchor outputs can be spent correctly.
+func TestP2ASpending(t *testing.T) {
+	tests := []struct {
+		name         string
+		scriptPubKey []byte
+		witness      wire.TxWitness
+		sigScript    []byte
+		shouldPass   bool
+		errCode      ErrorCode
+	}{
+		{
+			name: "valid P2A spend with empty witness and " +
+				"sigscript",
+			scriptPubKey: PayToAnchorScript,
+			witness:      wire.TxWitness{},
+			sigScript:    []byte{},
+			shouldPass:   true,
+		},
+		{
+			name: "P2A with non-empty witness should " +
+				"succeed",
+			scriptPubKey: PayToAnchorScript,
+			witness:      wire.TxWitness{[]byte{0x01}},
+			sigScript:    []byte{},
+			shouldPass:   true,
+		},
+		{
+			name:         "P2A with non-empty sigscript should fail",
+			scriptPubKey: PayToAnchorScript,
+			witness:      wire.TxWitness{},
+			sigScript:    []byte{0x01, 0x02},
+			shouldPass:   false,
+			errCode:      ErrWitnessMalleated,
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			// Create a transaction with the P2A output being spent.
+			prevTx := wire.NewMsgTx(2)
+			prevTx.AddTxOut(&wire.TxOut{
+				Value:    1000,
+				PkScript: test.scriptPubKey,
+			})
+			prevTxHash := prevTx.TxHash()
+
+			// Create the spending transaction.
+			tx := wire.NewMsgTx(2)
+			tx.AddTxIn(&wire.TxIn{
+				PreviousOutPoint: wire.OutPoint{
+					Hash:  prevTxHash,
+					Index: 0,
+				},
+				SignatureScript: test.sigScript,
+				Witness:         test.witness,
+			})
+			tx.AddTxOut(&wire.TxOut{
+				Value:    900,
+				PkScript: []byte{OP_TRUE},
+			})
+
+			// Create the script engine.
+			vm, err := NewEngine(
+				test.scriptPubKey, tx, 0,
+				StandardVerifyFlags, nil,
+				nil, 1000, nil,
+			)
+			if err != nil {
+				if test.errCode != 0 {
+					require.True(t, IsErrorCode(err, test.errCode))
+					return
+				} else {
+					require.NoError(t, err)
+				}
+			}
+
+			if test.shouldPass {
+				if err != nil {
+					t.Fatalf("NewEngine failed "+
+						"unexpectedly: %v", err)
+				}
+
+				err = vm.Execute()
+				if err != nil {
+					t.Fatalf("Execute failed unexpectedly: %v", err)
+				}
+			} else {
+				if err == nil {
+					t.Fatal("Expected NewEngine to fail, but it succeeded")
+				}
+
+				require.True(t, IsErrorCode(err, test.errCode))
+			}
+		})
+	}
+}