Is it possible write a test for Truffle to validate that I am preventing unpredictable state variable changes in my contracts?

Question

I recently read this paper on designing secure smart contracts, and it gives the following modifier to ensure that when an EOA (or contract address) interacts with your original contract that the values of the variables stored in the contract are predictable and do not change before their transaction is mined.

uint private transitionCounter = 0;

modifier transitionCounting(uint nextTransitionNumber) {
require(nextTransitionNumber == transitionCounter);
transitionCounter += 1;
_;}

Is there a way to write a test in JavaScript or Solidity for Truffle that would test the modifier above? Overall, you would need to simulate two transactions mined varying speeds, but is that possible with these tests? Or else how would you properly test this?

Answer 1

Having looked at the doc you linked, I don't think you need to simulate transactions happening at varying speeds. Since you also submit the nextTransitionCounter to the functions that you declare that modifier on, you can just submit two transactions each with the same nextTransitionCounter and assert that the second one fails.

To assert that a transaction has failed you can use this function which should work for both testrpc and live chains:

const assertThrows = (contractMethodCall) => {
    return new Promise((resolve, reject) => {
        try {
            resolve(contractMethodCall())
        } catch (error) {
            reject(error)
        }
    })
        .then(transaction => {
            // This asserts the mined transaction has failed, this occurs on live chains
            // or when a transaction is successful on testrpc.
            assert.equal(transaction.receipt.status, 0, "Transaction successful")
        })
        .catch(error => {
            // On testrpc a failed transaction is not mined but throws an error instead.
            // This checks for the term "revert" in the error and ignores it if it contains
            // it, declaring the test successful. It will re-throw any other errors.
            if ((error + "").indexOf("revert") < 0) {
                throw error
            }
        }) 
}

Example use in a test:

it("Test function reverts", async () => {
    await assertThrows(() => testContract.failingFunc())
})

Where testContract is an instance of your contract and failingFunc() is a function expected to fail/revert.