How to manipulate data in a Solidity smart contract?

Question

I have a smart contract with some members which should get modified on certain events. For simplicity, let's imagine we have a greeter contract.

If I call greeter.greet() in the JavaScript console, it responds with something like Hello World. But what if I want to count the number of greetings and store them inside the contract?

My first try was the following:

contract greeter
{
  string greeting;
  uint calls;

  function greeter ( string _greeting ) public
  {
    greeting = _greeting;
    calls = 0;
  }

  function greet ( ) constant returns ( string )
  {
    calls = calls + 1; // does not work
    return greeting;
  }
}

The calls variable was not updated. My first guess is that I need to somehow create a transaction to pay for the gas. I used web3.js to deploy the contract. Should I use web3 also for calling greet() with a transaction?

Or could I fund the contract account with some Ether to enable the contract to pay its own gas? How to manipulate data in a Solidity smart contract?

Answer 1

Because your greet() function is marked constant, web3 by default simulates the call and returns the value, but no transaction is sent, and thus no state changes are retained. This behavior can be forced in non-constant methods using contract.method.call().

To call the function in a way that does send a transaction and update the chain, use greeter.greet.sendTransaction({from:eth.coinbase, gas:100000}).

Unfortunately, while other contracts will recieve the proper return value, web3 will return a transaction hash, as opposed to a return value. In this case, it makes sense to use Events.

For example, the solidity would look something like:

contract greeter { 
    string greeting; 
    uint calls; 
    event Greet (string greeting);
    function greeter ( string _greeting ) public { 
        greeting = _greeting; 
        calls = 0; 
     }
     function greet ( ) public returns ( string ) { 
         calls = calls + 1; 
         Greet(greeting);
          return greeting; 
     } 
 }

And to get a return value:

 greeter.greet.sendTransaction(
    {from:eth.coinbase, gas:100000},

    function (error, result){ 
    var event = greeter.Greet()
    event.watch(
        function(error, result){ 
             if (!error) console.log(result.args.greeting); 
         }
    );
)

Answer 2

The problem is that greet is a constant function so no state changes are allowed. Changing the value of something in storage, would be a state change.

Solution: remove constant.

Yes, you should use web3 sendTransaction when you want a state change. sendTransaction is the default for non-constant functions, but it wasn't used because constant was specified. Note that the return value will only be accessible from another contract -- with web3js transactions, Events will need to be used to get the return value as Tjaden Hess answered.

More from the FAQ:

What is the difference between a function marked constant and one that is not?

constant functions can perform some action and return a value, but cannot change state (this is not yet enforced by the compiler). In other words, a constant function cannot save or update any variables within the contract or wider blockchain. These functions are called using c.someFunction(...) from geth or any other web3.js environment.

“non-constant” functions (those lacking the constant specifier) must be called with c.someMethod.sendTransaction({from:eth.accounts[x], gas: 1000000}); That is, because they can change state, they have to have a gas payment sent along to get the work done.

---

To answer the remaining question, a contract cannot pay for its own gas, in the way that might be imagined with this example, so funding it with Ether doesn't help.