roysc/plugeth
1
0
Fork 0
forked from cerc-io/plugeth
Code Pull Requests Activity

all: gofmt -w -s

Browse Source
This commit is contained in:
Felix Lange 2017-01-06 15:52:03 +01:00
parent e0fde02290
commit 35a7dcb162
64 changed files with 343 additions and 343 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

28
accounts/abi/abi_test.go
View File

@ -67,10 +67,10 @@ func TestTypeCheck(t *testing.T) {
{"uint16[3]", [4]uint16{1, 2, 3}, "abi: cannot use [4]uint16 as type [3]uint16 as argument"}, {"uint16[3]", [4]uint16{1, 2, 3}, "abi: cannot use [4]uint16 as type [3]uint16 as argument"},
{"uint16[3]", []uint16{1, 2, 3}, ""}, {"uint16[3]", []uint16{1, 2, 3}, ""},
{"uint16[3]", []uint16{1, 2, 3, 4}, "abi: cannot use [4]uint16 as type [3]uint16 as argument"}, {"uint16[3]", []uint16{1, 2, 3, 4}, "abi: cannot use [4]uint16 as type [3]uint16 as argument"},
{"address[]", []common.Address{common.Address{1}}, ""}, {"address[]", []common.Address{{1}}, ""},
{"address[1]", []common.Address{common.Address{1}}, ""}, {"address[1]", []common.Address{{1}}, ""},
{"address[1]", [1]common.Address{common.Address{1}}, ""}, {"address[1]", [1]common.Address{{1}}, ""},
{"address[2]", [1]common.Address{common.Address{1}}, "abi: cannot use [1]array as type [2]array as argument"}, {"address[2]", [1]common.Address{{1}}, "abi: cannot use [1]array as type [2]array as argument"},
{"bytes32", [32]byte{}, ""}, {"bytes32", [32]byte{}, ""},
{"bytes32", [33]byte{}, "abi: cannot use [33]uint8 as type [32]uint8 as argument"}, {"bytes32", [33]byte{}, "abi: cannot use [33]uint8 as type [32]uint8 as argument"},
{"bytes32", common.Hash{1}, ""}, {"bytes32", common.Hash{1}, ""},
@ -80,7 +80,7 @@ func TestTypeCheck(t *testing.T) {
{"bytes", [2]byte{0, 1}, ""}, {"bytes", [2]byte{0, 1}, ""},
{"bytes", common.Hash{1}, ""}, {"bytes", common.Hash{1}, ""},
{"string", "hello world", ""}, {"string", "hello world", ""},
{"bytes32[]", [][32]byte{[32]byte{}}, ""}, {"bytes32[]", [][32]byte{{}}, ""},
{"function", [24]byte{}, ""}, {"function", [24]byte{}, ""},
} { } {
typ, err := NewType(test.typ) typ, err := NewType(test.typ)
@ -343,8 +343,8 @@ func TestPack(t *testing.T) {
{"uint16[]", []uint16{1, 2}, formatSliceOutput([]byte{1}, []byte{2})}, {"uint16[]", []uint16{1, 2}, formatSliceOutput([]byte{1}, []byte{2})},
{"bytes20", [20]byte{1}, pad([]byte{1}, 32, false)}, {"bytes20", [20]byte{1}, pad([]byte{1}, 32, false)},
{"uint256[]", []*big.Int{big.NewInt(1), big.NewInt(2)}, formatSliceOutput([]byte{1}, []byte{2})}, {"uint256[]", []*big.Int{big.NewInt(1), big.NewInt(2)}, formatSliceOutput([]byte{1}, []byte{2})},
{"address[]", []common.Address{common.Address{1}, common.Address{2}}, formatSliceOutput(pad([]byte{1}, 20, false), pad([]byte{2}, 20, false))}, {"address[]", []common.Address{{1}, {2}}, formatSliceOutput(pad([]byte{1}, 20, false), pad([]byte{2}, 20, false))},
{"bytes32[]", []common.Hash{common.Hash{1}, common.Hash{2}}, formatSliceOutput(pad([]byte{1}, 32, false), pad([]byte{2}, 32, false))}, {"bytes32[]", []common.Hash{{1}, {2}}, formatSliceOutput(pad([]byte{1}, 32, false), pad([]byte{2}, 32, false))},
{"function", [24]byte{1}, pad([]byte{1}, 32, false)}, {"function", [24]byte{1}, pad([]byte{1}, 32, false)},
} { } {
typ, err := NewType(test.typ) typ, err := NewType(test.typ)
@ -458,12 +458,12 @@ func TestReader(t *testing.T) {
Uint256, _ := NewType("uint256") Uint256, _ := NewType("uint256")
exp := ABI{ exp := ABI{
Methods: map[string]Method{ Methods: map[string]Method{
"balance": Method{ "balance": {
"balance", true, nil, nil, "balance", true, nil, nil,
}, },
"send": Method{ "send": {
"send", false, []Argument{ "send", false, []Argument{
Argument{"amount", Uint256, false}, {"amount", Uint256, false},
}, nil, }, nil,
}, },
}, },
@ -562,7 +562,7 @@ func TestTestSlice(t *testing.T) {
func TestMethodSignature(t *testing.T) { func TestMethodSignature(t *testing.T) {
String, _ := NewType("string") String, _ := NewType("string")
m := Method{"foo", false, []Argument{Argument{"bar", String, false}, Argument{"baz", String, false}}, nil} m := Method{"foo", false, []Argument{{"bar", String, false}, {"baz", String, false}}, nil}
exp := "foo(string,string)" exp := "foo(string,string)"
if m.Sig() != exp { if m.Sig() != exp {
t.Error("signature mismatch", exp, "!=", m.Sig()) t.Error("signature mismatch", exp, "!=", m.Sig())
@ -574,7 +574,7 @@ func TestMethodSignature(t *testing.T) {
} }
uintt, _ := NewType("uint") uintt, _ := NewType("uint")
m = Method{"foo", false, []Argument{Argument{"bar", uintt, false}}, nil} m = Method{"foo", false, []Argument{{"bar", uintt, false}}, nil}
exp = "foo(uint256)" exp = "foo(uint256)"
if m.Sig() != exp { if m.Sig() != exp {
t.Error("signature mismatch", exp, "!=", m.Sig()) t.Error("signature mismatch", exp, "!=", m.Sig())
@ -779,8 +779,8 @@ func TestBareEvents(t *testing.T) {
"balance": {false, nil}, "balance": {false, nil},
"anon": {true, nil}, "anon": {true, nil},
"args": {false, []Argument{ "args": {false, []Argument{
Argument{Name: "arg0", Type: arg0, Indexed: false}, {Name: "arg0", Type: arg0, Indexed: false},
Argument{Name: "arg1", Type: arg1, Indexed: true}, {Name: "arg1", Type: arg1, Indexed: true},
}}, }},
} }

2
build/ci.go
View File

@ -195,7 +195,7 @@ func doInstall(cmdline []string) {
if err != nil { if err != nil {
log.Fatal(err) log.Fatal(err)
} }
for name, _ := range pkgs { for name := range pkgs {
if name == "main" { if name == "main" {
gobuild := goToolArch(*arch, "build", buildFlags(env)...) gobuild := goToolArch(*arch, "build", buildFlags(env)...)
gobuild.Args = append(gobuild.Args, "-v") gobuild.Args = append(gobuild.Args, "-v")

6
cmd/swarm/main.go
View File

@ -129,7 +129,7 @@ func init() {
app.HideVersion = true // we have a command to print the version app.HideVersion = true // we have a command to print the version
app.Copyright = "Copyright 2013-2016 The go-ethereum Authors" app.Copyright = "Copyright 2013-2016 The go-ethereum Authors"
app.Commands = []cli.Command{ app.Commands = []cli.Command{
cli.Command{ {
Action: version, Action: version,
Name: "version", Name: "version",
Usage: "Print version numbers", Usage: "Print version numbers",
@ -138,7 +138,7 @@ func init() {
The output of this command is supposed to be machine-readable. The output of this command is supposed to be machine-readable.
`, `,
}, },
cli.Command{ {
Action: upload, Action: upload,
Name: "up", Name: "up",
Usage: "upload a file or directory to swarm using the HTTP API", Usage: "upload a file or directory to swarm using the HTTP API",
@ -147,7 +147,7 @@ The output of this command is supposed to be machine-readable.
"upload a file or directory to swarm using the HTTP API and prints the root hash", "upload a file or directory to swarm using the HTTP API and prints the root hash",
`, `,
}, },
cli.Command{ {
Action: hash, Action: hash,
Name: "hash", Name: "hash",
Usage: "print the swarm hash of a file or directory", Usage: "print the swarm hash of a file or directory",

2
common/bytes.go
View File

@ -143,7 +143,7 @@ func Hex2BytesFixed(str string, flen int) []byte {
return h return h
} else { } else {
if len(h) > flen { if len(h) > flen {
return h[len(h)-flen : len(h)] return h[len(h)-flen:]
} else { } else {
hh := make([]byte, flen) hh := make([]byte, flen)
copy(hh[flen-len(h):flen], h[:]) copy(hh[flen-len(h):flen], h[:])

36
common/math/dist_test.go
View File

@ -41,24 +41,24 @@ func TestSum(t *testing.T) {
func TestDist(t *testing.T) { func TestDist(t *testing.T) {
var vectors = []Vector{ var vectors = []Vector{
Vector{big.NewInt(1000), big.NewInt(1234)}, {big.NewInt(1000), big.NewInt(1234)},
Vector{big.NewInt(500), big.NewInt(10023)}, {big.NewInt(500), big.NewInt(10023)},
Vector{big.NewInt(1034), big.NewInt(1987)}, {big.NewInt(1034), big.NewInt(1987)},
Vector{big.NewInt(1034), big.NewInt(1987)}, {big.NewInt(1034), big.NewInt(1987)},
Vector{big.NewInt(8983), big.NewInt(1977)}, {big.NewInt(8983), big.NewInt(1977)},
Vector{big.NewInt(98382), big.NewInt(1887)}, {big.NewInt(98382), big.NewInt(1887)},
Vector{big.NewInt(12398), big.NewInt(1287)}, {big.NewInt(12398), big.NewInt(1287)},
Vector{big.NewInt(12398), big.NewInt(1487)}, {big.NewInt(12398), big.NewInt(1487)},
Vector{big.NewInt(12398), big.NewInt(1987)}, {big.NewInt(12398), big.NewInt(1987)},
Vector{big.NewInt(12398), big.NewInt(128)}, {big.NewInt(12398), big.NewInt(128)},
Vector{big.NewInt(12398), big.NewInt(1987)}, {big.NewInt(12398), big.NewInt(1987)},
Vector{big.NewInt(1398), big.NewInt(187)}, {big.NewInt(1398), big.NewInt(187)},
Vector{big.NewInt(12328), big.NewInt(1927)}, {big.NewInt(12328), big.NewInt(1927)},
Vector{big.NewInt(12398), big.NewInt(1987)}, {big.NewInt(12398), big.NewInt(1987)},
Vector{big.NewInt(22398), big.NewInt(1287)}, {big.NewInt(22398), big.NewInt(1287)},
Vector{big.NewInt(1370), big.NewInt(1981)}, {big.NewInt(1370), big.NewInt(1981)},
Vector{big.NewInt(12398), big.NewInt(1957)}, {big.NewInt(12398), big.NewInt(1957)},
Vector{big.NewInt(42198), big.NewInt(1987)}, {big.NewInt(42198), big.NewInt(1987)},
} }
VectorsBy(GasSort).Sort(vectors) VectorsBy(GasSort).Sort(vectors)

2
core/blockchain.go
View File

@ -150,7 +150,7 @@ func NewBlockChain(chainDb ethdb.Database, config *params.ChainConfig, pow pow.P
return nil, err return nil, err
} }
// Check the current state of the block hashes and make sure that we do not have any of the bad blocks in our chain // Check the current state of the block hashes and make sure that we do not have any of the bad blocks in our chain
for hash, _ := range BadHashes { for hash := range BadHashes {
if header := bc.GetHeaderByHash(hash); header != nil { if header := bc.GetHeaderByHash(hash); header != nil {
// get the canonical block corresponding to the offending header's number // get the canonical block corresponding to the offending header's number
headerByNumber := bc.GetHeaderByNumber(header.Number.Uint64()) headerByNumber := bc.GetHeaderByNumber(header.Number.Uint64())

2
core/blockchain_test.go
View File

@ -1107,7 +1107,7 @@ func TestCanonicalBlockRetrieval(t *testing.T) {
chain, _ := GenerateChain(params.TestChainConfig, genesis, db, 10, func(i int, gen *BlockGen) {}) chain, _ := GenerateChain(params.TestChainConfig, genesis, db, 10, func(i int, gen *BlockGen) {})
for i, _ := range chain { for i := range chain {
go func(block *types.Block) { go func(block *types.Block) {
// try to retrieve a block by its canonical hash and see if the block data can be retrieved. // try to retrieve a block by its canonical hash and see if the block data can be retrieved.
for { for {

2
core/state/iterator_test.go
View File

@ -41,7 +41,7 @@ func TestNodeIteratorCoverage(t *testing.T) {
} }
} }
// Cross check the hashes and the database itself // Cross check the hashes and the database itself
for hash, _ := range hashes { for hash := range hashes {
if _, err := db.Get(hash.Bytes()); err != nil { if _, err := db.Get(hash.Bytes()); err != nil {
t.Errorf("failed to retrieve reported node %x: %v", hash, err) t.Errorf("failed to retrieve reported node %x: %v", hash, err)
} }

6
core/state/managed_state_test.go
View File

@ -52,7 +52,7 @@ func TestRemove(t *testing.T) {
ms, account := create() ms, account := create()
nn := make([]bool, 10) nn := make([]bool, 10)
for i, _ := range nn { for i := range nn {
nn[i] = true nn[i] = true
} }
account.nonces = append(account.nonces, nn...) account.nonces = append(account.nonces, nn...)
@ -68,7 +68,7 @@ func TestReuse(t *testing.T) {
ms, account := create() ms, account := create()
nn := make([]bool, 10) nn := make([]bool, 10)
for i, _ := range nn { for i := range nn {
nn[i] = true nn[i] = true
} }
account.nonces = append(account.nonces, nn...) account.nonces = append(account.nonces, nn...)
@ -84,7 +84,7 @@ func TestReuse(t *testing.T) {
func TestRemoteNonceChange(t *testing.T) { func TestRemoteNonceChange(t *testing.T) {
ms, account := create() ms, account := create()
nn := make([]bool, 10) nn := make([]bool, 10)
for i, _ := range nn { for i := range nn {
nn[i] = true nn[i] = true
} }
account.nonces = append(account.nonces, nn...) account.nonces = append(account.nonces, nn...)

6
core/state/statedb.go
View File

@ -479,7 +479,7 @@ func (self *StateDB) Copy() *StateDB {
logSize: self.logSize, logSize: self.logSize,
} }
// Copy the dirty states and logs // Copy the dirty states and logs
for addr, _ := range self.stateObjectsDirty { for addr := range self.stateObjectsDirty {
state.stateObjects[addr] = self.stateObjects[addr].deepCopy(state, state.MarkStateObjectDirty) state.stateObjects[addr] = self.stateObjects[addr].deepCopy(state, state.MarkStateObjectDirty)
state.stateObjectsDirty[addr] = struct{}{} state.stateObjectsDirty[addr] = struct{}{}
} }
@ -530,7 +530,7 @@ func (self *StateDB) GetRefund() *big.Int {
// It is called in between transactions to get the root hash that // It is called in between transactions to get the root hash that
// goes into transaction receipts. // goes into transaction receipts.
func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash { func (s *StateDB) IntermediateRoot(deleteEmptyObjects bool) common.Hash {
for addr, _ := range s.stateObjectsDirty { for addr := range s.stateObjectsDirty {
stateObject := s.stateObjects[addr] stateObject := s.stateObjects[addr]
if stateObject.suicided || (deleteEmptyObjects && stateObject.empty()) { if stateObject.suicided || (deleteEmptyObjects && stateObject.empty()) {
s.deleteStateObject(stateObject) s.deleteStateObject(stateObject)
@ -553,7 +553,7 @@ func (s *StateDB) DeleteSuicides() {
// Reset refund so that any used-gas calculations can use this method. // Reset refund so that any used-gas calculations can use this method.
s.clearJournalAndRefund() s.clearJournalAndRefund()
for addr, _ := range s.stateObjectsDirty { for addr := range s.stateObjectsDirty {
stateObject := s.stateObjects[addr] stateObject := s.stateObjects[addr]
// If the object has been removed by a suicide // If the object has been removed by a suicide

4
core/state/sync_test.go
View File

@ -198,7 +198,7 @@ func testIterativeRandomStateSync(t *testing.T, batch int) {
for len(queue) > 0 { for len(queue) > 0 {
// Fetch all the queued nodes in a random order // Fetch all the queued nodes in a random order
results := make([]trie.SyncResult, 0, len(queue)) results := make([]trie.SyncResult, 0, len(queue))
for hash, _ := range queue { for hash := range queue {
data, err := srcDb.Get(hash.Bytes()) data, err := srcDb.Get(hash.Bytes())
if err != nil { if err != nil {
t.Fatalf("failed to retrieve node data for %x: %v", hash, err) t.Fatalf("failed to retrieve node data for %x: %v", hash, err)
@ -235,7 +235,7 @@ func TestIterativeRandomDelayedStateSync(t *testing.T) {
for len(queue) > 0 { for len(queue) > 0 {
// Sync only half of the scheduled nodes, even those in random order // Sync only half of the scheduled nodes, even those in random order
results := make([]trie.SyncResult, 0, len(queue)/2+1) results := make([]trie.SyncResult, 0, len(queue)/2+1)
for hash, _ := range queue { for hash := range queue {
delete(queue, hash) delete(queue, hash)
data, err := srcDb.Get(hash.Bytes()) data, err := srcDb.Get(hash.Bytes())

2
core/tx_list.go
View File

@ -110,7 +110,7 @@ func (m *txSortedMap) Filter(filter func(*types.Transaction) bool) types.Transac
// If transactions were removed, the heap and cache are ruined // If transactions were removed, the heap and cache are ruined
if len(removed) > 0 { if len(removed) > 0 {
*m.index = make([]uint64, 0, len(m.items)) *m.index = make([]uint64, 0, len(m.items))
for nonce, _ := range m.items { for nonce := range m.items {
*m.index = append(*m.index, nonce) *m.index = append(*m.index, nonce)
} }
heap.Init(m.index) heap.Init(m.index)

2
core/tx_pool.go
View File

@ -609,7 +609,7 @@ func (pool *TxPool) promoteExecutables(state *state.StateDB) {
if queued > maxQueuedInTotal { if queued > maxQueuedInTotal {
// Sort all accounts with queued transactions by heartbeat // Sort all accounts with queued transactions by heartbeat
addresses := make(addresssByHeartbeat, 0, len(pool.queue)) addresses := make(addresssByHeartbeat, 0, len(pool.queue))
for addr, _ := range pool.queue { for addr := range pool.queue {
addresses = append(addresses, addressByHeartbeat{addr, pool.beats[addr]}) addresses = append(addresses, addressByHeartbeat{addr, pool.beats[addr]})
} }
sort.Sort(addresses) sort.Sort(addresses)

260
core/vm/jump_table.go
View File

@ -52,283 +52,283 @@ var defaultJumpTable = NewJumpTable()
func NewJumpTable() [256]operation { func NewJumpTable() [256]operation {
return [256]operation{ return [256]operation{
ADD: operation{ ADD: {
execute: opAdd, execute: opAdd,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
SUB: operation{ SUB: {
execute: opSub, execute: opSub,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
MUL: operation{ MUL: {
execute: opMul, execute: opMul,
gasCost: constGasFunc(GasFastStep), gasCost: constGasFunc(GasFastStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
DIV: operation{ DIV: {
execute: opDiv, execute: opDiv,
gasCost: constGasFunc(GasFastStep), gasCost: constGasFunc(GasFastStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
SDIV: operation{ SDIV: {
execute: opSdiv, execute: opSdiv,
gasCost: constGasFunc(GasFastStep), gasCost: constGasFunc(GasFastStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
MOD: operation{ MOD: {
execute: opMod, execute: opMod,
gasCost: constGasFunc(GasFastStep), gasCost: constGasFunc(GasFastStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
SMOD: operation{ SMOD: {
execute: opSmod, execute: opSmod,
gasCost: constGasFunc(GasFastStep), gasCost: constGasFunc(GasFastStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
EXP: operation{ EXP: {
execute: opExp, execute: opExp,
gasCost: gasExp, gasCost: gasExp,
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
SIGNEXTEND: operation{ SIGNEXTEND: {
execute: opSignExtend, execute: opSignExtend,
gasCost: constGasFunc(GasFastStep), gasCost: constGasFunc(GasFastStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
NOT: operation{ NOT: {
execute: opNot, execute: opNot,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(1, 1), validateStack: makeStackFunc(1, 1),
valid: true, valid: true,
}, },
LT: operation{ LT: {
execute: opLt, execute: opLt,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
GT: operation{ GT: {
execute: opGt, execute: opGt,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
SLT: operation{ SLT: {
execute: opSlt, execute: opSlt,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
SGT: operation{ SGT: {
execute: opSgt, execute: opSgt,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
EQ: operation{ EQ: {
execute: opEq, execute: opEq,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
ISZERO: operation{ ISZERO: {
execute: opIszero, execute: opIszero,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(1, 1), validateStack: makeStackFunc(1, 1),
valid: true, valid: true,
}, },
AND: operation{ AND: {
execute: opAnd, execute: opAnd,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
OR: operation{ OR: {
execute: opOr, execute: opOr,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
XOR: operation{ XOR: {
execute: opXor, execute: opXor,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
BYTE: operation{ BYTE: {
execute: opByte, execute: opByte,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
ADDMOD: operation{ ADDMOD: {
execute: opAddmod, execute: opAddmod,
gasCost: constGasFunc(GasMidStep), gasCost: constGasFunc(GasMidStep),
validateStack: makeStackFunc(3, 1), validateStack: makeStackFunc(3, 1),
valid: true, valid: true,
}, },
MULMOD: operation{ MULMOD: {
execute: opMulmod, execute: opMulmod,
gasCost: constGasFunc(GasMidStep), gasCost: constGasFunc(GasMidStep),
validateStack: makeStackFunc(3, 1), validateStack: makeStackFunc(3, 1),
valid: true, valid: true,
}, },
SHA3: operation{ SHA3: {
execute: opSha3, execute: opSha3,
gasCost: gasSha3, gasCost: gasSha3,
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
memorySize: memorySha3, memorySize: memorySha3,
valid: true, valid: true,
}, },
ADDRESS: operation{ ADDRESS: {
execute: opAddress, execute: opAddress,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
BALANCE: operation{ BALANCE: {
execute: opBalance, execute: opBalance,
gasCost: gasBalance, gasCost: gasBalance,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
ORIGIN: operation{ ORIGIN: {
execute: opOrigin, execute: opOrigin,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
CALLER: operation{ CALLER: {
execute: opCaller, execute: opCaller,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
CALLVALUE: operation{ CALLVALUE: {
execute: opCallValue, execute: opCallValue,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
CALLDATALOAD: operation{ CALLDATALOAD: {
execute: opCalldataLoad, execute: opCalldataLoad,
gasCost: constGasFunc(GasFastestStep), gasCost: constGasFunc(GasFastestStep),
validateStack: makeStackFunc(1, 1), validateStack: makeStackFunc(1, 1),
valid: true, valid: true,
}, },
CALLDATASIZE: operation{ CALLDATASIZE: {
execute: opCalldataSize, execute: opCalldataSize,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
CALLDATACOPY: operation{ CALLDATACOPY: {
execute: opCalldataCopy, execute: opCalldataCopy,
gasCost: gasCalldataCopy, gasCost: gasCalldataCopy,
validateStack: makeStackFunc(3, 1), validateStack: makeStackFunc(3, 1),
memorySize: memoryCalldataCopy, memorySize: memoryCalldataCopy,
valid: true, valid: true,
}, },
CODESIZE: operation{ CODESIZE: {
execute: opCodeSize, execute: opCodeSize,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
EXTCODESIZE: operation{ EXTCODESIZE: {
execute: opExtCodeSize, execute: opExtCodeSize,
gasCost: gasExtCodeSize, gasCost: gasExtCodeSize,
validateStack: makeStackFunc(1, 1), validateStack: makeStackFunc(1, 1),
valid: true, valid: true,
}, },
CODECOPY: operation{ CODECOPY: {
execute: opCodeCopy, execute: opCodeCopy,
gasCost: gasCodeCopy, gasCost: gasCodeCopy,
validateStack: makeStackFunc(3, 0), validateStack: makeStackFunc(3, 0),
memorySize: memoryCodeCopy, memorySize: memoryCodeCopy,
valid: true, valid: true,
}, },
EXTCODECOPY: operation{ EXTCODECOPY: {
execute: opExtCodeCopy, execute: opExtCodeCopy,
gasCost: gasExtCodeCopy, gasCost: gasExtCodeCopy,
validateStack: makeStackFunc(4, 0), validateStack: makeStackFunc(4, 0),
memorySize: memoryExtCodeCopy, memorySize: memoryExtCodeCopy,
valid: true, valid: true,
}, },
GASPRICE: operation{ GASPRICE: {
execute: opGasprice, execute: opGasprice,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
BLOCKHASH: operation{ BLOCKHASH: {
execute: opBlockhash, execute: opBlockhash,
gasCost: constGasFunc(GasExtStep), gasCost: constGasFunc(GasExtStep),
validateStack: makeStackFunc(1, 1), validateStack: makeStackFunc(1, 1),
valid: true, valid: true,
}, },
COINBASE: operation{ COINBASE: {
execute: opCoinbase, execute: opCoinbase,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
TIMESTAMP: operation{ TIMESTAMP: {
execute: opTimestamp, execute: opTimestamp,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
NUMBER: operation{ NUMBER: {
execute: opNumber, execute: opNumber,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
DIFFICULTY: operation{ DIFFICULTY: {
execute: opDifficulty, execute: opDifficulty,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
GASLIMIT: operation{ GASLIMIT: {
execute: opGasLimit, execute: opGasLimit,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
POP: operation{ POP: {
execute: opPop, execute: opPop,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(1, 0), validateStack: makeStackFunc(1, 0),
valid: true, valid: true,
}, },
MLOAD: operation{ MLOAD: {
execute: opMload, execute: opMload,
gasCost: gasMLoad, gasCost: gasMLoad,
validateStack: makeStackFunc(1, 1), validateStack: makeStackFunc(1, 1),
memorySize: memoryMLoad, memorySize: memoryMLoad,
valid: true, valid: true,
}, },
MSTORE: operation{ MSTORE: {
execute: opMstore, execute: opMstore,
gasCost: gasMStore, gasCost: gasMStore,
validateStack: makeStackFunc(2, 0), validateStack: makeStackFunc(2, 0),
memorySize: memoryMStore, memorySize: memoryMStore,
valid: true, valid: true,
}, },
MSTORE8: operation{ MSTORE8: {
execute: opMstore8, execute: opMstore8,
gasCost: gasMStore8, gasCost: gasMStore8,
memorySize: memoryMStore8, memorySize: memoryMStore8,
@ -336,71 +336,71 @@ func NewJumpTable() [256]operation {
valid: true, valid: true,
}, },
SLOAD: operation{ SLOAD: {
execute: opSload, execute: opSload,
gasCost: gasSLoad, gasCost: gasSLoad,
validateStack: makeStackFunc(1, 1), validateStack: makeStackFunc(1, 1),
valid: true, valid: true,
}, },
SSTORE: operation{ SSTORE: {
execute: opSstore, execute: opSstore,
gasCost: gasSStore, gasCost: gasSStore,
validateStack: makeStackFunc(2, 0), validateStack: makeStackFunc(2, 0),
valid: true, valid: true,
}, },
JUMPDEST: operation{ JUMPDEST: {
execute: opJumpdest, execute: opJumpdest,
gasCost: constGasFunc(params.JumpdestGas), gasCost: constGasFunc(params.JumpdestGas),
validateStack: makeStackFunc(0, 0), validateStack: makeStackFunc(0, 0),
valid: true, valid: true,
}, },
PC: operation{ PC: {
execute: opPc, execute: opPc,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
MSIZE: operation{ MSIZE: {
execute: opMsize, execute: opMsize,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
GAS: operation{ GAS: {
execute: opGas, execute: opGas,
gasCost: constGasFunc(GasQuickStep), gasCost: constGasFunc(GasQuickStep),
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
CREATE: operation{ CREATE: {
execute: opCreate, execute: opCreate,
gasCost: gasCreate, gasCost: gasCreate,
validateStack: makeStackFunc(3, 1), validateStack: makeStackFunc(3, 1),
memorySize: memoryCreate, memorySize: memoryCreate,
valid: true, valid: true,
}, },
CALL: operation{ CALL: {
execute: opCall, execute: opCall,
gasCost: gasCall, gasCost: gasCall,
validateStack: makeStackFunc(7, 1), validateStack: makeStackFunc(7, 1),
memorySize: memoryCall, memorySize: memoryCall,
valid: true, valid: true,
}, },
CALLCODE: operation{ CALLCODE: {
execute: opCallCode, execute: opCallCode,
gasCost: gasCallCode, gasCost: gasCallCode,
validateStack: makeStackFunc(7, 1), validateStack: makeStackFunc(7, 1),
memorySize: memoryCall, memorySize: memoryCall,
valid: true, valid: true,
}, },
DELEGATECALL: operation{ DELEGATECALL: {
execute: opDelegateCall, execute: opDelegateCall,
gasCost: gasDelegateCall, gasCost: gasDelegateCall,
validateStack: makeStackFunc(6, 1), validateStack: makeStackFunc(6, 1),
memorySize: memoryDelegateCall, memorySize: memoryDelegateCall,
valid: true, valid: true,
}, },
RETURN: operation{ RETURN: {
execute: opReturn, execute: opReturn,
gasCost: gasReturn, gasCost: gasReturn,
validateStack: makeStackFunc(2, 0), validateStack: makeStackFunc(2, 0),
@ -408,448 +408,448 @@ func NewJumpTable() [256]operation {
halts: true, halts: true,
valid: true, valid: true,
}, },
SUICIDE: operation{ SUICIDE: {
execute: opSuicide, execute: opSuicide,
gasCost: gasSuicide, gasCost: gasSuicide,
validateStack: makeStackFunc(1, 0), validateStack: makeStackFunc(1, 0),
halts: true, halts: true,
valid: true, valid: true,
}, },
JUMP: operation{ JUMP: {
execute: opJump, execute: opJump,
gasCost: constGasFunc(GasMidStep), gasCost: constGasFunc(GasMidStep),
validateStack: makeStackFunc(1, 0), validateStack: makeStackFunc(1, 0),
jumps: true, jumps: true,
valid: true, valid: true,
}, },
JUMPI: operation{ JUMPI: {
execute: opJumpi, execute: opJumpi,
gasCost: constGasFunc(GasSlowStep), gasCost: constGasFunc(GasSlowStep),
validateStack: makeStackFunc(2, 0), validateStack: makeStackFunc(2, 0),
jumps: true, jumps: true,
valid: true, valid: true,
}, },
STOP: operation{ STOP: {
execute: opStop, execute: opStop,
gasCost: constGasFunc(Zero), gasCost: constGasFunc(Zero),
validateStack: makeStackFunc(0, 0), validateStack: makeStackFunc(0, 0),
halts: true, halts: true,
valid: true, valid: true,
}, },
LOG0: operation{ LOG0: {
execute: makeLog(0), execute: makeLog(0),
gasCost: makeGasLog(0), gasCost: makeGasLog(0),
validateStack: makeStackFunc(2, 0), validateStack: makeStackFunc(2, 0),
memorySize: memoryLog, memorySize: memoryLog,
valid: true, valid: true,
}, },
LOG1: operation{ LOG1: {
execute: makeLog(1), execute: makeLog(1),
gasCost: makeGasLog(1), gasCost: makeGasLog(1),
validateStack: makeStackFunc(3, 0), validateStack: makeStackFunc(3, 0),
memorySize: memoryLog, memorySize: memoryLog,
valid: true, valid: true,
}, },
LOG2: operation{ LOG2: {
execute: makeLog(2), execute: makeLog(2),
gasCost: makeGasLog(2), gasCost: makeGasLog(2),
validateStack: makeStackFunc(4, 0), validateStack: makeStackFunc(4, 0),
memorySize: memoryLog, memorySize: memoryLog,
valid: true, valid: true,
}, },
LOG3: operation{ LOG3: {
execute: makeLog(3), execute: makeLog(3),
gasCost: makeGasLog(3), gasCost: makeGasLog(3),
validateStack: makeStackFunc(5, 0), validateStack: makeStackFunc(5, 0),
memorySize: memoryLog, memorySize: memoryLog,
valid: true, valid: true,
}, },
LOG4: operation{ LOG4: {
execute: makeLog(4), execute: makeLog(4),
gasCost: makeGasLog(4), gasCost: makeGasLog(4),
validateStack: makeStackFunc(6, 0), validateStack: makeStackFunc(6, 0),
memorySize: memoryLog, memorySize: memoryLog,
valid: true, valid: true,
}, },
SWAP1: operation{ SWAP1: {
execute: makeSwap(1), execute: makeSwap(1),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(2, 0), validateStack: makeStackFunc(2, 0),
valid: true, valid: true,
}, },
SWAP2: operation{ SWAP2: {
execute: makeSwap(2), execute: makeSwap(2),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(3, 0), validateStack: makeStackFunc(3, 0),
valid: true, valid: true,
}, },
SWAP3: operation{ SWAP3: {
execute: makeSwap(3), execute: makeSwap(3),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(4, 0), validateStack: makeStackFunc(4, 0),
valid: true, valid: true,
}, },
SWAP4: operation{ SWAP4: {
execute: makeSwap(4), execute: makeSwap(4),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(5, 0), validateStack: makeStackFunc(5, 0),
valid: true, valid: true,
}, },
SWAP5: operation{ SWAP5: {
execute: makeSwap(5), execute: makeSwap(5),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(6, 0), validateStack: makeStackFunc(6, 0),
valid: true, valid: true,
}, },
SWAP6: operation{ SWAP6: {
execute: makeSwap(6), execute: makeSwap(6),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(7, 0), validateStack: makeStackFunc(7, 0),
valid: true, valid: true,
}, },
SWAP7: operation{ SWAP7: {
execute: makeSwap(7), execute: makeSwap(7),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(8, 0), validateStack: makeStackFunc(8, 0),
valid: true, valid: true,
}, },
SWAP8: operation{ SWAP8: {
execute: makeSwap(8), execute: makeSwap(8),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(9, 0), validateStack: makeStackFunc(9, 0),
valid: true, valid: true,
}, },
SWAP9: operation{ SWAP9: {
execute: makeSwap(9), execute: makeSwap(9),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(10, 0), validateStack: makeStackFunc(10, 0),
valid: true, valid: true,
}, },
SWAP10: operation{ SWAP10: {
execute: makeSwap(10), execute: makeSwap(10),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(11, 0), validateStack: makeStackFunc(11, 0),
valid: true, valid: true,
}, },
SWAP11: operation{ SWAP11: {
execute: makeSwap(11), execute: makeSwap(11),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(12, 0), validateStack: makeStackFunc(12, 0),
valid: true, valid: true,
}, },
SWAP12: operation{ SWAP12: {
execute: makeSwap(12), execute: makeSwap(12),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(13, 0), validateStack: makeStackFunc(13, 0),
valid: true, valid: true,
}, },
SWAP13: operation{ SWAP13: {
execute: makeSwap(13), execute: makeSwap(13),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(14, 0), validateStack: makeStackFunc(14, 0),
valid: true, valid: true,
}, },
SWAP14: operation{ SWAP14: {
execute: makeSwap(14), execute: makeSwap(14),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(15, 0), validateStack: makeStackFunc(15, 0),
valid: true, valid: true,
}, },
SWAP15: operation{ SWAP15: {
execute: makeSwap(15), execute: makeSwap(15),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(16, 0), validateStack: makeStackFunc(16, 0),
valid: true, valid: true,
}, },
SWAP16: operation{ SWAP16: {
execute: makeSwap(16), execute: makeSwap(16),
gasCost: gasSwap, gasCost: gasSwap,
validateStack: makeStackFunc(17, 0), validateStack: makeStackFunc(17, 0),
valid: true, valid: true,
}, },
PUSH1: operation{ PUSH1: {
execute: makePush(1, big.NewInt(1)), execute: makePush(1, big.NewInt(1)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH2: operation{ PUSH2: {
execute: makePush(2, big.NewInt(2)), execute: makePush(2, big.NewInt(2)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH3: operation{ PUSH3: {
execute: makePush(3, big.NewInt(3)), execute: makePush(3, big.NewInt(3)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH4: operation{ PUSH4: {
execute: makePush(4, big.NewInt(4)), execute: makePush(4, big.NewInt(4)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH5: operation{ PUSH5: {
execute: makePush(5, big.NewInt(5)), execute: makePush(5, big.NewInt(5)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH6: operation{ PUSH6: {
execute: makePush(6, big.NewInt(6)), execute: makePush(6, big.NewInt(6)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH7: operation{ PUSH7: {
execute: makePush(7, big.NewInt(7)), execute: makePush(7, big.NewInt(7)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH8: operation{ PUSH8: {
execute: makePush(8, big.NewInt(8)), execute: makePush(8, big.NewInt(8)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH9: operation{ PUSH9: {
execute: makePush(9, big.NewInt(9)), execute: makePush(9, big.NewInt(9)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH10: operation{ PUSH10: {
execute: makePush(10, big.NewInt(10)), execute: makePush(10, big.NewInt(10)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH11: operation{ PUSH11: {
execute: makePush(11, big.NewInt(11)), execute: makePush(11, big.NewInt(11)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH12: operation{ PUSH12: {
execute: makePush(12, big.NewInt(12)), execute: makePush(12, big.NewInt(12)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH13: operation{ PUSH13: {
execute: makePush(13, big.NewInt(13)), execute: makePush(13, big.NewInt(13)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH14: operation{ PUSH14: {
execute: makePush(14, big.NewInt(14)), execute: makePush(14, big.NewInt(14)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH15: operation{ PUSH15: {
execute: makePush(15, big.NewInt(15)), execute: makePush(15, big.NewInt(15)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH16: operation{ PUSH16: {
execute: makePush(16, big.NewInt(16)), execute: makePush(16, big.NewInt(16)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH17: operation{ PUSH17: {
execute: makePush(17, big.NewInt(17)), execute: makePush(17, big.NewInt(17)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH18: operation{ PUSH18: {
execute: makePush(18, big.NewInt(18)), execute: makePush(18, big.NewInt(18)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH19: operation{ PUSH19: {
execute: makePush(19, big.NewInt(19)), execute: makePush(19, big.NewInt(19)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH20: operation{ PUSH20: {
execute: makePush(20, big.NewInt(20)), execute: makePush(20, big.NewInt(20)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH21: operation{ PUSH21: {
execute: makePush(21, big.NewInt(21)), execute: makePush(21, big.NewInt(21)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH22: operation{ PUSH22: {
execute: makePush(22, big.NewInt(22)), execute: makePush(22, big.NewInt(22)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH23: operation{ PUSH23: {
execute: makePush(23, big.NewInt(23)), execute: makePush(23, big.NewInt(23)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH24: operation{ PUSH24: {
execute: makePush(24, big.NewInt(24)), execute: makePush(24, big.NewInt(24)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH25: operation{ PUSH25: {
execute: makePush(25, big.NewInt(25)), execute: makePush(25, big.NewInt(25)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH26: operation{ PUSH26: {
execute: makePush(26, big.NewInt(26)), execute: makePush(26, big.NewInt(26)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH27: operation{ PUSH27: {
execute: makePush(27, big.NewInt(27)), execute: makePush(27, big.NewInt(27)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH28: operation{ PUSH28: {
execute: makePush(28, big.NewInt(28)), execute: makePush(28, big.NewInt(28)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH29: operation{ PUSH29: {
execute: makePush(29, big.NewInt(29)), execute: makePush(29, big.NewInt(29)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH30: operation{ PUSH30: {
execute: makePush(30, big.NewInt(30)), execute: makePush(30, big.NewInt(30)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH31: operation{ PUSH31: {
execute: makePush(31, big.NewInt(31)), execute: makePush(31, big.NewInt(31)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
PUSH32: operation{ PUSH32: {
execute: makePush(32, big.NewInt(32)), execute: makePush(32, big.NewInt(32)),
gasCost: gasPush, gasCost: gasPush,
validateStack: makeStackFunc(0, 1), validateStack: makeStackFunc(0, 1),
valid: true, valid: true,
}, },
DUP1: operation{ DUP1: {
execute: makeDup(1), execute: makeDup(1),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(1, 1), validateStack: makeStackFunc(1, 1),
valid: true, valid: true,
}, },
DUP2: operation{ DUP2: {
execute: makeDup(2), execute: makeDup(2),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(2, 1), validateStack: makeStackFunc(2, 1),
valid: true, valid: true,
}, },
DUP3: operation{ DUP3: {
execute: makeDup(3), execute: makeDup(3),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(3, 1), validateStack: makeStackFunc(3, 1),
valid: true, valid: true,
}, },
DUP4: operation{ DUP4: {
execute: makeDup(4), execute: makeDup(4),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(4, 1), validateStack: makeStackFunc(4, 1),
valid: true, valid: true,
}, },
DUP5: operation{ DUP5: {
execute: makeDup(5), execute: makeDup(5),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(5, 1), validateStack: makeStackFunc(5, 1),
valid: true, valid: true,
}, },
DUP6: operation{ DUP6: {
execute: makeDup(6), execute: makeDup(6),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(6, 1), validateStack: makeStackFunc(6, 1),
valid: true, valid: true,
}, },
DUP7: operation{ DUP7: {
execute: makeDup(7), execute: makeDup(7),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(7, 1), validateStack: makeStackFunc(7, 1),
valid: true, valid: true,
}, },
DUP8: operation{ DUP8: {
execute: makeDup(8), execute: makeDup(8),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(8, 1), validateStack: makeStackFunc(8, 1),
valid: true, valid: true,
}, },
DUP9: operation{ DUP9: {
execute: makeDup(9), execute: makeDup(9),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(9, 1), validateStack: makeStackFunc(9, 1),
valid: true, valid: true,
}, },
DUP10: operation{ DUP10: {
execute: makeDup(10), execute: makeDup(10),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(10, 1), validateStack: makeStackFunc(10, 1),
valid: true, valid: true,
}, },
DUP11: operation{ DUP11: {
execute: makeDup(11), execute: makeDup(11),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(11, 1), validateStack: makeStackFunc(11, 1),
valid: true, valid: true,
}, },
DUP12: operation{ DUP12: {
execute: makeDup(12), execute: makeDup(12),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(12, 1), validateStack: makeStackFunc(12, 1),
valid: true, valid: true,
}, },
DUP13: operation{ DUP13: {
execute: makeDup(13), execute: makeDup(13),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(13, 1), validateStack: makeStackFunc(13, 1),
valid: true, valid: true,
}, },
DUP14: operation{ DUP14: {
execute: makeDup(14), execute: makeDup(14),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(14, 1), validateStack: makeStackFunc(14, 1),
valid: true, valid: true,
}, },
DUP15: operation{ DUP15: {
execute: makeDup(15), execute: makeDup(15),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(15, 1), validateStack: makeStackFunc(15, 1),
valid: true, valid: true,
}, },
DUP16: operation{ DUP16: {
execute: makeDup(16), execute: makeDup(16),
gasCost: gasDup, gasCost: gasDup,
validateStack: makeStackFunc(16, 1), validateStack: makeStackFunc(16, 1),

12
crypto/ecies/asn1.go
View File

@ -109,7 +109,7 @@ func (curve secgNamedCurve) Equal(curve2 secgNamedCurve) bool {
if len(curve) != len(curve2) { if len(curve) != len(curve2) {
return false return false
} }
for i, _ := range curve { for i := range curve {
if curve[i] != curve2[i] { if curve[i] != curve2[i] {
return false return false
} }
@ -157,7 +157,7 @@ func (a asnAlgorithmIdentifier) Cmp(b asnAlgorithmIdentifier) bool {
if len(a.Algorithm) != len(b.Algorithm) { if len(a.Algorithm) != len(b.Algorithm) {
return false return false
} }
for i, _ := range a.Algorithm { for i := range a.Algorithm {
if a.Algorithm[i] != b.Algorithm[i] { if a.Algorithm[i] != b.Algorithm[i] {
return false return false
} }
@ -306,7 +306,7 @@ func (a asnECDHAlgorithm) Cmp(b asnECDHAlgorithm) bool {
if len(a.Algorithm) != len(b.Algorithm) { if len(a.Algorithm) != len(b.Algorithm) {
return false return false
} }
for i, _ := range a.Algorithm { for i := range a.Algorithm {
if a.Algorithm[i] != b.Algorithm[i] { if a.Algorithm[i] != b.Algorithm[i] {
return false return false
} }
@ -325,7 +325,7 @@ func (a asnKeyDerivationFunction) Cmp(b asnKeyDerivationFunction) bool {
if len(a.Algorithm) != len(b.Algorithm) { if len(a.Algorithm) != len(b.Algorithm) {
return false return false
} }
for i, _ := range a.Algorithm { for i := range a.Algorithm {
if a.Algorithm[i] != b.Algorithm[i] { if a.Algorithm[i] != b.Algorithm[i] {
return false return false
} }
@ -360,7 +360,7 @@ func (a asnSymmetricEncryption) Cmp(b asnSymmetricEncryption) bool {
if len(a.Algorithm) != len(b.Algorithm) { if len(a.Algorithm) != len(b.Algorithm) {
return false return false
} }
for i, _ := range a.Algorithm { for i := range a.Algorithm {
if a.Algorithm[i] != b.Algorithm[i] { if a.Algorithm[i] != b.Algorithm[i] {
return false return false
} }
@ -380,7 +380,7 @@ func (a asnMessageAuthenticationCode) Cmp(b asnMessageAuthenticationCode) bool {
if len(a.Algorithm) != len(b.Algorithm) { if len(a.Algorithm) != len(b.Algorithm) {
return false return false
} }
for i, _ := range a.Algorithm { for i := range a.Algorithm {
if a.Algorithm[i] != b.Algorithm[i] { if a.Algorithm[i] != b.Algorithm[i] {
return false return false
} }

6
crypto/ecies/ecies_test.go
View File

@ -492,17 +492,17 @@ type testCase struct {
} }
var testCases = []testCase{ var testCases = []testCase{
testCase{ {
Curve: elliptic.P256(), Curve: elliptic.P256(),
Name: "P256", Name: "P256",
Expected: true, Expected: true,
}, },
testCase{ {
Curve: elliptic.P384(), Curve: elliptic.P384(),
Name: "P384", Name: "P384",
Expected: true, Expected: true,
}, },
testCase{ {
Curve: elliptic.P521(), Curve: elliptic.P521(),
Name: "P521", Name: "P521",
Expected: true, Expected: true,

2
crypto/sha3/sha3_test.go
View File

@ -201,7 +201,7 @@ func TestSqueezing(t *testing.T) {
d1 := newShakeHash() d1 := newShakeHash()
d1.Write([]byte(testString)) d1.Write([]byte(testString))
var multiple []byte var multiple []byte
for _ = range ref { for range ref {
one := make([]byte, 1) one := make([]byte, 1)
d1.Read(one) d1.Read(one)
multiple = append(multiple, one...) multiple = append(multiple, one...)

4
eth/backend_test.go
View File

@ -37,12 +37,12 @@ func TestMipmapUpgrade(t *testing.T) {
switch i { switch i {
case 1: case 1:
receipt := types.NewReceipt(nil, new(big.Int)) receipt := types.NewReceipt(nil, new(big.Int))
receipt.Logs = []*types.Log{&types.Log{Address: addr}} receipt.Logs = []*types.Log{{Address: addr}}
gen.AddUncheckedReceipt(receipt) gen.AddUncheckedReceipt(receipt)
receipts = types.Receipts{receipt} receipts = types.Receipts{receipt}
case 2: case 2:
receipt := types.NewReceipt(nil, new(big.Int)) receipt := types.NewReceipt(nil, new(big.Int))
receipt.Logs = []*types.Log{&types.Log{Address: addr}} receipt.Logs = []*types.Log{{Address: addr}}
gen.AddUncheckedReceipt(receipt) gen.AddUncheckedReceipt(receipt)
receipts = types.Receipts{receipt} receipts = types.Receipts{receipt}
} }

4
eth/downloader/peer.go
View File

@ -205,7 +205,7 @@ func (p *peer) FetchNodeData(request *fetchRequest) error {
// Convert the hash set to a retrievable slice // Convert the hash set to a retrievable slice
hashes := make([]common.Hash, 0, len(request.Hashes)) hashes := make([]common.Hash, 0, len(request.Hashes))
for hash, _ := range request.Hashes { for hash := range request.Hashes {
hashes = append(hashes, hash) hashes = append(hashes, hash)
} }
go p.getNodeData(hashes) go p.getNodeData(hashes)
@ -314,7 +314,7 @@ func (p *peer) MarkLacking(hash common.Hash) {
defer p.lock.Unlock() defer p.lock.Unlock()
for len(p.lacking) >= maxLackingHashes { for len(p.lacking) >= maxLackingHashes {
for drop, _ := range p.lacking { for drop := range p.lacking {
delete(p.lacking, drop) delete(p.lacking, drop)
break break
} }

4
eth/downloader/queue.go
View File

@ -844,7 +844,7 @@ func (q *queue) expire(timeout time.Duration, pendPool map[string]*fetchRequest,
} }
} }
// Remove the expired requests from the pending pool // Remove the expired requests from the pending pool
for id, _ := range expiries { for id := range expiries {
delete(pendPool, id) delete(pendPool, id)
} }
return expiries return expiries
@ -1063,7 +1063,7 @@ func (q *queue) DeliverNodeData(id string, data [][]byte, callback func(int, boo
// If no data was retrieved, mark their hashes as unavailable for the origin peer // If no data was retrieved, mark their hashes as unavailable for the origin peer
if len(data) == 0 { if len(data) == 0 {
for hash, _ := range request.Hashes { for hash := range request.Hashes {
request.Peer.MarkLacking(hash) request.Peer.MarkLacking(hash)
} }
} }

2
eth/filters/api.go
View File

@ -505,7 +505,7 @@ func (args *FilterCriteria) UnmarshalJSON(data []byte) error {
switch topic := t.(type) { switch topic := t.(type) {
case nil: case nil:
// ignore topic when matching logs // ignore topic when matching logs
args.Topics[i] = []common.Hash{common.Hash{}} args.Topics[i] = []common.Hash{{}}
case string: case string:
// match specific topic // match specific topic

22
eth/filters/filter_system_test.go
View File

@ -281,15 +281,15 @@ func TestLogFilter(t *testing.T) {
// match all // match all
0: {FilterCriteria{}, allLogs, ""}, 0: {FilterCriteria{}, allLogs, ""},
// match none due to no matching addresses // match none due to no matching addresses
1: {FilterCriteria{Addresses: []common.Address{common.Address{}, notUsedAddress}, Topics: [][]common.Hash{allLogs[0].Topics}}, []*types.Log{}, ""}, 1: {FilterCriteria{Addresses: []common.Address{{}, notUsedAddress}, Topics: [][]common.Hash{allLogs[0].Topics}}, []*types.Log{}, ""},
// match logs based on addresses, ignore topics // match logs based on addresses, ignore topics
2: {FilterCriteria{Addresses: []common.Address{firstAddr}}, allLogs[:2], ""}, 2: {FilterCriteria{Addresses: []common.Address{firstAddr}}, allLogs[:2], ""},
// match none due to no matching topics (match with address) // match none due to no matching topics (match with address)
3: {FilterCriteria{Addresses: []common.Address{secondAddr}, Topics: [][]common.Hash{[]common.Hash{notUsedTopic}}}, []*types.Log{}, ""}, 3: {FilterCriteria{Addresses: []common.Address{secondAddr}, Topics: [][]common.Hash{{notUsedTopic}}}, []*types.Log{}, ""},
// match logs based on addresses and topics // match logs based on addresses and topics
4: {FilterCriteria{Addresses: []common.Address{thirdAddress}, Topics: [][]common.Hash{[]common.Hash{firstTopic, secondTopic}}}, allLogs[3:5], ""}, 4: {FilterCriteria{Addresses: []common.Address{thirdAddress}, Topics: [][]common.Hash{{firstTopic, secondTopic}}}, allLogs[3:5], ""},
// match logs based on multiple addresses and "or" topics // match logs based on multiple addresses and "or" topics
5: {FilterCriteria{Addresses: []common.Address{secondAddr, thirdAddress}, Topics: [][]common.Hash{[]common.Hash{firstTopic, secondTopic}}}, allLogs[2:5], ""}, 5: {FilterCriteria{Addresses: []common.Address{secondAddr, thirdAddress}, Topics: [][]common.Hash{{firstTopic, secondTopic}}}, allLogs[2:5], ""},
// logs in the pending block // logs in the pending block
6: {FilterCriteria{Addresses: []common.Address{firstAddr}, FromBlock: big.NewInt(rpc.PendingBlockNumber.Int64()), ToBlock: big.NewInt(rpc.PendingBlockNumber.Int64())}, allLogs[:2], ""}, 6: {FilterCriteria{Addresses: []common.Address{firstAddr}, FromBlock: big.NewInt(rpc.PendingBlockNumber.Int64()), ToBlock: big.NewInt(rpc.PendingBlockNumber.Int64())}, allLogs[:2], ""},
// mined logs with block num >= 2 or pending logs // mined logs with block num >= 2 or pending logs
@ -299,9 +299,9 @@ func TestLogFilter(t *testing.T) {
// all "mined" logs // all "mined" logs
9: {FilterCriteria{ToBlock: big.NewInt(rpc.LatestBlockNumber.Int64())}, allLogs, ""}, 9: {FilterCriteria{ToBlock: big.NewInt(rpc.LatestBlockNumber.Int64())}, allLogs, ""},
// all "mined" logs with 1>= block num <=2 and topic secondTopic // all "mined" logs with 1>= block num <=2 and topic secondTopic
10: {FilterCriteria{FromBlock: big.NewInt(1), ToBlock: big.NewInt(2), Topics: [][]common.Hash{[]common.Hash{secondTopic}}}, allLogs[3:4], ""}, 10: {FilterCriteria{FromBlock: big.NewInt(1), ToBlock: big.NewInt(2), Topics: [][]common.Hash{{secondTopic}}}, allLogs[3:4], ""},
// all "mined" and pending logs with topic firstTopic // all "mined" and pending logs with topic firstTopic
11: {FilterCriteria{FromBlock: big.NewInt(rpc.LatestBlockNumber.Int64()), ToBlock: big.NewInt(rpc.PendingBlockNumber.Int64()), Topics: [][]common.Hash{[]common.Hash{firstTopic}}}, expectedCase11, ""}, 11: {FilterCriteria{FromBlock: big.NewInt(rpc.LatestBlockNumber.Int64()), ToBlock: big.NewInt(rpc.PendingBlockNumber.Int64()), Topics: [][]common.Hash{{firstTopic}}}, expectedCase11, ""},
} }
) )
@ -402,19 +402,19 @@ func TestPendingLogsSubscription(t *testing.T) {
// match all // match all
{FilterCriteria{}, convertLogs(allLogs), nil, nil}, {FilterCriteria{}, convertLogs(allLogs), nil, nil},
// match none due to no matching addresses // match none due to no matching addresses
{FilterCriteria{Addresses: []common.Address{common.Address{}, notUsedAddress}, Topics: [][]common.Hash{[]common.Hash{}}}, []*types.Log{}, nil, nil}, {FilterCriteria{Addresses: []common.Address{{}, notUsedAddress}, Topics: [][]common.Hash{{}}}, []*types.Log{}, nil, nil},
// match logs based on addresses, ignore topics // match logs based on addresses, ignore topics
{FilterCriteria{Addresses: []common.Address{firstAddr}}, append(convertLogs(allLogs[:2]), allLogs[5].Logs[3]), nil, nil}, {FilterCriteria{Addresses: []common.Address{firstAddr}}, append(convertLogs(allLogs[:2]), allLogs[5].Logs[3]), nil, nil},
// match none due to no matching topics (match with address) // match none due to no matching topics (match with address)
{FilterCriteria{Addresses: []common.Address{secondAddr}, Topics: [][]common.Hash{[]common.Hash{notUsedTopic}}}, []*types.Log{}, nil, nil}, {FilterCriteria{Addresses: []common.Address{secondAddr}, Topics: [][]common.Hash{{notUsedTopic}}}, []*types.Log{}, nil, nil},
// match logs based on addresses and topics // match logs based on addresses and topics
{FilterCriteria{Addresses: []common.Address{thirdAddress}, Topics: [][]common.Hash{[]common.Hash{firstTopic, secondTopic}}}, append(convertLogs(allLogs[3:5]), allLogs[5].Logs[0]), nil, nil}, {FilterCriteria{Addresses: []common.Address{thirdAddress}, Topics: [][]common.Hash{{firstTopic, secondTopic}}}, append(convertLogs(allLogs[3:5]), allLogs[5].Logs[0]), nil, nil},
// match logs based on multiple addresses and "or" topics // match logs based on multiple addresses and "or" topics
{FilterCriteria{Addresses: []common.Address{secondAddr, thirdAddress}, Topics: [][]common.Hash{[]common.Hash{firstTopic, secondTopic}}}, append(convertLogs(allLogs[2:5]), allLogs[5].Logs[0]), nil, nil}, {FilterCriteria{Addresses: []common.Address{secondAddr, thirdAddress}, Topics: [][]common.Hash{{firstTopic, secondTopic}}}, append(convertLogs(allLogs[2:5]), allLogs[5].Logs[0]), nil, nil},
// block numbers are ignored for filters created with New***Filter, these return all logs that match the given criterias when the state changes // block numbers are ignored for filters created with New***Filter, these return all logs that match the given criterias when the state changes
{FilterCriteria{Addresses: []common.Address{firstAddr}, FromBlock: big.NewInt(2), ToBlock: big.NewInt(3)}, append(convertLogs(allLogs[:2]), allLogs[5].Logs[3]), nil, nil}, {FilterCriteria{Addresses: []common.Address{firstAddr}, FromBlock: big.NewInt(2), ToBlock: big.NewInt(3)}, append(convertLogs(allLogs[:2]), allLogs[5].Logs[3]), nil, nil},
// multiple pending logs, should match only 2 topics from the logs in block 5 // multiple pending logs, should match only 2 topics from the logs in block 5
{FilterCriteria{Addresses: []common.Address{thirdAddress}, Topics: [][]common.Hash{[]common.Hash{firstTopic, forthTopic}}}, []*types.Log{allLogs[5].Logs[0], allLogs[5].Logs[2]}, nil, nil}, {FilterCriteria{Addresses: []common.Address{thirdAddress}, Topics: [][]common.Hash{{firstTopic, forthTopic}}}, []*types.Log{allLogs[5].Logs[0], allLogs[5].Logs[2]}, nil, nil},
} }
) )

12
eth/filters/filter_test.go
View File

@ -210,7 +210,7 @@ func TestFilters(t *testing.T) {
filter := New(backend, true) filter := New(backend, true)
filter.SetAddresses([]common.Address{addr}) filter.SetAddresses([]common.Address{addr})
filter.SetTopics([][]common.Hash{[]common.Hash{hash1, hash2, hash3, hash4}}) filter.SetTopics([][]common.Hash{{hash1, hash2, hash3, hash4}})
filter.SetBeginBlock(0) filter.SetBeginBlock(0)
filter.SetEndBlock(-1) filter.SetEndBlock(-1)
@ -221,7 +221,7 @@ func TestFilters(t *testing.T) {
filter = New(backend, true) filter = New(backend, true)
filter.SetAddresses([]common.Address{addr}) filter.SetAddresses([]common.Address{addr})
filter.SetTopics([][]common.Hash{[]common.Hash{hash3}}) filter.SetTopics([][]common.Hash{{hash3}})
filter.SetBeginBlock(900) filter.SetBeginBlock(900)
filter.SetEndBlock(999) filter.SetEndBlock(999)
logs, _ = filter.Find(context.Background()) logs, _ = filter.Find(context.Background())
@ -234,7 +234,7 @@ func TestFilters(t *testing.T) {
filter = New(backend, true) filter = New(backend, true)
filter.SetAddresses([]common.Address{addr}) filter.SetAddresses([]common.Address{addr})
filter.SetTopics([][]common.Hash{[]common.Hash{hash3}}) filter.SetTopics([][]common.Hash{{hash3}})
filter.SetBeginBlock(990) filter.SetBeginBlock(990)
filter.SetEndBlock(-1) filter.SetEndBlock(-1)
logs, _ = filter.Find(context.Background()) logs, _ = filter.Find(context.Background())
@ -246,7 +246,7 @@ func TestFilters(t *testing.T) {
} }
filter = New(backend, true) filter = New(backend, true)
filter.SetTopics([][]common.Hash{[]common.Hash{hash1, hash2}}) filter.SetTopics([][]common.Hash{{hash1, hash2}})
filter.SetBeginBlock(1) filter.SetBeginBlock(1)
filter.SetEndBlock(10) filter.SetEndBlock(10)
@ -257,7 +257,7 @@ func TestFilters(t *testing.T) {
failHash := common.BytesToHash([]byte("fail")) failHash := common.BytesToHash([]byte("fail"))
filter = New(backend, true) filter = New(backend, true)
filter.SetTopics([][]common.Hash{[]common.Hash{failHash}}) filter.SetTopics([][]common.Hash{{failHash}})
filter.SetBeginBlock(0) filter.SetBeginBlock(0)
filter.SetEndBlock(-1) filter.SetEndBlock(-1)
@ -278,7 +278,7 @@ func TestFilters(t *testing.T) {
} }
filter = New(backend, true) filter = New(backend, true)
filter.SetTopics([][]common.Hash{[]common.Hash{failHash}, []common.Hash{hash1}}) filter.SetTopics([][]common.Hash{{failHash}, {hash1}})
filter.SetBeginBlock(0) filter.SetBeginBlock(0)
filter.SetEndBlock(-1) filter.SetEndBlock(-1)

12
eth/handler_test.go
View File

@ -75,7 +75,7 @@ func testGetBlockHeaders(t *testing.T, protocol int) {
// Create a "random" unknown hash for testing // Create a "random" unknown hash for testing
var unknown common.Hash var unknown common.Hash
for i, _ := range unknown { for i := range unknown {
unknown[i] = byte(i) unknown[i] = byte(i)
} }
// Create a batch of tests for various scenarios // Create a batch of tests for various scenarios
@ -246,17 +246,17 @@ func testGetBlockBodies(t *testing.T, protocol int) {
{limit + 1, nil, nil, limit}, // No more than the possible block count should be returned {limit + 1, nil, nil, limit}, // No more than the possible block count should be returned
{0, []common.Hash{pm.blockchain.Genesis().Hash()}, []bool{true}, 1}, // The genesis block should be retrievable {0, []common.Hash{pm.blockchain.Genesis().Hash()}, []bool{true}, 1}, // The genesis block should be retrievable
{0, []common.Hash{pm.blockchain.CurrentBlock().Hash()}, []bool{true}, 1}, // The chains head block should be retrievable {0, []common.Hash{pm.blockchain.CurrentBlock().Hash()}, []bool{true}, 1}, // The chains head block should be retrievable
{0, []common.Hash{common.Hash{}}, []bool{false}, 0}, // A non existent block should not be returned {0, []common.Hash{{}}, []bool{false}, 0}, // A non existent block should not be returned
// Existing and non-existing blocks interleaved should not cause problems // Existing and non-existing blocks interleaved should not cause problems
{0, []common.Hash{ {0, []common.Hash{
common.Hash{}, {},
pm.blockchain.GetBlockByNumber(1).Hash(), pm.blockchain.GetBlockByNumber(1).Hash(),
common.Hash{}, {},
pm.blockchain.GetBlockByNumber(10).Hash(), pm.blockchain.GetBlockByNumber(10).Hash(),
common.Hash{}, {},
pm.blockchain.GetBlockByNumber(100).Hash(), pm.blockchain.GetBlockByNumber(100).Hash(),
common.Hash{}, {},
}, []bool{false, true, false, true, false, true, false}, 3}, }, []bool{false, true, false, true, false, true, false}, 3},
} }
// Run each of the tests and verify the results against the chain // Run each of the tests and verify the results against the chain

2
eth/protocol_test.go
View File

@ -178,7 +178,7 @@ func testSendTransactions(t *testing.T, protocol int) {
func TestGetBlockHeadersDataEncodeDecode(t *testing.T) { func TestGetBlockHeadersDataEncodeDecode(t *testing.T) {
// Create a "random" hash for testing // Create a "random" hash for testing
var hash common.Hash var hash common.Hash
for i, _ := range hash { for i := range hash {
hash[i] = byte(i) hash[i] = byte(i)
} }
// Assemble some table driven tests // Assemble some table driven tests

2
ethdb/memory_database.go
View File

@ -67,7 +67,7 @@ func (db *MemDatabase) Keys() [][]byte {
defer db.lock.RUnlock() defer db.lock.RUnlock()
keys := [][]byte{} keys := [][]byte{}
for key, _ := range db.db { for key := range db.db {
keys = append(keys, []byte(key)) keys = append(keys, []byte(key))
} }
return keys return keys

14
ethstats/ethstats.go
View File

@ -326,7 +326,7 @@ func (s *Service) login(in *json.Decoder, out *json.Encoder) error {
Secret: s.pass, Secret: s.pass,
} }
login := map[string][]interface{}{ login := map[string][]interface{}{
"emit": []interface{}{"hello", auth}, "emit": {"hello", auth},
} }
if err := out.Encode(login); err != nil { if err := out.Encode(login); err != nil {
return err return err
@ -365,7 +365,7 @@ func (s *Service) reportLatency(out *json.Encoder) error {
start := time.Now() start := time.Now()
ping := map[string][]interface{}{ ping := map[string][]interface{}{
"emit": []interface{}{"node-ping", map[string]string{ "emit": {"node-ping", map[string]string{
"id": s.node, "id": s.node,
"clientTime": start.String(), "clientTime": start.String(),
}}, }},
@ -383,7 +383,7 @@ func (s *Service) reportLatency(out *json.Encoder) error {
} }
// Send back the measured latency // Send back the measured latency
latency := map[string][]interface{}{ latency := map[string][]interface{}{
"emit": []interface{}{"latency", map[string]string{ "emit": {"latency", map[string]string{
"id": s.node, "id": s.node,
"latency": strconv.Itoa(int((time.Since(start) / time.Duration(2)).Nanoseconds() / 1000000)), "latency": strconv.Itoa(int((time.Since(start) / time.Duration(2)).Nanoseconds() / 1000000)),
}}, }},
@ -438,7 +438,7 @@ func (s *Service) reportBlock(out *json.Encoder, block *types.Block) error {
"block": s.assembleBlockStats(block), "block": s.assembleBlockStats(block),
} }
report := map[string][]interface{}{ report := map[string][]interface{}{
"emit": []interface{}{"block", stats}, "emit": {"block", stats},
} }
if err := out.Encode(report); err != nil { if err := out.Encode(report); err != nil {
return err return err
@ -531,7 +531,7 @@ func (s *Service) reportHistory(out *json.Encoder, list []uint64) error {
"history": history, "history": history,
} }
report := map[string][]interface{}{ report := map[string][]interface{}{
"emit": []interface{}{"history", stats}, "emit": {"history", stats},
} }
if err := out.Encode(report); err != nil { if err := out.Encode(report); err != nil {
return err return err
@ -562,7 +562,7 @@ func (s *Service) reportPending(out *json.Encoder) error {
}, },
} }
report := map[string][]interface{}{ report := map[string][]interface{}{
"emit": []interface{}{"pending", stats}, "emit": {"pending", stats},
} }
if err := out.Encode(report); err != nil { if err := out.Encode(report); err != nil {
return err return err
@ -616,7 +616,7 @@ func (s *Service) reportStats(out *json.Encoder) error {
}, },
} }
report := map[string][]interface{}{ report := map[string][]interface{}{
"emit": []interface{}{"stats", stats}, "emit": {"stats", stats},
} }
if err := out.Encode(report); err != nil { if err := out.Encode(report); err != nil {
return err return err

4
event/event_test.go
View File

@ -144,7 +144,7 @@ func TestMuxConcurrent(t *testing.T) {
func emptySubscriber(mux *TypeMux, types ...interface{}) { func emptySubscriber(mux *TypeMux, types ...interface{}) {
s := mux.Subscribe(testEvent(0)) s := mux.Subscribe(testEvent(0))
go func() { go func() {
for _ = range s.Chan() { for range s.Chan() {
} }
}() }()
} }
@ -187,7 +187,7 @@ func BenchmarkChanSend(b *testing.B) {
c := make(chan interface{}) c := make(chan interface{})
closed := make(chan struct{}) closed := make(chan struct{})
go func() { go func() {
for _ = range c { for range c {
} }
}() }()

2
event/filter/generic_filter.go
View File

@ -34,7 +34,7 @@ func (self Generic) Compare(f Filter) bool {
strMatch = false strMatch = false
} }
for k, _ := range self.Data { for k := range self.Data {
if _, ok := filter.Data[k]; !ok { if _, ok := filter.Data[k]; !ok {
return false return false
} }

2
les/fetcher.go
View File

@ -664,7 +664,7 @@ func (f *lightFetcher) updateMaxConfirmedTd(td *big.Int) {
f.lastUpdateStats.next = newEntry f.lastUpdateStats.next = newEntry
} }
f.lastUpdateStats = newEntry f.lastUpdateStats = newEntry
for p, _ := range f.peers { for p := range f.peers {
f.checkUpdateStats(p, newEntry) f.checkUpdateStats(p, newEntry)
} }
} }

6
les/flowcontrol/manager.go
View File

@ -126,7 +126,7 @@ func (self *ClientManager) removeNode(node *cmNode) {
// recalc sumWeight // recalc sumWeight
func (self *ClientManager) updateNodes(time int64) (rce bool) { func (self *ClientManager) updateNodes(time int64) (rce bool) {
var sumWeight, rcSum uint64 var sumWeight, rcSum uint64
for node, _ := range self.nodes { for node := range self.nodes {
rc := node.recharging rc := node.recharging
node.update(time) node.update(time)
if rc && !node.recharging { if rc && !node.recharging {
@ -145,13 +145,13 @@ func (self *ClientManager) updateNodes(time int64) (rce bool) {
func (self *ClientManager) update(time int64) { func (self *ClientManager) update(time int64) {
for { for {
firstTime := time firstTime := time
for node, _ := range self.nodes { for node := range self.nodes {
if node.recharging && node.finishRecharge < firstTime { if node.recharging && node.finishRecharge < firstTime {
firstTime = node.finishRecharge firstTime = node.finishRecharge
} }
} }
if self.updateNodes(firstTime) { if self.updateNodes(firstTime) {
for node, _ := range self.nodes { for node := range self.nodes {
if node.recharging { if node.recharging {
node.set(node.serving, self.simReqCnt, self.sumWeight) node.set(node.serving, self.simReqCnt, self.sumWeight)
} }

14
les/handler_test.go
View File

@ -49,7 +49,7 @@ func testGetBlockHeaders(t *testing.T, protocol int) {
// Create a "random" unknown hash for testing // Create a "random" unknown hash for testing
var unknown common.Hash var unknown common.Hash
for i, _ := range unknown { for i := range unknown {
unknown[i] = byte(i) unknown[i] = byte(i)
} }
// Create a batch of tests for various scenarios // Create a batch of tests for various scenarios
@ -189,17 +189,17 @@ func testGetBlockBodies(t *testing.T, protocol int) {
//{limit + 1, nil, nil, limit}, // No more than the possible block count should be returned //{limit + 1, nil, nil, limit}, // No more than the possible block count should be returned
{0, []common.Hash{bc.Genesis().Hash()}, []bool{true}, 1}, // The genesis block should be retrievable {0, []common.Hash{bc.Genesis().Hash()}, []bool{true}, 1}, // The genesis block should be retrievable
{0, []common.Hash{bc.CurrentBlock().Hash()}, []bool{true}, 1}, // The chains head block should be retrievable {0, []common.Hash{bc.CurrentBlock().Hash()}, []bool{true}, 1}, // The chains head block should be retrievable
{0, []common.Hash{common.Hash{}}, []bool{false}, 0}, // A non existent block should not be returned {0, []common.Hash{{}}, []bool{false}, 0}, // A non existent block should not be returned
// Existing and non-existing blocks interleaved should not cause problems // Existing and non-existing blocks interleaved should not cause problems
{0, []common.Hash{ {0, []common.Hash{
common.Hash{}, {},
bc.GetBlockByNumber(1).Hash(), bc.GetBlockByNumber(1).Hash(),
common.Hash{}, {},
bc.GetBlockByNumber(10).Hash(), bc.GetBlockByNumber(10).Hash(),
common.Hash{}, {},
bc.GetBlockByNumber(100).Hash(), bc.GetBlockByNumber(100).Hash(),
common.Hash{}, {},
}, []bool{false, true, false, true, false, true, false}, 3}, }, []bool{false, true, false, true, false, true, false}, 3},
} }
// Run each of the tests and verify the results against the chain // Run each of the tests and verify the results against the chain
@ -312,7 +312,7 @@ func testGetProofs(t *testing.T, protocol int) {
var proofreqs []ProofReq var proofreqs []ProofReq
var proofs [][]rlp.RawValue var proofs [][]rlp.RawValue
accounts := []common.Address{testBankAddress, acc1Addr, acc2Addr, common.Address{}} accounts := []common.Address{testBankAddress, acc1Addr, acc2Addr, {}}
for i := uint64(0); i <= bc.CurrentBlock().NumberU64(); i++ { for i := uint64(0); i <= bc.CurrentBlock().NumberU64(); i++ {
header := bc.GetHeaderByNumber(i) header := bc.GetHeaderByNumber(i)
root := header.Root root := header.Root

2
les/peer.go
View File

@ -467,7 +467,7 @@ func (ps *peerSet) AllPeerIDs() []string {
res := make([]string, len(ps.peers)) res := make([]string, len(ps.peers))
idx := 0 idx := 0
for id, _ := range ps.peers { for id := range ps.peers {
res[idx] = id res[idx] = id
idx++ idx++
} }

2
les/randselect_test.go
View File

@ -39,7 +39,7 @@ func TestWeightedRandomSelect(t *testing.T) {
s := newWeightedRandomSelect() s := newWeightedRandomSelect()
w := -1 w := -1
list := make([]testWrsItem, cnt) list := make([]testWrsItem, cnt)
for i, _ := range list { for i := range list {
list[i] = testWrsItem{idx: i, widx: &w} list[i] = testWrsItem{idx: i, widx: &w}
s.update(&list[i]) s.update(&list[i])
} }

2
les/serverpool.go
View File

@ -414,7 +414,7 @@ func (pool *serverPool) loadNodes() {
// ordered from least to most recently connected. // ordered from least to most recently connected.
func (pool *serverPool) saveNodes() { func (pool *serverPool) saveNodes() {
list := make([]*poolEntry, len(pool.knownQueue.queue)) list := make([]*poolEntry, len(pool.knownQueue.queue))
for i, _ := range list { for i := range list {
list[i] = pool.knownQueue.fetchOldest() list[i] = pool.knownQueue.fetchOldest()
} }
enc, err := rlp.EncodeToBytes(list) enc, err := rlp.EncodeToBytes(list)

12
les/sync.go
View File

@ -43,12 +43,12 @@ func (pm *ProtocolManager) syncer() {
for { for {
select { select {
case <-pm.newPeerCh: case <-pm.newPeerCh:
/* // Make sure we have peers to select from, then sync /* // Make sure we have peers to select from, then sync
if pm.peers.Len() < minDesiredPeerCount { if pm.peers.Len() < minDesiredPeerCount {
break break
} }
go pm.synchronise(pm.peers.BestPeer()) go pm.synchronise(pm.peers.BestPeer())
*/ */
/*case <-forceSync: /*case <-forceSync:
// Force a sync even if not enough peers are present // Force a sync even if not enough peers are present
go pm.synchronise(pm.peers.BestPeer()) go pm.synchronise(pm.peers.BestPeer())

2
les/txrelay.go
View File

@ -138,7 +138,7 @@ func (self *LesTxRelay) NewHead(head common.Hash, mined []common.Hash, rollback
if len(self.txPending) > 0 { if len(self.txPending) > 0 {
txs := make(types.Transactions, len(self.txPending)) txs := make(types.Transactions, len(self.txPending))
i := 0 i := 0
for hash, _ := range self.txPending { for hash := range self.txPending {
txs[i] = self.txSent[hash].tx txs[i] = self.txSent[hash].tx
i++ i++
} }

2
light/lightchain.go
View File

@ -135,7 +135,7 @@ func NewLightChain(odr OdrBackend, config *params.ChainConfig, pow pow.PoW, mux
return nil, err return nil, err
} }
// Check the current state of the block hashes and make sure that we do not have any of the bad blocks in our chain // Check the current state of the block hashes and make sure that we do not have any of the bad blocks in our chain
for hash, _ := range core.BadHashes { for hash := range core.BadHashes {
if header := bc.GetHeaderByHash(hash); header != nil { if header := bc.GetHeaderByHash(hash); header != nil {
glog.V(logger.Error).Infof("Found bad hash, rewinding chain to block #%d [%x…]", header.Number, header.ParentHash[:4]) glog.V(logger.Error).Infof("Found bad hash, rewinding chain to block #%d [%x…]", header.Number, header.ParentHash[:4])
bc.SetHead(header.Number.Uint64() - 1) bc.SetHead(header.Number.Uint64() - 1)

2
light/txpool_test.go
View File

@ -73,7 +73,7 @@ func txPoolTestChainGen(i int, block *core.BlockGen) {
} }
func TestTxPool(t *testing.T) { func TestTxPool(t *testing.T) {
for i, _ := range testTx { for i := range testTx {
testTx[i], _ = types.SignTx(types.NewTransaction(uint64(i), acc1Addr, big.NewInt(10000), params.TxGas, nil, nil), types.HomesteadSigner{}, testBankKey) testTx[i], _ = types.SignTx(types.NewTransaction(uint64(i), acc1Addr, big.NewInt(10000), params.TxGas, nil, nil), types.HomesteadSigner{}, testBankKey)
} }

2
logger/glog/glog.go
View File

@ -928,7 +928,7 @@ const flushInterval = 30 * time.Second
// flushDaemon periodically flushes the log file buffers. // flushDaemon periodically flushes the log file buffers.
func (l *loggingT) flushDaemon() { func (l *loggingT) flushDaemon() {
for _ = range time.NewTicker(flushInterval).C { for range time.NewTicker(flushInterval).C {
l.lockAndFlushAll() l.lockAndFlushAll()
} }
} }

2
miner/worker.go
View File

@ -256,7 +256,7 @@ func (self *worker) update() {
self.currentMu.Lock() self.currentMu.Lock()
acc, _ := types.Sender(self.current.signer, ev.Tx) acc, _ := types.Sender(self.current.signer, ev.Tx)
txs := map[common.Address]types.Transactions{acc: types.Transactions{ev.Tx}} txs := map[common.Address]types.Transactions{acc: {ev.Tx}}
txset := types.NewTransactionsByPriceAndNonce(txs) txset := types.NewTransactionsByPriceAndNonce(txs)
self.current.commitTransactions(self.mux, txset, self.gasPrice, self.chain) self.current.commitTransactions(self.mux, txset, self.gasPrice, self.chain)

2
mobile/p2p.go
View File

@ -38,7 +38,7 @@ func (ni *NodeInfo) GetListenerPort() int { return ni.info.Ports.Listener
func (ni *NodeInfo) GetListenerAddress() string { return ni.info.ListenAddr } func (ni *NodeInfo) GetListenerAddress() string { return ni.info.ListenAddr }
func (ni *NodeInfo) GetProtocols() *Strings { func (ni *NodeInfo) GetProtocols() *Strings {
protos := []string{} protos := []string{}
for proto, _ := range ni.info.Protocols { for proto := range ni.info.Protocols {
protos = append(protos, proto) protos = append(protos, proto)
} }
return &Strings{protos} return &Strings{protos}

12
node/node_test.go
View File

@ -166,7 +166,7 @@ func TestServiceLifeCycle(t *testing.T) {
if err := stack.Start(); err != nil { if err := stack.Start(); err != nil {
t.Fatalf("failed to start protocol stack: %v", err) t.Fatalf("failed to start protocol stack: %v", err)
} }
for id, _ := range services { for id := range services {
if !started[id] { if !started[id] {
t.Fatalf("service %s: freshly started service not running", id) t.Fatalf("service %s: freshly started service not running", id)
} }
@ -178,7 +178,7 @@ func TestServiceLifeCycle(t *testing.T) {
if err := stack.Stop(); err != nil { if err := stack.Stop(); err != nil {
t.Fatalf("failed to stop protocol stack: %v", err) t.Fatalf("failed to stop protocol stack: %v", err)
} }
for id, _ := range services { for id := range services {
if !stopped[id] { if !stopped[id] {
t.Fatalf("service %s: freshly terminated service still running", id) t.Fatalf("service %s: freshly terminated service still running", id)
} }
@ -270,7 +270,7 @@ func TestServiceConstructionAbortion(t *testing.T) {
if err := stack.Start(); err != failure { if err := stack.Start(); err != failure {
t.Fatalf("iter %d: stack startup failure mismatch: have %v, want %v", i, err, failure) t.Fatalf("iter %d: stack startup failure mismatch: have %v, want %v", i, err, failure)
} }
for id, _ := range services { for id := range services {
if started[id] { if started[id] {
t.Fatalf("service %s: started should not have", id) t.Fatalf("service %s: started should not have", id)
} }
@ -322,7 +322,7 @@ func TestServiceStartupAbortion(t *testing.T) {
if err := stack.Start(); err != failure { if err := stack.Start(); err != failure {
t.Fatalf("iter %d: stack startup failure mismatch: have %v, want %v", i, err, failure) t.Fatalf("iter %d: stack startup failure mismatch: have %v, want %v", i, err, failure)
} }
for id, _ := range services { for id := range services {
if started[id] && !stopped[id] { if started[id] && !stopped[id] {
t.Fatalf("service %s: started but not stopped", id) t.Fatalf("service %s: started but not stopped", id)
} }
@ -376,7 +376,7 @@ func TestServiceTerminationGuarantee(t *testing.T) {
if err := stack.Start(); err != nil { if err := stack.Start(); err != nil {
t.Fatalf("iter %d: failed to start protocol stack: %v", i, err) t.Fatalf("iter %d: failed to start protocol stack: %v", i, err)
} }
for id, _ := range services { for id := range services {
if !started[id] { if !started[id] {
t.Fatalf("iter %d, service %s: service not running", i, id) t.Fatalf("iter %d, service %s: service not running", i, id)
} }
@ -397,7 +397,7 @@ func TestServiceTerminationGuarantee(t *testing.T) {
t.Fatalf("iter %d: failure count mismatch: have %d, want %d", i, len(err.Services), 1) t.Fatalf("iter %d: failure count mismatch: have %d, want %d", i, len(err.Services), 1)
} }
} }
for id, _ := range services { for id := range services {
if !stopped[id] { if !stopped[id] {
t.Fatalf("iter %d, service %s: service not terminated", i, id) t.Fatalf("iter %d, service %s: service not terminated", i, id)
} }

4
p2p/discover/database_test.go
View File

@ -242,12 +242,12 @@ func TestNodeDBSeedQuery(t *testing.T) {
if len(seeds) != len(want) { if len(seeds) != len(want) {
t.Errorf("seed count mismatch: have %v, want %v", len(seeds), len(want)) t.Errorf("seed count mismatch: have %v, want %v", len(seeds), len(want))
} }
for id, _ := range have { for id := range have {
if _, ok := want[id]; !ok { if _, ok := want[id]; !ok {
t.Errorf("extra seed: %v", id) t.Errorf("extra seed: %v", id)
} }
} }
for id, _ := range want { for id := range want {
if _, ok := have[id]; !ok { if _, ok := have[id]; !ok {
t.Errorf("missing seed: %v", id) t.Errorf("missing seed: %v", id)
} }

2
p2p/discover/table.go
View File

@ -433,7 +433,7 @@ func (tab *Table) bondall(nodes []*Node) (result []*Node) {
rc <- nn rc <- nn
}(nodes[i]) }(nodes[i])
} }
for _ = range nodes { for range nodes {
if n := <-rc; n != nil { if n := <-rc; n != nil {
result = append(result, n) result = append(result, n)
} }

26
p2p/discover/table_test.go
View File

@ -314,19 +314,19 @@ var lookupTestnet = &preminedTestnet{
target: MustHexID("166aea4f556532c6d34e8b740e5d314af7e9ac0ca79833bd751d6b665f12dfd38ec563c363b32f02aef4a80b44fd3def94612d497b99cb5f17fd24de454927ec"), target: MustHexID("166aea4f556532c6d34e8b740e5d314af7e9ac0ca79833bd751d6b665f12dfd38ec563c363b32f02aef4a80b44fd3def94612d497b99cb5f17fd24de454927ec"),
targetSha: common.Hash{0x5c, 0x94, 0x4e, 0xe5, 0x1c, 0x5a, 0xe9, 0xf7, 0x2a, 0x95, 0xec, 0xcb, 0x8a, 0xed, 0x3, 0x74, 0xee, 0xcb, 0x51, 0x19, 0xd7, 0x20, 0xcb, 0xea, 0x68, 0x13, 0xe8, 0xe0, 0xd6, 0xad, 0x92, 0x61}, targetSha: common.Hash{0x5c, 0x94, 0x4e, 0xe5, 0x1c, 0x5a, 0xe9, 0xf7, 0x2a, 0x95, 0xec, 0xcb, 0x8a, 0xed, 0x3, 0x74, 0xee, 0xcb, 0x51, 0x19, 0xd7, 0x20, 0xcb, 0xea, 0x68, 0x13, 0xe8, 0xe0, 0xd6, 0xad, 0x92, 0x61},
dists: [257][]NodeID{ dists: [257][]NodeID{
240: []NodeID{ 240: {
MustHexID("2001ad5e3e80c71b952161bc0186731cf5ffe942d24a79230a0555802296238e57ea7a32f5b6f18564eadc1c65389448481f8c9338df0a3dbd18f708cbc2cbcb"), MustHexID("2001ad5e3e80c71b952161bc0186731cf5ffe942d24a79230a0555802296238e57ea7a32f5b6f18564eadc1c65389448481f8c9338df0a3dbd18f708cbc2cbcb"),
MustHexID("6ba3f4f57d084b6bf94cc4555b8c657e4a8ac7b7baf23c6874efc21dd1e4f56b7eb2721e07f5242d2f1d8381fc8cae535e860197c69236798ba1ad231b105794"), MustHexID("6ba3f4f57d084b6bf94cc4555b8c657e4a8ac7b7baf23c6874efc21dd1e4f56b7eb2721e07f5242d2f1d8381fc8cae535e860197c69236798ba1ad231b105794"),
}, },
244: []NodeID{ 244: {
MustHexID("696ba1f0a9d55c59246f776600542a9e6432490f0cd78f8bb55a196918df2081a9b521c3c3ba48e465a75c10768807717f8f689b0b4adce00e1c75737552a178"), MustHexID("696ba1f0a9d55c59246f776600542a9e6432490f0cd78f8bb55a196918df2081a9b521c3c3ba48e465a75c10768807717f8f689b0b4adce00e1c75737552a178"),
}, },
246: []NodeID{ 246: {
MustHexID("d6d32178bdc38416f46ffb8b3ec9e4cb2cfff8d04dd7e4311a70e403cb62b10be1b447311b60b4f9ee221a8131fc2cbd45b96dd80deba68a949d467241facfa8"), MustHexID("d6d32178bdc38416f46ffb8b3ec9e4cb2cfff8d04dd7e4311a70e403cb62b10be1b447311b60b4f9ee221a8131fc2cbd45b96dd80deba68a949d467241facfa8"),
MustHexID("3ea3d04a43a3dfb5ac11cffc2319248cf41b6279659393c2f55b8a0a5fc9d12581a9d97ef5d8ff9b5abf3321a290e8f63a4f785f450dc8a672aba3ba2ff4fdab"), MustHexID("3ea3d04a43a3dfb5ac11cffc2319248cf41b6279659393c2f55b8a0a5fc9d12581a9d97ef5d8ff9b5abf3321a290e8f63a4f785f450dc8a672aba3ba2ff4fdab"),
MustHexID("2fc897f05ae585553e5c014effd3078f84f37f9333afacffb109f00ca8e7a3373de810a3946be971cbccdfd40249f9fe7f322118ea459ac71acca85a1ef8b7f4"), MustHexID("2fc897f05ae585553e5c014effd3078f84f37f9333afacffb109f00ca8e7a3373de810a3946be971cbccdfd40249f9fe7f322118ea459ac71acca85a1ef8b7f4"),
}, },
247: []NodeID{ 247: {
MustHexID("3155e1427f85f10a5c9a7755877748041af1bcd8d474ec065eb33df57a97babf54bfd2103575fa829115d224c523596b401065a97f74010610fce76382c0bf32"), MustHexID("3155e1427f85f10a5c9a7755877748041af1bcd8d474ec065eb33df57a97babf54bfd2103575fa829115d224c523596b401065a97f74010610fce76382c0bf32"),
MustHexID("312c55512422cf9b8a4097e9a6ad79402e87a15ae909a4bfefa22398f03d20951933beea1e4dfa6f968212385e829f04c2d314fc2d4e255e0d3bc08792b069db"), MustHexID("312c55512422cf9b8a4097e9a6ad79402e87a15ae909a4bfefa22398f03d20951933beea1e4dfa6f968212385e829f04c2d314fc2d4e255e0d3bc08792b069db"),
MustHexID("38643200b172dcfef857492156971f0e6aa2c538d8b74010f8e140811d53b98c765dd2d96126051913f44582e8c199ad7c6d6819e9a56483f637feaac9448aac"), MustHexID("38643200b172dcfef857492156971f0e6aa2c538d8b74010f8e140811d53b98c765dd2d96126051913f44582e8c199ad7c6d6819e9a56483f637feaac9448aac"),
@ -338,7 +338,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("4ab0a75941b12892369b4490a1928c8ca52a9ad6d3dffbd1d8c0b907bc200fe74c022d011ec39b64808a39c0ca41f1d3254386c3e7733e7044c44259486461b6"), MustHexID("4ab0a75941b12892369b4490a1928c8ca52a9ad6d3dffbd1d8c0b907bc200fe74c022d011ec39b64808a39c0ca41f1d3254386c3e7733e7044c44259486461b6"),
MustHexID("d45150a72dc74388773e68e03133a3b5f51447fe91837d566706b3c035ee4b56f160c878c6273394daee7f56cc398985269052f22f75a8057df2fe6172765354"), MustHexID("d45150a72dc74388773e68e03133a3b5f51447fe91837d566706b3c035ee4b56f160c878c6273394daee7f56cc398985269052f22f75a8057df2fe6172765354"),
}, },
248: []NodeID{ 248: {
MustHexID("6aadfce366a189bab08ac84721567483202c86590642ea6d6a14f37ca78d82bdb6509eb7b8b2f6f63c78ae3ae1d8837c89509e41497d719b23ad53dd81574afa"), MustHexID("6aadfce366a189bab08ac84721567483202c86590642ea6d6a14f37ca78d82bdb6509eb7b8b2f6f63c78ae3ae1d8837c89509e41497d719b23ad53dd81574afa"),
MustHexID("a605ecfd6069a4cf4cf7f5840e5bc0ce10d23a3ac59e2aaa70c6afd5637359d2519b4524f56fc2ca180cdbebe54262f720ccaae8c1b28fd553c485675831624d"), MustHexID("a605ecfd6069a4cf4cf7f5840e5bc0ce10d23a3ac59e2aaa70c6afd5637359d2519b4524f56fc2ca180cdbebe54262f720ccaae8c1b28fd553c485675831624d"),
MustHexID("29701451cb9448ca33fc33680b44b840d815be90146eb521641efbffed0859c154e8892d3906eae9934bfacee72cd1d2fa9dd050fd18888eea49da155ab0efd2"), MustHexID("29701451cb9448ca33fc33680b44b840d815be90146eb521641efbffed0859c154e8892d3906eae9934bfacee72cd1d2fa9dd050fd18888eea49da155ab0efd2"),
@ -356,7 +356,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("b76ea1a6fd6506ef6e3506a4f1f60ed6287fff8114af6141b2ff13e61242331b54082b023cfea5b3083354a4fb3f9eb8be01fb4a518f579e731a5d0707291a6b"), MustHexID("b76ea1a6fd6506ef6e3506a4f1f60ed6287fff8114af6141b2ff13e61242331b54082b023cfea5b3083354a4fb3f9eb8be01fb4a518f579e731a5d0707291a6b"),
MustHexID("9b53a37950ca8890ee349b325032d7b672cab7eced178d3060137b24ef6b92a43977922d5bdfb4a3409a2d80128e02f795f9dae6d7d99973ad0e23a2afb8442f"), MustHexID("9b53a37950ca8890ee349b325032d7b672cab7eced178d3060137b24ef6b92a43977922d5bdfb4a3409a2d80128e02f795f9dae6d7d99973ad0e23a2afb8442f"),
}, },
249: []NodeID{ 249: {
MustHexID("675ae65567c3c72c50c73bc0fd4f61f202ea5f93346ca57b551de3411ccc614fad61cb9035493af47615311b9d44ee7a161972ee4d77c28fe1ec029d01434e6a"), MustHexID("675ae65567c3c72c50c73bc0fd4f61f202ea5f93346ca57b551de3411ccc614fad61cb9035493af47615311b9d44ee7a161972ee4d77c28fe1ec029d01434e6a"),
MustHexID("8eb81408389da88536ae5800392b16ef5109d7ea132c18e9a82928047ecdb502693f6e4a4cdd18b54296caf561db937185731456c456c98bfe7de0baf0eaa495"), MustHexID("8eb81408389da88536ae5800392b16ef5109d7ea132c18e9a82928047ecdb502693f6e4a4cdd18b54296caf561db937185731456c456c98bfe7de0baf0eaa495"),
MustHexID("2adba8b1612a541771cb93a726a38a4b88e97b18eced2593eb7daf82f05a5321ca94a72cc780c306ff21e551a932fc2c6d791e4681907b5ceab7f084c3fa2944"), MustHexID("2adba8b1612a541771cb93a726a38a4b88e97b18eced2593eb7daf82f05a5321ca94a72cc780c306ff21e551a932fc2c6d791e4681907b5ceab7f084c3fa2944"),
@ -374,7 +374,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("d94193f236105010972f5df1b7818b55846592a0445b9cdc4eaed811b8c4c0f7c27dc8cc9837a4774656d6b34682d6d329d42b6ebb55da1d475c2474dc3dfdf4"), MustHexID("d94193f236105010972f5df1b7818b55846592a0445b9cdc4eaed811b8c4c0f7c27dc8cc9837a4774656d6b34682d6d329d42b6ebb55da1d475c2474dc3dfdf4"),
MustHexID("edd9af6aded4094e9785637c28fccbd3980cbe28e2eb9a411048a23c2ace4bd6b0b7088a7817997b49a3dd05fc6929ca6c7abbb69438dbdabe65e971d2a794b2"), MustHexID("edd9af6aded4094e9785637c28fccbd3980cbe28e2eb9a411048a23c2ace4bd6b0b7088a7817997b49a3dd05fc6929ca6c7abbb69438dbdabe65e971d2a794b2"),
}, },
250: []NodeID{ 250: {
MustHexID("53a5bd1215d4ab709ae8fdc2ced50bba320bced78bd9c5dc92947fb402250c914891786db0978c898c058493f86fc68b1c5de8a5cb36336150ac7a88655b6c39"), MustHexID("53a5bd1215d4ab709ae8fdc2ced50bba320bced78bd9c5dc92947fb402250c914891786db0978c898c058493f86fc68b1c5de8a5cb36336150ac7a88655b6c39"),
MustHexID("b7f79e3ab59f79262623c9ccefc8f01d682323aee56ffbe295437487e9d5acaf556a9c92e1f1c6a9601f2b9eb6b027ae1aeaebac71d61b9b78e88676efd3e1a3"), MustHexID("b7f79e3ab59f79262623c9ccefc8f01d682323aee56ffbe295437487e9d5acaf556a9c92e1f1c6a9601f2b9eb6b027ae1aeaebac71d61b9b78e88676efd3e1a3"),
MustHexID("d374bf7e8d7ffff69cc00bebff38ef5bc1dcb0a8d51c1a3d70e61ac6b2e2d6617109254b0ac224354dfbf79009fe4239e09020c483cc60c071e00b9238684f30"), MustHexID("d374bf7e8d7ffff69cc00bebff38ef5bc1dcb0a8d51c1a3d70e61ac6b2e2d6617109254b0ac224354dfbf79009fe4239e09020c483cc60c071e00b9238684f30"),
@ -392,7 +392,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("5b116f0751526868a909b61a30b0c5282c37df6925cc03ddea556ef0d0602a9595fd6c14d371f8ed7d45d89918a032dcd22be4342a8793d88fdbeb3ca3d75bd7"), MustHexID("5b116f0751526868a909b61a30b0c5282c37df6925cc03ddea556ef0d0602a9595fd6c14d371f8ed7d45d89918a032dcd22be4342a8793d88fdbeb3ca3d75bd7"),
MustHexID("50f3222fb6b82481c7c813b2172e1daea43e2710a443b9c2a57a12bd160dd37e20f87aa968c82ad639af6972185609d47036c0d93b4b7269b74ebd7073221c10"), MustHexID("50f3222fb6b82481c7c813b2172e1daea43e2710a443b9c2a57a12bd160dd37e20f87aa968c82ad639af6972185609d47036c0d93b4b7269b74ebd7073221c10"),
}, },
251: []NodeID{ 251: {
MustHexID("9b8f702a62d1bee67bedfeb102eca7f37fa1713e310f0d6651cc0c33ea7c5477575289ccd463e5a2574a00a676a1fdce05658ba447bb9d2827f0ba47b947e894"), MustHexID("9b8f702a62d1bee67bedfeb102eca7f37fa1713e310f0d6651cc0c33ea7c5477575289ccd463e5a2574a00a676a1fdce05658ba447bb9d2827f0ba47b947e894"),
MustHexID("b97532eb83054ed054b4abdf413bb30c00e4205545c93521554dbe77faa3cfaa5bd31ef466a107b0b34a71ec97214c0c83919720142cddac93aa7a3e928d4708"), MustHexID("b97532eb83054ed054b4abdf413bb30c00e4205545c93521554dbe77faa3cfaa5bd31ef466a107b0b34a71ec97214c0c83919720142cddac93aa7a3e928d4708"),
MustHexID("2f7a5e952bfb67f2f90b8441b5fadc9ee13b1dcde3afeeb3dd64bf937f86663cc5c55d1fa83952b5422763c7df1b7f2794b751c6be316ebc0beb4942e65ab8c1"), MustHexID("2f7a5e952bfb67f2f90b8441b5fadc9ee13b1dcde3afeeb3dd64bf937f86663cc5c55d1fa83952b5422763c7df1b7f2794b751c6be316ebc0beb4942e65ab8c1"),
@ -410,7 +410,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("fcc9a2e1ac3667026ff16192876d1813bb75abdbf39b929a92863012fe8b1d890badea7a0de36274d5c1eb1e8f975785532c50d80fd44b1a4b692f437303393f"), MustHexID("fcc9a2e1ac3667026ff16192876d1813bb75abdbf39b929a92863012fe8b1d890badea7a0de36274d5c1eb1e8f975785532c50d80fd44b1a4b692f437303393f"),
MustHexID("6d8b3efb461151dd4f6de809b62726f5b89e9b38e9ba1391967f61cde844f7528fecf821b74049207cee5a527096b31f3ad623928cd3ce51d926fa345a6b2951"), MustHexID("6d8b3efb461151dd4f6de809b62726f5b89e9b38e9ba1391967f61cde844f7528fecf821b74049207cee5a527096b31f3ad623928cd3ce51d926fa345a6b2951"),
}, },
252: []NodeID{ 252: {
MustHexID("f1ae93157cc48c2075dd5868fbf523e79e06caf4b8198f352f6e526680b78ff4227263de92612f7d63472bd09367bb92a636fff16fe46ccf41614f7a72495c2a"), MustHexID("f1ae93157cc48c2075dd5868fbf523e79e06caf4b8198f352f6e526680b78ff4227263de92612f7d63472bd09367bb92a636fff16fe46ccf41614f7a72495c2a"),
MustHexID("587f482d111b239c27c0cb89b51dd5d574db8efd8de14a2e6a1400c54d4567e77c65f89c1da52841212080b91604104768350276b6682f2f961cdaf4039581c7"), MustHexID("587f482d111b239c27c0cb89b51dd5d574db8efd8de14a2e6a1400c54d4567e77c65f89c1da52841212080b91604104768350276b6682f2f961cdaf4039581c7"),
MustHexID("e3f88274d35cefdaabdf205afe0e80e936cc982b8e3e47a84ce664c413b29016a4fb4f3a3ebae0a2f79671f8323661ed462bf4390af94c424dc8ace0c301b90f"), MustHexID("e3f88274d35cefdaabdf205afe0e80e936cc982b8e3e47a84ce664c413b29016a4fb4f3a3ebae0a2f79671f8323661ed462bf4390af94c424dc8ace0c301b90f"),
@ -428,7 +428,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("d84f06fe64debc4cd0625e36d19b99014b6218375262cc2209202bdbafd7dffcc4e34ce6398e182e02fd8faeed622c3e175545864902dfd3d1ac57647cddf4c6"), MustHexID("d84f06fe64debc4cd0625e36d19b99014b6218375262cc2209202bdbafd7dffcc4e34ce6398e182e02fd8faeed622c3e175545864902dfd3d1ac57647cddf4c6"),
MustHexID("d0ed87b294f38f1d741eb601020eeec30ac16331d05880fe27868f1e454446de367d7457b41c79e202eaf9525b029e4f1d7e17d85a55f83a557c005c68d7328a"), MustHexID("d0ed87b294f38f1d741eb601020eeec30ac16331d05880fe27868f1e454446de367d7457b41c79e202eaf9525b029e4f1d7e17d85a55f83a557c005c68d7328a"),
}, },
253: []NodeID{ 253: {
MustHexID("ad4485e386e3cc7c7310366a7c38fb810b8896c0d52e55944bfd320ca294e7912d6c53c0a0cf85e7ce226e92491d60430e86f8f15cda0161ed71893fb4a9e3a1"), MustHexID("ad4485e386e3cc7c7310366a7c38fb810b8896c0d52e55944bfd320ca294e7912d6c53c0a0cf85e7ce226e92491d60430e86f8f15cda0161ed71893fb4a9e3a1"),
MustHexID("36d0e7e5b7734f98c6183eeeb8ac5130a85e910a925311a19c4941b1290f945d4fc3996b12ef4966960b6fa0fb29b1604f83a0f81bd5fd6398d2e1a22e46af0c"), MustHexID("36d0e7e5b7734f98c6183eeeb8ac5130a85e910a925311a19c4941b1290f945d4fc3996b12ef4966960b6fa0fb29b1604f83a0f81bd5fd6398d2e1a22e46af0c"),
MustHexID("7d307d8acb4a561afa23bdf0bd945d35c90245e26345ec3a1f9f7df354222a7cdcb81339c9ed6744526c27a1a0c8d10857e98df942fa433602facac71ac68a31"), MustHexID("7d307d8acb4a561afa23bdf0bd945d35c90245e26345ec3a1f9f7df354222a7cdcb81339c9ed6744526c27a1a0c8d10857e98df942fa433602facac71ac68a31"),
@ -446,7 +446,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("7a369b2b8962cc4c65900be046482fbf7c14f98a135bbbae25152c82ad168fb2097b3d1429197cf46d3ce9fdeb64808f908a489cc6019725db040060fdfe5405"), MustHexID("7a369b2b8962cc4c65900be046482fbf7c14f98a135bbbae25152c82ad168fb2097b3d1429197cf46d3ce9fdeb64808f908a489cc6019725db040060fdfe5405"),
MustHexID("47bcae48288da5ecc7f5058dfa07cf14d89d06d6e449cb946e237aa6652ea050d9f5a24a65efdc0013ccf232bf88670979eddef249b054f63f38da9d7796dbd8"), MustHexID("47bcae48288da5ecc7f5058dfa07cf14d89d06d6e449cb946e237aa6652ea050d9f5a24a65efdc0013ccf232bf88670979eddef249b054f63f38da9d7796dbd8"),
}, },
254: []NodeID{ 254: {
MustHexID("099739d7abc8abd38ecc7a816c521a1168a4dbd359fa7212a5123ab583ffa1cf485a5fed219575d6475dbcdd541638b2d3631a6c7fce7474e7fe3cba1d4d5853"), MustHexID("099739d7abc8abd38ecc7a816c521a1168a4dbd359fa7212a5123ab583ffa1cf485a5fed219575d6475dbcdd541638b2d3631a6c7fce7474e7fe3cba1d4d5853"),
MustHexID("c2b01603b088a7182d0cf7ef29fb2b04c70acb320fccf78526bf9472e10c74ee70b3fcfa6f4b11d167bd7d3bc4d936b660f2c9bff934793d97cb21750e7c3d31"), MustHexID("c2b01603b088a7182d0cf7ef29fb2b04c70acb320fccf78526bf9472e10c74ee70b3fcfa6f4b11d167bd7d3bc4d936b660f2c9bff934793d97cb21750e7c3d31"),
MustHexID("20e4d8f45f2f863e94b45548c1ef22a11f7d36f263e4f8623761e05a64c4572379b000a52211751e2561b0f14f4fc92dd4130410c8ccc71eb4f0e95a700d4ca9"), MustHexID("20e4d8f45f2f863e94b45548c1ef22a11f7d36f263e4f8623761e05a64c4572379b000a52211751e2561b0f14f4fc92dd4130410c8ccc71eb4f0e95a700d4ca9"),
@ -464,7 +464,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("82504b6eb49bb2c0f91a7006ce9cefdbaf6df38706198502c2e06601091fc9dc91e4f15db3410d45c6af355bc270b0f268d3dff560f956985c7332d4b10bd1ed"), MustHexID("82504b6eb49bb2c0f91a7006ce9cefdbaf6df38706198502c2e06601091fc9dc91e4f15db3410d45c6af355bc270b0f268d3dff560f956985c7332d4b10bd1ed"),
MustHexID("b39b5b677b45944ceebe76e76d1f051de2f2a0ec7b0d650da52135743e66a9a5dba45f638258f9a7545d9a790c7fe6d3fdf82c25425c7887323e45d27d06c057"), MustHexID("b39b5b677b45944ceebe76e76d1f051de2f2a0ec7b0d650da52135743e66a9a5dba45f638258f9a7545d9a790c7fe6d3fdf82c25425c7887323e45d27d06c057"),
}, },
255: []NodeID{ 255: {
MustHexID("5c4d58d46e055dd1f093f81ee60a675e1f02f54da6206720adee4dccef9b67a31efc5c2a2949c31a04ee31beadc79aba10da31440a1f9ff2a24093c63c36d784"), MustHexID("5c4d58d46e055dd1f093f81ee60a675e1f02f54da6206720adee4dccef9b67a31efc5c2a2949c31a04ee31beadc79aba10da31440a1f9ff2a24093c63c36d784"),
MustHexID("ea72161ffdd4b1e124c7b93b0684805f4c4b58d617ed498b37a145c670dbc2e04976f8785583d9c805ffbf343c31d492d79f841652bbbd01b61ed85640b23495"), MustHexID("ea72161ffdd4b1e124c7b93b0684805f4c4b58d617ed498b37a145c670dbc2e04976f8785583d9c805ffbf343c31d492d79f841652bbbd01b61ed85640b23495"),
MustHexID("51caa1d93352d47a8e531692a3612adac1e8ac68d0a200d086c1c57ae1e1a91aa285ab242e8c52ef9d7afe374c9485b122ae815f1707b875569d0433c1c3ce85"), MustHexID("51caa1d93352d47a8e531692a3612adac1e8ac68d0a200d086c1c57ae1e1a91aa285ab242e8c52ef9d7afe374c9485b122ae815f1707b875569d0433c1c3ce85"),
@ -482,7 +482,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("f492c6ee2696d5f682f7f537757e52744c2ae560f1090a07024609e903d334e9e174fc01609c5a229ddbcac36c9d21adaf6457dab38a25bfd44f2f0ee4277998"), MustHexID("f492c6ee2696d5f682f7f537757e52744c2ae560f1090a07024609e903d334e9e174fc01609c5a229ddbcac36c9d21adaf6457dab38a25bfd44f2f0ee4277998"),
MustHexID("459e4db99298cb0467a90acee6888b08bb857450deac11015cced5104853be5adce5b69c740968bc7f931495d671a70cad9f48546d7cd203357fe9af0e8d2164"), MustHexID("459e4db99298cb0467a90acee6888b08bb857450deac11015cced5104853be5adce5b69c740968bc7f931495d671a70cad9f48546d7cd203357fe9af0e8d2164"),
}, },
256: []NodeID{ 256: {
MustHexID("a8593af8a4aef7b806b5197612017951bac8845a1917ca9a6a15dd6086d608505144990b245785c4cd2d67a295701c7aac2aa18823fb0033987284b019656268"), MustHexID("a8593af8a4aef7b806b5197612017951bac8845a1917ca9a6a15dd6086d608505144990b245785c4cd2d67a295701c7aac2aa18823fb0033987284b019656268"),
MustHexID("d2eebef914928c3aad77fc1b2a495f52d2294acf5edaa7d8a530b540f094b861a68fe8348a46a7c302f08ab609d85912a4968eacfea0740847b29421b4795d9e"), MustHexID("d2eebef914928c3aad77fc1b2a495f52d2294acf5edaa7d8a530b540f094b861a68fe8348a46a7c302f08ab609d85912a4968eacfea0740847b29421b4795d9e"),
MustHexID("b14bfcb31495f32b650b63cf7d08492e3e29071fdc73cf2da0da48d4b191a70ba1a65f42ad8c343206101f00f8a48e8db4b08bf3f622c0853e7323b250835b91"), MustHexID("b14bfcb31495f32b650b63cf7d08492e3e29071fdc73cf2da0da48d4b191a70ba1a65f42ad8c343206101f00f8a48e8db4b08bf3f622c0853e7323b250835b91"),

4
p2p/discv5/database_test.go
View File

@ -242,12 +242,12 @@ func TestNodeDBSeedQuery(t *testing.T) {
if len(seeds) != len(want) { if len(seeds) != len(want) {
t.Errorf("seed count mismatch: have %v, want %v", len(seeds), len(want)) t.Errorf("seed count mismatch: have %v, want %v", len(seeds), len(want))
} }
for id, _ := range have { for id := range have {
if _, ok := want[id]; !ok { if _, ok := want[id]; !ok {
t.Errorf("extra seed: %v", id) t.Errorf("extra seed: %v", id)
} }
} }
for id, _ := range want { for id := range want {
if _, ok := have[id]; !ok { if _, ok := have[id]; !ok {
t.Errorf("missing seed: %v", id) t.Errorf("missing seed: %v", id)
} }

26
p2p/discv5/net_test.go
View File

@ -69,19 +69,19 @@ var lookupTestnet = &preminedTestnet{
target: MustHexID("166aea4f556532c6d34e8b740e5d314af7e9ac0ca79833bd751d6b665f12dfd38ec563c363b32f02aef4a80b44fd3def94612d497b99cb5f17fd24de454927ec"), target: MustHexID("166aea4f556532c6d34e8b740e5d314af7e9ac0ca79833bd751d6b665f12dfd38ec563c363b32f02aef4a80b44fd3def94612d497b99cb5f17fd24de454927ec"),
targetSha: common.Hash{0x5c, 0x94, 0x4e, 0xe5, 0x1c, 0x5a, 0xe9, 0xf7, 0x2a, 0x95, 0xec, 0xcb, 0x8a, 0xed, 0x3, 0x74, 0xee, 0xcb, 0x51, 0x19, 0xd7, 0x20, 0xcb, 0xea, 0x68, 0x13, 0xe8, 0xe0, 0xd6, 0xad, 0x92, 0x61}, targetSha: common.Hash{0x5c, 0x94, 0x4e, 0xe5, 0x1c, 0x5a, 0xe9, 0xf7, 0x2a, 0x95, 0xec, 0xcb, 0x8a, 0xed, 0x3, 0x74, 0xee, 0xcb, 0x51, 0x19, 0xd7, 0x20, 0xcb, 0xea, 0x68, 0x13, 0xe8, 0xe0, 0xd6, 0xad, 0x92, 0x61},
dists: [257][]NodeID{ dists: [257][]NodeID{
240: []NodeID{ 240: {
MustHexID("2001ad5e3e80c71b952161bc0186731cf5ffe942d24a79230a0555802296238e57ea7a32f5b6f18564eadc1c65389448481f8c9338df0a3dbd18f708cbc2cbcb"), MustHexID("2001ad5e3e80c71b952161bc0186731cf5ffe942d24a79230a0555802296238e57ea7a32f5b6f18564eadc1c65389448481f8c9338df0a3dbd18f708cbc2cbcb"),
MustHexID("6ba3f4f57d084b6bf94cc4555b8c657e4a8ac7b7baf23c6874efc21dd1e4f56b7eb2721e07f5242d2f1d8381fc8cae535e860197c69236798ba1ad231b105794"), MustHexID("6ba3f4f57d084b6bf94cc4555b8c657e4a8ac7b7baf23c6874efc21dd1e4f56b7eb2721e07f5242d2f1d8381fc8cae535e860197c69236798ba1ad231b105794"),
}, },
244: []NodeID{ 244: {
MustHexID("696ba1f0a9d55c59246f776600542a9e6432490f0cd78f8bb55a196918df2081a9b521c3c3ba48e465a75c10768807717f8f689b0b4adce00e1c75737552a178"), MustHexID("696ba1f0a9d55c59246f776600542a9e6432490f0cd78f8bb55a196918df2081a9b521c3c3ba48e465a75c10768807717f8f689b0b4adce00e1c75737552a178"),
}, },
246: []NodeID{ 246: {
MustHexID("d6d32178bdc38416f46ffb8b3ec9e4cb2cfff8d04dd7e4311a70e403cb62b10be1b447311b60b4f9ee221a8131fc2cbd45b96dd80deba68a949d467241facfa8"), MustHexID("d6d32178bdc38416f46ffb8b3ec9e4cb2cfff8d04dd7e4311a70e403cb62b10be1b447311b60b4f9ee221a8131fc2cbd45b96dd80deba68a949d467241facfa8"),
MustHexID("3ea3d04a43a3dfb5ac11cffc2319248cf41b6279659393c2f55b8a0a5fc9d12581a9d97ef5d8ff9b5abf3321a290e8f63a4f785f450dc8a672aba3ba2ff4fdab"), MustHexID("3ea3d04a43a3dfb5ac11cffc2319248cf41b6279659393c2f55b8a0a5fc9d12581a9d97ef5d8ff9b5abf3321a290e8f63a4f785f450dc8a672aba3ba2ff4fdab"),
MustHexID("2fc897f05ae585553e5c014effd3078f84f37f9333afacffb109f00ca8e7a3373de810a3946be971cbccdfd40249f9fe7f322118ea459ac71acca85a1ef8b7f4"), MustHexID("2fc897f05ae585553e5c014effd3078f84f37f9333afacffb109f00ca8e7a3373de810a3946be971cbccdfd40249f9fe7f322118ea459ac71acca85a1ef8b7f4"),
}, },
247: []NodeID{ 247: {
MustHexID("3155e1427f85f10a5c9a7755877748041af1bcd8d474ec065eb33df57a97babf54bfd2103575fa829115d224c523596b401065a97f74010610fce76382c0bf32"), MustHexID("3155e1427f85f10a5c9a7755877748041af1bcd8d474ec065eb33df57a97babf54bfd2103575fa829115d224c523596b401065a97f74010610fce76382c0bf32"),
MustHexID("312c55512422cf9b8a4097e9a6ad79402e87a15ae909a4bfefa22398f03d20951933beea1e4dfa6f968212385e829f04c2d314fc2d4e255e0d3bc08792b069db"), MustHexID("312c55512422cf9b8a4097e9a6ad79402e87a15ae909a4bfefa22398f03d20951933beea1e4dfa6f968212385e829f04c2d314fc2d4e255e0d3bc08792b069db"),
MustHexID("38643200b172dcfef857492156971f0e6aa2c538d8b74010f8e140811d53b98c765dd2d96126051913f44582e8c199ad7c6d6819e9a56483f637feaac9448aac"), MustHexID("38643200b172dcfef857492156971f0e6aa2c538d8b74010f8e140811d53b98c765dd2d96126051913f44582e8c199ad7c6d6819e9a56483f637feaac9448aac"),
@ -93,7 +93,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("4ab0a75941b12892369b4490a1928c8ca52a9ad6d3dffbd1d8c0b907bc200fe74c022d011ec39b64808a39c0ca41f1d3254386c3e7733e7044c44259486461b6"), MustHexID("4ab0a75941b12892369b4490a1928c8ca52a9ad6d3dffbd1d8c0b907bc200fe74c022d011ec39b64808a39c0ca41f1d3254386c3e7733e7044c44259486461b6"),
MustHexID("d45150a72dc74388773e68e03133a3b5f51447fe91837d566706b3c035ee4b56f160c878c6273394daee7f56cc398985269052f22f75a8057df2fe6172765354"), MustHexID("d45150a72dc74388773e68e03133a3b5f51447fe91837d566706b3c035ee4b56f160c878c6273394daee7f56cc398985269052f22f75a8057df2fe6172765354"),
}, },
248: []NodeID{ 248: {
MustHexID("6aadfce366a189bab08ac84721567483202c86590642ea6d6a14f37ca78d82bdb6509eb7b8b2f6f63c78ae3ae1d8837c89509e41497d719b23ad53dd81574afa"), MustHexID("6aadfce366a189bab08ac84721567483202c86590642ea6d6a14f37ca78d82bdb6509eb7b8b2f6f63c78ae3ae1d8837c89509e41497d719b23ad53dd81574afa"),
MustHexID("a605ecfd6069a4cf4cf7f5840e5bc0ce10d23a3ac59e2aaa70c6afd5637359d2519b4524f56fc2ca180cdbebe54262f720ccaae8c1b28fd553c485675831624d"), MustHexID("a605ecfd6069a4cf4cf7f5840e5bc0ce10d23a3ac59e2aaa70c6afd5637359d2519b4524f56fc2ca180cdbebe54262f720ccaae8c1b28fd553c485675831624d"),
MustHexID("29701451cb9448ca33fc33680b44b840d815be90146eb521641efbffed0859c154e8892d3906eae9934bfacee72cd1d2fa9dd050fd18888eea49da155ab0efd2"), MustHexID("29701451cb9448ca33fc33680b44b840d815be90146eb521641efbffed0859c154e8892d3906eae9934bfacee72cd1d2fa9dd050fd18888eea49da155ab0efd2"),
@ -111,7 +111,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("b76ea1a6fd6506ef6e3506a4f1f60ed6287fff8114af6141b2ff13e61242331b54082b023cfea5b3083354a4fb3f9eb8be01fb4a518f579e731a5d0707291a6b"), MustHexID("b76ea1a6fd6506ef6e3506a4f1f60ed6287fff8114af6141b2ff13e61242331b54082b023cfea5b3083354a4fb3f9eb8be01fb4a518f579e731a5d0707291a6b"),
MustHexID("9b53a37950ca8890ee349b325032d7b672cab7eced178d3060137b24ef6b92a43977922d5bdfb4a3409a2d80128e02f795f9dae6d7d99973ad0e23a2afb8442f"), MustHexID("9b53a37950ca8890ee349b325032d7b672cab7eced178d3060137b24ef6b92a43977922d5bdfb4a3409a2d80128e02f795f9dae6d7d99973ad0e23a2afb8442f"),
}, },
249: []NodeID{ 249: {
MustHexID("675ae65567c3c72c50c73bc0fd4f61f202ea5f93346ca57b551de3411ccc614fad61cb9035493af47615311b9d44ee7a161972ee4d77c28fe1ec029d01434e6a"), MustHexID("675ae65567c3c72c50c73bc0fd4f61f202ea5f93346ca57b551de3411ccc614fad61cb9035493af47615311b9d44ee7a161972ee4d77c28fe1ec029d01434e6a"),
MustHexID("8eb81408389da88536ae5800392b16ef5109d7ea132c18e9a82928047ecdb502693f6e4a4cdd18b54296caf561db937185731456c456c98bfe7de0baf0eaa495"), MustHexID("8eb81408389da88536ae5800392b16ef5109d7ea132c18e9a82928047ecdb502693f6e4a4cdd18b54296caf561db937185731456c456c98bfe7de0baf0eaa495"),
MustHexID("2adba8b1612a541771cb93a726a38a4b88e97b18eced2593eb7daf82f05a5321ca94a72cc780c306ff21e551a932fc2c6d791e4681907b5ceab7f084c3fa2944"), MustHexID("2adba8b1612a541771cb93a726a38a4b88e97b18eced2593eb7daf82f05a5321ca94a72cc780c306ff21e551a932fc2c6d791e4681907b5ceab7f084c3fa2944"),
@ -129,7 +129,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("d94193f236105010972f5df1b7818b55846592a0445b9cdc4eaed811b8c4c0f7c27dc8cc9837a4774656d6b34682d6d329d42b6ebb55da1d475c2474dc3dfdf4"), MustHexID("d94193f236105010972f5df1b7818b55846592a0445b9cdc4eaed811b8c4c0f7c27dc8cc9837a4774656d6b34682d6d329d42b6ebb55da1d475c2474dc3dfdf4"),
MustHexID("edd9af6aded4094e9785637c28fccbd3980cbe28e2eb9a411048a23c2ace4bd6b0b7088a7817997b49a3dd05fc6929ca6c7abbb69438dbdabe65e971d2a794b2"), MustHexID("edd9af6aded4094e9785637c28fccbd3980cbe28e2eb9a411048a23c2ace4bd6b0b7088a7817997b49a3dd05fc6929ca6c7abbb69438dbdabe65e971d2a794b2"),
}, },
250: []NodeID{ 250: {
MustHexID("53a5bd1215d4ab709ae8fdc2ced50bba320bced78bd9c5dc92947fb402250c914891786db0978c898c058493f86fc68b1c5de8a5cb36336150ac7a88655b6c39"), MustHexID("53a5bd1215d4ab709ae8fdc2ced50bba320bced78bd9c5dc92947fb402250c914891786db0978c898c058493f86fc68b1c5de8a5cb36336150ac7a88655b6c39"),
MustHexID("b7f79e3ab59f79262623c9ccefc8f01d682323aee56ffbe295437487e9d5acaf556a9c92e1f1c6a9601f2b9eb6b027ae1aeaebac71d61b9b78e88676efd3e1a3"), MustHexID("b7f79e3ab59f79262623c9ccefc8f01d682323aee56ffbe295437487e9d5acaf556a9c92e1f1c6a9601f2b9eb6b027ae1aeaebac71d61b9b78e88676efd3e1a3"),
MustHexID("d374bf7e8d7ffff69cc00bebff38ef5bc1dcb0a8d51c1a3d70e61ac6b2e2d6617109254b0ac224354dfbf79009fe4239e09020c483cc60c071e00b9238684f30"), MustHexID("d374bf7e8d7ffff69cc00bebff38ef5bc1dcb0a8d51c1a3d70e61ac6b2e2d6617109254b0ac224354dfbf79009fe4239e09020c483cc60c071e00b9238684f30"),
@ -147,7 +147,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("5b116f0751526868a909b61a30b0c5282c37df6925cc03ddea556ef0d0602a9595fd6c14d371f8ed7d45d89918a032dcd22be4342a8793d88fdbeb3ca3d75bd7"), MustHexID("5b116f0751526868a909b61a30b0c5282c37df6925cc03ddea556ef0d0602a9595fd6c14d371f8ed7d45d89918a032dcd22be4342a8793d88fdbeb3ca3d75bd7"),
MustHexID("50f3222fb6b82481c7c813b2172e1daea43e2710a443b9c2a57a12bd160dd37e20f87aa968c82ad639af6972185609d47036c0d93b4b7269b74ebd7073221c10"), MustHexID("50f3222fb6b82481c7c813b2172e1daea43e2710a443b9c2a57a12bd160dd37e20f87aa968c82ad639af6972185609d47036c0d93b4b7269b74ebd7073221c10"),
}, },
251: []NodeID{ 251: {
MustHexID("9b8f702a62d1bee67bedfeb102eca7f37fa1713e310f0d6651cc0c33ea7c5477575289ccd463e5a2574a00a676a1fdce05658ba447bb9d2827f0ba47b947e894"), MustHexID("9b8f702a62d1bee67bedfeb102eca7f37fa1713e310f0d6651cc0c33ea7c5477575289ccd463e5a2574a00a676a1fdce05658ba447bb9d2827f0ba47b947e894"),
MustHexID("b97532eb83054ed054b4abdf413bb30c00e4205545c93521554dbe77faa3cfaa5bd31ef466a107b0b34a71ec97214c0c83919720142cddac93aa7a3e928d4708"), MustHexID("b97532eb83054ed054b4abdf413bb30c00e4205545c93521554dbe77faa3cfaa5bd31ef466a107b0b34a71ec97214c0c83919720142cddac93aa7a3e928d4708"),
MustHexID("2f7a5e952bfb67f2f90b8441b5fadc9ee13b1dcde3afeeb3dd64bf937f86663cc5c55d1fa83952b5422763c7df1b7f2794b751c6be316ebc0beb4942e65ab8c1"), MustHexID("2f7a5e952bfb67f2f90b8441b5fadc9ee13b1dcde3afeeb3dd64bf937f86663cc5c55d1fa83952b5422763c7df1b7f2794b751c6be316ebc0beb4942e65ab8c1"),
@ -165,7 +165,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("fcc9a2e1ac3667026ff16192876d1813bb75abdbf39b929a92863012fe8b1d890badea7a0de36274d5c1eb1e8f975785532c50d80fd44b1a4b692f437303393f"), MustHexID("fcc9a2e1ac3667026ff16192876d1813bb75abdbf39b929a92863012fe8b1d890badea7a0de36274d5c1eb1e8f975785532c50d80fd44b1a4b692f437303393f"),
MustHexID("6d8b3efb461151dd4f6de809b62726f5b89e9b38e9ba1391967f61cde844f7528fecf821b74049207cee5a527096b31f3ad623928cd3ce51d926fa345a6b2951"), MustHexID("6d8b3efb461151dd4f6de809b62726f5b89e9b38e9ba1391967f61cde844f7528fecf821b74049207cee5a527096b31f3ad623928cd3ce51d926fa345a6b2951"),
}, },
252: []NodeID{ 252: {
MustHexID("f1ae93157cc48c2075dd5868fbf523e79e06caf4b8198f352f6e526680b78ff4227263de92612f7d63472bd09367bb92a636fff16fe46ccf41614f7a72495c2a"), MustHexID("f1ae93157cc48c2075dd5868fbf523e79e06caf4b8198f352f6e526680b78ff4227263de92612f7d63472bd09367bb92a636fff16fe46ccf41614f7a72495c2a"),
MustHexID("587f482d111b239c27c0cb89b51dd5d574db8efd8de14a2e6a1400c54d4567e77c65f89c1da52841212080b91604104768350276b6682f2f961cdaf4039581c7"), MustHexID("587f482d111b239c27c0cb89b51dd5d574db8efd8de14a2e6a1400c54d4567e77c65f89c1da52841212080b91604104768350276b6682f2f961cdaf4039581c7"),
MustHexID("e3f88274d35cefdaabdf205afe0e80e936cc982b8e3e47a84ce664c413b29016a4fb4f3a3ebae0a2f79671f8323661ed462bf4390af94c424dc8ace0c301b90f"), MustHexID("e3f88274d35cefdaabdf205afe0e80e936cc982b8e3e47a84ce664c413b29016a4fb4f3a3ebae0a2f79671f8323661ed462bf4390af94c424dc8ace0c301b90f"),
@ -183,7 +183,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("d84f06fe64debc4cd0625e36d19b99014b6218375262cc2209202bdbafd7dffcc4e34ce6398e182e02fd8faeed622c3e175545864902dfd3d1ac57647cddf4c6"), MustHexID("d84f06fe64debc4cd0625e36d19b99014b6218375262cc2209202bdbafd7dffcc4e34ce6398e182e02fd8faeed622c3e175545864902dfd3d1ac57647cddf4c6"),
MustHexID("d0ed87b294f38f1d741eb601020eeec30ac16331d05880fe27868f1e454446de367d7457b41c79e202eaf9525b029e4f1d7e17d85a55f83a557c005c68d7328a"), MustHexID("d0ed87b294f38f1d741eb601020eeec30ac16331d05880fe27868f1e454446de367d7457b41c79e202eaf9525b029e4f1d7e17d85a55f83a557c005c68d7328a"),
}, },
253: []NodeID{ 253: {
MustHexID("ad4485e386e3cc7c7310366a7c38fb810b8896c0d52e55944bfd320ca294e7912d6c53c0a0cf85e7ce226e92491d60430e86f8f15cda0161ed71893fb4a9e3a1"), MustHexID("ad4485e386e3cc7c7310366a7c38fb810b8896c0d52e55944bfd320ca294e7912d6c53c0a0cf85e7ce226e92491d60430e86f8f15cda0161ed71893fb4a9e3a1"),
MustHexID("36d0e7e5b7734f98c6183eeeb8ac5130a85e910a925311a19c4941b1290f945d4fc3996b12ef4966960b6fa0fb29b1604f83a0f81bd5fd6398d2e1a22e46af0c"), MustHexID("36d0e7e5b7734f98c6183eeeb8ac5130a85e910a925311a19c4941b1290f945d4fc3996b12ef4966960b6fa0fb29b1604f83a0f81bd5fd6398d2e1a22e46af0c"),
MustHexID("7d307d8acb4a561afa23bdf0bd945d35c90245e26345ec3a1f9f7df354222a7cdcb81339c9ed6744526c27a1a0c8d10857e98df942fa433602facac71ac68a31"), MustHexID("7d307d8acb4a561afa23bdf0bd945d35c90245e26345ec3a1f9f7df354222a7cdcb81339c9ed6744526c27a1a0c8d10857e98df942fa433602facac71ac68a31"),
@ -201,7 +201,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("7a369b2b8962cc4c65900be046482fbf7c14f98a135bbbae25152c82ad168fb2097b3d1429197cf46d3ce9fdeb64808f908a489cc6019725db040060fdfe5405"), MustHexID("7a369b2b8962cc4c65900be046482fbf7c14f98a135bbbae25152c82ad168fb2097b3d1429197cf46d3ce9fdeb64808f908a489cc6019725db040060fdfe5405"),
MustHexID("47bcae48288da5ecc7f5058dfa07cf14d89d06d6e449cb946e237aa6652ea050d9f5a24a65efdc0013ccf232bf88670979eddef249b054f63f38da9d7796dbd8"), MustHexID("47bcae48288da5ecc7f5058dfa07cf14d89d06d6e449cb946e237aa6652ea050d9f5a24a65efdc0013ccf232bf88670979eddef249b054f63f38da9d7796dbd8"),
}, },
254: []NodeID{ 254: {
MustHexID("099739d7abc8abd38ecc7a816c521a1168a4dbd359fa7212a5123ab583ffa1cf485a5fed219575d6475dbcdd541638b2d3631a6c7fce7474e7fe3cba1d4d5853"), MustHexID("099739d7abc8abd38ecc7a816c521a1168a4dbd359fa7212a5123ab583ffa1cf485a5fed219575d6475dbcdd541638b2d3631a6c7fce7474e7fe3cba1d4d5853"),
MustHexID("c2b01603b088a7182d0cf7ef29fb2b04c70acb320fccf78526bf9472e10c74ee70b3fcfa6f4b11d167bd7d3bc4d936b660f2c9bff934793d97cb21750e7c3d31"), MustHexID("c2b01603b088a7182d0cf7ef29fb2b04c70acb320fccf78526bf9472e10c74ee70b3fcfa6f4b11d167bd7d3bc4d936b660f2c9bff934793d97cb21750e7c3d31"),
MustHexID("20e4d8f45f2f863e94b45548c1ef22a11f7d36f263e4f8623761e05a64c4572379b000a52211751e2561b0f14f4fc92dd4130410c8ccc71eb4f0e95a700d4ca9"), MustHexID("20e4d8f45f2f863e94b45548c1ef22a11f7d36f263e4f8623761e05a64c4572379b000a52211751e2561b0f14f4fc92dd4130410c8ccc71eb4f0e95a700d4ca9"),
@ -219,7 +219,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("82504b6eb49bb2c0f91a7006ce9cefdbaf6df38706198502c2e06601091fc9dc91e4f15db3410d45c6af355bc270b0f268d3dff560f956985c7332d4b10bd1ed"), MustHexID("82504b6eb49bb2c0f91a7006ce9cefdbaf6df38706198502c2e06601091fc9dc91e4f15db3410d45c6af355bc270b0f268d3dff560f956985c7332d4b10bd1ed"),
MustHexID("b39b5b677b45944ceebe76e76d1f051de2f2a0ec7b0d650da52135743e66a9a5dba45f638258f9a7545d9a790c7fe6d3fdf82c25425c7887323e45d27d06c057"), MustHexID("b39b5b677b45944ceebe76e76d1f051de2f2a0ec7b0d650da52135743e66a9a5dba45f638258f9a7545d9a790c7fe6d3fdf82c25425c7887323e45d27d06c057"),
}, },
255: []NodeID{ 255: {
MustHexID("5c4d58d46e055dd1f093f81ee60a675e1f02f54da6206720adee4dccef9b67a31efc5c2a2949c31a04ee31beadc79aba10da31440a1f9ff2a24093c63c36d784"), MustHexID("5c4d58d46e055dd1f093f81ee60a675e1f02f54da6206720adee4dccef9b67a31efc5c2a2949c31a04ee31beadc79aba10da31440a1f9ff2a24093c63c36d784"),
MustHexID("ea72161ffdd4b1e124c7b93b0684805f4c4b58d617ed498b37a145c670dbc2e04976f8785583d9c805ffbf343c31d492d79f841652bbbd01b61ed85640b23495"), MustHexID("ea72161ffdd4b1e124c7b93b0684805f4c4b58d617ed498b37a145c670dbc2e04976f8785583d9c805ffbf343c31d492d79f841652bbbd01b61ed85640b23495"),
MustHexID("51caa1d93352d47a8e531692a3612adac1e8ac68d0a200d086c1c57ae1e1a91aa285ab242e8c52ef9d7afe374c9485b122ae815f1707b875569d0433c1c3ce85"), MustHexID("51caa1d93352d47a8e531692a3612adac1e8ac68d0a200d086c1c57ae1e1a91aa285ab242e8c52ef9d7afe374c9485b122ae815f1707b875569d0433c1c3ce85"),
@ -237,7 +237,7 @@ var lookupTestnet = &preminedTestnet{
MustHexID("f492c6ee2696d5f682f7f537757e52744c2ae560f1090a07024609e903d334e9e174fc01609c5a229ddbcac36c9d21adaf6457dab38a25bfd44f2f0ee4277998"), MustHexID("f492c6ee2696d5f682f7f537757e52744c2ae560f1090a07024609e903d334e9e174fc01609c5a229ddbcac36c9d21adaf6457dab38a25bfd44f2f0ee4277998"),
MustHexID("459e4db99298cb0467a90acee6888b08bb857450deac11015cced5104853be5adce5b69c740968bc7f931495d671a70cad9f48546d7cd203357fe9af0e8d2164"), MustHexID("459e4db99298cb0467a90acee6888b08bb857450deac11015cced5104853be5adce5b69c740968bc7f931495d671a70cad9f48546d7cd203357fe9af0e8d2164"),
}, },
256: []NodeID{ 256: {
MustHexID("a8593af8a4aef7b806b5197612017951bac8845a1917ca9a6a15dd6086d608505144990b245785c4cd2d67a295701c7aac2aa18823fb0033987284b019656268"), MustHexID("a8593af8a4aef7b806b5197612017951bac8845a1917ca9a6a15dd6086d608505144990b245785c4cd2d67a295701c7aac2aa18823fb0033987284b019656268"),
MustHexID("d2eebef914928c3aad77fc1b2a495f52d2294acf5edaa7d8a530b540f094b861a68fe8348a46a7c302f08ab609d85912a4968eacfea0740847b29421b4795d9e"), MustHexID("d2eebef914928c3aad77fc1b2a495f52d2294acf5edaa7d8a530b540f094b861a68fe8348a46a7c302f08ab609d85912a4968eacfea0740847b29421b4795d9e"),
MustHexID("b14bfcb31495f32b650b63cf7d08492e3e29071fdc73cf2da0da48d4b191a70ba1a65f42ad8c343206101f00f8a48e8db4b08bf3f622c0853e7323b250835b91"), MustHexID("b14bfcb31495f32b650b63cf7d08492e3e29071fdc73cf2da0da48d4b191a70ba1a65f42ad8c343206101f00f8a48e8db4b08bf3f622c0853e7323b250835b91"),

6
p2p/discv5/sim_test.go
View File

@ -74,7 +74,7 @@ func TestSimTopics(t *testing.T) {
go func() { go func() {
nets := make([]*Network, 1024) nets := make([]*Network, 1024)
for i, _ := range nets { for i := range nets {
net := sim.launchNode(false) net := sim.launchNode(false)
nets[i] = net nets[i] = net
if err := net.SetFallbackNodes([]*Node{bootnode.Self()}); err != nil { if err := net.SetFallbackNodes([]*Node{bootnode.Self()}); err != nil {
@ -147,7 +147,7 @@ func TestSimTopics(t *testing.T) {
func testHierarchicalTopics(i int) []Topic { func testHierarchicalTopics(i int) []Topic {
digits := strconv.FormatInt(int64(128+i/8), 2) digits := strconv.FormatInt(int64(128+i/8), 2)
res := make([]Topic, 8) res := make([]Topic, 8)
for i, _ := range res { for i := range res {
res[i] = Topic("foo" + digits[1:i+1]) res[i] = Topic("foo" + digits[1:i+1])
} }
return res return res
@ -167,7 +167,7 @@ func TestSimTopicHierarchy(t *testing.T) {
go func() { go func() {
nets := make([]*Network, 1024) nets := make([]*Network, 1024)
for i, _ := range nets { for i := range nets {
net := sim.launchNode(false) net := sim.launchNode(false)
nets[i] = net nets[i] = net
if err := net.SetFallbackNodes([]*Node{bootnode.Self()}); err != nil { if err := net.SetFallbackNodes([]*Node{bootnode.Self()}); err != nil {

2
p2p/discv5/ticket.go
View File

@ -831,7 +831,7 @@ func (r *topicRadius) recalcRadius() (radius uint64, radiusLookup int) {
maxValue := float64(0) maxValue := float64(0)
now := mclock.Now() now := mclock.Now()
v := float64(0) v := float64(0)
for i, _ := range r.buckets { for i := range r.buckets {
r.buckets[i].update(now) r.buckets[i].update(now)
v += r.buckets[i].weights[trOutside] - r.buckets[i].weights[trInside] v += r.buckets[i].weights[trOutside] - r.buckets[i].weights[trInside]
r.buckets[i].value = v r.buckets[i].value = v

2
p2p/discv5/topic.go
View File

@ -316,7 +316,7 @@ func (t *topicTable) collectGarbage() {
t.checkDeleteNode(node) t.checkDeleteNode(node)
} }
for topic, _ := range t.topics { for topic := range t.topics {
t.checkDeleteTopic(topic) t.checkDeleteTopic(topic)
} }
} }

2
p2p/nat/natpmp.go
View File

@ -82,7 +82,7 @@ func discoverPMP() Interface {
// any responses after a very short timeout. // any responses after a very short timeout.
timeout := time.NewTimer(1 * time.Second) timeout := time.NewTimer(1 * time.Second)
defer timeout.Stop() defer timeout.Stop()
for _ = range gws { for range gws {
select { select {
case c := <-found: case c := <-found:
if c != nil { if c != nil {

2
p2p/peer_test.go
View File

@ -299,7 +299,7 @@ func TestMatchProtocols(t *testing.T) {
} }
} }
// Make sure no protocols missed negotiation // Make sure no protocols missed negotiation
for name, _ := range tt.Match { for name := range tt.Match {
if _, ok := result[name]; !ok { if _, ok := result[name]; !ok {
t.Errorf("test %d, proto '%s': not negotiated, should have", i, name) t.Errorf("test %d, proto '%s': not negotiated, should have", i, name)
continue continue

8
rpc/json.go
View File

@ -166,7 +166,7 @@ func parseRequest(incomingMsg json.RawMessage) ([]rpcRequest, bool, Error) {
// subscribe are special, they will always use `subscribeMethod` as first param in the payload // subscribe are special, they will always use `subscribeMethod` as first param in the payload
if in.Method == subscribeMethod { if in.Method == subscribeMethod {
reqs := []rpcRequest{rpcRequest{id: &in.Id, isPubSub: true}} reqs := []rpcRequest{{id: &in.Id, isPubSub: true}}
if len(in.Payload) > 0 { if len(in.Payload) > 0 {
// first param must be subscription name // first param must be subscription name
var subscribeMethod [1]string var subscribeMethod [1]string
@ -184,7 +184,7 @@ func parseRequest(incomingMsg json.RawMessage) ([]rpcRequest, bool, Error) {
} }
if in.Method == unsubscribeMethod { if in.Method == unsubscribeMethod {
return []rpcRequest{rpcRequest{id: &in.Id, isPubSub: true, return []rpcRequest{{id: &in.Id, isPubSub: true,
method: unsubscribeMethod, params: in.Payload}}, false, nil method: unsubscribeMethod, params: in.Payload}}, false, nil
} }
@ -195,10 +195,10 @@ func parseRequest(incomingMsg json.RawMessage) ([]rpcRequest, bool, Error) {
// regular RPC call // regular RPC call
if len(in.Payload) == 0 { if len(in.Payload) == 0 {
return []rpcRequest{rpcRequest{service: elems[0], method: elems[1], id: &in.Id}}, false, nil return []rpcRequest{{service: elems[0], method: elems[1], id: &in.Id}}, false, nil
} }
return []rpcRequest{rpcRequest{service: elems[0], method: elems[1], id: &in.Id, params: in.Payload}}, false, nil return []rpcRequest{{service: elems[0], method: elems[1], id: &in.Id, params: in.Payload}}, false, nil
} }
// parseBatchRequest will parse a batch request into a collection of requests from the given RawMessage, an indication // parseBatchRequest will parse a batch request into a collection of requests from the given RawMessage, an indication

4
swarm/storage/dpa_test.go
View File

@ -67,7 +67,7 @@ func TestDPArandom(t *testing.T) {
ioutil.WriteFile("/tmp/result.bzz.16M", resultSlice, 0666) ioutil.WriteFile("/tmp/result.bzz.16M", resultSlice, 0666)
localStore.memStore = NewMemStore(dbStore, defaultCacheCapacity) localStore.memStore = NewMemStore(dbStore, defaultCacheCapacity)
resultReader = dpa.Retrieve(key) resultReader = dpa.Retrieve(key)
for i, _ := range resultSlice { for i := range resultSlice {
resultSlice[i] = 0 resultSlice[i] = 0
} }
n, err = resultReader.ReadAt(resultSlice, 0) n, err = resultReader.ReadAt(resultSlice, 0)
@ -128,7 +128,7 @@ func TestDPA_capacity(t *testing.T) {
dpa.ChunkStore = localStore dpa.ChunkStore = localStore
// localStore.dbStore.setCapacity(0) // localStore.dbStore.setCapacity(0)
resultReader = dpa.Retrieve(key) resultReader = dpa.Retrieve(key)
for i, _ := range resultSlice { for i := range resultSlice {
resultSlice[i] = 0 resultSlice[i] = 0
} }
n, err = resultReader.ReadAt(resultSlice, 0) n, err = resultReader.ReadAt(resultSlice, 0)

2
trie/encoding.go
View File

@ -80,7 +80,7 @@ func compactHexEncode(nibbles []byte) []byte {
} }
l := (nl + 1) / 2 l := (nl + 1) / 2
var str = make([]byte, l) var str = make([]byte, l)
for i, _ := range str { for i := range str {
b := nibbles[i*2] * 16 b := nibbles[i*2] * 16
if nl > i*2 { if nl > i*2 {
b += nibbles[i*2+1] b += nibbles[i*2+1]

2
trie/iterator_test.go
View File

@ -105,7 +105,7 @@ func TestNodeIteratorCoverage(t *testing.T) {
} }
} }
// Cross check the hashes and the database itself // Cross check the hashes and the database itself
for hash, _ := range hashes { for hash := range hashes {
if _, err := db.Get(hash.Bytes()); err != nil { if _, err := db.Get(hash.Bytes()); err != nil {
t.Errorf("failed to retrieve reported node %x: %v", hash, err) t.Errorf("failed to retrieve reported node %x: %v", hash, err)
} }

4
trie/sync_test.go
View File

@ -182,7 +182,7 @@ func testIterativeRandomTrieSync(t *testing.T, batch int) {
for len(queue) > 0 { for len(queue) > 0 {
// Fetch all the queued nodes in a random order // Fetch all the queued nodes in a random order
results := make([]SyncResult, 0, len(queue)) results := make([]SyncResult, 0, len(queue))
for hash, _ := range queue { for hash := range queue {
data, err := srcDb.Get(hash.Bytes()) data, err := srcDb.Get(hash.Bytes())
if err != nil { if err != nil {
t.Fatalf("failed to retrieve node data for %x: %v", hash, err) t.Fatalf("failed to retrieve node data for %x: %v", hash, err)
@ -219,7 +219,7 @@ func TestIterativeRandomDelayedTrieSync(t *testing.T) {
for len(queue) > 0 { for len(queue) > 0 {
// Sync only half of the scheduled nodes, even those in random order // Sync only half of the scheduled nodes, even those in random order
results := make([]SyncResult, 0, len(queue)/2+1) results := make([]SyncResult, 0, len(queue)/2+1)
for hash, _ := range queue { for hash := range queue {
data, err := srcDb.Get(hash.Bytes()) data, err := srcDb.Get(hash.Bytes())
if err != nil { if err != nil {
t.Fatalf("failed to retrieve node data for %x: %v", hash, err) t.Fatalf("failed to retrieve node data for %x: %v", hash, err)

2
whisper/whisperv2/filter.go
View File

@ -116,7 +116,7 @@ func (self filterer) Compare(f filter.Filter) bool {
topics := make([]Topic, len(filter.matcher.conditions)) topics := make([]Topic, len(filter.matcher.conditions))
for i, group := range filter.matcher.conditions { for i, group := range filter.matcher.conditions {
// Message should contain a single topic entry, extract // Message should contain a single topic entry, extract
for topics[i], _ = range group { for topics[i] = range group {
break break
} }
} }

2
whisper/whisperv2/peer.go
View File

@ -149,7 +149,7 @@ func (self *peer) expire() {
return true return true
}) })
// Dump all known but unavailable // Dump all known but unavailable
for hash, _ := range unmark { for hash := range unmark {
self.known.Remove(hash) self.known.Remove(hash)
} }
} }

2
whisper/whisperv2/peer_test.go
View File

@ -221,7 +221,7 @@ func TestPeerMessageExpiration(t *testing.T) {
t.Fatalf("peer pool size mismatch: have %v, want %v", peers, 1) t.Fatalf("peer pool size mismatch: have %v, want %v", peers, 1)
} }
var peer *peer var peer *peer
for peer, _ = range tester.client.peers { for peer = range tester.client.peers {
break break
} }
tester.client.peerMu.RUnlock() tester.client.peerMu.RUnlock()

52
whisper/whisperv2/topic_test.go
View File

@ -73,30 +73,30 @@ var topicMatcherCreationTest = struct {
matcher []map[[4]byte]struct{} matcher []map[[4]byte]struct{}
}{ }{
binary: [][][]byte{ binary: [][][]byte{
[][]byte{}, {},
[][]byte{ {
[]byte("Topic A"), []byte("Topic A"),
}, },
[][]byte{ {
[]byte("Topic B1"), []byte("Topic B1"),
[]byte("Topic B2"), []byte("Topic B2"),
[]byte("Topic B3"), []byte("Topic B3"),
}, },
}, },
textual: [][]string{ textual: [][]string{
[]string{}, {},
[]string{"Topic A"}, {"Topic A"},
[]string{"Topic B1", "Topic B2", "Topic B3"}, {"Topic B1", "Topic B2", "Topic B3"},
}, },
matcher: []map[[4]byte]struct{}{ matcher: []map[[4]byte]struct{}{
map[[4]byte]struct{}{}, {},
map[[4]byte]struct{}{ {
[4]byte{0x25, 0xfc, 0x95, 0x66}: struct{}{}, {0x25, 0xfc, 0x95, 0x66}: {},
}, },
map[[4]byte]struct{}{ {
[4]byte{0x93, 0x6d, 0xec, 0x09}: struct{}{}, {0x93, 0x6d, 0xec, 0x09}: {},
[4]byte{0x25, 0x23, 0x34, 0xd3}: struct{}{}, {0x25, 0x23, 0x34, 0xd3}: {},
[4]byte{0x6b, 0xc2, 0x73, 0xd1}: struct{}{}, {0x6b, 0xc2, 0x73, 0xd1}: {},
}, },
}, },
} }
@ -106,14 +106,14 @@ func TestTopicMatcherCreation(t *testing.T) {
matcher := newTopicMatcherFromBinary(test.binary...) matcher := newTopicMatcherFromBinary(test.binary...)
for i, cond := range matcher.conditions { for i, cond := range matcher.conditions {
for topic, _ := range cond { for topic := range cond {
if _, ok := test.matcher[i][topic]; !ok { if _, ok := test.matcher[i][topic]; !ok {
t.Errorf("condition %d; extra topic found: 0x%x", i, topic[:]) t.Errorf("condition %d; extra topic found: 0x%x", i, topic[:])
} }
} }
} }
for i, cond := range test.matcher { for i, cond := range test.matcher {
for topic, _ := range cond { for topic := range cond {
if _, ok := matcher.conditions[i][topic]; !ok { if _, ok := matcher.conditions[i][topic]; !ok {
t.Errorf("condition %d; topic not found: 0x%x", i, topic[:]) t.Errorf("condition %d; topic not found: 0x%x", i, topic[:])
} }
@ -122,14 +122,14 @@ func TestTopicMatcherCreation(t *testing.T) {
matcher = newTopicMatcherFromStrings(test.textual...) matcher = newTopicMatcherFromStrings(test.textual...)
for i, cond := range matcher.conditions { for i, cond := range matcher.conditions {
for topic, _ := range cond { for topic := range cond {
if _, ok := test.matcher[i][topic]; !ok { if _, ok := test.matcher[i][topic]; !ok {
t.Errorf("condition %d; extra topic found: 0x%x", i, topic[:]) t.Errorf("condition %d; extra topic found: 0x%x", i, topic[:])
} }
} }
} }
for i, cond := range test.matcher { for i, cond := range test.matcher {
for topic, _ := range cond { for topic := range cond {
if _, ok := matcher.conditions[i][topic]; !ok { if _, ok := matcher.conditions[i][topic]; !ok {
t.Errorf("condition %d; topic not found: 0x%x", i, topic[:]) t.Errorf("condition %d; topic not found: 0x%x", i, topic[:])
} }
@ -155,49 +155,49 @@ var topicMatcherTests = []struct {
}, },
// Fixed topic matcher should match strictly, but only prefix // Fixed topic matcher should match strictly, but only prefix
{ {
filter: [][]string{[]string{"a"}, []string{"b"}}, filter: [][]string{{"a"}, {"b"}},
topics: []string{"a"}, topics: []string{"a"},
match: false, match: false,
}, },
{ {
filter: [][]string{[]string{"a"}, []string{"b"}}, filter: [][]string{{"a"}, {"b"}},
topics: []string{"a", "b"}, topics: []string{"a", "b"},
match: true, match: true,
}, },
{ {
filter: [][]string{[]string{"a"}, []string{"b"}}, filter: [][]string{{"a"}, {"b"}},
topics: []string{"a", "b", "c"}, topics: []string{"a", "b", "c"},
match: true, match: true,
}, },
// Multi-matcher should match any from a sub-group // Multi-matcher should match any from a sub-group
{ {
filter: [][]string{[]string{"a1", "a2"}}, filter: [][]string{{"a1", "a2"}},
topics: []string{"a"}, topics: []string{"a"},
match: false, match: false,
}, },
{ {
filter: [][]string{[]string{"a1", "a2"}}, filter: [][]string{{"a1", "a2"}},
topics: []string{"a1"}, topics: []string{"a1"},
match: true, match: true,
}, },
{ {
filter: [][]string{[]string{"a1", "a2"}}, filter: [][]string{{"a1", "a2"}},
topics: []string{"a2"}, topics: []string{"a2"},
match: true, match: true,
}, },
// Wild-card condition should match anything // Wild-card condition should match anything
{ {
filter: [][]string{[]string{}, []string{"b"}}, filter: [][]string{{}, {"b"}},
topics: []string{"a"}, topics: []string{"a"},
match: false, match: false,
}, },
{ {
filter: [][]string{[]string{}, []string{"b"}}, filter: [][]string{{}, {"b"}},
topics: []string{"a", "b"}, topics: []string{"a", "b"},
match: true, match: true,
}, },
{ {
filter: [][]string{[]string{}, []string{"b"}}, filter: [][]string{{}, {"b"}},
topics: []string{"b", "b"}, topics: []string{"b", "b"},
match: true, match: true,
}, },

2
whisper/whisperv5/peer.go
View File

@ -148,7 +148,7 @@ func (peer *Peer) expire() {
return true return true
}) })
// Dump all known but unavailable // Dump all known but unavailable
for hash, _ := range unmark { for hash := range unmark {
peer.known.Remove(hash) peer.known.Remove(hash)
} }
} }

2
whisper/whisperv5/whisper.go
View File

@ -105,7 +105,7 @@ func (w *Whisper) Version() uint {
func (w *Whisper) getPeer(peerID []byte) (*Peer, error) { func (w *Whisper) getPeer(peerID []byte) (*Peer, error) {
w.peerMu.Lock() w.peerMu.Lock()
defer w.peerMu.Unlock() defer w.peerMu.Unlock()
for p, _ := range w.peers { for p := range w.peers {
id := p.peer.ID() id := p.peer.ID()
if bytes.Equal(peerID, id[:]) { if bytes.Equal(peerID, id[:]) {
return p, nil return p, nil