Should contracts be written as if everyone has their own copy?

Question

I'm trying to start my first ethereum project with truffle. I noticed that one of the contracts that comes with truffle init is:

contract MetaCoin {
  mapping (address => uint) balances;

  event Transfer(address indexed _from, address indexed _to, uint256 _value);

  function MetaCoin() {
    balances[tx.origin] = 10000;
  }

  function sendCoin(address receiver, uint amount) returns(bool sufficient) {
    if (balances[msg.sender] < amount) return false;
    balances[msg.sender] -= amount;
    balances[receiver] += amount;
    Transfer(msg.sender, receiver, amount);
    return true;
  }

  function getBalanceInEth(address addr) returns(uint){
    return ConvertLib.convert(getBalance(addr),2);
  }

  function getBalance(address addr) returns(uint) {
    return balances[addr];
  }
}

However, to my understanding everyone has their own copy of the contract. So how would something like balances[receiver] += amount; or balances[msg.sender] -= amount; work?

If Person A sends Person B money, then on Person A's contract what's the point of adding to Person B's balance locally (through balances[receiver] += amount;)? Person B's contract should just update itself. It's not like anyone will ever ask Person A what Person B's balance is, so I don't see why it's stored.

Or perhaps it's the opposite? There's only 1 copy shared among every user in the network?

Answer 1

There's only one logical copy of the contract and the contract state. It's the state that the nodes eventually agree upon after they evaluate transactions independently. In the physical sense, they all have it but they can't (successfully) change anything independently. That would be like editing your local blockchain and expecting it to spend. It just won't work.

The tokens are non-local, just like ether, bitcoin, altcoins. The contract just keeps track of quantities assigned to addresses, and the only way to move them is to sign and send a transaction to sendCoin().

This bit here:

if (balances[msg.sender] < amount) return false;

ensures that the transaction is signed (msg.sender) and it looks up a balance from a DHT that holds simple integers. Whomever sent the transaction to sendCoin() can only take from the balance associated with their own address.

Then it does the math. Take from Alice to pay Bob. If the transaction is properly signed and Alice has the funds, then all nodes will agree on the new state. If not, then all nodes will agree the transaction was invalid.

Usual disclaimer: That contract is for illustrative purposes only and not suitable for real life use. ;-)

Hope it helps.