Ethereum Oracle

Author: ezeike

cmd/cli/main.go

@@ -15,6 +15,8 @@ import (
 	"time"
 
 	"github.com/canopy-network/canopy/cmd/rpc"
+	"github.com/canopy-network/canopy/cmd/rpc/oracle"
+	"github.com/canopy-network/canopy/cmd/rpc/oracle/eth"
 	"github.com/canopy-network/canopy/controller"
 	"github.com/canopy-network/canopy/fsm"
 	"github.com/canopy-network/canopy/lib"
@@ -87,8 +89,21 @@ func Start() {
 	if err != nil {
 		l.Fatal(err.Error())
 	}
+	// create a seperate logger for the oracle and all oracle components
+	oracleLogger := lib.NewOracleLogger(lib.LoggerConfig{Level: config.GetLogLevel()}, config.OracleConfig.LogPath)
+	// create a new ethereum disk storage instance for the oracle order store
+	oracleStorage, e := oracle.NewOracleDiskStorage(config.OracleConfig.OrderStorePath, oracleLogger)
+	if e != nil {
+		l.Fatal(err.Error())
+	}
+	// create the ethereum block provider
+	ethBlockProvider := eth.NewEthBlockProvider(config.EthBlockProviderConfig, oracleLogger)
+	// create a new oracle instance and pass the ethereum block provider
+	oracle := oracle.NewOracle(config.OracleConfig, ethBlockProvider, oracleStorage, oracleLogger)
+	// start the oracle
+	oracle.Start()
 	// create a new instance of the application
-	app, err := controller.New(sm, config, validatorKey, metrics, l)
+	app, err := controller.New(sm, oracle, config, validatorKey, metrics, l)
 	if err != nil {
 		l.Fatal(err.Error())
 	}
@@ -102,6 +117,8 @@ func Start() {
 	rpcServer.Start()
 	// block until a kill signal is received
 	waitForKill()
+	// gracefuly stop oracle
+	oracle.Stop()
 	// gracefully stop the app
 	app.Stop()
 	// gracefully stop the metrics server

cmd/rpc/oracle/eth/block.go

@@ -0,0 +1,52 @@
+package eth
+
+import (
+	"github.com/canopy-network/canopy/cmd/rpc/oracle/types"
+	"github.com/canopy-network/canopy/lib"
+	ethtypes "github.com/ethereum/go-ethereum/core/types"
+)
+
+var _ types.BlockI = &Block{} // Ensures *Block implements BlockI
+
+// Block represents an ethereum block that implements BlockI interface
+type Block struct {
+	hash         string         // block hash as hex string
+	number       uint64         // block number
+	transactions []*Transaction // array of transactions in this block
+}
+
+// NewBlock creates a new Block from an ethereum block
+func NewBlock(ethBlock *ethtypes.Block) (*Block, error) {
+	// validate input block is not nil
+	if ethBlock == nil {
+		return nil, lib.ErrNilBlock()
+	}
+	// create new block instance
+	block := &Block{
+		hash:         ethBlock.Hash().Hex(),   // convert block hash to hex string
+		number:       ethBlock.NumberU64(),    // get block number as uint64
+		transactions: make([]*Transaction, 0), // initialize empty transaction slice
+	}
+	return block, nil // return successfully created block
+}
+
+// Hash returns the block hash as a string
+func (b *Block) Hash() string {
+	return b.hash // return the stored block hash
+}
+
+// Number returns the block number
+func (b *Block) Number() uint64 {
+	return b.number // return the stored block number
+}
+
+// Transactions returns all transactions in this block
+func (b *Block) Transactions() []types.TransactionI {
+	// create slice to hold transaction interfaces
+	txs := make([]types.TransactionI, len(b.transactions))
+	// convert each transaction to interface type
+	for i, tx := range b.transactions {
+		txs[i] = tx // assign transaction to interface slice
+	}
+	return txs // return slice of transaction interfaces
+}