Here is a quick introduction to what bitcoin policy rules are
We start with (consensus) valid transactions. These transactions abide by the bitcoin consensus rules which all nodes on the network enforce. For example, a non coinbase transaction can't spend more than the sum of the inputs.
Next we have standard transactions, which are the transactions permitted into the mempool of a node according to it's policy rules.
The default policy rules which come packaged with the latest bitcoin core release are generally adopted by the network within a year. Each release with new policy rules will result in different set of standard transactions, so it's a moving target, but on any given node the rules are set at any given time.
Each node can configure it's policy rules as it sees fit (in theory, more on this later) and transactions must first pass consensus rules before considering policy. This means that there is no risk that using different policy rules will break consensus. Another way to say this is that standard transactions are a subset of valid transactions.
Another subset of valid transactions are Denial of Service (DOS) transactions, which for one reason or another will cause a node to have a bad time. For example a DOS transasction might crash the node, or cause it to take a very long time to validate. We know about a number of DOS transactions, but presumably there are some DOS transactions which we don't yet know about. So we can add to our diagram two circles, one for all DOS transactions, and within that a smaller circle for the known DOS transactions.
Ideally the standard transactions & DOS transactions sets don't intersect, that's the intention of most policy rules.
Note: There are some who believe that policy rules should be used to guide the use of the permissionless network. Personally I think this is a folly when there is an economic incentive.
It's relatively simple to ensure that the standard transactions and known DOS transactions don't intersect because they are both well defined. It's harder to know whether the standard transactions and the unknown DOS transactions don't intersect, but we can reason about how we would construct a DOS transaction and then add some policy rules. For example, we can set a limit on the total size of a transaction, which will presumably mean some unknown DOS transactions are now non standard (and our node is protected).
So to be prudent we can add in lots of policy / standardness rules to protect us from unknown DOS transactions, which makes our node less vulnerable. The tradeoff is that in doing this we also make some safe (non DOS) transactions non standard. Arguably this is what happened over the years with bitcoin core, and for good reason.
This is a key point when considering policy rules. Our understanding of what transactions potentially result in a DOS risk is undoubtedly incomplete, and the widespread adoption of current bitcoin core standardness rules might be protecting the network more than we realise. But, having strict policy rules is also making some perfectly safe transactions non standard. For miners, these non standard, known non DOS transactions represent a safe source of extra revenue.
If economic demand for these transactions grows, it is reasonable to expect that some miners will relax the policy rules on their blockmaker node to earn this extra revenue.
These transactions won't relay over the standard bitcoin core p2p relay, so they will either be submitted directly to the miner (e.g. slipstream) or over an alternate relay path (e.g. opreturn bot using libre relay). Once mined they will be downloaded by all nodes in the network.
From my perspective, it's inevitable that systems will be built to get valid transactions to miners if they can't be relayed p2p. This has already happened, and will likely continue to happen as people develop systems which require the use of nonstandard transactions.
Call for transparent development
In my opinion it is critical that bitcoin developers have an opportunity to verify that these nonstandard transactions don't pose DOS risks. With that in mind, it would be great to be able to perform benchmarking on these transactions prior to them being widely deployed on chain.
If you are building systems which use nonstandard transactions, I would love to discuss this with you!
I will post more about this in the future, if anything was unclear please comment below!
Note: There is also the set of transactions using upgrade hooks, where pretty much everyone benefits from not including certain transactions. Ideally we can ensure that there is no economic demand for these, because they make upgrades much easier.
