txscript: increase OP_RETURN data limit to 100KB

This commit increases the MaxDataCarrierSize from 80 bytes to 100,000
bytes to align with Bitcoin Core v30, which removes the specific
80-byte OP_RETURN data limit.

Rationale:

1. Policy Alignment: Maintains consistency with Bitcoin Core v30,
   ensuring btcd nodes accept the same set of standard transactions
   as the majority of the network.

2. Fee Estimation: Filtering large OP_RETURN transactions from the
   mempool prevents accurate fee estimation by hiding transactions
   that are competing for blockspace. Full mempool visibility is
   essential for informed fee rate calculation.

3. Validation Performance: Rejecting transactions that will be mined
   by other nodes means they must be validated when processing blocks,
   without cached results. This delays block validation and
   propagation, harming both the node operator and network health.

4. Decentralization: Slow block propagation advantages large mining
   operations with preferentially peered nodes, as they get a head
   start on the next block. Ensuring all likely-to-be-mined
   transactions are pre-validated helps maintain network
   decentralization.

Key changes:

- Increase MaxDataCarrierSize constant from 80 to 100000 bytes
- Modify NullDataScript to use AddFullData instead of AddData to
  bypass MaxScriptElementSize (520 bytes) since OP_RETURN outputs
  are provably unspendable and never executed
- Update AddFullData documentation to reflect legitimate use for
  OP_RETURN outputs, not just testing

The practical limit for OP_RETURN data remains around 75KB due to
the maxStandardTxWeight limit of 400,000 weight units (~100KB total
transaction size including inputs and outputs).

Test coverage includes:
- Unit tests for script creation and size validation
- Policy tests for transaction standardness (75KB OP_RETURN)
- Integration tests for mempool acceptance and size limit enforcement

This change maintains backward compatibility while enabling larger
data storage in OP_RETURN outputs for applications like inscriptions,
timestamps, and data anchoring.

Author: mikekelly

integration/rawtx_test.go

@@ -201,3 +201,88 @@ func decodeHex(t *testing.T, txHex string) *wire.MsgTx {
 
 	return tx.MsgTx()
 }
+
+// TestLargeOPReturnMempool tests that large OP_RETURN transactions (up to 100KB)
+// are accepted into the mempool. This validates the Bitcoin Core v30 change that
+// removes the 80-byte OP_RETURN limit.
+func TestLargeOPReturnMempool(t *testing.T) {
+	t.Parallel()
+
+	// Create a single node for testing mempool acceptance.
+	// Use --rejectnonstd to enforce standardness rules (including maxStandardTxWeight).
+	btcdCfg := []string{"--rejectnonstd", "--debuglevel=debug"}
+	node, err := rpctest.New(&chaincfg.SimNetParams, nil, btcdCfg, "")
+	require.NoError(t, err)
+
+	// Setup the node with mature coinbase outputs.
+	require.NoError(t, node.SetUp(true, 100))
+	t.Cleanup(func() {
+		require.NoError(t, node.TearDown())
+	})
+
+	testCases := []struct {
+		name          string
+		dataSize      int
+		shouldSucceed bool
+		failureReason string
+	}{
+		{
+			name:          "75KB OP_RETURN (well over old 80 byte/520 byte limits)",
+			dataSize:      75000,
+			shouldSucceed: true,
+		},
+		{
+			name:          "100KB OP_RETURN (at MaxDataCarrierSize limit)",
+			dataSize:      100000,
+			shouldSucceed: false,
+			failureReason: "transaction size exceeds maxStandardTxWeight (100,000 vbytes)",
+		},
+	}
+
+	for _, tc := range testCases {
+		tc := tc
+		t.Run(tc.name, func(t *testing.T) {
+			// Create large OP_RETURN script.
+			largeData := make([]byte, tc.dataSize)
+			for i := range largeData {
+				largeData[i] = byte(i % 256)
+			}
+
+			opReturnScript, err := txscript.NullDataScript(largeData)
+			require.NoError(t, err)
+
+			// Create a transaction with OP_RETURN output using the harness wallet.
+			// The wallet will handle signing and input selection.
+			opReturnOutput := &wire.TxOut{
+				Value:    0,
+				PkScript: opReturnScript,
+			}
+
+			// Create transaction with the OP_RETURN output.
+			// The wallet automatically adds inputs and a change output if needed.
+			tx, err := node.CreateTransaction([]*wire.TxOut{opReturnOutput}, 10, true)
+			require.NoError(t, err)
+
+			// Log the actual transaction size.
+			txSize := tx.SerializeSize()
+			txWeight := txSize * 4 // Non-segwit: weight = size * 4
+			t.Logf("Transaction size: %d bytes, weight: %d (limit: 400000)", txSize, txWeight)
+
+			// Submit to the mempool.
+			txHash, err := node.Client.SendRawTransaction(tx, true)
+
+			if tc.shouldSucceed {
+				require.NoError(t, err, "Large OP_RETURN tx should be accepted")
+				t.Logf("✓ Large OP_RETURN tx (%d bytes data) accepted: %s", tc.dataSize, txHash)
+
+				// Verify it's in the mempool.
+				mempool, err := node.Client.GetRawMempool()
+				require.NoError(t, err)
+				require.Contains(t, mempool, txHash, "Transaction should be in mempool")
+			} else {
+				require.Error(t, err, "Transaction should be rejected: %s", tc.failureReason)
+				t.Logf("✓ Transaction correctly rejected (%s): %v", tc.failureReason, err)
+			}
+		})
+	}
+}

