Drop more dead code.

Author: pascaldekloe

node/config.go

@@ -177,12 +177,6 @@ func (c *Config) HTTPEndpoint() string {
 	return fmt.Sprintf("%s:%d", c.HTTPHost, c.HTTPPort)
 }
 
-// DefaultHTTPEndpoint returns the HTTP endpoint used by default.
-func DefaultHTTPEndpoint() string {
-	config := &Config{HTTPHost: common.DefaultHTTPHost, HTTPPort: common.DefaultHTTPPort}
-	return config.HTTPEndpoint()
-}
-
 // WSEndpoint resolves an websocket endpoint based on the configured host interface
 // and port parameters.
 func (c *Config) WSEndpoint() string {
@@ -192,12 +186,6 @@ func (c *Config) WSEndpoint() string {
 	return fmt.Sprintf("%s:%d", c.WSHost, c.WSPort)
 }
 
-// DefaultWSEndpoint returns the websocket endpoint used by default.
-func DefaultWSEndpoint() string {
-	config := &Config{WSHost: common.DefaultWSHost, WSPort: common.DefaultWSPort}
-	return config.WSEndpoint()
-}
-
 // NodeKey retrieves the currently configured private key of the node, checking
 // first any manually set key, falling back to the one found in the configured
 // data folder. If no key can be found, a new one is generated.

rlp/decode.go

@@ -635,16 +635,6 @@ func NewStream(r io.Reader, inputLimit uint64) *Stream {
 	return s
 }
 
-// NewListStream creates a new stream that pretends to be positioned
-// at an encoded list of the given length.
-func NewListStream(r io.Reader, len uint64) *Stream {
-	s := new(Stream)
-	s.Reset(r, len)
-	s.kind = List
-	s.size = len
-	return s
-}
-
 // Bytes reads an RLP string and returns its contents as a byte slice.
 // If the input does not contain an RLP string, the returned
 // error will be ErrExpectedString.

rlp/decode_test.go

@@ -65,24 +65,6 @@ func TestStreamKind(t *testing.T) {
 	}
 }
 
-func TestNewListStream(t *testing.T) {
-	ls := NewListStream(bytes.NewReader(unhex("0101010101")), 3)
-	if k, size, err := ls.Kind(); k != List || size != 3 || err != nil {
-		t.Errorf("Kind() returned (%v, %d, %v), expected (List, 3, nil)", k, size, err)
-	}
-	if size, err := ls.List(); size != 3 || err != nil {
-		t.Errorf("List() returned (%d, %v), expected (3, nil)", size, err)
-	}
-	for i := 0; i < 3; i++ {
-		if val, err := ls.Uint(); val != 1 || err != nil {
-			t.Errorf("Uint() returned (%d, %v), expected (1, nil)", val, err)
-		}
-	}
-	if err := ls.ListEnd(); err != nil {
-		t.Errorf("ListEnd() returned %v, expected (3, nil)", err)
-	}
-}
-
 func TestStreamErrors(t *testing.T) {
 	withoutInputLimit := func(b []byte) *Stream {
 		return NewStream(newPlainReader(b), 0)

trie/proof.go

@@ -83,26 +83,3 @@ func (t *Trie) Prove(key []byte) []rlp.RawValue {
 	}
 	return proof
 }
-
-func get(tn node, key []byte) ([]byte, node) {
-	for len(key) > 0 {
-		switch n := tn.(type) {
-		case *shortNode:
-			if len(key) < len(n.Key) || !bytes.Equal(n.Key, key[:len(n.Key)]) {
-				return nil, nil
-			}
-			tn = n.Val
-			key = key[len(n.Key):]
-		case *fullNode:
-			tn = n.Children[key[0]]
-			key = key[1:]
-		case hashNode:
-			return key, n
-		case nil:
-			return key, nil
-		default:
-			panic(fmt.Sprintf("%T: invalid node: %v", tn, tn))
-		}
-	}
-	return nil, tn.(valueNode)
-}

trie/proof_test.go

@@ -177,3 +177,26 @@ func verifyProof(rootHash common.Hash, key []byte, proof []rlp.RawValue) (value
 	}
 	return nil, errors.New("unexpected end of proof")
 }
+
+func get(tn node, key []byte) ([]byte, node) {
+	for len(key) > 0 {
+		switch n := tn.(type) {
+		case *shortNode:
+			if len(key) < len(n.Key) || !bytes.Equal(n.Key, key[:len(n.Key)]) {
+				return nil, nil
+			}
+			tn = n.Val
+			key = key[len(n.Key):]
+		case *fullNode:
+			tn = n.Children[key[0]]
+			key = key[1:]
+		case hashNode:
+			return key, n
+		case nil:
+			return key, nil
+		default:
+			panic(fmt.Sprintf("%T: invalid node: %v", tn, tn))
+		}
+	}
+	return nil, tn.(valueNode)
+}