Handle events

- Adds interfaces for developers to build handlers that update data in
response to log events
- Resolves #29

pkg/datastore/inmemory/block_repository.go

@@ -0,0 +1,51 @@
+package inmemory
+
+import (
+	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore"
+)
+
+type BlockRepository struct {
+	*InMemory
+}
+
+func (blockRepository *BlockRepository) CreateOrUpdateBlock(block core.Block) error {
+	blockRepository.CreateOrUpdateBlockCallCount++
+	blockRepository.blocks[block.Number] = block
+	for _, transaction := range block.Transactions {
+		blockRepository.receipts[transaction.Hash] = transaction.Receipt
+		blockRepository.logs[transaction.TxHash] = transaction.Logs
+	}
+	return nil
+}
+
+func (blockRepository *BlockRepository) GetBlock(blockNumber int64) (core.Block, error) {
+	if block, ok := blockRepository.blocks[blockNumber]; ok {
+		return block, nil
+	}
+	return core.Block{}, datastore.ErrBlockDoesNotExist(blockNumber)
+}
+
+func (blockRepository *BlockRepository) MissingBlockNumbers(startingBlockNumber int64, endingBlockNumber int64) []int64 {
+	missingNumbers := []int64{}
+	for blockNumber := int64(startingBlockNumber); blockNumber <= endingBlockNumber; blockNumber++ {
+		if _, ok := blockRepository.blocks[blockNumber]; !ok {
+			missingNumbers = append(missingNumbers, blockNumber)
+		}
+	}
+	return missingNumbers
+}
+
+func (blockRepository *BlockRepository) SetBlocksStatus(chainHead int64) {
+	for key, block := range blockRepository.blocks {
+		if key < (chainHead - blocksFromHeadBeforeFinal) {
+			tmp := block
+			tmp.IsFinal = true
+			blockRepository.blocks[key] = tmp
+		}
+	}
+}
+
+func (blockRepository *BlockRepository) BlockCount() int {
+	return len(blockRepository.blocks)
+}

pkg/datastore/inmemory/contract_repository.go

@@ -0,0 +1,35 @@
+package inmemory
+
+import (
+	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/datastore"
+)
+
+type ContractRepostiory struct {
+	*InMemory
+}
+
+func (contractRepository *ContractRepostiory) ContractExists(contractHash string) bool {
+	_, present := contractRepository.contracts[contractHash]
+	return present
+}
+
+func (contractRepository *ContractRepostiory) GetContract(contractHash string) (core.Contract, error) {
+	contract, ok := contractRepository.contracts[contractHash]
+	if !ok {
+		return core.Contract{}, datastore.ErrContractDoesNotExist(contractHash)
+	}
+	for _, block := range contractRepository.blocks {
+		for _, transaction := range block.Transactions {
+			if transaction.To == contractHash {
+				contract.Transactions = append(contract.Transactions, transaction)
+			}
+		}
+	}
+	return contract, nil
+}
+
+func (contractRepository *ContractRepostiory) CreateContract(contract core.Contract) error {
+	contractRepository.contracts[contract.Hash] = contract
+	return nil
+}

pkg/datastore/inmemory/in_memory.go

@@ -0,0 +1,30 @@
+package inmemory
+
+import (
+	"github.com/vulcanize/vulcanizedb/pkg/core"
+	"github.com/vulcanize/vulcanizedb/pkg/filters"
+)
+
+const (
+	blocksFromHeadBeforeFinal = 20
+)
+
+type InMemory struct {
+	blocks                       map[int64]core.Block
+	receipts                     map[string]core.Receipt
+	contracts                    map[string]core.Contract
+	logs                         map[string][]core.Log
+	logFilters                   map[string]filters.LogFilter
+	CreateOrUpdateBlockCallCount int
+}
+
+func NewInMemory() *InMemory {
+	return &InMemory{
+		CreateOrUpdateBlockCallCount: 0,
+		blocks:     make(map[int64]core.Block),
+		receipts:   make(map[string]core.Receipt),
+		contracts:  make(map[string]core.Contract),
+		logs:       make(map[string][]core.Log),
+		logFilters: make(map[string]filters.LogFilter),
+	}
+}