aboutsummaryrefslogtreecommitdiffstats
path: root/ethereum.go
blob: 5cbf866653aa5e296846b036e5681184c5c10f45 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
package main

import (
    "encoding/hex"
    "flag"
    "fmt"
    "github.com/ethereum/eth-go"
    "github.com/ethereum/ethchain-go"
    "github.com/ethereum/ethutil-go"
    _ "github.com/ethereum/ethwire-go"
    "log"
    "os"
    "os/signal"
    "runtime"
)

const Debug = true

var StartConsole bool
var StartMining bool
var UseUPnP bool
var OutboundPort string

func Init() {
    flag.BoolVar(&StartConsole, "c", false, "debug and testing console")
    flag.BoolVar(&StartMining, "m", false, "start dagger mining")
    flag.BoolVar(&UseUPnP, "upnp", false, "enable UPnP support")
    flag.StringVar(&OutboundPort, "port", "30303", "listening port")

    flag.Parse()
}

// Register interrupt handlers so we can stop the ethereum
func RegisterInterupts(s *eth.Ethereum) {
    // Buffered chan of one is enough
    c := make(chan os.Signal, 1)
    // Notify about interrupts for now
    signal.Notify(c, os.Interrupt)
    go func() {
        for sig := range c {
            fmt.Printf("Shutting down (%v) ... \n", sig)

            s.Stop()
        }
    }()
}

func main() {
    runtime.GOMAXPROCS(runtime.NumCPU())
    Init()

    ethchain.InitFees()
    ethutil.ReadConfig()

    log.Printf("Starting Ethereum v%s\n", ethutil.Config.Ver)

    // Instantiated a eth stack
    ethereum, err := eth.New(eth.CapDefault, UseUPnP)
    if err != nil {
        log.Println(err)
        return
    }

    if StartConsole {
        err := os.Mkdir(ethutil.Config.ExecPath, os.ModePerm)
        // Error is OK if the error is ErrExist
        if err != nil && !os.IsExist(err) {
            log.Panic("Unable to create EXECPATH:", err)
        }

        console := NewConsole(ethereum)
        go console.Start()
    }

    RegisterInterupts(ethereum)

    ethereum.Start()

    if StartMining {
        log.Printf("Dev Test Mining started...\n")

        // Fake block mining. It broadcasts a new block every 5 seconds
        go func() {
            pow := &ethchain.EasyPow{}
            addr, _ := hex.DecodeString("82c3b0b72cf62f1a9ce97c64da8072efa28225d8")

            for {
                txs := ethereum.TxPool.Flush()
                // Create a new block which we're going to mine
                block := ethereum.BlockManager.BlockChain().NewBlock(addr, txs)
                // Apply all transactions to the block
                ethereum.BlockManager.ApplyTransactions(block, block.Transactions())
                // Search the nonce
                block.Nonce = pow.Search(block)
                ethereum.BlockManager.ProcessBlock(block)
                //ethereum.Broadcast(ethwire.MsgBlockTy, []interface{}{block.RlpValue().Value})
                log.Println("\n+++++++ MINED BLK +++++++\n", block.String())
            }
        }()
    }

    // Wait for shutdown
    ethereum.WaitForShutdown()
}