mempool/policy_test.go

@@ -462,6 +462,33 @@ func TestCheckTransactionStandard(t *testing.T) {
 			height:     300000,
 			isStandard: true,
 		},
+		{
+			name: "Large nulldata output with 75KB data (standard after v30)",
+			tx: func() wire.MsgTx {
+				// Create a large OP_RETURN with 75KB of data
+				// This is well over previous limits (80 bytes, 520 bytes MaxScriptElementSize)
+				// but under the new 100KB MaxDataCarrierSize limit
+				largeData := make([]byte, 75000)
+				for i := range largeData {
+					largeData[i] = byte(i % 256)
+				}
+				pkScript, err := txscript.NullDataScript(largeData)
+				if err != nil {
+					t.Fatalf("NullDataScript: unexpected error: %v", err)
+				}
+				return wire.MsgTx{
+					Version: 1,
+					TxIn:    []*wire.TxIn{&dummyTxIn},
+					TxOut: []*wire.TxOut{{
+						Value:    0,
+						PkScript: pkScript,
+					}},
+					LockTime: 0,
+				}
+			}(),
+			height:     300000,
+			isStandard: true,
+		},
 	}
 
 	pastMedianTime := time.Now()

txscript/scriptbuilder.go

@@ -199,13 +199,19 @@ func (b *ScriptBuilder) addData(data []byte) *ScriptBuilder {
 	return b
 }
 
-// AddFullData should not typically be used by ordinary users as it does not
-// include the checks which prevent data pushes larger than the maximum allowed
-// sizes which leads to scripts that can't be executed.  This is provided for
-// testing purposes such as regression tests where sizes are intentionally made
-// larger than allowed.
+// AddFullData pushes the passed data to the end of the script without
+// enforcing MaxScriptElementSize limits. It automatically chooses canonical
+// opcodes depending on the length of the data.
 //
