swarm: remove unused/dead code

cmd/swarm/flags.go

@@ -164,10 +164,6 @@ var (
 		Name:  "topic",
 		Usage: "User-defined topic this feed is tracking, hex encoded. Limited to 64 hexadecimal characters",
 	}
-	SwarmFeedDataOnCreateFlag = cli.StringFlag{
-		Name:  "data",
-		Usage: "Initializes the feed with the given hex-encoded data. Data must be prefixed by 0x",
-	}
 	SwarmFeedManifestFlag = cli.StringFlag{
 		Name:  "manifest",
 		Usage: "Refers to the feed through a manifest",

swarm/api/api.go

@@ -50,10 +50,6 @@ import (
 	opentracing "github.com/opentracing/opentracing-go"
 )
 
-var (
-	ErrNotFound = errors.New("not found")
-)
-
 var (
 	apiResolveCount        = metrics.NewRegisteredCounter("api.resolve.count", nil)
 	apiResolveFail         = metrics.NewRegisteredCounter("api.resolve.fail", nil)
@@ -136,13 +132,6 @@ func MultiResolverOptionWithResolver(r ResolveValidator, tld string) MultiResolv
 	}
 }
 
-// MultiResolverOptionWithNameHash is unused at the time of this writing
-func MultiResolverOptionWithNameHash(nameHash func(string) common.Hash) MultiResolverOption {
-	return func(m *MultiResolver) {
-		m.nameHash = nameHash
-	}
-}
-
 // NewMultiResolver creates a new instance of MultiResolver.
 func NewMultiResolver(opts ...MultiResolverOption) (m *MultiResolver) {
 	m = &MultiResolver{
@@ -173,40 +162,6 @@ func (m *MultiResolver) Resolve(addr string) (h common.Hash, err error) {
 	return
 }
 
-// ValidateOwner checks the ENS to validate that the owner of the given domain is the given eth address
-func (m *MultiResolver) ValidateOwner(name string, address common.Address) (bool, error) {
-	rs, err := m.getResolveValidator(name)
-	if err != nil {
-		return false, err
-	}
-	var addr common.Address
-	for _, r := range rs {
-		addr, err = r.Owner(m.nameHash(name))
-		// we hide the error if it is not for the last resolver we check
-		if err == nil {
-			return addr == address, nil
-		}
-	}
-	return false, err
-}
-
-// HeaderByNumber uses the validator of the given domainname and retrieves the header for the given block number
-func (m *MultiResolver) HeaderByNumber(ctx context.Context, name string, blockNr *big.Int) (*types.Header, error) {
-	rs, err := m.getResolveValidator(name)
-	if err != nil {
-		return nil, err
-	}
-	for _, r := range rs {
-		var header *types.Header
-		header, err = r.HeaderByNumber(ctx, blockNr)
-		// we hide the error if it is not for the last resolver we check
-		if err == nil {
-			return header, nil
-		}
-	}
-	return nil, err
-}
-
 // getResolveValidator uses the hostname to retrieve the resolver associated with the top level domain
 func (m *MultiResolver) getResolveValidator(name string) ([]ResolveValidator, error) {
 	rs := m.resolvers[""]
@@ -224,11 +179,6 @@ func (m *MultiResolver) getResolveValidator(name string) ([]ResolveValidator, er
 	return rs, nil
 }
 
-// SetNameHash sets the hasher function that hashes the domain into a name hash that ENS uses
-func (m *MultiResolver) SetNameHash(nameHash func(string) common.Hash) {
-	m.nameHash = nameHash
-}
-
 /*
 API implements webserver/file system related content storage and retrieval
 on top of the FileStore
@@ -265,9 +215,6 @@ func (a *API) Store(ctx context.Context, data io.Reader, size int64, toEncrypt b
 	return a.fileStore.Store(ctx, data, size, toEncrypt)
 }
 
-// ErrResolve is returned when an URI cannot be resolved from ENS.
-type ErrResolve error
-
 // Resolve a name into a content-addressed hash
 // where address could be an ENS name, or a content addressed hash
 func (a *API) Resolve(ctx context.Context, address string) (storage.Address, error) {
@@ -980,11 +927,6 @@ func (a *API) FeedsUpdate(ctx context.Context, request *feed.Request) (storage.A
 	return a.feed.Update(ctx, request)
 }
 
-// FeedsHashSize returned the size of the digest produced by Swarm feeds' hashing function
-func (a *API) FeedsHashSize() int {
-	return a.feed.HashSize
-}
-
 // ErrCannotLoadFeedManifest is returned when looking up a feeds manifest fails
 var ErrCannotLoadFeedManifest = errors.New("Cannot load feed manifest")
 

swarm/api/client/client.go

@@ -45,11 +45,6 @@ import (
 	"github.com/pborman/uuid"
 )
 
-var (
-	DefaultGateway = "http://localhost:8500"
-	DefaultClient  = NewClient(DefaultGateway)
-)
-
 var (
 	ErrUnauthorized = errors.New("unauthorized")
 )

swarm/api/storage.go

@@ -83,23 +83,3 @@ func (s *Storage) Get(ctx context.Context, bzzpath string) (*Response, error) {
 	}
 	return &Response{mimeType, status, expsize, string(body[:size])}, err
 }
-
-// Modify(rootHash, basePath, contentHash, contentType) takes th e manifest trie rooted in rootHash,
-// and merge on  to it. creating an entry w conentType (mime)
-//
-// DEPRECATED: Use the HTTP API instead
-func (s *Storage) Modify(ctx context.Context, rootHash, path, contentHash, contentType string) (newRootHash string, err error) {
-	uri, err := Parse("bzz:/" + rootHash)
-	if err != nil {
-		return "", err
-	}
-	addr, err := s.api.Resolve(ctx, uri.Addr)
-	if err != nil {
-		return "", err
-	}
-	addr, err = s.api.Modify(ctx, addr, path, contentHash, contentType)
-	if err != nil {
-		return "", err
-	}
-	return addr.Hex(), nil
-}

swarm/api/testapi.go

@@ -29,18 +29,6 @@ func NewControl(api *API, hive *network.Hive) *Control {
 	return &Control{api, hive}
 }
 
-//func (self *Control) BlockNetworkRead(on bool) {
-//	self.hive.BlockNetworkRead(on)
-//}
-//
-//func (self *Control) SyncEnabled(on bool) {
-//	self.hive.SyncEnabled(on)
-//}
-//
-//func (self *Control) SwapEnabled(on bool) {
-//	self.hive.SwapEnabled(on)
-//}
-//
 func (c *Control) Hive() string {
 	return c.hive.String()
 }

swarm/api/uri_test.go

@@ -26,17 +26,15 @@ import (
 
 func TestParseURI(t *testing.T) {
 	type test struct {
-		uri                       string
-		expectURI                 *URI
-		expectErr                 bool
-		expectRaw                 bool
-		expectImmutable           bool
-		expectList                bool
-		expectHash                bool
-		expectDeprecatedRaw       bool
-		expectDeprecatedImmutable bool
-		expectValidKey            bool
-		expectAddr                storage.Address
+		uri             string
+		expectURI       *URI
+		expectErr       bool
+		expectRaw       bool
+		expectImmutable bool
+		expectList      bool
+		expectHash      bool
+		expectValidKey  bool
+		expectAddr      storage.Address
 	}
 	tests := []test{
 		{

swarm/network/bitvector/bitvector.go

@@ -60,7 +60,3 @@ func (bv *BitVector) Set(i int, v bool) {
 func (bv *BitVector) Bytes() []byte {
 	return bv.b
 }
-
-func (bv *BitVector) Length() int {
-	return bv.len
-}

swarm/network/protocol.go

@@ -35,8 +35,6 @@ import (
 
 const (
 	DefaultNetworkID = 3
-	// ProtocolMaxMsgSize maximum allowed message size
-	ProtocolMaxMsgSize = 10 * 1024 * 1024
 	// timeout for waiting
 	bzzHandshakeTimeout = 3000 * time.Millisecond
 )
@@ -250,11 +248,6 @@ func NewBzzPeer(p *protocols.Peer) *BzzPeer {
 	return &BzzPeer{Peer: p, BzzAddr: NewAddr(p.Node())}
 }
 
-// LastActive returns the time the peer was last active
-func (p *BzzPeer) LastActive() time.Time {
-	return p.lastActive
-}
-
 // ID returns the peer's underlay node identifier.
 func (p *BzzPeer) ID() enode.ID {
 	// This is here to resolve a method tie: both protocols.Peer and BzzAddr are embedded

swarm/network/protocol_test.go

@@ -20,7 +20,6 @@ import (
 	"flag"
 	"fmt"
 	"os"
-	"sync"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/log"
@@ -44,31 +43,7 @@ func init() {
 	log.Root().SetHandler(log.LvlFilterHandler(log.Lvl(*loglevel), log.StreamHandler(os.Stderr, log.TerminalFormat(true))))
 }
 
-type testStore struct {
-	sync.Mutex
-
-	values map[string][]byte
-}
-
-func (t *testStore) Load(key string) ([]byte, error) {
-	t.Lock()
-	defer t.Unlock()
-	v, ok := t.values[key]
-	if !ok {
-		return nil, fmt.Errorf("key not found: %s", key)
-	}
-	return v, nil
-}
-
-func (t *testStore) Save(key string, v []byte) error {
-	t.Lock()
-	defer t.Unlock()
-	t.values[key] = v
-	return nil
-}
-
 func HandshakeMsgExchange(lhs, rhs *HandshakeMsg, id enode.ID) []p2ptest.Exchange {
-
 	return []p2ptest.Exchange{
 		{
 			Expects: []p2ptest.Expect{

swarm/network/stream/intervals/store_test.go

@@ -17,14 +17,11 @@
 package intervals
 
 import (
-	"errors"
 	"testing"
 
 	"github.com/ethereum/go-ethereum/swarm/state"
 )
 
-var ErrNotFound = errors.New("not found")
-
 // TestInmemoryStore tests basic functionality of InmemoryStore.
 func TestInmemoryStore(t *testing.T) {
 	testStore(t, state.NewInmemoryStore())

swarm/network/stream/stream.go

@@ -388,14 +388,6 @@ func (r *Registry) Quit(peerId enode.ID, s Stream) error {
 	return peer.Send(context.TODO(), msg)
 }
 
-func (r *Registry) NodeInfo() interface{} {
-	return nil
-}
-
-func (r *Registry) PeerInfo(id enode.ID) interface{} {
-	return nil
-}
-
 func (r *Registry) Close() error {
 	return r.intervalsStore.Close()
 }

swarm/network/stream/syncer.go

@@ -127,19 +127,9 @@ func (s *SwarmSyncerServer) SetNextBatch(from, to uint64) ([]byte, uint64, uint6
 
 // SwarmSyncerClient
 type SwarmSyncerClient struct {
-	sessionAt     uint64
-	nextC         chan struct{}
-	sessionRoot   storage.Address
-	sessionReader storage.LazySectionReader
-	retrieveC     chan *storage.Chunk
-	storeC        chan *storage.Chunk
-	store         storage.SyncChunkStore
-	// chunker               storage.Chunker
-	currentRoot storage.Address
-	requestFunc func(chunk *storage.Chunk)
-	end, start  uint64
-	peer        *Peer
-	stream      Stream
+	store  storage.SyncChunkStore
+	peer   *Peer
+	stream Stream
 }
 
 // NewSwarmSyncerClient is a contructor for provable data exchange syncer
@@ -209,46 +199,6 @@ func (s *SwarmSyncerClient) BatchDone(stream Stream, from uint64, hashes []byte,
 	return nil
 }
 
-func (s *SwarmSyncerClient) TakeoverProof(stream Stream, from uint64, hashes []byte, root storage.Address) (*TakeoverProof, error) {
-	// for provable syncer currentRoot is non-zero length
-	// TODO: reenable this with putter/getter
-	// if s.chunker != nil {
-	// 	if from > s.sessionAt { // for live syncing currentRoot is always updated
-	// 		//expRoot, err := s.chunker.Append(s.currentRoot, bytes.NewReader(hashes), s.retrieveC, s.storeC)
-	// 		expRoot, _, err := s.chunker.Append(s.currentRoot, bytes.NewReader(hashes), s.retrieveC)
-	// 		if err != nil {
-	// 			return nil, err
-	// 		}
-	// 		if !bytes.Equal(root, expRoot) {
-	// 			return nil, fmt.Errorf("HandoverProof mismatch")
-	// 		}
-	// 		s.currentRoot = root
-	// 	} else {
-	// 		expHashes := make([]byte, len(hashes))
-	// 		_, err := s.sessionReader.ReadAt(expHashes, int64(s.end*HashSize))
-	// 		if err != nil && err != io.EOF {
-	// 			return nil, err
-	// 		}
-	// 		if !bytes.Equal(expHashes, hashes) {
-	// 			return nil, errors.New("invalid proof")
-	// 		}
-	// 	}
-	// 	return nil, nil
-	// }
-	s.end += uint64(len(hashes)) / HashSize
-	takeover := &Takeover{
-		Stream: stream,
-		Start:  s.start,
-		End:    s.end,
-		Root:   root,
-	}
-	// serialise and sign
-	return &TakeoverProof{
-		Takeover: takeover,
-		Sig:      nil,
-	}, nil
-}
-
 func (s *SwarmSyncerClient) Close() {}
 
 // base for parsing and formating sync bin key

swarm/pot/address.go

@@ -41,10 +41,6 @@ func NewAddressFromBytes(b []byte) Address {
 	return Address(h)
 }
 
-func (a Address) IsZero() bool {
-	return a.Bin() == zerosBin
-}
-
 func (a Address) String() string {
 	return fmt.Sprintf("%x", a[:])
 }

swarm/pot/pot.go

@@ -477,18 +477,14 @@ func (t *Pot) each(f func(Val, int) bool) bool {
 	return f(t.pin, t.po)
 }
 
-// EachFrom called with (f, start) is a synchronous iterator over the elements of a Pot
+// eachFrom called with (f, start) is a synchronous iterator over the elements of a Pot
 // within the inclusive range starting from proximity order start
 // the function argument is passed the value and the proximity order wrt the root pin
 // it does NOT include the pinned item of the root
 // respecting an ordering
 // proximity > pinnedness
 // the iteration ends if the function return false or there are no more elements
 // end of a po range can be implemented since po is passed to the function
-func (t *Pot) EachFrom(f func(Val, int) bool, po int) bool {
-	return t.eachFrom(f, po)
-}
-
 func (t *Pot) eachFrom(f func(Val, int) bool, po int) bool {
 	var next bool
 	_, lim := t.getPos(po)