Is it possible to have multiple coin types in one contract?

Question

I'm still pretty new to ethereum but I have a decent understanding of how it works and I've written a couple different contracts.

What I am trying to figure out is if it is possible to have n different coin types in a single contract.

So for example if I took the example coin code from the go-ethereum github

contract token { 
    mapping (address => uint) public coinBalanceOf;
    event CoinTransfer(address sender, address receiver, uint amount);

    /* Initializes contract with initial supply tokens to the creator of the contract */
   function token(uint supply) {
     coinBalanceOf[msg.sender] = supply;
   }

   /* Very simple trade function */
   function sendCoin(address receiver, uint amount) returns(bool sufficient) {
     if (coinBalanceOf[msg.sender] < amount) return false;
     coinBalanceOf[msg.sender] -= amount;
     coinBalanceOf[receiver] += amount;
     CoinTransfer(msg.sender, receiver, amount);
     return true;
   }
}

and instead of just having the one coin type I wanted to have three different coin types, coin1, coin2, and coin3, what would be the best way to implement this in my contract?

My initial thought was to have an array of all of the different coin types and then each element in the array would contain another array that contains the address and balance information but I'm not exactly sure how I would write that.

Answer 1

The simplest way should be to deploy the contract three times. Each instance of the contract refer to a separate coin. But in that situation is not simple to interact with different coin types.

If you want to be able to handle more than coin type in a single contract it can be done in several ways.

You can try using nested mappings. Here coinBalanceOf[k] will refer to the balances of the coin type k. And coinBalanceOf[k][address] will refer to the balance of address in the coin type k.

contract token { 
    mapping (uint => mapping (address => uint)) coinBalanceOf;
    event CoinTransfer(uint coinType, address sender, address receiver, uint amount);

    /* Initializes contract with initial supply tokens to the creator of the contract */
   function token(uint numCoinTypes, uint supply) {
     for (uint k=0; k<numCoinTypes; ++k) {
       coinBalanceOf[k][msg.sender] = supply;
     }
   }

   /* Very simple trade function */
   function sendCoin(uint coinType, address receiver, uint amount) returns(bool sufficient) {
     if (coinBalanceOf[coinType][msg.sender] < amount) return false;
     coinBalanceOf[coinType][msg.sender] -= amount;
     coinBalanceOf[coinType][receiver] += amount;
     CoinTransfer(coinType, msg.sender, receiver, amount);
     return true;
   }
}

If you have a fixed numberof coin types, instead of a nested mapping you can have a mapping to an array of balances for each key.

mapping (address => uint[3]) coinBalanceOf;

Now coinBalanceOf[address] are the balances of address, and coinBalanceOf[address] is balance of address in the coin type k.