-// Use AddData instead.
+// This function bypasses the 520-byte MaxScriptElementSize limit and is
+// intended for:
+//
+//  1. Creating OP_RETURN outputs with data larger than 520 bytes, since they
+//     are provably unspendable and never executed.
+//  2. Testing purposes where scripts need to intentionally exceed limits.
+//
+// For regular data pushes that will be executed, use AddData instead, which
+// enforces size limits to ensure the resulting script can be executed.
 func (b *ScriptBuilder) AddFullData(data []byte) *ScriptBuilder {
 	if b.err != nil {
 		return b

txscript/standard.go

@@ -15,7 +15,7 @@ import (
 const (
 	// MaxDataCarrierSize is the maximum number of bytes allowed in pushed
 	// data to be considered a nulldata transaction
-	MaxDataCarrierSize = 80
+	MaxDataCarrierSize = 100000
 
 	// StandardVerifyFlags are the script flags which are used when
 	// executing transaction scripts to enforce additional checks which
@@ -885,14 +885,18 @@ func PayToAddrScript(addr btcutil.Address) ([]byte, error) {
 // NullDataScript creates a provably-prunable script containing OP_RETURN
 // followed by the passed data.  An Error with the error code ErrTooMuchNullData
 // will be returned if the length of the passed data exceeds MaxDataCarrierSize.
+//
+// Note: This function uses AddFullData to bypass MaxScriptElementSize since
+// OP_RETURN outputs are provably unspendable and never executed. The data size
+// is only constrained by MaxDataCarrierSize policy and MaxScriptSize consensus.
 func NullDataScript(data []byte) ([]byte, error) {
 	if len(data) > MaxDataCarrierSize {
 		str := fmt.Sprintf("data size %d is larger than max "+
 			"allowed size %d", len(data), MaxDataCarrierSize)
 		return nil, scriptError(ErrTooMuchNullData, str)
 	}
 
-	return NewScriptBuilder().AddOp(OP_RETURN).AddData(data).Script()
+	return NewScriptBuilder().AddOp(OP_RETURN).AddFullData(data).Script()
 }
 
 // MultiSigScript returns a valid script for a multisignature redemption where

txscript/standard_test.go

@@ -1022,14 +1022,14 @@ var scriptClassTests = []struct {
 		class: NullDataTy,
 	},
 	{
-		// Nulldata with more than max allowed data to be considered
-		// standard (so therefore nonstandard)
-		name: "nulldata exceed max standard push",
+		// Nulldata with 81 bytes is now standard (previously exceeded
+		// the old 80 byte limit, but is well under the new 100KB limit)
+		name: "nulldata 81 bytes standard",
 		script: "RETURN PUSHDATA1 0x51 0x046708afdb0fe5548271967f1a67" +
 			"130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef3" +
 			"046708afdb0fe5548271967f1a67130b7105cd6a828e03909a67" +
 			"962e0ea1f61deb649f6bc3f4cef308",
-		class: NonStandardTy,
+		class: NullDataTy,
 	},
 	{
 		// Almost nulldata, but add an additional opcode after the data
@@ -1238,11 +1238,30 @@ func TestNullDataScript(t *testing.T) {
 			class: NullDataTy,
 		},
 		{
-			name: "too big",
+			name: "81 bytes now standard",
 			data: hexToBytes("000102030405060708090a0b0c0d0e0f101" +
 				"112131415161718191a1b1c1d1e1f202122232425262" +
 				"728292a2b2c2d2e2f303132333435363738393a3b3c3" +
 				"d3e3f404142434445464748494a4b4c4d4e4f50"),
+			expected: mustParseShortForm("RETURN PUSHDATA1 0x51 " +
+				"0x000102030405060708090a0b0c0d0e0f101112131" +
+				"415161718191a1b1c1d1e1f20212223242526272829" +
+				"2a2b2c2d2e2f303132333435363738393a3b3c3d3e3" +
+				"f404142434445464748494a4b4c4d4e4f50"),
+			err:   nil,
+			class: NullDataTy,
+		},
+		{
+			name: "large data - 9995 bytes (under MaxScriptSize)",
+			data: make([]byte, 9995),
+			// MaxScriptSize (10000) - OP_RETURN (1) - PUSHDATA2 (3) - length field (1) ≈ 9995
+			expected: nil, // Not checking exact encoding for large data
+			err:      nil,
+			class:    NullDataTy,
+		},
+		{
+			name:     "exceeds MaxDataCarrierSize limit",
+			data:     make([]byte, 100001),
 			expected: nil,
 			err:      scriptError(ErrTooMuchNullData, ""),
 			class:    NonStandardTy,
@@ -1259,7 +1278,8 @@ func TestNullDataScript(t *testing.T) {
 		}
 
 		// Check that the expected result was returned.
-		if !bytes.Equal(script, test.expected) {
+		// Skip exact comparison if expected is nil (for large data tests).
+		if test.expected != nil && !bytes.Equal(script, test.expected) {
 			t.Errorf("NullDataScript: #%d (%s) wrong result\n"+
 				"got: %x\nwant: %x", i, test.name, script,
 				test.expected)