So this suggestion
does not involve fixing the malleability problem but rather
an attempt to find out who is doing it (if at all intentionally) :
Theory : The "malleated" tx only goes through if it reaches the node (or set of nodes) that solved the block. So we should, in theory, be able to identify if one of the major/small pools is causing this problem (coz it did not cause so much of a problem earlier so it appears to be intentional).
Make very small transactions (to save money of course) with BTC and submit them to well known pools (since
https://en.bitcoin.it/wiki/IP_Transactions is no longer turned on we might need volunteers or miners who could try this out from various pools or maybe even with a custom implementation). I believe (yea assumption) that some pool is doing this on purpose, and it may very well be (yea 2nd assumption) that it is being done by some of the seed nodes (due to connectivity).
The transactions above can (or some custom implementation - see Difficulty below) be done using something similar to bitcoind because it will give the original txid which will be of help to track down later and see if it has been changed.
For every transaction we do above, check if the amount has been credited to your own second address
with the same txid. If it is credited with a
different txid then that is
most probably your culprit(s/pool) that is causing the problem.
I say most probably because the wiki
https://en.bitcoin.it/wiki/Transaction_Malleability says that it is uncommon but possible. There are well known causes of malleability, so we can't be certain at first. Repeat the above process more and more to say with some degree of certainty that the given pool is the culprit. Just as in a court of law.
Difficulty : maybe that whichever implementation of the client you use could try will connect to many peers as in the protocol. Maybe we will need a custom implementation of the code to just connect to the seeds of well known pools. Basically the idea of only connecting to the seed nodes of one particular pool at one given time. Then do the same with other pools' seed nodes sequentially.
Action : And if we so happen to find the culprit then maybe the lead developer could use use
https://en.bitcoin.it/wiki/Alerts for all to stay (stop mining) away from the pool (if we happen to identify it with some degree of confidence). This way the network propagation power of the pool goes low (not all out though) and consequently,so will the number of "malleated" txs,
hopefully returning to as it was before this problem surfaced.This is a very rough idea, but I feel it can be tried, so feel free to shoot me or correct me as it seems appropriate.
Something that could perhaps be of use conceptwise (im not a programmer so maybe irrelevant links but did help me with the above idea)
https://github.com/bitcoin/bitcoin/pull/3403https://en.bitcoin.it/wiki/IP_Transactions