diff --git a/cmd/integration/commands/stages.go b/cmd/integration/commands/stages.go
index b896d8e6396240a99353adc053ea30f707957b0d..d5d961269b23417fd6e417e3e5769c61a6e60b7a 100644
--- a/cmd/integration/commands/stages.go
+++ b/cmd/integration/commands/stages.go
@@ -245,7 +245,7 @@ func init() {
withDatadir(cmdStageHashState)
rootCmd.AddCommand(cmdStageHashState)
-
+
withChaindata(cmdStageIHash)
withLmdbFlags(cmdStageIHash)
withReset(cmdStageIHash)
diff --git a/consensus/clique/clique.go b/consensus/clique/clique.go
index 88676d64c3763ab401f435a493e55e5286200eae..0259f3f74f73d010db4da536d8a2367bd84e26b1 100644
--- a/consensus/clique/clique.go
+++ b/consensus/clique/clique.go
@@ -645,7 +645,7 @@ func (c *Clique) Seal(ctx consensus.Cancel, chain consensus.ChainHeaderReader, b
}
select {
- case results <- consensus.ResultWithContext{ctx, block.WithSeal(header)}:
+ case results <- consensus.ResultWithContext{Cancel: ctx, Block: block.WithSeal(header)}:
default:
log.Warn("Sealing result is not read by miner", "sealhash", SealHash(header))
}
diff --git a/consensus/ethash/sealer.go b/consensus/ethash/sealer.go
index 06865768c9278988146ff601b5f44760e356f689..dc3be7b5a559df328479d9b9fccd26d2c3f0b790 100644
--- a/consensus/ethash/sealer.go
+++ b/consensus/ethash/sealer.go
@@ -171,7 +171,7 @@ search:
// Seal and return a block (if still needed)
select {
- case found <- consensus.ResultWithContext{ctx, block.WithSeal(header)}:
+ case found <- consensus.ResultWithContext{Cancel: ctx, Block: block.WithSeal(header)}:
logger.Trace("Ethash nonce found and reported", "attempts", nonce-seed, "nonce", nonce)
case <-ctx.Done():
logger.Trace("Ethash nonce found but discarded", "attempts", nonce-seed, "nonce", nonce)
@@ -427,7 +427,7 @@ func (s *remoteSealer) submitWork(ctx consensus.Cancel, nonce types.BlockNonce,
// The submitted solution is within the scope of acceptance.
if solution.NumberU64()+staleThreshold > s.currentBlock.NumberU64() {
select {
- case s.results <- consensus.ResultWithContext{ctx, solution}:
+ case s.results <- consensus.ResultWithContext{Cancel: ctx, Block: solution}:
s.ethash.config.Log.Debug("Work submitted is acceptable", "number", solution.NumberU64(), "sealhash", sealhash, "hash", solution.Hash())
return true
default:
diff --git a/core/state/history_test.go b/core/state/history_test.go
index 15dbc80b8c6d1f09e9b628865344c7db8426b889..1db410670ee96da156a5d075d1e7054c34c90e1f 100644
--- a/core/state/history_test.go
+++ b/core/state/history_test.go
@@ -549,16 +549,16 @@ func TestWalkAsOfStatePlain(t *testing.T) {
block4Expected.Changes = []changeset.Change{
{
- withoutInc(addrs[0], key),
- block3Val.Bytes(),
+ Key: withoutInc(addrs[0], key),
+ Value: block3Val.Bytes(),
},
{
- withoutInc(addrs[2], key),
- stateVal.Bytes(),
+ Key: withoutInc(addrs[2], key),
+ Value: stateVal.Bytes(),
},
{
- withoutInc(addrs[3], key),
- block3Val.Bytes(),
+ Key: withoutInc(addrs[3], key),
+ Value: block3Val.Bytes(),
},
}
assertChangesEquals(t, block4, block4Expected)
@@ -580,16 +580,16 @@ func TestWalkAsOfStatePlain(t *testing.T) {
block6Expected.Changes = []changeset.Change{
{
- withoutInc(addrs[0], key),
- stateVal.Bytes(),
+ Key: withoutInc(addrs[0], key),
+ Value: stateVal.Bytes(),
},
{
- withoutInc(addrs[1], key),
- stateVal.Bytes(),
+ Key: withoutInc(addrs[1], key),
+ Value: stateVal.Bytes(),
},
{
- withoutInc(addrs[2], key),
- stateVal.Bytes(),
+ Key: withoutInc(addrs[2], key),
+ Value: stateVal.Bytes(),
},
}
assertChangesEquals(t, block6, block6Expected)
@@ -632,63 +632,63 @@ func TestWalkAsOfUsingFixedBytesStatePlain(t *testing.T) {
writeStorageBlockData(t, tds, 3, []storageData{
{
- addr1,
- changeset.DefaultIncarnation,
- key1,
- emptyVal,
- block3Val,
+ addr: addr1,
+ inc: changeset.DefaultIncarnation,
+ key: key1,
+ oldVal: emptyVal,
+ newVal: block3Val,
},
{
- addr1,
- changeset.DefaultIncarnation,
- key2,
- emptyVal,
- block3Val,
+ addr: addr1,
+ inc: changeset.DefaultIncarnation,
+ key: key2,
+ oldVal: emptyVal,
+ newVal: block3Val,
},
{
- addr1,
- changeset.DefaultIncarnation,
- key3,
- emptyVal,
- block3Val,
+ addr: addr1,
+ inc: changeset.DefaultIncarnation,
+ key: key3,
+ oldVal: emptyVal,
+ newVal: block3Val,
},
{
- addr2,
- changeset.DefaultIncarnation,
- key3,
- emptyVal,
- block3Val,
+ addr: addr2,
+ inc: changeset.DefaultIncarnation,
+ key: key3,
+ oldVal: emptyVal,
+ newVal: block3Val,
},
})
writeStorageBlockData(t, tds, 5, []storageData{
{
- addr1,
- changeset.DefaultIncarnation,
- key1,
- block3Val,
- stateVal,
+ addr: addr1,
+ inc: changeset.DefaultIncarnation,
+ key: key1,
+ oldVal: block3Val,
+ newVal: stateVal,
},
{
- addr1,
- changeset.DefaultIncarnation,
- key2,
- block3Val,
- stateVal,
+ addr: addr1,
+ inc: changeset.DefaultIncarnation,
+ key: key2,
+ oldVal: block3Val,
+ newVal: stateVal,
},
{
- addr1,
- changeset.DefaultIncarnation,
- key3,
- block3Val,
- emptyVal,
+ addr: addr1,
+ inc: changeset.DefaultIncarnation,
+ key: key3,
+ oldVal: block3Val,
+ newVal: emptyVal,
},
{
- addr2,
- changeset.DefaultIncarnation,
- key3,
- block3Val,
- stateVal,
+ addr: addr2,
+ inc: changeset.DefaultIncarnation,
+ key: key3,
+ oldVal: block3Val,
+ newVal: stateVal,
},
})
@@ -732,16 +732,16 @@ func TestWalkAsOfUsingFixedBytesStatePlain(t *testing.T) {
block4Expected.Changes = []changeset.Change{
{
- withoutInc(addr1, key1),
- block3Val.Bytes(),
+ Key: withoutInc(addr1, key1),
+ Value: block3Val.Bytes(),
},
{
- withoutInc(addr1, key2),
- block3Val.Bytes(),
+ Key: withoutInc(addr1, key2),
+ Value: block3Val.Bytes(),
},
{
- withoutInc(addr1, key3),
- block3Val.Bytes(),
+ Key: withoutInc(addr1, key3),
+ Value: block3Val.Bytes(),
},
}
assertChangesEquals(t, block4, block4Expected)
@@ -780,12 +780,12 @@ func TestWalkAsOfUsingFixedBytesStatePlain(t *testing.T) {
block6Expected.Changes = []changeset.Change{
{
- withoutInc(addr1, key1),
- stateVal.Bytes(),
+ Key: withoutInc(addr1, key1),
+ Value: stateVal.Bytes(),
},
{
- withoutInc(addr1, key2),
- stateVal.Bytes(),
+ Key: withoutInc(addr1, key2),
+ Value: stateVal.Bytes(),
},
}
assertChangesEquals(t, block6, block6Expected)
@@ -848,37 +848,37 @@ func TestWalkAsOfAccountPlain(t *testing.T) {
writeBlockData(t, tds, 3, []accData{
{
- addrs[0],
- &emptyValAcc,
- block3ValAcc,
+ addr: addrs[0],
+ oldVal: &emptyValAcc,
+ newVal: block3ValAcc,
},
{
- addrs[2],
- &emptyValAcc,
- block3ValAcc,
+ addr: addrs[2],
+ oldVal: &emptyValAcc,
+ newVal: block3ValAcc,
},
{
- addrs[3],
- &emptyValAcc,
- block3ValAcc,
+ addr: addrs[3],
+ oldVal: &emptyValAcc,
+ newVal: block3ValAcc,
},
})
writeBlockData(t, tds, 5, []accData{
{
- addrs[0],
- block3ValAcc,
- stateValAcc,
+ addr: addrs[0],
+ oldVal: block3ValAcc,
+ newVal: stateValAcc,
},
{
- addrs[1],
- &emptyValAcc,
- stateValAcc,
+ addr: addrs[1],
+ oldVal: &emptyValAcc,
+ newVal: stateValAcc,
},
{
- addrs[3],
- block3ValAcc,
- nil,
+ addr: addrs[3],
+ oldVal: block3ValAcc,
+ newVal: nil,
},
})
@@ -905,16 +905,16 @@ func TestWalkAsOfAccountPlain(t *testing.T) {
block4Expected := &changeset.ChangeSet{
Changes: []changeset.Change{
{
- addrs[0].Bytes(),
- block3Val,
+ Key: addrs[0].Bytes(),
+ Value: block3Val,
},
{
- addrs[2].Bytes(),
- block3Val,
+ Key: addrs[2].Bytes(),
+ Value: block3Val,
},
{
- addrs[3].Bytes(),
- block3Val,
+ Key: addrs[3].Bytes(),
+ Value: block3Val,
},
},
}
@@ -937,16 +937,16 @@ func TestWalkAsOfAccountPlain(t *testing.T) {
block6Expected := &changeset.ChangeSet{
Changes: []changeset.Change{
{
- addrs[0].Bytes(),
- stateVal,
+ Key: addrs[0].Bytes(),
+ Value: stateVal,
},
{
- addrs[1].Bytes(),
- stateVal,
+ Key: addrs[1].Bytes(),
+ Value: stateVal,
},
{
- addrs[2].Bytes(),
- block3Val,
+ Key: addrs[2].Bytes(),
+ Value: block3Val,
},
},
}
@@ -1006,19 +1006,19 @@ func TestWalkAsOfAccountPlain_WithChunks(t *testing.T) {
writeBlockData(t, tds, 1, []accData{
{
- addrs[0],
- &emptyValAcc,
- addr1Old,
+ addr: addrs[0],
+ oldVal: &emptyValAcc,
+ newVal: addr1Old,
},
{
- addrs[1],
- &emptyValAcc,
- addr1Old,
+ addr: addrs[1],
+ oldVal: &emptyValAcc,
+ newVal: addr1Old,
},
{
- addrs[2],
- &emptyValAcc,
- addr1Old,
+ addr: addrs[2],
+ oldVal: &emptyValAcc,
+ newVal: addr1Old,
},
})
@@ -1031,19 +1031,19 @@ func TestWalkAsOfAccountPlain_WithChunks(t *testing.T) {
addr3New.Nonce = uint64(i)
writeBlockData(t, tds, uint64(i), []accData{
{
- addrs[0],
- addr1Old,
- addr1New,
+ addr: addrs[0],
+ oldVal: addr1Old,
+ newVal: addr1New,
},
{
- addrs[1],
- addr2Old,
- addr2New,
+ addr: addrs[1],
+ oldVal: addr2Old,
+ newVal: addr2New,
},
{
- addrs[2],
- addr3Old,
- addr3New,
+ addr: addrs[2],
+ oldVal: addr3Old,
+ newVal: addr3New,
},
})
addr1Old = addr1New.SelfCopy()
@@ -1060,19 +1060,19 @@ func TestWalkAsOfAccountPlain_WithChunks(t *testing.T) {
writeBlockData(t, tds, 1100, []accData{
{
- addrs[0],
- addr1Old,
- addr1New,
+ addr: addrs[0],
+ oldVal: addr1Old,
+ newVal: addr1New,
},
{
- addrs[1],
- addr1Old,
- addr1New,
+ addr: addrs[1],
+ oldVal: addr1Old,
+ newVal: addr1New,
},
{
- addrs[2],
- addr1Old,
- addr1New,
+ addr: addrs[2],
+ oldVal: addr1Old,
+ newVal: addr1New,
},
})
@@ -1139,25 +1139,25 @@ func TestWalkAsOfStoragePlain_WithChunks(t *testing.T) {
val := uint256.NewInt().SetBytes([]byte("block 1"))
writeStorageBlockData(t, tds, 1, []storageData{
{
- addrs[0],
- 1,
- key,
- emptyVal,
- val,
+ addr: addrs[0],
+ inc: 1,
+ key: key,
+ oldVal: emptyVal,
+ newVal: val,
},
{
- addrs[1],
- 1,
- key,
- emptyVal,
- val,
+ addr: addrs[1],
+ inc: 1,
+ key: key,
+ oldVal: emptyVal,
+ newVal: val,
},
{
- addrs[2],
- 1,
- key,
- emptyVal,
- val,
+ addr: addrs[2],
+ inc: 1,
+ key: key,
+ oldVal: emptyVal,
+ newVal: val,
},
})
@@ -1166,25 +1166,25 @@ func TestWalkAsOfStoragePlain_WithChunks(t *testing.T) {
val = uint256.NewInt().SetBytes([]byte("block " + strconv.Itoa(i)))
writeStorageBlockData(t, tds, uint64(i), []storageData{
{
- addrs[0],
- 1,
- key,
- prev,
- val,
+ addr: addrs[0],
+ inc: 1,
+ key: key,
+ oldVal: prev,
+ newVal: val,
},
{
- addrs[1],
- 1,
- key,
- prev,
- val,
+ addr: addrs[1],
+ inc: 1,
+ key: key,
+ oldVal: prev,
+ newVal: val,
},
{
- addrs[2],
- 1,
- key,
- prev,
- val,
+ addr: addrs[2],
+ inc: 1,
+ key: key,
+ oldVal: prev,
+ newVal: val,
},
})
prev = val
@@ -1194,25 +1194,25 @@ func TestWalkAsOfStoragePlain_WithChunks(t *testing.T) {
writeStorageBlockData(t, tds, 1100, []storageData{
{
- addrs[0],
- 1,
- key,
- prev,
- val,
+ addr: addrs[0],
+ inc: 1,
+ key: key,
+ oldVal: prev,
+ newVal: val,
},
{
- addrs[1],
- 1,
- key,
- prev,
- val,
+ addr: addrs[1],
+ inc: 1,
+ key: key,
+ oldVal: prev,
+ newVal: val,
},
{
- addrs[2],
- 1,
- key,
- prev,
- val,
+ addr: addrs[2],
+ inc: 1,
+ key: key,
+ oldVal: prev,
+ newVal: val,
},
})
diff --git a/eth/downloader/testchain_test.go b/eth/downloader/testchain_test.go
index 338604034bb02a1fad69e550170d5903d324a27e..b8a1059190793a28b7628d365e774088dbfe46b8 100644
--- a/eth/downloader/testchain_test.go
+++ b/eth/downloader/testchain_test.go
@@ -41,8 +41,8 @@ var (
testDb = ethdb.NewMemDatabase()
testGenesis = core.GenesisWithAccounts(testDb, []core.GenAccount{
- {testAddress,
- big.NewInt(1000000000),
+ {Addr: testAddress,
+ Balance: big.NewInt(1000000000),
},
})
diff --git a/eth/handler.go b/eth/handler.go
index 2c6240fa5529b8ea99d2bfcfcc852d9153914a45..26eefeb607f9135b9bbfbb94fe2298f5cddca514 100644
--- a/eth/handler.go
+++ b/eth/handler.go
@@ -1039,7 +1039,6 @@ func (pm *ProtocolManager) handleDebugMsg(p *debugPeer) error {
default:
return errResp(ErrInvalidMsgCode, "%v", msg.Code)
}
- return nil
}
// BroadcastBlock will either propagate a block to a subset of its peers, or
diff --git a/eth/stagedsync/stage_log_index.go b/eth/stagedsync/stage_log_index.go
index 7c737376dbc56c6a4d68cb73f1efcc649b312a4d..dc7418e3a79fc365c1e555efa61c032105504f2a 100644
--- a/eth/stagedsync/stage_log_index.go
+++ b/eth/stagedsync/stage_log_index.go
@@ -188,8 +188,6 @@ func promoteLogIndex(logPrefix string, db ethdb.Database, start uint64, bufLimit
}
return next(k, chunkKey, buf.Bytes())
})
- currentBitmap.Clear()
- return nil
}
if err := collectorTopics.Load(logPrefix, db, dbutils.LogTopicIndex, loaderFunc, etl.TransformArgs{Quit: quit}); err != nil {
diff --git a/turbo/snapshotsync/bittorrent/logger.go b/turbo/snapshotsync/bittorrent/logger.go
index 2f4c5d439c2d46b2474db7af5e30b8a22f25df82..b78d4b75ef22515bd2da7c0ab6a91c586198f6b3 100644
--- a/turbo/snapshotsync/bittorrent/logger.go
+++ b/turbo/snapshotsync/bittorrent/logger.go
@@ -10,7 +10,7 @@ func init() {
}
func NewAdapterLogger() lg.Logger {
return lg.Logger{
- lg.LoggerImpl(adapterLogger{}),
+ LoggerImpl: lg.LoggerImpl(adapterLogger{}),
}
}