Prefer all caps for initialisms and acronyms

cmd/composeAndExecute.go

@@ -187,7 +187,7 @@ func composeAndExecute() {
 			rpcClient, _ := getClients()
 			stateDiffStreamer := streamer.NewStateDiffStreamer(rpcClient)
 			payloadChan := make(chan statediff.Payload)
-			storageFetcher := fetcher.NewGethRpcStorageFetcher(&stateDiffStreamer, payloadChan)
+			storageFetcher := fetcher.NewGethRPCStorageFetcher(&stateDiffStreamer, payloadChan)
 			sw := watcher.NewStorageWatcher(storageFetcher, &db)
 			sw.AddTransformers(ethStorageInitializers)
 			wg.Add(1)

cmd/execute.go

@@ -131,7 +131,7 @@ func execute() {
 			rpcClient, _ := getClients()
 			stateDiffStreamer := streamer.NewStateDiffStreamer(rpcClient)
 			payloadChan := make(chan statediff.Payload)
-			storageFetcher := fetcher.NewGethRpcStorageFetcher(&stateDiffStreamer, payloadChan)
+			storageFetcher := fetcher.NewGethRPCStorageFetcher(&stateDiffStreamer, payloadChan)
 			sw := watcher.NewStorageWatcher(storageFetcher, &db)
 			sw.AddTransformers(ethStorageInitializers)
 			wg.Add(1)

cmd/root.go

@@ -159,18 +159,18 @@ func getBlockChain() *eth.BlockChain {
 	rpcClient, ethClient := getClients()
 	vdbEthClient := client.NewEthClient(ethClient)
 	vdbNode := node.MakeNode(rpcClient)
-	transactionConverter := vRpc.NewRpcTransactionConverter(ethClient)
+	transactionConverter := vRpc.NewRPCTransactionConverter(ethClient)
 	return eth.NewBlockChain(vdbEthClient, rpcClient, vdbNode, transactionConverter)
 }
 
-func getClients() (client.RpcClient, *ethclient.Client) {
+func getClients() (client.RPCClient, *ethclient.Client) {
-	rawRpcClient, err := rpc.Dial(ipc)
+	rawRPCClient, err := rpc.Dial(ipc)
 
 	if err != nil {
 		LogWithCommand.Fatal(err)
 	}
-	rpcClient := client.NewRpcClient(rawRpcClient, ipc)
+	rpcClient := client.NewRPCClient(rawRPCClient, ipc)
-	ethClient := ethclient.NewClient(rawRpcClient)
+	ethClient := ethclient.NewClient(rawRPCClient)
 
 	return rpcClient, ethClient
 }

integration_test/block_rewards_test.go

@@ -32,13 +32,13 @@ import (
 var _ = Describe("Rewards calculations", func() {
 
 	It("calculates a block reward for a real block", func() {
-		rawRpcClient, err := rpc.Dial(test_config.TestClient.IPCPath)
+		rawRPCClient, err := rpc.Dial(test_config.TestClient.IPCPath)
 		Expect(err).NotTo(HaveOccurred())
-		rpcClient := client.NewRpcClient(rawRpcClient, test_config.TestClient.IPCPath)
+		rpcClient := client.NewRPCClient(rawRPCClient, test_config.TestClient.IPCPath)
-		ethClient := ethclient.NewClient(rawRpcClient)
+		ethClient := ethclient.NewClient(rawRPCClient)
 		blockChainClient := client.NewEthClient(ethClient)
 		node := node.MakeNode(rpcClient)
-		transactionConverter := vRpc.NewRpcTransactionConverter(ethClient)
+		transactionConverter := vRpc.NewRPCTransactionConverter(ethClient)
 		blockChain := eth.NewBlockChain(blockChainClient, rpcClient, node, transactionConverter)
 		block, err := blockChain.GetBlockByNumber(1071819)
 		Expect(err).ToNot(HaveOccurred())
@@ -46,13 +46,13 @@ var _ = Describe("Rewards calculations", func() {
 	})
 
 	It("calculates an uncle reward for a real block", func() {
-		rawRpcClient, err := rpc.Dial(test_config.TestClient.IPCPath)
+		rawRPCClient, err := rpc.Dial(test_config.TestClient.IPCPath)
 		Expect(err).NotTo(HaveOccurred())
-		rpcClient := client.NewRpcClient(rawRpcClient, test_config.TestClient.IPCPath)
+		rpcClient := client.NewRPCClient(rawRPCClient, test_config.TestClient.IPCPath)
-		ethClient := ethclient.NewClient(rawRpcClient)
+		ethClient := ethclient.NewClient(rawRPCClient)
 		blockChainClient := client.NewEthClient(ethClient)
 		node := node.MakeNode(rpcClient)
-		transactionConverter := vRpc.NewRpcTransactionConverter(ethClient)
+		transactionConverter := vRpc.NewRPCTransactionConverter(ethClient)
 		blockChain := eth.NewBlockChain(blockChainClient, rpcClient, node, transactionConverter)
 		block, err := blockChain.GetBlockByNumber(1071819)
 		Expect(err).ToNot(HaveOccurred())

integration_test/contract_test.go

@@ -49,13 +49,13 @@ var _ = Describe("Reading contracts", func() {
 				},
 				Index: 19,
 				Data:  "0x0000000000000000000000000000000000000000000000000c7d713b49da0000"}
-			rawRpcClient, err := rpc.Dial(test_config.TestClient.IPCPath)
+			rawRPCClient, err := rpc.Dial(test_config.TestClient.IPCPath)
 			Expect(err).NotTo(HaveOccurred())
-			rpcClient := client.NewRpcClient(rawRpcClient, test_config.TestClient.IPCPath)
+			rpcClient := client.NewRPCClient(rawRPCClient, test_config.TestClient.IPCPath)
-			ethClient := ethclient.NewClient(rawRpcClient)
+			ethClient := ethclient.NewClient(rawRPCClient)
 			blockChainClient := client.NewEthClient(ethClient)
 			node := node.MakeNode(rpcClient)
-			transactionConverter := rpc2.NewRpcTransactionConverter(ethClient)
+			transactionConverter := rpc2.NewRPCTransactionConverter(ethClient)
 			blockChain := eth.NewBlockChain(blockChainClient, rpcClient, node, transactionConverter)
 			contract := testing.SampleContract()
 
@@ -67,13 +67,13 @@ var _ = Describe("Reading contracts", func() {
 		})
 
 		It("returns and empty log array when no events for a given block / contract combo", func() {
-			rawRpcClient, err := rpc.Dial(test_config.TestClient.IPCPath)
+			rawRPCClient, err := rpc.Dial(test_config.TestClient.IPCPath)
 			Expect(err).NotTo(HaveOccurred())
-			rpcClient := client.NewRpcClient(rawRpcClient, test_config.TestClient.IPCPath)
+			rpcClient := client.NewRPCClient(rawRPCClient, test_config.TestClient.IPCPath)
-			ethClient := ethclient.NewClient(rawRpcClient)
+			ethClient := ethclient.NewClient(rawRPCClient)
 			blockChainClient := client.NewEthClient(ethClient)
 			node := node.MakeNode(rpcClient)
-			transactionConverter := rpc2.NewRpcTransactionConverter(ethClient)
+			transactionConverter := rpc2.NewRPCTransactionConverter(ethClient)
 			blockChain := eth.NewBlockChain(blockChainClient, rpcClient, node, transactionConverter)
 
 			logs, err := blockChain.GetFullSyncLogs(core.Contract{Hash: "0x123"}, big.NewInt(4703824), nil)
@@ -85,13 +85,13 @@ var _ = Describe("Reading contracts", func() {
 
 	Describe("Fetching Contract data", func() {
 		It("returns the correct attribute for a real contract", func() {
-			rawRpcClient, err := rpc.Dial(test_config.TestClient.IPCPath)
+			rawRPCClient, err := rpc.Dial(test_config.TestClient.IPCPath)
 			Expect(err).NotTo(HaveOccurred())
-			rpcClient := client.NewRpcClient(rawRpcClient, test_config.TestClient.IPCPath)
+			rpcClient := client.NewRPCClient(rawRPCClient, test_config.TestClient.IPCPath)
-			ethClient := ethclient.NewClient(rawRpcClient)
+			ethClient := ethclient.NewClient(rawRPCClient)
 			blockChainClient := client.NewEthClient(ethClient)
 			node := node.MakeNode(rpcClient)
-			transactionConverter := rpc2.NewRpcTransactionConverter(ethClient)
+			transactionConverter := rpc2.NewRPCTransactionConverter(ethClient)
 			blockChain := eth.NewBlockChain(blockChainClient, rpcClient, node, transactionConverter)
 
 			contract := testing.SampleContract()

integration_test/geth_blockchain_test.go

@@ -37,13 +37,13 @@ var _ = Describe("Reading from the Geth blockchain", func() {
 	var blockChain *eth.BlockChain
 
 	BeforeEach(func() {
-		rawRpcClient, err := rpc.Dial(test_config.TestClient.IPCPath)
+		rawRPCClient, err := rpc.Dial(test_config.TestClient.IPCPath)
 		Expect(err).NotTo(HaveOccurred())
-		rpcClient := client.NewRpcClient(rawRpcClient, test_config.TestClient.IPCPath)
+		rpcClient := client.NewRPCClient(rawRPCClient, test_config.TestClient.IPCPath)
-		ethClient := ethclient.NewClient(rawRpcClient)
+		ethClient := ethclient.NewClient(rawRPCClient)
 		blockChainClient := client.NewEthClient(ethClient)
 		node := node.MakeNode(rpcClient)
-		transactionConverter := rpc2.NewRpcTransactionConverter(ethClient)
+		transactionConverter := rpc2.NewRPCTransactionConverter(ethClient)
 		blockChain = eth.NewBlockChain(blockChainClient, rpcClient, node, transactionConverter)
 	})
 

libraries/shared/factories/event/transformer_test.go

@@ -48,11 +48,11 @@ var _ = Describe("Transformer", func() {
 			Config:     config,
 		}.NewTransformer(nil)
 
-		headerOne = core.Header{Id: rand.Int63(), BlockNumber: rand.Int63()}
+		headerOne = core.Header{ID: rand.Int63(), BlockNumber: rand.Int63()}
 
 		logs = []core.HeaderSyncLog{{
 			ID:          0,
-			HeaderID:    headerOne.Id,
+			HeaderID:    headerOne.ID,
 			Log:         test_data.GenericTestLog(),
 			Transformed: false,
 		}}

libraries/shared/fetcher/geth_rpc_storage_fetcher.go

@@ -23,19 +23,19 @@ import (
 	"github.com/vulcanize/vulcanizedb/libraries/shared/streamer"
 )
 
-type GethRpcStorageFetcher struct {
+type GethRPCStorageFetcher struct {
 	statediffPayloadChan chan statediff.Payload
 	streamer             streamer.Streamer
 }
 
-func NewGethRpcStorageFetcher(streamer streamer.Streamer, statediffPayloadChan chan statediff.Payload) GethRpcStorageFetcher {
+func NewGethRPCStorageFetcher(streamer streamer.Streamer, statediffPayloadChan chan statediff.Payload) GethRPCStorageFetcher {
-	return GethRpcStorageFetcher{
+	return GethRPCStorageFetcher{
 		statediffPayloadChan: statediffPayloadChan,
 		streamer:             streamer,
 	}
 }
 
-func (fetcher GethRpcStorageFetcher) FetchStorageDiffs(out chan<- utils.StorageDiff, errs chan<- error) {
+func (fetcher GethRPCStorageFetcher) FetchStorageDiffs(out chan<- utils.StorageDiff, errs chan<- error) {
 	ethStatediffPayloadChan := fetcher.statediffPayloadChan
 	clientSubscription, clientSubErr := fetcher.streamer.Stream(ethStatediffPayloadChan)
 	if clientSubErr != nil {

libraries/shared/fetcher/geth_rpc_storage_fetcher_test.go

@@ -57,14 +57,14 @@ func (streamer *MockStoragediffStreamer) SetPayloads(payloads []statediff.Payloa
 var _ = Describe("Geth RPC Storage Fetcher", func() {
 	var streamer MockStoragediffStreamer
 	var statediffPayloadChan chan statediff.Payload
-	var statediffFetcher fetcher.GethRpcStorageFetcher
+	var statediffFetcher fetcher.GethRPCStorageFetcher
 	var storagediffChan chan utils.StorageDiff
 	var errorChan chan error
 
 	BeforeEach(func() {
 		streamer = MockStoragediffStreamer{}
 		statediffPayloadChan = make(chan statediff.Payload, 1)
-		statediffFetcher = fetcher.NewGethRpcStorageFetcher(&streamer, statediffPayloadChan)
+		statediffFetcher = fetcher.NewGethRPCStorageFetcher(&streamer, statediffPayloadChan)
 		storagediffChan = make(chan utils.StorageDiff)
 		errorChan = make(chan error)
 	})

libraries/shared/logs/extractor.go

@@ -93,20 +93,20 @@ func (extractor LogExtractor) ExtractLogs(recheckHeaders constants.TransformerEx
 		}
 
 		if len(logs) > 0 {
-			transactionsSyncErr := extractor.Syncer.SyncTransactions(header.Id, logs)
+			transactionsSyncErr := extractor.Syncer.SyncTransactions(header.ID, logs)
 			if transactionsSyncErr != nil {
 				logError("error syncing transactions: %s", transactionsSyncErr, header)
 				return transactionsSyncErr
 			}
 
-			createLogsErr := extractor.LogRepository.CreateHeaderSyncLogs(header.Id, logs)
+			createLogsErr := extractor.LogRepository.CreateHeaderSyncLogs(header.ID, logs)
 			if createLogsErr != nil {
 				logError("error persisting logs: %s", createLogsErr, header)
 				return createLogsErr
 			}
 		}
 
-		markHeaderCheckedErr := extractor.CheckedHeadersRepository.MarkHeaderChecked(header.Id)
+		markHeaderCheckedErr := extractor.CheckedHeadersRepository.MarkHeaderChecked(header.ID)
 		if markHeaderCheckedErr != nil {
 			logError("error marking header checked: %s", markHeaderCheckedErr, header)
 			return markHeaderCheckedErr
@@ -121,7 +121,7 @@ func earlierStartingBlockNumber(transformerBlock, watcherBlock int64) bool {
 
 func logError(description string, err error, header core.Header) {
 	logrus.WithFields(logrus.Fields{
-		"headerId":    header.Id,
+		"headerId":    header.ID,
 		"headerHash":  header.Hash,
 		"blockNumber": header.BlockNumber,
 	}).Errorf(description, err.Error())

libraries/shared/logs/extractor_test.go

@@ -349,7 +349,7 @@ var _ = Describe("Log extractor", func() {
 				addTransformerConfig(extractor)
 				mockCheckedHeadersRepository := &fakes.MockCheckedHeadersRepository{}
 				headerID := rand.Int63()
-				mockCheckedHeadersRepository.UncheckedHeadersReturnHeaders = []core.Header{{Id: headerID}}
+				mockCheckedHeadersRepository.UncheckedHeadersReturnHeaders = []core.Header{{ID: headerID}}
 				extractor.CheckedHeadersRepository = mockCheckedHeadersRepository
 
 				err := extractor.ExtractLogs(constants.HeaderUnchecked)
@@ -362,7 +362,7 @@ var _ = Describe("Log extractor", func() {
 				addFetchedLog(extractor)
 				addTransformerConfig(extractor)
 				mockCheckedHeadersRepository := &fakes.MockCheckedHeadersRepository{}
-				mockCheckedHeadersRepository.UncheckedHeadersReturnHeaders = []core.Header{{Id: rand.Int63()}}
+				mockCheckedHeadersRepository.UncheckedHeadersReturnHeaders = []core.Header{{ID: rand.Int63()}}
 				mockCheckedHeadersRepository.MarkHeaderCheckedReturnError = fakes.FakeError
 				extractor.CheckedHeadersRepository = mockCheckedHeadersRepository
 

libraries/shared/mocks/storage_queue.go

@@ -25,7 +25,7 @@ type MockStorageQueue struct {
 	AddError       error
 	AddPassedDiff  utils.StorageDiff
 	DeleteErr      error
-	DeletePassedId int
+	DeletePassedID int
 	GetAllErr      error
 	DiffsToReturn  []utils.StorageDiff
 }
@@ -37,7 +37,7 @@ func (queue *MockStorageQueue) Add(diff utils.StorageDiff) error {
 }
 
 func (queue *MockStorageQueue) Delete(id int) error {
-	queue.DeletePassedId = id
+	queue.DeletePassedID = id
 	return queue.DeleteErr
 }
 

libraries/shared/repository/address_repository.go

@@ -47,23 +47,23 @@ func GetOrCreateAddress(db *postgres.DB, address string) (int64, error) {
 	checksumAddress := getChecksumAddress(address)
 	hashedAddress := utils.HexToKeccak256Hash(checksumAddress).Hex()
 
-	var addressId int64
+	var addressID int64
-	getOrCreateErr := db.Get(&addressId, getOrCreateAddressQuery, checksumAddress, hashedAddress)
+	getOrCreateErr := db.Get(&addressID, getOrCreateAddressQuery, checksumAddress, hashedAddress)
 
-	return addressId, getOrCreateErr
+	return addressID, getOrCreateErr
 }
 
 func GetOrCreateAddressInTransaction(tx *sqlx.Tx, address string) (int64, error) {
 	checksumAddress := getChecksumAddress(address)
 	hashedAddress := utils.HexToKeccak256Hash(checksumAddress).Hex()
 
-	var addressId int64
+	var addressID int64
-	getOrCreateErr := tx.Get(&addressId, getOrCreateAddressQuery, checksumAddress, hashedAddress)
+	getOrCreateErr := tx.Get(&addressID, getOrCreateAddressQuery, checksumAddress, hashedAddress)
 
-	return addressId, getOrCreateErr
+	return addressID, getOrCreateErr
 }
 
-func GetAddressById(db *postgres.DB, id int64) (string, error) {
+func GetAddressByID(db *postgres.DB, id int64) (string, error) {
 	var address string
 	getErr := db.Get(&address, `SELECT address FROM public.addresses WHERE id = $1`, id)
 	return address, getErr

libraries/shared/repository/address_repository_test.go

@@ -164,18 +164,18 @@ var _ = Describe("address lookup", func() {
 		})
 	})
 
-	Describe("GetAddressById", func() {
+	Describe("GetAddressByID", func() {
 		It("gets and address by it's id", func() {
 			addressId, createErr := repository.GetOrCreateAddress(db, address)
 			Expect(createErr).NotTo(HaveOccurred())
 
-			actualAddress, getErr := repository.GetAddressById(db, addressId)
+			actualAddress, getErr := repository.GetAddressByID(db, addressId)
 			Expect(getErr).NotTo(HaveOccurred())
 			Expect(actualAddress).To(Equal(address))
 		})
 
 		It("returns an error if the id doesn't exist", func() {
-			_, getErr := repository.GetAddressById(db, 0)
+			_, getErr := repository.GetAddressByID(db, 0)
 			Expect(getErr).To(HaveOccurred())
 			Expect(getErr).To(MatchError("sql: no rows in result set"))
 		})

libraries/shared/storage/storage_queue_test.go

@@ -72,7 +72,7 @@ var _ = Describe("Storage queue", func() {
 		Expect(getErr).NotTo(HaveOccurred())
 		Expect(len(diffs)).To(Equal(1))
 
-		err := queue.Delete(diffs[0].Id)
+		err := queue.Delete(diffs[0].ID)
 
 		Expect(err).NotTo(HaveOccurred())
 		remainingRows, secondGetErr := queue.GetAll()
@@ -97,13 +97,13 @@ var _ = Describe("Storage queue", func() {
 		Expect(err).NotTo(HaveOccurred())
 		Expect(len(diffs)).To(Equal(2))
 		Expect(diffs[0]).NotTo(Equal(diffs[1]))
-		Expect(diffs[0].Id).NotTo(BeZero())
+		Expect(diffs[0].ID).NotTo(BeZero())
 		Expect(diffs[0].HashedAddress).To(Or(Equal(diff.HashedAddress), Equal(diffTwo.HashedAddress)))
 		Expect(diffs[0].BlockHash).To(Or(Equal(diff.BlockHash), Equal(diffTwo.BlockHash)))
 		Expect(diffs[0].BlockHeight).To(Or(Equal(diff.BlockHeight), Equal(diffTwo.BlockHeight)))
 		Expect(diffs[0].StorageKey).To(Or(Equal(diff.StorageKey), Equal(diffTwo.StorageKey)))
 		Expect(diffs[0].StorageValue).To(Or(Equal(diff.StorageValue), Equal(diffTwo.StorageValue)))
-		Expect(diffs[1].Id).NotTo(BeZero())
+		Expect(diffs[1].ID).NotTo(BeZero())
 		Expect(diffs[1].HashedAddress).To(Or(Equal(diff.HashedAddress), Equal(diffTwo.HashedAddress)))
 		Expect(diffs[1].BlockHash).To(Or(Equal(diff.BlockHash), Equal(diffTwo.BlockHash)))
 		Expect(diffs[1].BlockHeight).To(Or(Equal(diff.BlockHeight), Equal(diffTwo.BlockHeight)))

libraries/shared/storage/utils/diff.go

@@ -27,7 +27,7 @@ import (
 const ExpectedRowLength = 5
 
 type StorageDiff struct {
-	Id            int
+	ID            int
 	HashedAddress common.Hash `db:"contract"`
 	BlockHash     common.Hash `db:"block_hash"`
 	BlockHeight   int         `db:"block_height"`

libraries/shared/streamer/statediff_streamer.go

@@ -26,7 +26,7 @@ type Streamer interface {
 }
 
 type StateDiffStreamer struct {
-	client core.RpcClient
+	client core.RPCClient
 }
 
 func (streamer *StateDiffStreamer) Stream(payloadChan chan statediff.Payload) (*rpc.ClientSubscription, error) {
@@ -34,7 +34,7 @@ func (streamer *StateDiffStreamer) Stream(payloadChan chan statediff.Payload) (*
 	return streamer.client.Subscribe("statediff", payloadChan, "stream")
 }
 
-func NewStateDiffStreamer(client core.RpcClient) StateDiffStreamer {
+func NewStateDiffStreamer(client core.RPCClient) StateDiffStreamer {
 	return StateDiffStreamer{
 		client: client,
 	}

libraries/shared/streamer/statediff_streamer_test.go

@@ -24,7 +24,7 @@ import (
 
 var _ = Describe("StateDiff Streamer", func() {
 	It("subscribes to the geth statediff service", func() {
-		client := &fakes.MockRpcClient{}
+		client := &fakes.MockRPCClient{}
 		streamer := streamer.NewStateDiffStreamer(client)
 		payloadChan := make(chan statediff.Payload)
 		_, err := streamer.Stream(payloadChan)

libraries/shared/watcher/storage_watcher.go

@@ -103,12 +103,12 @@ func (storageWatcher StorageWatcher) processQueue() {
 		storageTransformer, ok := storageWatcher.getTransformer(diff)
 		if !ok {
 			// delete diff from queue if address no longer watched
-			storageWatcher.deleteRow(diff.Id)
+			storageWatcher.deleteRow(diff.ID)
 			continue
 		}
 		executeErr := storageTransformer.Execute(diff)
 		if executeErr == nil {
-			storageWatcher.deleteRow(diff.Id)
+			storageWatcher.deleteRow(diff.ID)
 		}
 	}
 }

libraries/shared/watcher/storage_watcher_test.go

@@ -65,7 +65,7 @@ var _ = Describe("Storage Watcher", func() {
 			mockQueue = &mocks.MockStorageQueue{}
 			mockTransformer = &mocks.MockStorageTransformer{KeccakOfAddress: hashedAddress}
 			csvDiff = utils.StorageDiff{
-				Id:            1337,
+				ID:            1337,
 				HashedAddress: hashedAddress,
 				BlockHash:     common.HexToHash("0xfedcba9876543210"),
 				BlockHeight:   0,
@@ -167,8 +167,8 @@ var _ = Describe("Storage Watcher", func() {
 				go storageWatcher.Execute(diffs, errs, time.Nanosecond)
 
 				Eventually(func() int {
-					return mockQueue.DeletePassedId
+					return mockQueue.DeletePassedID
-				}).Should(Equal(csvDiff.Id))
+				}).Should(Equal(csvDiff.ID))
 				close(done)
 			})
 
@@ -190,7 +190,7 @@ var _ = Describe("Storage Watcher", func() {
 
 			It("deletes obsolete diff from queue if contract not recognized", func(done Done) {
 				obsoleteDiff := utils.StorageDiff{
-					Id:            csvDiff.Id + 1,
+					ID:            csvDiff.ID + 1,
 					HashedAddress: utils.HexToKeccak256Hash("0xfedcba9876543210"),
 				}
 				mockQueue.DiffsToReturn = []utils.StorageDiff{obsoleteDiff}
@@ -198,14 +198,14 @@ var _ = Describe("Storage Watcher", func() {
 				go storageWatcher.Execute(diffs, errs, time.Nanosecond)
 
 				Eventually(func() int {
-					return mockQueue.DeletePassedId
+					return mockQueue.DeletePassedID
-				}).Should(Equal(obsoleteDiff.Id))
+				}).Should(Equal(obsoleteDiff.ID))
 				close(done)
 			})
 
 			It("logs error if deleting obsolete diff fails", func(done Done) {
 				obsoleteDiff := utils.StorageDiff{
-					Id:            csvDiff.Id + 1,
+					ID:            csvDiff.ID + 1,
 					HashedAddress: utils.HexToKeccak256Hash("0xfedcba9876543210"),
 				}
 				mockQueue.DiffsToReturn = []utils.StorageDiff{obsoleteDiff}

pkg/contract_watcher/header/repository/header_repository.go

@@ -148,7 +148,7 @@ func (r *headerRepository) MarkHeadersCheckedForAll(headers []core.Header, ids [
 			pgStr += fmt.Sprintf("%s = checked_headers.%s + 1, ", id, id)
 		}
 		pgStr = pgStr[:len(pgStr)-2]
-		_, err = tx.Exec(pgStr, header.Id)
+		_, err = tx.Exec(pgStr, header.ID)
 		if err != nil {
 			rollbackErr := tx.Rollback()
 			if rollbackErr != nil {

pkg/contract_watcher/header/repository/header_repository_test.go

@@ -174,16 +174,16 @@ var _ = Describe("Repository", func() {
 			Expect(err).ToNot(HaveOccurred())
 			Expect(len(missingHeaders)).To(Equal(3))
 
-			err = contractHeaderRepo.MarkHeaderChecked(missingHeaders[0].Id, eventIDs[0])
+			err = contractHeaderRepo.MarkHeaderChecked(missingHeaders[0].ID, eventIDs[0])
 			Expect(err).ToNot(HaveOccurred())
 
 			missingHeaders, err = contractHeaderRepo.MissingHeadersForAll(mocks.MockHeader1.BlockNumber, mocks.MockHeader4.BlockNumber, eventIDs)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(len(missingHeaders)).To(Equal(3))
 
-			err = contractHeaderRepo.MarkHeaderChecked(missingHeaders[0].Id, eventIDs[1])
+			err = contractHeaderRepo.MarkHeaderChecked(missingHeaders[0].ID, eventIDs[1])
 			Expect(err).ToNot(HaveOccurred())
-			err = contractHeaderRepo.MarkHeaderChecked(missingHeaders[0].Id, eventIDs[2])
+			err = contractHeaderRepo.MarkHeaderChecked(missingHeaders[0].ID, eventIDs[2])
 			Expect(err).ToNot(HaveOccurred())
 
 			missingHeaders, err = contractHeaderRepo.MissingHeadersForAll(mocks.MockHeader2.BlockNumber, mocks.MockHeader4.BlockNumber, eventIDs)
@@ -236,7 +236,7 @@ var _ = Describe("Repository", func() {
 			Expect(err).ToNot(HaveOccurred())
 			Expect(len(missingHeaders)).To(Equal(3))
 
-			headerID := missingHeaders[0].Id
+			headerID := missingHeaders[0].ID
 			err = contractHeaderRepo.MarkHeaderChecked(headerID, eventIDs[0])
 			Expect(err).ToNot(HaveOccurred())
 
@@ -254,7 +254,7 @@ var _ = Describe("Repository", func() {
 			Expect(err).ToNot(HaveOccurred())
 			Expect(len(missingHeaders)).To(Equal(3))
 
-			headerID := missingHeaders[0].Id
+			headerID := missingHeaders[0].ID
 			err = contractHeaderRepo.MarkHeaderChecked(headerID, "notEventId")
 			Expect(err).To(HaveOccurred())
 
@@ -274,7 +274,7 @@ var _ = Describe("Repository", func() {
 			Expect(err).ToNot(HaveOccurred())
 			Expect(len(missingHeaders)).To(Equal(3))
 
-			headerID := missingHeaders[0].Id
+			headerID := missingHeaders[0].ID
 			err = contractHeaderRepo.MarkHeaderCheckedForAll(headerID, eventIDs)
 			Expect(err).ToNot(HaveOccurred())
 
@@ -326,8 +326,8 @@ var _ = Describe("Repository", func() {
 			Expect(err).ToNot(HaveOccurred())
 			Expect(len(missingHeaders)).To(Equal(3))
 
-			headerID := missingHeaders[0].Id
+			headerID := missingHeaders[0].ID
-			headerID2 := missingHeaders[1].Id
+			headerID2 := missingHeaders[1].ID
 			for i, id := range eventIDs {
 				err = contractHeaderRepo.MarkHeaderChecked(headerID, id)
 				Expect(err).ToNot(HaveOccurred())
@@ -340,7 +340,7 @@ var _ = Describe("Repository", func() {
 			intersectionHeaders, err := contractHeaderRepo.MissingMethodsCheckedEventsIntersection(mocks.MockHeader1.BlockNumber, mocks.MockHeader4.BlockNumber, methodIDs, eventIDs)
 			Expect(err).ToNot(HaveOccurred())
 			Expect(len(intersectionHeaders)).To(Equal(1))
-			Expect(intersectionHeaders[0].Id).To(Equal(headerID2))
+			Expect(intersectionHeaders[0].ID).To(Equal(headerID2))
 		})
 	})
 })

pkg/contract_watcher/header/transformer/transformer.go

@@ -239,7 +239,7 @@ func (tr *Transformer) Execute() error {
 		// If no logs are found mark the header checked for all of these eventIDs
 		// and continue to method polling and onto the next iteration
 		if len(allLogs) < 1 {
-			markCheckedErr := tr.HeaderRepository.MarkHeaderCheckedForAll(header.Id, tr.eventIds)
+			markCheckedErr := tr.HeaderRepository.MarkHeaderCheckedForAll(header.ID, tr.eventIds)
 			if markCheckedErr != nil {
 				return fmt.Errorf("error marking header checked: %s", markCheckedErr.Error())
 			}
@@ -268,7 +268,7 @@ func (tr *Transformer) Execute() error {
 			tr.Converter.Update(con)
 
 			// Convert logs into batches of log mappings (eventName => []types.Logs
-			convertedLogs, convertErr := tr.Converter.ConvertBatch(logs, con.Events, header.Id)
+			convertedLogs, convertErr := tr.Converter.ConvertBatch(logs, con.Events, header.ID)
 			if convertErr != nil {
 				return fmt.Errorf("error converting logs: %s", convertErr.Error())
 			}
@@ -287,7 +287,7 @@ func (tr *Transformer) Execute() error {
 			}
 		}
 
-		markCheckedErr := tr.HeaderRepository.MarkHeaderCheckedForAll(header.Id, tr.eventIds)
+		markCheckedErr := tr.HeaderRepository.MarkHeaderCheckedForAll(header.ID, tr.eventIds)
 		if markCheckedErr != nil {
 			return fmt.Errorf("error marking header checked: %s", markCheckedErr.Error())
 		}
@@ -321,7 +321,7 @@ func (tr *Transformer) methodPolling(header core.Header, sortedMethodIds map[str
 		}
 
 		// Mark this header checked for the methods
-		markCheckedErr := tr.HeaderRepository.MarkHeaderCheckedForAll(header.Id, sortedMethodIds[con.Address])
+		markCheckedErr := tr.HeaderRepository.MarkHeaderCheckedForAll(header.ID, sortedMethodIds[con.Address])
 		if markCheckedErr != nil {
 			return fmt.Errorf("error marking header checked: %s", markCheckedErr.Error())
 		}

pkg/contract_watcher/shared/getter/getter_test.go

@@ -40,11 +40,11 @@ var _ = Describe("Interface Getter", func() {
 			blockNumber := int64(6885696)
 			rawRpcClient, err := rpc.Dial(testIPC)
 			Expect(err).NotTo(HaveOccurred())
-			rpcClient := client.NewRpcClient(rawRpcClient, testIPC)
+			rpcClient := client.NewRPCClient(rawRpcClient, testIPC)
 			ethClient := ethclient.NewClient(rawRpcClient)
 			blockChainClient := client.NewEthClient(ethClient)
 			node := node.MakeNode(rpcClient)
-			transactionConverter := rpc2.NewRpcTransactionConverter(ethClient)
+			transactionConverter := rpc2.NewRPCTransactionConverter(ethClient)
 			blockChain := eth.NewBlockChain(blockChainClient, rpcClient, node, transactionConverter)
 			interfaceGetter := getter.NewInterfaceGetter(blockChain)
 			abi, err := interfaceGetter.GetABI(constants.PublicResolverAddress, blockNumber)

pkg/contract_watcher/shared/helpers/test_helpers/database.go

@@ -38,8 +38,8 @@ import (
 )
 
 type TransferLog struct {
-	Id             int64  `db:"id"`
+	ID             int64  `db:"id"`
-	VulcanizeLogId int64  `db:"vulcanize_log_id"`
+	VulcanizeLogID int64  `db:"vulcanize_log_id"`
 	TokenName      string `db:"token_name"`
 	Block          int64  `db:"block"`
 	Tx             string `db:"tx"`
@@ -49,8 +49,8 @@ type TransferLog struct {
 }
 
 type NewOwnerLog struct {
-	Id             int64  `db:"id"`
+	ID             int64  `db:"id"`
-	VulcanizeLogId int64  `db:"vulcanize_log_id"`
+	VulcanizeLogID int64  `db:"vulcanize_log_id"`
 	TokenName      string `db:"token_name"`
 	Block          int64  `db:"block"`
 	Tx             string `db:"tx"`
@@ -60,7 +60,7 @@ type NewOwnerLog struct {
 }
 
 type HeaderSyncTransferLog struct {
-	Id        int64  `db:"id"`
+	ID        int64  `db:"id"`
 	HeaderID  int64  `db:"header_id"`
 	TokenName string `db:"token_name"`
 	LogIndex  int64  `db:"log_idx"`
@@ -72,7 +72,7 @@ type HeaderSyncTransferLog struct {
 }
 
 type HeaderSyncNewOwnerLog struct {
-	Id        int64  `db:"id"`
+	ID        int64  `db:"id"`
 	HeaderID  int64  `db:"header_id"`
 	TokenName string `db:"token_name"`
 	LogIndex  int64  `db:"log_idx"`
@@ -84,7 +84,7 @@ type HeaderSyncNewOwnerLog struct {
 }
 
 type BalanceOf struct {
-	Id        int64  `db:"id"`
+	ID        int64  `db:"id"`
 	TokenName string `db:"token_name"`
 	Block     int64  `db:"block"`
 	Address   string `db:"who_"`
@@ -92,7 +92,7 @@ type BalanceOf struct {
 }
 
 type Resolver struct {
-	Id        int64  `db:"id"`
+	ID        int64  `db:"id"`
 	TokenName string `db:"token_name"`
 	Block     int64  `db:"block"`
 	Node      string `db:"node_"`
@@ -100,7 +100,7 @@ type Resolver struct {
 }
 
 type Owner struct {
-	Id        int64  `db:"id"`
+	ID        int64  `db:"id"`
 	TokenName string `db:"token_name"`
 	Block     int64  `db:"block"`
 	Node      string `db:"node_"`
@@ -110,13 +110,13 @@ type Owner struct {
 func SetupDBandBC() (*postgres.DB, core.BlockChain) {
 	con := test_config.TestClient
 	testIPC := con.IPCPath
-	rawRpcClient, err := rpc.Dial(testIPC)
+	rawRPCClient, err := rpc.Dial(testIPC)
 	Expect(err).NotTo(HaveOccurred())
-	rpcClient := client.NewRpcClient(rawRpcClient, testIPC)
+	rpcClient := client.NewRPCClient(rawRPCClient, testIPC)
-	ethClient := ethclient.NewClient(rawRpcClient)
+	ethClient := ethclient.NewClient(rawRPCClient)
 	blockChainClient := client.NewEthClient(ethClient)
 	madeNode := node.MakeNode(rpcClient)
-	transactionConverter := rpc2.NewRpcTransactionConverter(ethClient)
+	transactionConverter := rpc2.NewRPCTransactionConverter(ethClient)
 	blockChain := eth.NewBlockChain(blockChainClient, rpcClient, madeNode, transactionConverter)
 
 	db, err := postgres.NewDB(config.Database{
@@ -129,7 +129,7 @@ func SetupDBandBC() (*postgres.DB, core.BlockChain) {
 	return db, blockChain
 }
 
-func SetupTusdRepo(vulcanizeLogId *int64, wantedEvents, wantedMethods []string) (*postgres.DB, *contract.Contract) {
+func SetupTusdRepo(vulcanizeLogID *int64, wantedEvents, wantedMethods []string) (*postgres.DB, *contract.Contract) {
 	db, err := postgres.NewDB(config.Database{
 		Hostname: "localhost",
 		Name:     "vulcanize_testing",
@@ -142,14 +142,14 @@ func SetupTusdRepo(vulcanizeLogId *int64, wantedEvents, wantedMethods []string)
 	blockRepository := *repositories.NewBlockRepository(db)
 
 	blockNumber := rand.Int63()
-	blockId := CreateBlock(blockNumber, blockRepository)
+	blockID := CreateBlock(blockNumber, blockRepository)
 
 	receipts := []core.Receipt{{Logs: []core.FullSyncLog{{}}}}
 
-	err = receiptRepository.CreateReceiptsAndLogs(blockId, receipts)
+	err = receiptRepository.CreateReceiptsAndLogs(blockID, receipts)
 	Expect(err).ToNot(HaveOccurred())
 
-	err = logRepository.Get(vulcanizeLogId, `SELECT id FROM full_sync_logs`)
+	err = logRepository.Get(vulcanizeLogID, `SELECT id FROM full_sync_logs`)
 	Expect(err).ToNot(HaveOccurred())
 
 	info := SetupTusdContract(wantedEvents, wantedMethods)
@@ -175,7 +175,7 @@ func SetupTusdContract(wantedEvents, wantedMethods []string) *contract.Contract
 	}.Init()
 }
 
-func SetupENSRepo(vulcanizeLogId *int64, wantedEvents, wantedMethods []string) (*postgres.DB, *contract.Contract) {
+func SetupENSRepo(vulcanizeLogID *int64, wantedEvents, wantedMethods []string) (*postgres.DB, *contract.Contract) {
 	db, err := postgres.NewDB(config.Database{
 		Hostname: "localhost",
 		Name:     "vulcanize_testing",
@@ -188,14 +188,14 @@ func SetupENSRepo(vulcanizeLogId *int64, wantedEvents, wantedMethods []string) (
 	blockRepository := *repositories.NewBlockRepository(db)
 
 	blockNumber := rand.Int63()
-	blockId := CreateBlock(blockNumber, blockRepository)
+	blockID := CreateBlock(blockNumber, blockRepository)
 
 	receipts := []core.Receipt{{Logs: []core.FullSyncLog{{}}}}
 
-	err = receiptRepository.CreateReceiptsAndLogs(blockId, receipts)
+	err = receiptRepository.CreateReceiptsAndLogs(blockID, receipts)
 	Expect(err).ToNot(HaveOccurred())
 
-	err = logRepository.Get(vulcanizeLogId, `SELECT id FROM full_sync_logs`)
+	err = logRepository.Get(vulcanizeLogID, `SELECT id FROM full_sync_logs`)
 	Expect(err).ToNot(HaveOccurred())
 
 	info := SetupENSContract(wantedEvents, wantedMethods)
@@ -316,9 +316,9 @@ func TearDown(db *postgres.DB) {
 	Expect(err).NotTo(HaveOccurred())
 }
 
-func CreateBlock(blockNumber int64, repository repositories.BlockRepository) (blockId int64) {
+func CreateBlock(blockNumber int64, repository repositories.BlockRepository) int64 {
-	blockId, err := repository.CreateOrUpdateBlock(core.Block{Number: blockNumber})
+	blockID, err := repository.CreateOrUpdateBlock(core.Block{Number: blockNumber})
 	Expect(err).NotTo(HaveOccurred())
 
-	return blockId
+	return blockID
 }

pkg/contract_watcher/shared/repository/event_repository_test.go

@@ -157,8 +157,8 @@ var _ = Describe("Repository", func() {
 				err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.transfer_event", constants.TusdContractAddress)).StructScan(&scanLog)
 				Expect(err).ToNot(HaveOccurred())
 				expectedLog := test_helpers.TransferLog{
-					Id:             1,
+					ID:             1,
-					VulcanizeLogId: vulcanizeLogId,
+					VulcanizeLogID: vulcanizeLogId,
 					TokenName:      "TrueUSD",
 					Block:          5488076,
 					Tx:             "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad6546ae",
@@ -179,8 +179,8 @@ var _ = Describe("Repository", func() {
 				err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.transfer_event", constants.TusdContractAddress)).StructScan(&scanLog)
 				Expect(err).ToNot(HaveOccurred())
 				expectedLog := test_helpers.TransferLog{
-					Id:             1,
+					ID:             1,
-					VulcanizeLogId: vulcanizeLogId,
+					VulcanizeLogID: vulcanizeLogId,
 					TokenName:      "TrueUSD",
 					Block:          5488076,
 					Tx:             "0x135391a0962a63944e5908e6fedfff90fb4be3e3290a21017861099bad6546ae",

pkg/contract_watcher/shared/repository/method_repository_test.go

@@ -133,7 +133,7 @@ var _ = Describe("Repository", func() {
 
 				err = db.QueryRowx(fmt.Sprintf("SELECT * FROM full_%s.balanceof_method", constants.TusdContractAddress)).StructScan(&scanStruct)
 				expectedLog := test_helpers.BalanceOf{
-					Id:        1,
+					ID:        1,
 					TokenName: "TrueUSD",
 					Block:     6707323,
 					Address:   "0xfE9e8709d3215310075d67E3ed32A380CCf451C8",
@@ -222,7 +222,7 @@ var _ = Describe("Repository", func() {
 
 				err = db.QueryRowx(fmt.Sprintf("SELECT * FROM header_%s.balanceof_method", constants.TusdContractAddress)).StructScan(&scanStruct)
 				expectedLog := test_helpers.BalanceOf{
-					Id:        1,
+					ID:        1,
 					TokenName: "TrueUSD",
 					Block:     6707323,
 					Address:   "0xfE9e8709d3215310075d67E3ed32A380CCf451C8",

pkg/core/header.go

@@ -23,7 +23,7 @@ import (
 )
 
 type Header struct {
-	Id          int64
+	ID          int64
 	BlockNumber int64 `db:"block_number"`
 	Hash        string
 	Raw         []byte

pkg/core/rpc_client.go

@@ -23,7 +23,7 @@ import (
 	"github.com/vulcanize/vulcanizedb/pkg/eth/client"
 )
 
-type RpcClient interface {
+type RPCClient interface {
 	CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) error
 	BatchCall(batch []client.BatchElem) error
 	IpcPath() string

pkg/core/transaction.go

@@ -30,7 +30,7 @@ type TransactionModel struct {
 	Value   string
 }
 
-type RpcTransaction struct {
+type RPCTransaction struct {
 	Nonce            string `json:"nonce"`
 	GasPrice         string `json:"gasPrice"`
 	GasLimit         string `json:"gas"`

pkg/core/uncle.go

@@ -17,7 +17,7 @@
 package core
 
 type Uncle struct {
-	Id        int64
+	ID        int64
 	Miner     string
 	Reward    string
 	Hash      string

pkg/datastore/postgres/postgres.go

@@ -46,7 +46,7 @@ func NewDB(databaseConfig config.Database, node core.Node) (*DB, error) {
 }
 
 func (db *DB) CreateNode(node *core.Node) error {
-	var nodeId int64
+	var nodeID int64
 	err := db.QueryRow(
 		`INSERT INTO eth_nodes (genesis_block, network_id, eth_node_id, client_name)
                 VALUES ($1, $2, $3, $4)
@@ -57,10 +57,10 @@ func (db *DB) CreateNode(node *core.Node) error {
                         eth_node_id = $3,
                         client_name = $4
                 RETURNING id`,
-		node.GenesisBlock, node.NetworkID, node.ID, node.ClientName).Scan(&nodeId)
+		node.GenesisBlock, node.NetworkID, node.ID, node.ClientName).Scan(&nodeID)
 	if err != nil {
 		return ErrUnableToSetNode(err)
 	}
-	db.NodeID = nodeId
+	db.NodeID = nodeID
 	return nil
 }

pkg/datastore/postgres/repositories/block_repository.go

@@ -52,7 +52,7 @@ func (blockRepository BlockRepository) SetBlocksStatus(chainHead int64) error {
 
 func (blockRepository BlockRepository) CreateOrUpdateBlock(block core.Block) (int64, error) {
 	var err error
-	var blockId int64
+	var blockID int64
 	retrievedBlockHash, ok := blockRepository.getBlockHash(block)
 	if !ok {
 		return blockRepository.insertBlock(block)
@@ -64,10 +64,10 @@ func (blockRepository BlockRepository) CreateOrUpdateBlock(block core.Block) (in
 		}
 		return blockRepository.insertBlock(block)
 	}
-	return blockId, ErrBlockExists
+	return blockID, ErrBlockExists
 }
 
-func (blockRepository BlockRepository) MissingBlockNumbers(startingBlockNumber int64, highestBlockNumber int64, nodeId string) []int64 {
+func (blockRepository BlockRepository) MissingBlockNumbers(startingBlockNumber int64, highestBlockNumber int64, nodeID string) []int64 {
 	numbers := make([]int64, 0)
 	err := blockRepository.database.Select(&numbers,
 		`SELECT all_block_numbers
@@ -77,7 +77,7 @@ func (blockRepository BlockRepository) MissingBlockNumbers(startingBlockNumber i
 		  	  SELECT number FROM blocks WHERE eth_node_fingerprint = $3
 		  ) `,
 		startingBlockNumber,
-		highestBlockNumber, nodeId)
+		highestBlockNumber, nodeID)
 	if err != nil {
 		logrus.Error("MissingBlockNumbers: error getting blocks: ", err)
 	}
@@ -118,7 +118,7 @@ func (blockRepository BlockRepository) GetBlock(blockNumber int64) (core.Block,
 }
 
 func (blockRepository BlockRepository) insertBlock(block core.Block) (int64, error) {
-	var blockId int64
+	var blockID int64
 	tx, beginErr := blockRepository.database.Beginx()
 	if beginErr != nil {
 		return 0, postgres.ErrBeginTransactionFailed(beginErr)
@@ -145,7 +145,7 @@ func (blockRepository BlockRepository) insertBlock(block core.Block) (int64, err
 		nullStringToZero(block.Reward),
 		nullStringToZero(block.UnclesReward),
 		blockRepository.database.Node.ID).
-		Scan(&blockId)
+		Scan(&blockID)
 	if insertBlockErr != nil {
 		rollbackErr := tx.Rollback()
 		if rollbackErr != nil {
@@ -154,14 +154,14 @@ func (blockRepository BlockRepository) insertBlock(block core.Block) (int64, err
 		return 0, postgres.ErrDBInsertFailed(insertBlockErr)
 	}
 	if len(block.Uncles) > 0 {
-		insertUncleErr := blockRepository.createUncles(tx, blockId, block.Hash, block.Uncles)
+		insertUncleErr := blockRepository.createUncles(tx, blockID, block.Hash, block.Uncles)
 		if insertUncleErr != nil {
 			tx.Rollback()
 			return 0, postgres.ErrDBInsertFailed(insertUncleErr)
 		}
 	}
 	if len(block.Transactions) > 0 {
-		insertTxErr := blockRepository.createTransactions(tx, blockId, block.Transactions)
+		insertTxErr := blockRepository.createTransactions(tx, blockID, block.Transactions)
 		if insertTxErr != nil {
 			rollbackErr := tx.Rollback()
 			if rollbackErr != nil {
@@ -178,12 +178,12 @@ func (blockRepository BlockRepository) insertBlock(block core.Block) (int64, err
 		}
 		return 0, commitErr
 	}
-	return blockId, nil
+	return blockID, nil
 }
 
-func (blockRepository BlockRepository) createUncles(tx *sqlx.Tx, blockId int64, blockHash string, uncles []core.Uncle) error {
+func (blockRepository BlockRepository) createUncles(tx *sqlx.Tx, blockID int64, blockHash string, uncles []core.Uncle) error {
 	for _, uncle := range uncles {
-		err := blockRepository.createUncle(tx, blockId, uncle)
+		err := blockRepository.createUncle(tx, blockID, uncle)
 		if err != nil {
 			return err
 		}
@@ -191,19 +191,19 @@ func (blockRepository BlockRepository) createUncles(tx *sqlx.Tx, blockId int64,
 	return nil
 }
 
-func (blockRepository BlockRepository) createUncle(tx *sqlx.Tx, blockId int64, uncle core.Uncle) error {
+func (blockRepository BlockRepository) createUncle(tx *sqlx.Tx, blockID int64, uncle core.Uncle) error {
 	_, err := tx.Exec(
 		`INSERT INTO uncles
        (hash, block_id, reward, miner, raw, block_timestamp, eth_node_id, eth_node_fingerprint)
        VALUES ($1, $2, $3, $4, $5, $6, $7::NUMERIC, $8)
        RETURNING id`,
-		uncle.Hash, blockId, nullStringToZero(uncle.Reward), uncle.Miner, uncle.Raw, uncle.Timestamp, blockRepository.database.NodeID, blockRepository.database.Node.ID)
+		uncle.Hash, blockID, nullStringToZero(uncle.Reward), uncle.Miner, uncle.Raw, uncle.Timestamp, blockRepository.database.NodeID, blockRepository.database.Node.ID)
 	return err
 }
 
-func (blockRepository BlockRepository) createTransactions(tx *sqlx.Tx, blockId int64, transactions []core.TransactionModel) error {
+func (blockRepository BlockRepository) createTransactions(tx *sqlx.Tx, blockID int64, transactions []core.TransactionModel) error {
 	for _, transaction := range transactions {
-		err := blockRepository.createTransaction(tx, blockId, transaction)
+		err := blockRepository.createTransaction(tx, blockID, transaction)
 		if err != nil {
 			return err
 		}
@@ -221,24 +221,24 @@ func nullStringToZero(s string) string {
 	return s
 }
 
-func (blockRepository BlockRepository) createTransaction(tx *sqlx.Tx, blockId int64, transaction core.TransactionModel) error {
+func (blockRepository BlockRepository) createTransaction(tx *sqlx.Tx, blockID int64, transaction core.TransactionModel) error {
 	_, err := tx.Exec(
 		`INSERT INTO full_sync_transactions
        (block_id, gas_limit, gas_price, hash, input_data, nonce, raw, tx_from, tx_index, tx_to, "value")
        VALUES ($1, $2::NUMERIC, $3::NUMERIC, $4, $5, $6::NUMERIC, $7,  $8, $9::NUMERIC, $10, $11::NUMERIC)
-       RETURNING id`, blockId, transaction.GasLimit, transaction.GasPrice, transaction.Hash, transaction.Data,
+       RETURNING id`, blockID, transaction.GasLimit, transaction.GasPrice, transaction.Hash, transaction.Data,
 		transaction.Nonce, transaction.Raw, transaction.From, transaction.TxIndex, transaction.To, nullStringToZero(transaction.Value))
 	if err != nil {
 		return err
 	}
 	if hasReceipt(transaction) {
 		receiptRepo := FullSyncReceiptRepository{}
-		receiptId, err := receiptRepo.CreateFullSyncReceiptInTx(blockId, transaction.Receipt, tx)
+		receiptID, err := receiptRepo.CreateFullSyncReceiptInTx(blockID, transaction.Receipt, tx)
 		if err != nil {
 			return err
 		}
 		if hasLogs(transaction) {
-			err = blockRepository.createLogs(tx, transaction.Receipt.Logs, receiptId)
+			err = blockRepository.createLogs(tx, transaction.Receipt.Logs, receiptID)
 			if err != nil {
 				return err
 			}
@@ -266,13 +266,13 @@ func (blockRepository BlockRepository) getBlockHash(block core.Block) (string, b
 	return retrievedBlockHash, blockExists(retrievedBlockHash)
 }
 
-func (blockRepository BlockRepository) createLogs(tx *sqlx.Tx, logs []core.FullSyncLog, receiptId int64) error {
+func (blockRepository BlockRepository) createLogs(tx *sqlx.Tx, logs []core.FullSyncLog, receiptID int64) error {
 	for _, tlog := range logs {
 		_, err := tx.Exec(
 			`INSERT INTO full_sync_logs (block_number, address, tx_hash, index, topic0, topic1, topic2, topic3, data, receipt_id)
                 VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
                 `,
-			tlog.BlockNumber, tlog.Address, tlog.TxHash, tlog.Index, tlog.Topics[0], tlog.Topics[1], tlog.Topics[2], tlog.Topics[3], tlog.Data, receiptId,
+			tlog.BlockNumber, tlog.Address, tlog.TxHash, tlog.Index, tlog.Topics[0], tlog.Topics[1], tlog.Topics[2], tlog.Topics[3], tlog.Data, receiptID,
 		)
 		if err != nil {
 			return postgres.ErrDBInsertFailed(err)

pkg/datastore/postgres/repositories/full_sync_log_repository.go

@@ -27,14 +27,14 @@ type FullSyncLogRepository struct {
 	*postgres.DB
 }
 
-func (repository FullSyncLogRepository) CreateLogs(lgs []core.FullSyncLog, receiptId int64) error {
+func (repository FullSyncLogRepository) CreateLogs(lgs []core.FullSyncLog, receiptID int64) error {
 	tx, _ := repository.DB.Beginx()
 	for _, tlog := range lgs {
 		_, insertLogErr := tx.Exec(
 			`INSERT INTO full_sync_logs (block_number, address, tx_hash, index, topic0, topic1, topic2, topic3, data, receipt_id)
                 VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
                 `,
-			tlog.BlockNumber, tlog.Address, tlog.TxHash, tlog.Index, tlog.Topics[0], tlog.Topics[1], tlog.Topics[2], tlog.Topics[3], tlog.Data, receiptId,
+			tlog.BlockNumber, tlog.Address, tlog.TxHash, tlog.Index, tlog.Topics[0], tlog.Topics[1], tlog.Topics[2], tlog.Topics[3], tlog.Data, receiptID,
 		)
 		if insertLogErr != nil {
 			rollbackErr := tx.Rollback()

pkg/datastore/postgres/repositories/full_sync_receipt_repository.go

@@ -30,19 +30,19 @@ type FullSyncReceiptRepository struct {
 	*postgres.DB
 }
 
-func (receiptRepository FullSyncReceiptRepository) CreateReceiptsAndLogs(blockId int64, receipts []core.Receipt) error {
+func (receiptRepository FullSyncReceiptRepository) CreateReceiptsAndLogs(blockID int64, receipts []core.Receipt) error {
 	tx, err := receiptRepository.DB.Beginx()
 	if err != nil {
 		return err
 	}
 	for _, receipt := range receipts {
-		receiptId, err := receiptRepository.CreateFullSyncReceiptInTx(blockId, receipt, tx)
+		receiptID, err := receiptRepository.CreateFullSyncReceiptInTx(blockID, receipt, tx)
 		if err != nil {
 			tx.Rollback()
 			return err
 		}
 		if len(receipt.Logs) > 0 {
-			err = createLogs(receipt.Logs, receiptId, tx)
+			err = createLogs(receipt.Logs, receiptID, tx)
 			if err != nil {
 				tx.Rollback()
 				return err
@@ -53,28 +53,28 @@ func (receiptRepository FullSyncReceiptRepository) CreateReceiptsAndLogs(blockId
 	return nil
 }
 
-func createReceipt(receipt core.Receipt, blockId int64, tx *sqlx.Tx) (int64, error) {
+func createReceipt(receipt core.Receipt, blockID int64, tx *sqlx.Tx) (int64, error) {
-	var receiptId int64
+	var receiptID int64
 	err := tx.QueryRow(
 		`INSERT INTO full_sync_receipts
 		               (contract_address, tx_hash, cumulative_gas_used, gas_used, state_root, status, block_id)
 		               VALUES ($1, $2, $3, $4, $5, $6, $7)
 		               RETURNING id`,
-		receipt.ContractAddress, receipt.TxHash, receipt.CumulativeGasUsed, receipt.GasUsed, receipt.StateRoot, receipt.Status, blockId,
+		receipt.ContractAddress, receipt.TxHash, receipt.CumulativeGasUsed, receipt.GasUsed, receipt.StateRoot, receipt.Status, blockID,
-	).Scan(&receiptId)
+	).Scan(&receiptID)
 	if err != nil {
 		logrus.Error("createReceipt: Error inserting: ", err)
 	}
-	return receiptId, err
+	return receiptID, err
 }
 
-func createLogs(logs []core.FullSyncLog, receiptId int64, tx *sqlx.Tx) error {
+func createLogs(logs []core.FullSyncLog, receiptID int64, tx *sqlx.Tx) error {
 	for _, log := range logs {
 		_, err := tx.Exec(
 			`INSERT INTO full_sync_logs (block_number, address, tx_hash, index, topic0, topic1, topic2, topic3, data, receipt_id)
                 VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
                 `,
-			log.BlockNumber, log.Address, log.TxHash, log.Index, log.Topics[0], log.Topics[1], log.Topics[2], log.Topics[3], log.Data, receiptId,
+			log.BlockNumber, log.Address, log.TxHash, log.Index, log.Topics[0], log.Topics[1], log.Topics[2], log.Topics[3], log.Data, receiptID,
 		)
 		if err != nil {
 			return err
@@ -83,25 +83,25 @@ func createLogs(logs []core.FullSyncLog, receiptId int64, tx *sqlx.Tx) error {
 	return nil
 }
 
-func (FullSyncReceiptRepository) CreateFullSyncReceiptInTx(blockId int64, receipt core.Receipt, tx *sqlx.Tx) (int64, error) {
+func (FullSyncReceiptRepository) CreateFullSyncReceiptInTx(blockID int64, receipt core.Receipt, tx *sqlx.Tx) (int64, error) {
-	var receiptId int64
+	var receiptID int64
-	addressId, getAddressErr := repository.GetOrCreateAddressInTransaction(tx, receipt.ContractAddress)
+	addressID, getAddressErr := repository.GetOrCreateAddressInTransaction(tx, receipt.ContractAddress)
 	if getAddressErr != nil {
 		logrus.Error("createReceipt: Error getting address id: ", getAddressErr)
-		return receiptId, getAddressErr
+		return receiptID, getAddressErr
 	}
 	err := tx.QueryRow(
 		`INSERT INTO full_sync_receipts
                (contract_address_id, tx_hash, cumulative_gas_used, gas_used, state_root, status, block_id)
                VALUES ($1, $2, $3, $4, $5, $6, $7)
                RETURNING id`,
-		addressId, receipt.TxHash, receipt.CumulativeGasUsed, receipt.GasUsed, receipt.StateRoot, receipt.Status, blockId).Scan(&receiptId)
+		addressID, receipt.TxHash, receipt.CumulativeGasUsed, receipt.GasUsed, receipt.StateRoot, receipt.Status, blockID).Scan(&receiptID)
 	if err != nil {
 		tx.Rollback()
 		logrus.Warning("CreateReceipt: error inserting receipt: ", err)
-		return receiptId, err
+		return receiptID, err
 	}
-	return receiptId, nil
+	return receiptID, nil
 }
 
 func (receiptRepository FullSyncReceiptRepository) GetFullSyncReceipt(txHash string) (core.Receipt, error) {

pkg/datastore/postgres/repositories/header_repository.go

@@ -68,7 +68,7 @@ func (repository HeaderRepository) CreateTransactions(headerID int64, transactio
 }
 
 func (repository HeaderRepository) CreateTransactionInTx(tx *sqlx.Tx, headerID int64, transaction core.TransactionModel) (int64, error) {
-	var txId int64
+	var txID int64
 	err := tx.QueryRowx(`INSERT INTO public.header_sync_transactions
 		(header_id, hash, gas_limit, gas_price, input_data, nonce, raw, tx_from, tx_index, tx_to, "value")
 		VALUES ($1, $2, $3::NUMERIC, $4::NUMERIC, $5, $6::NUMERIC, $7, $8, $9::NUMERIC, $10, $11::NUMERIC)
@@ -77,12 +77,12 @@ func (repository HeaderRepository) CreateTransactionInTx(tx *sqlx.Tx, headerID i
 		RETURNING id`,
 		headerID, transaction.Hash, transaction.GasLimit, transaction.GasPrice,
 		transaction.Data, transaction.Nonce, transaction.Raw, transaction.From,
-		transaction.TxIndex, transaction.To, transaction.Value).Scan(&txId)
+		transaction.TxIndex, transaction.To, transaction.Value).Scan(&txID)
 	if err != nil {
 		log.Error("header_repository: error inserting transaction: ", err)
-		return txId, err
+		return txID, err
 	}
-	return txId, err
+	return txID, err
 }
 
 func (repository HeaderRepository) GetHeader(blockNumber int64) (core.Header, error) {
@@ -132,19 +132,19 @@ func (repository HeaderRepository) getHeaderHash(header core.Header) (string, er
 // Can happen when concurrent processes are inserting headers
 // Otherwise should not occur since only called in CreateOrUpdateHeader
 func (repository HeaderRepository) InternalInsertHeader(header core.Header) (int64, error) {
-	var headerId int64
+	var headerID int64
 	row := repository.database.QueryRowx(
 		`INSERT INTO public.headers (block_number, hash, block_timestamp, raw, eth_node_id, eth_node_fingerprint)
 		VALUES ($1, $2, $3::NUMERIC, $4, $5, $6) ON CONFLICT DO NOTHING RETURNING id`,
 		header.BlockNumber, header.Hash, header.Timestamp, header.Raw, repository.database.NodeID, repository.database.Node.ID)
-	err := row.Scan(&headerId)
+	err := row.Scan(&headerID)
 	if err != nil {
 		if err == sql.ErrNoRows {
 			return 0, ErrValidHeaderExists
 		}
 		log.Error("InternalInsertHeader: error inserting header: ", err)
 	}
-	return headerId, err
+	return headerID, err
 }
 
 func (repository HeaderRepository) replaceHeader(header core.Header) (int64, error) {

pkg/datastore/postgres/repositories/header_repository_test.go

@@ -423,7 +423,7 @@ var _ = Describe("Block header repository", func() {
 			dbHeader, err := repo.GetHeader(header.BlockNumber)
 
 			Expect(err).NotTo(HaveOccurred())
-			Expect(dbHeader.Id).NotTo(BeZero())
+			Expect(dbHeader.ID).NotTo(BeZero())
 			Expect(dbHeader.BlockNumber).To(Equal(header.BlockNumber))
 			Expect(dbHeader.Hash).To(Equal(header.Hash))
 			Expect(dbHeader.Raw).To(MatchJSON(header.Raw))

pkg/datastore/postgres/repositories/header_sync_log_repository.go

@@ -73,7 +73,7 @@ func (repo HeaderSyncLogRepository) GetUntransformedHeaderSyncLogs() ([]core.Hea
 		for _, topic := range rawLog.Topics {
 			logTopics = append(logTopics, common.BytesToHash(topic))
 		}
-		address, addrErr := repository.GetAddressById(repo.db, rawLog.Address)
+		address, addrErr := repository.GetAddressByID(repo.db, rawLog.Address)
 		if addrErr != nil {
 			return nil, addrErr
 		}

pkg/datastore/postgres/repositories/header_sync_log_repository_test.go

@@ -80,7 +80,7 @@ var _ = Describe("Header sync log repository", func() {
 			Expect(lookupErr).NotTo(HaveOccurred())
 			Expect(dbLog.ID).NotTo(BeZero())
 			Expect(dbLog.HeaderID).To(Equal(headerID))
-			actualAddress, addressErr := repository2.GetAddressById(db, dbLog.Address)
+			actualAddress, addressErr := repository2.GetAddressByID(db, dbLog.Address)
 			Expect(addressErr).NotTo(HaveOccurred())
 			Expect(actualAddress).To(Equal(log.Address.Hex()))
 			Expect(dbLog.Topics[0]).To(Equal(log.Topics[0].Bytes()))
@@ -128,7 +128,7 @@ var _ = Describe("Header sync log repository", func() {
 				logTopics = append(logTopics, common.BytesToHash(topic))
 			}
 
-			actualAddress, addressErr := repository2.GetAddressById(db, dbLog.Address)
+			actualAddress, addressErr := repository2.GetAddressByID(db, dbLog.Address)
 			Expect(addressErr).NotTo(HaveOccurred())
 			reconstructedLog := types.Log{
 				Address:     common.HexToAddress(actualAddress),

pkg/datastore/postgres/repositories/header_sync_receipt_repository.go

@@ -26,11 +26,11 @@ import (
 type HeaderSyncReceiptRepository struct{}
 
 func (HeaderSyncReceiptRepository) CreateHeaderSyncReceiptInTx(headerID, transactionID int64, receipt core.Receipt, tx *sqlx.Tx) (int64, error) {
-	var receiptId int64
+	var receiptID int64
-	addressId, getAddressErr := repository.GetOrCreateAddressInTransaction(tx, receipt.ContractAddress)
+	addressID, getAddressErr := repository.GetOrCreateAddressInTransaction(tx, receipt.ContractAddress)
 	if getAddressErr != nil {
 		log.Error("createReceipt: Error getting address id: ", getAddressErr)
-		return receiptId, getAddressErr
+		return receiptID, getAddressErr
 	}
 	err := tx.QueryRowx(`INSERT INTO public.header_sync_receipts
                (header_id, transaction_id, contract_address_id, cumulative_gas_used, gas_used, state_root, status, tx_hash, rlp)
@@ -38,10 +38,10 @@ func (HeaderSyncReceiptRepository) CreateHeaderSyncReceiptInTx(headerID, transac
 			   ON CONFLICT (header_id, transaction_id) DO UPDATE
 			   SET (contract_address_id, cumulative_gas_used, gas_used, state_root, status, tx_hash, rlp) = ($3, $4::NUMERIC, $5::NUMERIC, $6, $7, $8, $9)
                RETURNING id`,
-		headerID, transactionID, addressId, receipt.CumulativeGasUsed, receipt.GasUsed, receipt.StateRoot, receipt.Status, receipt.TxHash, receipt.Rlp).Scan(&receiptId)
+		headerID, transactionID, addressID, receipt.CumulativeGasUsed, receipt.GasUsed, receipt.StateRoot, receipt.Status, receipt.TxHash, receipt.Rlp).Scan(&receiptID)
 	if err != nil {
 		log.Error("header_repository: error inserting receipt: ", err)
-		return receiptId, err
+		return receiptID, err
 	}
-	return receiptId, err
+	return receiptID, err
 }

pkg/datastore/repository.go

@@ -57,7 +57,7 @@ type FilterRepository interface {
 }
 
 type FullSyncLogRepository interface {
-	CreateLogs(logs []core.FullSyncLog, receiptId int64) error
+	CreateLogs(logs []core.FullSyncLog, receiptID int64) error
 	GetLogs(address string, blockNumber int64) ([]core.FullSyncLog, error)
 }
 
@@ -74,13 +74,13 @@ type HeaderSyncLogRepository interface {
 }
 
 type FullSyncReceiptRepository interface {
-	CreateReceiptsAndLogs(blockId int64, receipts []core.Receipt) error
+	CreateReceiptsAndLogs(blockID int64, receipts []core.Receipt) error
-	CreateFullSyncReceiptInTx(blockId int64, receipt core.Receipt, tx *sqlx.Tx) (int64, error)
+	CreateFullSyncReceiptInTx(blockID int64, receipt core.Receipt, tx *sqlx.Tx) (int64, error)
 	GetFullSyncReceipt(txHash string) (core.Receipt, error)
 }
 
 type HeaderSyncReceiptRepository interface {
-	CreateFullSyncReceiptInTx(blockId int64, receipt core.Receipt, tx *sqlx.Tx) (int64, error)
+	CreateFullSyncReceiptInTx(blockID int64, receipt core.Receipt, tx *sqlx.Tx) (int64, error)
 }
 
 type WatchedEventRepository interface {

pkg/eth/abi.go

@@ -32,7 +32,7 @@ import (
 var (
 	ErrInvalidAbiFile   = errors.New("invalid abi")
 	ErrMissingAbiFile   = errors.New("missing abi")
-	ErrApiRequestFailed = errors.New("etherscan api request failed")
+	ErrAPIRequestFailed = errors.New("etherscan api request failed")
 )
 
 type Response struct {
@@ -72,7 +72,7 @@ func (e *EtherScanAPI) GetAbi(contractHash string) (string, error) {
 	request := fmt.Sprintf("%s/api?module=contract&action=getabi&address=%s", e.url, contractHash)
 	r, err := e.client.Get(request)
 	if err != nil {
-		return "", ErrApiRequestFailed
+		return "", ErrAPIRequestFailed
 	}
 	defer r.Body.Close()
 	err = json.NewDecoder(r.Body).Decode(&target)

pkg/eth/blockchain.go

@@ -41,11 +41,11 @@ type BlockChain struct {
 	ethClient            core.EthClient
 	headerConverter      vulcCommon.HeaderConverter
 	node                 core.Node
-	rpcClient            core.RpcClient
+	rpcClient            core.RPCClient
 	transactionConverter vulcCommon.TransactionConverter
 }
 
-func NewBlockChain(ethClient core.EthClient, rpcClient core.RpcClient, node core.Node, converter vulcCommon.TransactionConverter) *BlockChain {
+func NewBlockChain(ethClient core.EthClient, rpcClient core.RPCClient, node core.Node, converter vulcCommon.TransactionConverter) *BlockChain {
 	return &BlockChain{
 		blockConverter:       vulcCommon.NewBlockConverter(converter),
 		ethClient:            ethClient,
@@ -108,7 +108,7 @@ func (blockChain *BlockChain) GetFullSyncLogs(contract core.Contract, startingBl
 func (blockChain *BlockChain) GetTransactions(transactionHashes []common.Hash) ([]core.TransactionModel, error) {
 	numTransactions := len(transactionHashes)
 	var batch []client.BatchElem
-	transactions := make([]core.RpcTransaction, numTransactions)
+	transactions := make([]core.RPCTransaction, numTransactions)
 
 	for index, transactionHash := range transactionHashes {
 		batchElem := client.BatchElem{
@@ -124,7 +124,7 @@ func (blockChain *BlockChain) GetTransactions(transactionHashes []common.Hash) (
 		return []core.TransactionModel{}, rpcErr
 	}
 
-	return blockChain.transactionConverter.ConvertRpcTransactionsToModels(transactions)
+	return blockChain.transactionConverter.ConvertRPCTransactionsToModels(transactions)
 }
 
 func (blockChain *BlockChain) LastBlock() (*big.Int, error) {

pkg/eth/blockchain_test.go

@@ -37,14 +37,14 @@ var _ = Describe("Geth blockchain", func() {
 	var (
 		mockClient               *fakes.MockEthClient
 		blockChain               *eth.BlockChain
-		mockRpcClient            *fakes.MockRpcClient
+		mockRpcClient            *fakes.MockRPCClient
 		mockTransactionConverter *fakes.MockTransactionConverter
 		node                     vulcCore.Node
 	)
 
 	BeforeEach(func() {
 		mockClient = fakes.NewMockEthClient()
-		mockRpcClient = fakes.NewMockRpcClient()
+		mockRpcClient = fakes.NewMockRPCClient()
 		mockTransactionConverter = fakes.NewMockTransactionConverter()
 		node = vulcCore.Node{}
 		blockChain = eth.NewBlockChain(mockClient, mockRpcClient, node, mockTransactionConverter)

pkg/eth/client/rpc_client.go

@@ -24,7 +24,7 @@ import (
 	"github.com/ethereum/go-ethereum/rpc"
 )
 
-type RpcClient struct {
+type RPCClient struct {
 	client  *rpc.Client
 	ipcPath string
 }
@@ -36,14 +36,14 @@ type BatchElem struct {
 	Error  error
 }
 
-func NewRpcClient(client *rpc.Client, ipcPath string) RpcClient {
+func NewRPCClient(client *rpc.Client, ipcPath string) RPCClient {
-	return RpcClient{
+	return RPCClient{
 		client:  client,
 		ipcPath: ipcPath,
 	}
 }
 
-func (client RpcClient) CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) error {
+func (client RPCClient) CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) error {
 	//If an empty interface (or other nil object) is passed to CallContext, when the JSONRPC message is created the params will
 	//be interpreted as [null]. This seems to work fine for most of the ethereum clients (which presumably ignore a null parameter.
 	//Ganache however does not ignore it, and throws an 'Incorrect number of arguments' error.
@@ -53,15 +53,15 @@ func (client RpcClient) CallContext(ctx context.Context, result interface{}, met
 	return client.client.CallContext(ctx, result, method, args...)
 }
 
-func (client RpcClient) IpcPath() string {
+func (client RPCClient) IpcPath() string {
 	return client.ipcPath
 }
 
-func (client RpcClient) SupportedModules() (map[string]string, error) {
+func (client RPCClient) SupportedModules() (map[string]string, error) {
 	return client.client.SupportedModules()
 }
 
-func (client RpcClient) BatchCall(batch []BatchElem) error {
+func (client RPCClient) BatchCall(batch []BatchElem) error {
 	var rpcBatch []rpc.BatchElem
 	for _, batchElem := range batch {
 		var newBatchElem = rpc.BatchElem{
@@ -78,7 +78,7 @@ func (client RpcClient) BatchCall(batch []BatchElem) error {
 
 // Subscribe subscribes to an rpc "namespace_subscribe" subscription with the given channel
 // The first argument needs to be the method we wish to invoke
-func (client RpcClient) Subscribe(namespace string, payloadChan interface{}, args ...interface{}) (*rpc.ClientSubscription, error) {
+func (client RPCClient) Subscribe(namespace string, payloadChan interface{}, args ...interface{}) (*rpc.ClientSubscription, error) {
 	chanVal := reflect.ValueOf(payloadChan)
 	if chanVal.Kind() != reflect.Chan || chanVal.Type().ChanDir()&reflect.SendDir == 0 {
 		return nil, errors.New("second argument to Subscribe must be a writable channel")

pkg/eth/cold_import/importer.go

@@ -38,16 +38,16 @@ func NewColdImporter(ethDB ethereum.Database, blockRepository datastore.BlockRep
 	}
 }
 
-func (ci *ColdImporter) Execute(startingBlockNumber int64, endingBlockNumber int64, nodeId string) error {
+func (ci *ColdImporter) Execute(startingBlockNumber int64, endingBlockNumber int64, nodeID string) error {
-	missingBlocks := ci.blockRepository.MissingBlockNumbers(startingBlockNumber, endingBlockNumber, nodeId)
+	missingBlocks := ci.blockRepository.MissingBlockNumbers(startingBlockNumber, endingBlockNumber, nodeID)
 	for _, n := range missingBlocks {
 		hash := ci.ethDB.GetBlockHash(n)
 
-		blockId, err := ci.createBlocksAndTransactions(hash, n)
+		blockID, err := ci.createBlocksAndTransactions(hash, n)
 		if err != nil {
 			return err
 		}
-		err = ci.createReceiptsAndLogs(hash, n, blockId)
+		err = ci.createReceiptsAndLogs(hash, n, blockID)
 		if err != nil {
 			return err
 		}
@@ -65,11 +65,11 @@ func (ci *ColdImporter) createBlocksAndTransactions(hash []byte, i int64) (int64
 	return ci.blockRepository.CreateOrUpdateBlock(coreBlock)
 }
 
-func (ci *ColdImporter) createReceiptsAndLogs(hash []byte, number int64, blockId int64) error {
+func (ci *ColdImporter) createReceiptsAndLogs(hash []byte, number int64, blockID int64) error {
 	receipts := ci.ethDB.GetBlockReceipts(hash, number)
 	coreReceipts, err := common.ToCoreReceipts(receipts)
 	if err != nil {
 		return err
 	}
-	return ci.receiptRepository.CreateReceiptsAndLogs(blockId, coreReceipts)
+	return ci.receiptRepository.CreateReceiptsAndLogs(blockID, coreReceipts)
 }

pkg/eth/cold_import/node_builder.go

@@ -27,7 +27,7 @@ import (
 
 const (
 	ColdImportClientName         = "LevelDbColdImport"
-	ColdImportNetworkId  float64 = 1
+	ColdImportNetworkID  float64 = 1
 )
 
 var (
@@ -54,15 +54,15 @@ func (cinb ColdImportNodeBuilder) GetNode(genesisBlock []byte, levelPath string)
 	if err != nil {
 		return coldNode, err
 	}
-	nodeId, err := cinb.parser.ParsePublicKey(string(nodeKey))
+	nodeID, err := cinb.parser.ParsePublicKey(string(nodeKey))
 	if err != nil {
 		return coldNode, err
 	}
 	genesisBlockHash := common.BytesToHash(genesisBlock).String()
 	coldNode = core.Node{
 		GenesisBlock: genesisBlockHash,
-		NetworkID:    ColdImportNetworkId,
+		NetworkID:    ColdImportNetworkID,
-		ID:           nodeId,
+		ID:           nodeID,
 		ClientName:   ColdImportClientName,
 	}
 	return coldNode, nil

pkg/eth/cold_import/node_builder_test.go

@@ -106,7 +106,7 @@ var _ = Describe("Cold importer node builder", func() {
 			expectedGenesisBlock := common.BytesToHash(fakeGenesisBlock).String()
 			Expect(result.GenesisBlock).To(Equal(expectedGenesisBlock))
 			Expect(result.ID).To(Equal(fakePublicKeyString))
-			Expect(result.NetworkID).To(Equal(cold_import.ColdImportNetworkId))
+			Expect(result.NetworkID).To(Equal(cold_import.ColdImportNetworkID))
 		})
 	})
 

pkg/eth/converters/cold_db/transaction_converter.go

@@ -54,7 +54,7 @@ func (cdtc *ColdDbTransactionConverter) ConvertBlockTransactionsToCore(gethBlock
 	return coreTransactions, nil
 }
 
-func (cdtc *ColdDbTransactionConverter) ConvertRpcTransactionsToModels(transactions []core.RpcTransaction) ([]core.TransactionModel, error) {
+func (cdtc *ColdDbTransactionConverter) ConvertRPCTransactionsToModels(transactions []core.RPCTransaction) ([]core.TransactionModel, error) {
 	panic("converting transaction indexes to integer not supported for cold import")
 }
 

pkg/eth/converters/common/block_converter_test.go

@@ -60,7 +60,7 @@ var _ = Describe("Conversion of GethBlock to core.Block", func() {
 		}
 		block := types.NewBlock(&header, []*types.Transaction{}, []*types.Header{}, []*types.Receipt{})
 		client := fakes.NewMockEthClient()
-		transactionConverter := rpc.NewRpcTransactionConverter(client)
+		transactionConverter := rpc.NewRPCTransactionConverter(client)
 		blockConverter := vulcCommon.NewBlockConverter(transactionConverter)
 
 		coreBlock, err := blockConverter.ToCoreBlock(block)
@@ -110,7 +110,7 @@ var _ = Describe("Conversion of GethBlock to core.Block", func() {
 			}
 			uncles := []*types.Header{{Number: big.NewInt(1071817)}, {Number: big.NewInt(1071818)}}
 			block := types.NewBlock(&header, transactions, uncles, []*types.Receipt{&receipt})
-			transactionConverter := rpc.NewRpcTransactionConverter(client)
+			transactionConverter := rpc.NewRPCTransactionConverter(client)
 			blockConverter := vulcCommon.NewBlockConverter(transactionConverter)
 
 			coreBlock, err := blockConverter.ToCoreBlock(block)
@@ -151,7 +151,7 @@ var _ = Describe("Conversion of GethBlock to core.Block", func() {
 
 			client := fakes.NewMockEthClient()
 			client.SetTransactionReceipts(receipts)
-			transactionConverter := rpc.NewRpcTransactionConverter(client)
+			transactionConverter := rpc.NewRPCTransactionConverter(client)
 			blockConverter := vulcCommon.NewBlockConverter(transactionConverter)
 
 			coreBlock, err := blockConverter.ToCoreBlock(block)
@@ -211,7 +211,7 @@ var _ = Describe("Conversion of GethBlock to core.Block", func() {
 
 			client := fakes.NewMockEthClient()
 			client.SetTransactionReceipts(receipts)
-			transactionConverter := rpc.NewRpcTransactionConverter(client)
+			transactionConverter := rpc.NewRPCTransactionConverter(client)
 			blockConverter := vulcCommon.NewBlockConverter(transactionConverter)
 
 			coreBlock, err := blockConverter.ToCoreBlock(block)
@@ -229,7 +229,7 @@ var _ = Describe("Conversion of GethBlock to core.Block", func() {
 			header := types.Header{}
 			block := types.NewBlock(&header, []*types.Transaction{}, []*types.Header{}, []*types.Receipt{})
 			client := fakes.NewMockEthClient()
-			transactionConverter := rpc.NewRpcTransactionConverter(client)
+			transactionConverter := rpc.NewRPCTransactionConverter(client)
 			blockConverter := vulcCommon.NewBlockConverter(transactionConverter)
 
 			coreBlock, err := blockConverter.ToCoreBlock(block)
@@ -270,7 +270,7 @@ var _ = Describe("Conversion of GethBlock to core.Block", func() {
 				[]*types.Header{},
 				[]*types.Receipt{gethReceipt},
 			)
-			transactionConverter := rpc.NewRpcTransactionConverter(client)
+			transactionConverter := rpc.NewRPCTransactionConverter(client)
 			blockConverter := vulcCommon.NewBlockConverter(transactionConverter)
 
 			coreBlock, err := blockConverter.ToCoreBlock(block)
@@ -320,7 +320,7 @@ var _ = Describe("Conversion of GethBlock to core.Block", func() {
 				[]*types.Header{},
 				[]*types.Receipt{gethReceipt},
 			)
-			transactionConverter := rpc.NewRpcTransactionConverter(client)
+			transactionConverter := rpc.NewRPCTransactionConverter(client)
 			blockConverter := vulcCommon.NewBlockConverter(transactionConverter)
 
 			coreBlock, err := blockConverter.ToCoreBlock(block)
@@ -370,7 +370,7 @@ var _ = Describe("Conversion of GethBlock to core.Block", func() {
 		It("returns an error when transaction sender call fails", func() {
 			client := fakes.NewMockEthClient()
 			client.SetTransactionSenderErr(fakes.FakeError)
-			transactionConverter := rpc.NewRpcTransactionConverter(client)
+			transactionConverter := rpc.NewRPCTransactionConverter(client)
 			blockConverter := vulcCommon.NewBlockConverter(transactionConverter)
 
 			_, err := blockConverter.ToCoreBlock(block)
@@ -381,7 +381,7 @@ var _ = Describe("Conversion of GethBlock to core.Block", func() {
 		It("returns an error when transaction receipt call fails", func() {
 			client := fakes.NewMockEthClient()
 			client.SetTransactionReceiptErr(fakes.FakeError)
-			transactionConverter := rpc.NewRpcTransactionConverter(client)
+			transactionConverter := rpc.NewRPCTransactionConverter(client)
 			blockConverter := vulcCommon.NewBlockConverter(transactionConverter)
 
 			_, err := blockConverter.ToCoreBlock(block)

pkg/eth/converters/common/transaction_converter.go

@@ -23,5 +23,5 @@ import (
 
 type TransactionConverter interface {
 	ConvertBlockTransactionsToCore(gethBlock *types.Block) ([]core.TransactionModel, error)
-	ConvertRpcTransactionsToModels(transactions []core.RpcTransaction) ([]core.TransactionModel, error)
+	ConvertRPCTransactionsToModels(transactions []core.RPCTransaction) ([]core.TransactionModel, error)
 }

pkg/eth/converters/rpc/transaction_converter.go

@@ -34,7 +34,7 @@ import (
 	vulcCommon "github.com/vulcanize/vulcanizedb/pkg/eth/converters/common"
 )
 
-type RpcTransactionConverter struct {
+type RPCTransactionConverter struct {
 	client core.EthClient
 }
 
@@ -51,11 +51,11 @@ type transactionData struct {
 	S            *big.Int
 }
 
-func NewRpcTransactionConverter(client core.EthClient) *RpcTransactionConverter {
+func NewRPCTransactionConverter(client core.EthClient) *RPCTransactionConverter {
-	return &RpcTransactionConverter{client: client}
+	return &RPCTransactionConverter{client: client}
 }
 
-func (converter *RpcTransactionConverter) ConvertRpcTransactionsToModels(transactions []core.RpcTransaction) ([]core.TransactionModel, error) {
+func (converter *RPCTransactionConverter) ConvertRPCTransactionsToModels(transactions []core.RPCTransaction) ([]core.TransactionModel, error) {
 	var results []core.TransactionModel
 	for _, transaction := range transactions {
 		txData, convertErr := getTransactionData(transaction)
@@ -88,7 +88,7 @@ func (converter *RpcTransactionConverter) ConvertRpcTransactionsToModels(transac
 	return results, nil
 }
 
-func (converter *RpcTransactionConverter) ConvertBlockTransactionsToCore(gethBlock *types.Block) ([]core.TransactionModel, error) {
+func (converter *RPCTransactionConverter) ConvertBlockTransactionsToCore(gethBlock *types.Block) ([]core.TransactionModel, error) {
 	var g errgroup.Group
 	coreTransactions := make([]core.TransactionModel, len(gethBlock.Transactions()))
 
@@ -122,8 +122,8 @@ func (converter *RpcTransactionConverter) ConvertBlockTransactionsToCore(gethBlo
 	return coreTransactions, nil
 }
 
-func (rtc *RpcTransactionConverter) appendReceiptToTransaction(transaction core.TransactionModel) (core.TransactionModel, error) {
+func (converter *RPCTransactionConverter) appendReceiptToTransaction(transaction core.TransactionModel) (core.TransactionModel, error) {
-	gethReceipt, err := rtc.client.TransactionReceipt(context.Background(), common.HexToHash(transaction.Hash))
+	gethReceipt, err := converter.client.TransactionReceipt(context.Background(), common.HexToHash(transaction.Hash))
 	if err != nil {
 		return transaction, err
 	}
@@ -155,7 +155,7 @@ func convertGethTransactionToModel(transaction *types.Transaction, from *common.
 	}, nil
 }
 
-func getTransactionData(transaction core.RpcTransaction) (transactionData, error) {
+func getTransactionData(transaction core.RPCTransaction) (transactionData, error) {
 	nonce, nonceErr := hexToBigInt(transaction.Nonce)
 	if nonceErr != nil {
 		return transactionData{}, nonceErr

pkg/eth/converters/rpc/transaction_converter_test.go

@@ -25,16 +25,16 @@ import (
 )
 
 var _ = Describe("RPC transaction converter", func() {
-	var converter rpc.RpcTransactionConverter
+	var converter rpc.RPCTransactionConverter
 
 	BeforeEach(func() {
-		converter = rpc.RpcTransactionConverter{}
+		converter = rpc.RPCTransactionConverter{}
 	})
 
 	It("converts hex fields to integers", func() {
 		rpcTransaction := getFakeRpcTransaction("0x1")
 
-		transactionModels, err := converter.ConvertRpcTransactionsToModels([]core.RpcTransaction{rpcTransaction})
+		transactionModels, err := converter.ConvertRPCTransactionsToModels([]core.RPCTransaction{rpcTransaction})
 
 		Expect(err).NotTo(HaveOccurred())
 		Expect(len(transactionModels)).To(Equal(1))
@@ -48,7 +48,7 @@ var _ = Describe("RPC transaction converter", func() {
 	It("returns error if invalid hex cannot be converted", func() {
 		invalidTransaction := getFakeRpcTransaction("invalid")
 
-		_, err := converter.ConvertRpcTransactionsToModels([]core.RpcTransaction{invalidTransaction})
+		_, err := converter.ConvertRPCTransactionsToModels([]core.RPCTransaction{invalidTransaction})
 
 		Expect(err).To(HaveOccurred())
 	})
@@ -56,7 +56,7 @@ var _ = Describe("RPC transaction converter", func() {
 	It("copies RPC transaction hash, from, and to values to model", func() {
 		rpcTransaction := getFakeRpcTransaction("0x1")
 
-		transactionModels, err := converter.ConvertRpcTransactionsToModels([]core.RpcTransaction{rpcTransaction})
+		transactionModels, err := converter.ConvertRPCTransactionsToModels([]core.RPCTransaction{rpcTransaction})
 
 		Expect(err).NotTo(HaveOccurred())
 		Expect(len(transactionModels)).To(Equal(1))
@@ -67,7 +67,7 @@ var _ = Describe("RPC transaction converter", func() {
 
 	It("derives transaction RLP", func() {
 		// actual transaction: https://kovan.etherscan.io/tx/0x3b29ef265425d304069c57e5145cd1c7558568b06d231775f50a693bee1aad4f
-		rpcTransaction := core.RpcTransaction{
+		rpcTransaction := core.RPCTransaction{
 			Nonce:            "0x7aa9",
 			GasPrice:         "0x3b9aca00",
 			GasLimit:         "0x7a120",
@@ -82,7 +82,7 @@ var _ = Describe("RPC transaction converter", func() {
 			TransactionIndex: "0xa",
 		}
 
-		transactionModels, err := converter.ConvertRpcTransactionsToModels([]core.RpcTransaction{rpcTransaction})
+		transactionModels, err := converter.ConvertRPCTransactionsToModels([]core.RPCTransaction{rpcTransaction})
 
 		Expect(err).NotTo(HaveOccurred())
 		Expect(len(transactionModels)).To(Equal(1))
@@ -98,7 +98,7 @@ var _ = Describe("RPC transaction converter", func() {
 	It("does not include transaction receipt", func() {
 		rpcTransaction := getFakeRpcTransaction("0x1")
 
-		transactionModels, err := converter.ConvertRpcTransactionsToModels([]core.RpcTransaction{rpcTransaction})
+		transactionModels, err := converter.ConvertRPCTransactionsToModels([]core.RPCTransaction{rpcTransaction})
 
 		Expect(err).NotTo(HaveOccurred())
 		Expect(len(transactionModels)).To(Equal(1))
@@ -106,8 +106,8 @@ var _ = Describe("RPC transaction converter", func() {
 	})
 })
 
-func getFakeRpcTransaction(hex string) core.RpcTransaction {
+func getFakeRpcTransaction(hex string) core.RPCTransaction {
-	return core.RpcTransaction{
+	return core.RPCTransaction{
 		Hash:             "0x2",
 		Amount:           hex,
 		GasLimit:         hex,

pkg/eth/node/node.go

@@ -33,12 +33,12 @@ import (
 
 type IPropertiesReader interface {
 	NodeInfo() (id string, name string)
-	NetworkId() float64
+	NetworkID() float64
 	GenesisBlock() string
 }
 
 type PropertiesReader struct {
-	client core.RpcClient
+	client core.RPCClient
 }
 
 type ParityClient struct {
@@ -57,18 +57,18 @@ type GanacheClient struct {
 	PropertiesReader
 }
 
-func MakeNode(rpcClient core.RpcClient) core.Node {
+func MakeNode(rpcClient core.RPCClient) core.Node {
 	pr := makePropertiesReader(rpcClient)
 	id, name := pr.NodeInfo()
 	return core.Node{
 		GenesisBlock: pr.GenesisBlock(),
-		NetworkID:    pr.NetworkId(),
+		NetworkID:    pr.NetworkID(),
 		ID:           id,
 		ClientName:   name,
 	}
 }
 
-func makePropertiesReader(client core.RpcClient) IPropertiesReader {
+func makePropertiesReader(client core.RPCClient) IPropertiesReader {
 	switch getNodeType(client) {
 	case core.GETH:
 		return GethClient{PropertiesReader: PropertiesReader{client: client}}
@@ -83,7 +83,7 @@ func makePropertiesReader(client core.RpcClient) IPropertiesReader {
 	}
 }
 
-func getNodeType(client core.RpcClient) core.NodeType {
+func getNodeType(client core.RPCClient) core.NodeType {
 	if strings.Contains(client.IpcPath(), "infura") {
 		return core.INFURA
 	}
@@ -97,14 +97,14 @@ func getNodeType(client core.RpcClient) core.NodeType {
 	return core.PARITY
 }
 
-func (reader PropertiesReader) NetworkId() float64 {
+func (reader PropertiesReader) NetworkID() float64 {
 	var version string
 	err := reader.client.CallContext(context.Background(), &version, "net_version")
 	if err != nil {
 		log.Println(err)
 	}
-	networkId, _ := strconv.ParseFloat(version, 64)
+	networkID, _ := strconv.ParseFloat(version, 64)
-	return networkId
+	return networkID
 }
 
 func (reader PropertiesReader) GenesisBlock() string {
@@ -142,10 +142,10 @@ func (client ParityClient) parityNodeInfo() string {
 }
 
 func (client ParityClient) parityID() string {
-	var enodeId = regexp.MustCompile(`^enode://(.+)@.+$`)
+	var enodeID = regexp.MustCompile(`^enode://(.+)@.+$`)
 	var enodeURL string
 	client.client.CallContext(context.Background(), &enodeURL, "parity_enode")
-	enode := enodeId.FindStringSubmatch(enodeURL)
+	enode := enodeID.FindStringSubmatch(enodeURL)
 	if len(enode) < 2 {
 		return ""
 	}

pkg/eth/node/node_test.go

@@ -65,7 +65,7 @@ var _ = Describe("Node Info", func() {
 		})
 
 		It("returns parity ID and client name for parity node", func() {
-			client := fakes.NewMockRpcClient()
+			client := fakes.NewMockRPCClient()
 
 			n := node.MakeNode(client)
 			Expect(n.ID).To(Equal("ParityNode"))
@@ -74,19 +74,19 @@ var _ = Describe("Node Info", func() {
 	})
 
 	It("returns the genesis block for any client", func() {
-		client := fakes.NewMockRpcClient()
+		client := fakes.NewMockRPCClient()
 		n := node.MakeNode(client)
 		Expect(n.GenesisBlock).To(Equal(EmpytHeaderHash))
 	})
 
 	It("returns the network id for any client", func() {
-		client := fakes.NewMockRpcClient()
+		client := fakes.NewMockRPCClient()
 		n := node.MakeNode(client)
 		Expect(n.NetworkID).To(Equal(float64(1234)))
 	})
 
 	It("returns geth ID and client name for geth node", func() {
-		client := fakes.NewMockRpcClient()
+		client := fakes.NewMockRPCClient()
 		supportedModules := make(map[string]string)
 		supportedModules["admin"] = "ok"
 		client.SetSupporedModules(supportedModules)
@@ -97,7 +97,7 @@ var _ = Describe("Node Info", func() {
 	})
 
 	It("returns infura ID and client name for infura node", func() {
-		client := fakes.NewMockRpcClient()
+		client := fakes.NewMockRPCClient()
 		client.SetIpcPath("infura/path")
 		n := node.MakeNode(client)
 		Expect(n.ID).To(Equal("infura"))
@@ -105,7 +105,7 @@ var _ = Describe("Node Info", func() {
 	})
 
 	It("returns local id and client name for Local node", func() {
-		client := fakes.NewMockRpcClient()
+		client := fakes.NewMockRPCClient()
 		client.SetIpcPath("127.0.0.1")
 		n := node.MakeNode(client)
 		Expect(n.ID).To(Equal("ganache"))

pkg/fakes/mock_block_repository.go

@@ -31,7 +31,7 @@ type MockBlockRepository struct {
 	createOrUpdateBlockReturnInt                 int64
 	missingBlockNumbersCalled                    bool
 	missingBlockNumbersPassedEndingBlockNumber   int64
-	missingBlockNumbersPassedNodeId              string
+	missingBlockNumbersPassedNodeID              string
 	missingBlockNumbersPassedStartingBlockNumber int64
 	missingBlockNumbersReturnArray               []int64
 	setBlockStatusCalled                         bool
@@ -48,7 +48,7 @@ func NewMockBlockRepository() *MockBlockRepository {
 		createOrUpdateBlockReturnInt:                 0,
 		missingBlockNumbersCalled:                    false,
 		missingBlockNumbersPassedEndingBlockNumber:   0,
-		missingBlockNumbersPassedNodeId:              "",
+		missingBlockNumbersPassedNodeID:              "",
 		missingBlockNumbersPassedStartingBlockNumber: 0,
 		missingBlockNumbersReturnArray:               nil,
 		setBlockStatusCalled:                         false,
@@ -77,11 +77,11 @@ func (repository *MockBlockRepository) GetBlock(blockNumber int64) (core.Block,
 	return core.Block{Number: blockNumber}, nil
 }
 
-func (repository *MockBlockRepository) MissingBlockNumbers(startingBlockNumber int64, endingBlockNumber int64, nodeId string) []int64 {
+func (repository *MockBlockRepository) MissingBlockNumbers(startingBlockNumber int64, endingBlockNumber int64, nodeID string) []int64 {
 	repository.missingBlockNumbersCalled = true
 	repository.missingBlockNumbersPassedStartingBlockNumber = startingBlockNumber
 	repository.missingBlockNumbersPassedEndingBlockNumber = endingBlockNumber
-	repository.missingBlockNumbersPassedNodeId = nodeId
+	repository.missingBlockNumbersPassedNodeID = nodeID
 	return repository.missingBlockNumbersReturnArray
 }
 
@@ -105,11 +105,11 @@ func (repository *MockBlockRepository) AssertCreateOrUpdateBlockCalledWith(block
 	Expect(repository.createOrUpdateBlockPassedBlock).To(Equal(block))
 }
 
-func (repository *MockBlockRepository) AssertMissingBlockNumbersCalledWith(startingBlockNumber int64, endingBlockNumber int64, nodeId string) {
+func (repository *MockBlockRepository) AssertMissingBlockNumbersCalledWith(startingBlockNumber int64, endingBlockNumber int64, nodeID string) {
 	Expect(repository.missingBlockNumbersCalled).To(BeTrue())
 	Expect(repository.missingBlockNumbersPassedStartingBlockNumber).To(Equal(startingBlockNumber))
 	Expect(repository.missingBlockNumbersPassedEndingBlockNumber).To(Equal(endingBlockNumber))
-	Expect(repository.missingBlockNumbersPassedNodeId).To(Equal(nodeId))
+	Expect(repository.missingBlockNumbersPassedNodeID).To(Equal(nodeID))
 }
 
 func (repository *MockBlockRepository) AssertSetBlockStatusCalledWith(chainHead int64) {

pkg/fakes/mock_blockchain.go

@@ -75,23 +75,23 @@ func (chain *MockBlockChain) SetGetEthLogsWithCustomQueryReturnLogs(logs []types
 	chain.logQueryReturnLogs = logs
 }
 
-func (blockChain *MockBlockChain) FetchContractData(abiJSON string, address string, method string, methodArgs []interface{}, result interface{}, blockNumber int64) error {
+func (chain *MockBlockChain) FetchContractData(abiJSON string, address string, method string, methodArgs []interface{}, result interface{}, blockNumber int64) error {
-	blockChain.fetchContractDataPassedAbi = abiJSON
+	chain.fetchContractDataPassedAbi = abiJSON
-	blockChain.fetchContractDataPassedAddress = address
+	chain.fetchContractDataPassedAddress = address
-	blockChain.fetchContractDataPassedMethod = method
+	chain.fetchContractDataPassedMethod = method
-	blockChain.fetchContractDataPassedMethodArgs = methodArgs
+	chain.fetchContractDataPassedMethodArgs = methodArgs
-	blockChain.fetchContractDataPassedResult = result
+	chain.fetchContractDataPassedResult = result
-	blockChain.fetchContractDataPassedBlockNumber = blockNumber
+	chain.fetchContractDataPassedBlockNumber = blockNumber
-	return blockChain.fetchContractDataErr
+	return chain.fetchContractDataErr
 }
 
 func (chain *MockBlockChain) GetBlockByNumber(blockNumber int64) (core.Block, error) {
 	return core.Block{Number: blockNumber}, chain.getBlockByNumberErr
 }
 
-func (blockChain *MockBlockChain) GetEthLogsWithCustomQuery(query ethereum.FilterQuery) ([]types.Log, error) {
+func (chain *MockBlockChain) GetEthLogsWithCustomQuery(query ethereum.FilterQuery) ([]types.Log, error) {
-	blockChain.logQuery = query
+	chain.logQuery = query
-	return blockChain.logQueryReturnLogs, blockChain.logQueryErr
+	return chain.logQueryReturnLogs, chain.logQueryErr
 }
 
 func (chain *MockBlockChain) GetHeaderByNumber(blockNumber int64) (core.Header, error) {
@@ -140,18 +140,18 @@ func (chain *MockBlockChain) AssertFetchContractDataCalledWith(abiJSON string, a
 	Expect(chain.fetchContractDataPassedBlockNumber).To(Equal(blockNumber))
 }
 
-func (blockChain *MockBlockChain) AssertGetEthLogsWithCustomQueryCalledWith(query ethereum.FilterQuery) {
+func (chain *MockBlockChain) AssertGetEthLogsWithCustomQueryCalledWith(query ethereum.FilterQuery) {
-	Expect(blockChain.logQuery).To(Equal(query))
+	Expect(chain.logQuery).To(Equal(query))
 }
 
-func (blockChain *MockBlockChain) SetGetAccountBalanceErr(err error) {
+func (chain *MockBlockChain) SetGetAccountBalanceErr(err error) {
-	blockChain.getAccountBalanceErr = err
+	chain.getAccountBalanceErr = err
 }
 
-func (blockChain *MockBlockChain) SetGetAccountBalance(balance *big.Int) {
+func (chain *MockBlockChain) SetGetAccountBalance(balance *big.Int) {
-	blockChain.accountBalanceReturnValue = balance
+	chain.accountBalanceReturnValue = balance
 }
 
-func (blockChain *MockBlockChain) GetAccountBalance(address common.Address, blockNumber *big.Int) (*big.Int, error) {
+func (chain *MockBlockChain) GetAccountBalance(address common.Address, blockNumber *big.Int) (*big.Int, error) {
-	return blockChain.accountBalanceReturnValue, blockChain.getAccountBalanceErr
+	return chain.accountBalanceReturnValue, chain.getAccountBalanceErr
 }

pkg/fakes/mock_parser.go

@@ -31,8 +31,8 @@ func (*MockParser) Parse(contractAddr string) error {
 	return nil
 }
 
-func (m *MockParser) ParseAbiStr(abiStr string) error {
+func (parser *MockParser) ParseAbiStr(abiStr string) error {
-	m.AbiToReturn = abiStr
+	parser.AbiToReturn = abiStr
 	return nil
 }
 

pkg/fakes/mock_receipt_repository.go

@@ -25,7 +25,7 @@ import (
 
 type MockReceiptRepository struct {
 	createReceiptsAndLogsCalled         bool
-	createReceiptsAndLogsPassedBlockId  int64
+	createReceiptsAndLogsPassedBlockID  int64
 	createReceiptsAndLogsPassedReceipts []core.Receipt
 	createReceiptsAndLogsReturnErr      error
 }
@@ -33,7 +33,7 @@ type MockReceiptRepository struct {
 func NewMockReceiptRepository() *MockReceiptRepository {
 	return &MockReceiptRepository{
 		createReceiptsAndLogsCalled:         false,
-		createReceiptsAndLogsPassedBlockId:  0,
+		createReceiptsAndLogsPassedBlockID:  0,
 		createReceiptsAndLogsPassedReceipts: nil,
 		createReceiptsAndLogsReturnErr:      nil,
 	}
@@ -43,14 +43,14 @@ func (mrr *MockReceiptRepository) SetCreateReceiptsAndLogsReturnErr(err error) {
 	mrr.createReceiptsAndLogsReturnErr = err
 }
 
-func (mrr *MockReceiptRepository) CreateReceiptsAndLogs(blockId int64, receipts []core.Receipt) error {
+func (mrr *MockReceiptRepository) CreateReceiptsAndLogs(blockID int64, receipts []core.Receipt) error {
 	mrr.createReceiptsAndLogsCalled = true
-	mrr.createReceiptsAndLogsPassedBlockId = blockId
+	mrr.createReceiptsAndLogsPassedBlockID = blockID
 	mrr.createReceiptsAndLogsPassedReceipts = receipts
 	return mrr.createReceiptsAndLogsReturnErr
 }
 
-func (mrr *MockReceiptRepository) CreateFullSyncReceiptInTx(blockId int64, receipt core.Receipt, tx *sqlx.Tx) (int64, error) {
+func (mrr *MockReceiptRepository) CreateFullSyncReceiptInTx(blockID int64, receipt core.Receipt, tx *sqlx.Tx) (int64, error) {
 	panic("implement me")
 }
 
@@ -58,9 +58,9 @@ func (mrr *MockReceiptRepository) GetFullSyncReceipt(txHash string) (core.Receip
 	panic("implement me")
 }
 
-func (mrr *MockReceiptRepository) AssertCreateReceiptsAndLogsCalledWith(blockId int64, receipts []core.Receipt) {
+func (mrr *MockReceiptRepository) AssertCreateReceiptsAndLogsCalledWith(blockID int64, receipts []core.Receipt) {
 	Expect(mrr.createReceiptsAndLogsCalled).To(BeTrue())
-	Expect(mrr.createReceiptsAndLogsPassedBlockId).To(Equal(blockId))
+	Expect(mrr.createReceiptsAndLogsPassedBlockID).To(Equal(blockID))
 	Expect(mrr.createReceiptsAndLogsPassedReceipts).To(Equal(receipts))
 }
 

pkg/fakes/mock_rpc_client.go

@@ -31,7 +31,7 @@ import (
 	"github.com/vulcanize/vulcanizedb/pkg/eth/client"
 )
 
-type MockRpcClient struct {
+type MockRPCClient struct {
 	callContextErr      error
 	ipcPath             string
 	nodeType            core.NodeType
@@ -49,7 +49,7 @@ type MockRpcClient struct {
 	supportedModules    map[string]string
 }
 
-func (client *MockRpcClient) Subscribe(namespace string, payloadChan interface{}, args ...interface{}) (*rpc.ClientSubscription, error) {
+func (client *MockRPCClient) Subscribe(namespace string, payloadChan interface{}, args ...interface{}) (*rpc.ClientSubscription, error) {
 	client.passedNamespace = namespace
 
 	passedPayloadChan, ok := payloadChan.(chan statediff.Payload)
@@ -66,21 +66,21 @@ func (client *MockRpcClient) Subscribe(namespace string, payloadChan interface{}
 	return &subscription, nil
 }
 
-func (client *MockRpcClient) AssertSubscribeCalledWith(namespace string, payloadChan chan statediff.Payload, args []interface{}) {
+func (client *MockRPCClient) AssertSubscribeCalledWith(namespace string, payloadChan chan statediff.Payload, args []interface{}) {
 	Expect(client.passedNamespace).To(Equal(namespace))
 	Expect(client.passedPayloadChan).To(Equal(payloadChan))
 	Expect(client.passedSubscribeArgs).To(Equal(args))
 }
 
-func NewMockRpcClient() *MockRpcClient {
+func NewMockRPCClient() *MockRPCClient {
-	return &MockRpcClient{}
+	return &MockRPCClient{}
 }
 
-func (client *MockRpcClient) SetIpcPath(ipcPath string) {
+func (client *MockRPCClient) SetIpcPath(ipcPath string) {
 	client.ipcPath = ipcPath
 }
 
-func (client *MockRpcClient) BatchCall(batch []client.BatchElem) error {
+func (client *MockRPCClient) BatchCall(batch []client.BatchElem) error {
 	client.passedBatch = batch
 	client.passedMethod = batch[0].Method
 	client.lengthOfBatch = len(batch)
@@ -101,7 +101,7 @@ func (client *MockRpcClient) BatchCall(batch []client.BatchElem) error {
 	return nil
 }
 
-func (client *MockRpcClient) CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) error {
+func (client *MockRPCClient) CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) error {
 	client.passedContext = ctx
 	client.passedResult = result
 	client.passedMethod = method
@@ -146,41 +146,41 @@ func (client *MockRpcClient) CallContext(ctx context.Context, result interface{}
 	return nil
 }
 
-func (client *MockRpcClient) IpcPath() string {
+func (client *MockRPCClient) IpcPath() string {
 	return client.ipcPath
 }
 
-func (client *MockRpcClient) SupportedModules() (map[string]string, error) {
+func (client *MockRPCClient) SupportedModules() (map[string]string, error) {
 	return client.supportedModules, nil
 }
 
-func (client *MockRpcClient) SetSupporedModules(supportedModules map[string]string) {
+func (client *MockRPCClient) SetSupporedModules(supportedModules map[string]string) {
 	client.supportedModules = supportedModules
 }
 
-func (client *MockRpcClient) SetCallContextErr(err error) {
+func (client *MockRPCClient) SetCallContextErr(err error) {
 	client.callContextErr = err
 }
 
-func (client *MockRpcClient) SetReturnPOAHeader(header core.POAHeader) {
+func (client *MockRPCClient) SetReturnPOAHeader(header core.POAHeader) {
 	client.returnPOAHeader = header
 }
 
-func (client *MockRpcClient) SetReturnPOWHeaders(headers []*types.Header) {
+func (client *MockRPCClient) SetReturnPOWHeaders(headers []*types.Header) {
 	client.returnPOWHeaders = headers
 }
 
-func (client *MockRpcClient) SetReturnPOAHeaders(headers []core.POAHeader) {
+func (client *MockRPCClient) SetReturnPOAHeaders(headers []core.POAHeader) {
 	client.returnPOAHeaders = headers
 }
 
-func (client *MockRpcClient) AssertCallContextCalledWith(ctx context.Context, result interface{}, method string) {
+func (client *MockRPCClient) AssertCallContextCalledWith(ctx context.Context, result interface{}, method string) {
 	Expect(client.passedContext).To(Equal(ctx))
 	Expect(client.passedResult).To(BeAssignableToTypeOf(result))
 	Expect(client.passedMethod).To(Equal(method))
 }
 
-func (client *MockRpcClient) AssertBatchCalledWith(method string, lengthOfBatch int) {
+func (client *MockRPCClient) AssertBatchCalledWith(method string, lengthOfBatch int) {
 	Expect(client.lengthOfBatch).To(Equal(lengthOfBatch))
 	for _, batch := range client.passedBatch {
 		Expect(batch.Method).To(Equal(method))

pkg/fakes/mock_transaction_converter.go

@@ -41,7 +41,7 @@ func (converter *MockTransactionConverter) ConvertBlockTransactionsToCore(gethBl
 	return []core.TransactionModel{}, nil
 }
 
-func (converter *MockTransactionConverter) ConvertRpcTransactionsToModels(transactions []core.RpcTransaction) ([]core.TransactionModel, error) {
+func (converter *MockTransactionConverter) ConvertRPCTransactionsToModels(transactions []core.RPCTransaction) ([]core.TransactionModel, error) {
 	converter.ConvertHeaderTransactionIndexToIntCalled = true
 	return nil, nil
 }

test_config/test_config.go

@@ -120,9 +120,9 @@ func NewTestNode() core.Node {
 	}
 }
 
-func NewTestBlock(blockNumber int64, repository repositories.BlockRepository) (blockId int64) {
+func NewTestBlock(blockNumber int64, repository repositories.BlockRepository) int64 {
-	blockId, err := repository.CreateOrUpdateBlock(core.Block{Number: blockNumber})
+	blockID, err := repository.CreateOrUpdateBlock(core.Block{Number: blockNumber})
 	Expect(err).NotTo(HaveOccurred())
 
-	return blockId
+	return blockID
 }