What is the difference between transaction cost and execution cost in remix?

Question

What is the difference between transaction cost and execution cost as seen after contract instantiation in remix?

I don't think it matters, but here is my contract:

contract DepositCounter {
    uint deposits = 0;
    function() {
        deposits++;
    }
}

Answer 1

Transaction costs are the costs for sending the contract code to the ethereum blockchain, they depend on the size of the contract.

Check out the source code:

 var getGasUsedOutput = function (result, vmResult) {
        var $gasUsed = $('<div class="gasUsed">');
        var caveat = lookupOnly ? '<em>(<span class="caveat" title="Cost only applies when called by a contract">caveat</span>)</em>' : '';
        if (result.gasUsed) {
            var gas = result.gasUsed.toString(10);
            $gasUsed.html('<strong>Transaction cost:</strong> ' + gas + ' gas. ' + caveat);
        }
        if (vmResult.gasUsed) {
            var $callGasUsed = $('<div class="gasUsed">');
            var gas = vmResult.gasUsed.toString(10);
            $callGasUsed.append('<strong>Execution cost:</strong> ' + gas + ' gas.');
            $gasUsed.append($callGasUsed);
        }
        return $gasUsed;
    };

Execution costs should be really the vm execution costs, if I interprete the parameter vmResult correctly. Is this maybe because a default constructor will be called any way?

Answer 2

I hope this answer helps to provide a more complete picture alongside the accepted answer.

Transaction costs are based on the cost of sending data to the blockchain. There are 4 items which make up the full transaction cost:

1. the base cost of a transaction (21000 gas)
2. the cost of a contract deployment (32000 gas)
3. the cost for every zero byte of data or code for a transaction.
4. the cost of every non-zero byte of data or code for a transaction.

Execution costs are based on the cost of computational operations which are executed as a result of the transaction.

You can see the breakdown in the yellow paper, Appendix G.

Answer 3

This post is an addition to the previous answer from Roland Kofler in June 2016.

Execution costs should be really the vm execution costs, if I interprete the parameter vmResult correctly. Is this maybe because a default constructor will be called any way? In addition to Roland:

Execution cost has everything to do with the costs for storing global variables and the runtime of the method calls.

Storing global variables seems rather expensive to me. In the code below you see me testing the mathematical efficiency of exponentiation. All the computations together cost roughly 500. Adding the line "result = res;" changes this from 500 to roughly 20,000 execution cost.

uint256 result;
    function modPow2() returns (uint res){
        res = 2341**4 % 3456;
        res = res**8 % 3456;
        res = res**2 % 3456;
        res = res**2 % 3456;
        res = res**2 % 3456;
        res = res**4 % 3456;
        result = res;
    }

If you run this method twice in a row, it costs respectively 20,000 and then 5,000. The third time I run it, it costs 5,000 again. My guess is that changing the bit-size of the global variable result is expensive. I tested this by resetting the value with result=0; or do result=result+1; between the runs.

Then Transaction cost has everything to do with the size of the compiled contract PLUS the execution cost. Comments don't change the transaction costs and the naming of the variables also don't. But adding a (non-called) method does. You can call some methods within your contract and it appears that transaction cost - execution cost = constant for the compiled contract you are currently working with.