Comments

big.go

@@ -4,6 +4,9 @@ import (
   "math/big"
 )
 
+/*
+ * Returns the power of two integers
+ */
 func BigPow(a,b int) *big.Int {
   c := new(big.Int)
   c.Exp(big.NewInt(int64(a)), big.NewInt(int64(b)), big.NewInt(0))
@@ -11,6 +14,9 @@ func BigPow(a,b int) *big.Int {
   return c
 }
 
+/*
+ * Like big.NewInt(uint64); this takes a string instead.
+ */
 func Big(num string) *big.Int {
   n := new(big.Int)
   n.SetString(num, 0)

block.go

@@ -7,17 +7,23 @@ import (
 )
 
 type Block struct {
+  // The number of this block
   number        uint32
+  // Hash to the previous block
   prevHash      string
+  // Uncles of this block
   uncles        []*Block
   coinbase      string
   // state xxx
   difficulty    uint32
+  // Creation time
   time          time.Time
   nonce         uint32
+  // List of transactions and/or contracts
   transactions  []*Transaction
 }
 
+// Creates a new block. This is currently for testing
 func NewBlock(/* TODO use raw data */transactions []*Transaction) *Block {
   block := &Block{
     // Slice of transactions to include in this block
@@ -37,14 +43,16 @@ func NewBlock(/* TODO use raw data */transactions []*Transaction) *Block {
 func (block *Block) Update() {
 }
 
+// Returns a hash of the block
 func (block *Block) Hash() string {
   return Sha256Hex(block.MarshalRlp())
 }
 
 func (block *Block) MarshalRlp() []byte {
-  // Encoding method requires []interface{} type. It's actual a slice of strings
+  // Marshal the transactions of this block
   encTx := make([]string, len(block.transactions))
   for i, tx := range block.transactions {
+    // Cast it to a string (safe)
     encTx[i] = string(tx.MarshalRlp())
   }
 
@@ -64,14 +72,16 @@ func (block *Block) MarshalRlp() []byte {
     // extra?
   }
 
-  encoded := Encode([]interface{}{header, encTx})
+  // Encode a slice interface which contains the header and the list of transactions.
-
+  return Encode([]interface{}{header, encTx})
-  return encoded
 }
 
 func (block *Block) UnmarshalRlp(data []byte) {
   t, _ := Decode(data,0)
+
+  // interface slice assertion
   if slice, ok := t.([]interface{}); ok {
+    // interface slice assertion
     if header, ok := slice[0].([]interface{}); ok {
       if number, ok := header[0].(uint8); ok {
         block.number = uint32(number)
@@ -109,11 +119,15 @@ func (block *Block) UnmarshalRlp(data []byte) {
     }
 
     if txSlice, ok := slice[1].([]interface{}); ok {
+      // Create transaction slice equal to decoded tx interface slice
       block.transactions = make([]*Transaction, len(txSlice))
 
+      // Unmarshal transactions
       for i, tx := range txSlice {
         if t, ok := tx.([]byte); ok {
           tx := &Transaction{}
+          // Use the unmarshaled data to unmarshal the transaction
+          // t is still decoded.
           tx.UnmarshalRlp(t)
 
           block.transactions[i] = tx

block_manager.go

@@ -26,9 +26,12 @@ func NewBlockManager() *BlockManager {
 
 // Process a block.
 func (bm *BlockManager) ProcessBlock(block *Block) error {
+  // Get the tx count. Used to create enough channels to 'join' the go routines
   txCount  := len(block.transactions)
+  // Locking channel. When it has been fully buffered this method will return
   lockChan := make(chan bool, txCount)
 
+  // Process each transaction/contract
   for _, tx := range block.transactions {
     go bm.ProcessTransaction(tx, lockChan)
   }

ethereum.go

@@ -37,7 +37,6 @@ func main() {
 
   bm.ProcessBlock( blck )
 
-
   t := blck.MarshalRlp()
   copyBlock := &Block{}
   copyBlock.UnmarshalRlp(t)

transaction.go

@@ -125,6 +125,7 @@ func (tx *Transaction) UnmarshalRlp(data []byte) {
       tx.fee = uint32(fee)
     }
 
+    // Encode the data/instructions
     if data, ok := slice[5].([]interface{}); ok {
       tx.data = make([]string, len(data))
       for i, d := range data {