bencode/decode.go                     |  5 ++---
 bencode/decode_test.go                |  7 ++++---
 bencode/encode.go                     |  1 -
 client.go                             |  5 ++---
 client_test.go                        |  4 ++--
 cmd/torrent-create/main.go            | 12 +++++-------
 cmd/torrent-pick/main.go              |  2 +-
 cmd/torrent-verify/main.go            |  2 +-
 cmd/torrent/download.go               |  2 +-
 cmd/torrentfs/main.go                 | 40 +++++++++++++++++++---------------------
 config.go                             |  4 ++--
 file_test.go                          |  1 -
 fs/file_handle.go                     |  2 +-
 fs/filenode.go                        |  4 +---
 fs/torrentfs.go                       | 10 +++-------
 fs/torrentfs_test.go                  |  4 ++--
 iplist/cmd/iplist/main.go             |  2 +-
 metainfo/hash.go                      |  1 +
 metainfo/magnet_test.go               |  1 -
 metainfo/nodes.go                     |  4 +---
 metainfo/urllist.go                   |  4 +---
 mmap_span/mmap_span.go                |  6 +++---
 mse/cmd/mse/main.go                   |  2 +-
 mse/mse_test.go                       |  2 +-
 peerconn.go                           |  7 +++----
 peerconn_test.go                      |  6 +++---
 piece.go                              |  4 ++--
 request-strategy/order.go             |  2 +-
 request-strategy/order_test.go        |  3 ++-
 requesting.go                         |  6 ++++--
 requesting_test.go                    |  1 -
 segments/segments_test.go             |  6 ++++--
 storage/bolt-piece-completion.go      |  8 +++-----
 storage/bolt-piece.go                 |  1 +
 storage/bolt.go                       |  2 +-
 storage/file.go                       | 10 +++++-----
 storage/mmap.go                       |  4 ++--
 storage/safe-path_test.go             |  6 ++++--
 storage/sqlite/sqlite-storage_test.go |  2 +-
 t.go                                  |  1 -
 test/issue377_test.go                 |  2 +-
 test/transfer_test.go                 | 10 +++++-----
 torrent.go                            |  6 ++----
 tracker/http/http_test.go             |  3 ++-
 tracker/tracker.go                    |  4 +---
 tracker_scraper.go                    |  2 --
 webtorrent/tracker_client.go          |  5 ++---

diff --git a/bencode/decode.go b/bencode/decode.go
index 768c9c7ba43cf27659f2c716a713758dd84ded72..5f97e70aa971fe068ac29db62f76da4598a69312 100644
--- a/bencode/decode.go
+++ b/bencode/decode.go
@@ -224,7 +224,7 @@ 					if mapValue.IsNil() {
 						mapValue.Set(reflect.MakeMap(dict))
 					}
 					// Assigns the value into the map.
-					//log.Printf("map type: %v", mapValue.Type())
+					// log.Printf("map type: %v", mapValue.Type())
 					mapValue.SetMapIndex(reflect.ValueOf(key).Convert(dict.Key()), value)
 				}
 			},
@@ -345,7 +345,7 @@ 			}
 			continue
 		}
 		setValue := reflect.New(df.Type).Elem()
-		//log.Printf("parsing into %v", setValue.Type())
+		// log.Printf("parsing into %v", setValue.Type())
 		ok, err = d.parseValue(setValue)
 		if err != nil {
 			var target *UnmarshalTypeError
@@ -468,7 +468,6 @@ 		d.raiseUnknownValueType(b, d.Offset-1)
 	}
 
 	return true
-
 }
 
 func (d *Decoder) parseUnmarshaler(v reflect.Value) bool {
diff --git a/bencode/decode_test.go b/bencode/decode_test.go
index e9de91bd6c4c09c06e44465bea9369fa66f931a4..60541e86d096bc66ae9fc414f0dff81b4867f9d9 100644
--- a/bencode/decode_test.go
+++ b/bencode/decode_test.go
@@ -23,8 +23,10 @@ 	{"i-9223372036854775808e", int64(-9223372036854775808)},
 	{"5:hello", "hello"},
 	{"29:unicode test проверка", "unicode test проверка"},
 	{"d1:ai5e1:b5:helloe", map[string]interface{}{"a": int64(5), "b": "hello"}},
-	{"li5ei10ei15ei20e7:bencodee",
-		[]interface{}{int64(5), int64(10), int64(15), int64(20), "bencode"}},
+	{
+		"li5ei10ei15ei20e7:bencodee",
+		[]interface{}{int64(5), int64(10), int64(15), int64(20), "bencode"},
+	},
 	{"ldedee", []interface{}{map[string]interface{}{}, map[string]interface{}{}}},
 	{"le", []interface{}{}},
 	{"i604919719469385652980544193299329427705624352086e", func() *big.Int {
@@ -135,7 +137,6 @@ 	check_error(t, Unmarshal([]byte("l5:hello5:fruit3:waye"), &ss))
 	assert_equal(t, ss[0].x, "5:hello")
 	assert_equal(t, ss[1].x, "5:fruit")
 	assert_equal(t, ss[2].x, "3:way")
-
 }
 
 func TestIgnoreUnmarshalTypeError(t *testing.T) {
diff --git a/bencode/encode.go b/bencode/encode.go
index 8ca3f9b3977a41c351e663447098d9f12df364d1..5e80cb16f5c60cc7c5c720cbd04e49479f3bcd33 100644
--- a/bencode/encode.go
+++ b/bencode/encode.go
@@ -101,7 +101,6 @@
 var bigIntType = reflect.TypeOf((*big.Int)(nil)).Elem()
 
 func (e *Encoder) reflectValue(v reflect.Value) {
-
 	if e.reflectMarshaler(v) {
 		return
 	}
diff --git a/client.go b/client.go
index 15d742cb20817e01fbea92c26f47106732e90a68..81a3f75ea41fc22468c16dc8f336a0794198e7e3 100644
--- a/client.go
+++ b/client.go
@@ -477,7 +477,6 @@ 			return errors.New("ipv4 peers disabled")
 		}
 		if cl.config.DisableIPv4 && len(rip) == net.IPv4len {
 			return errors.New("ipv4 disabled")
-
 		}
 		if cl.config.DisableIPv6 && len(rip) == net.IPv6len && rip.To4() == nil {
 			return errors.New("ipv6 disabled")
@@ -735,7 +734,7 @@ 	if err == nil {
 		torrent.Add("initiated conn with preferred header obfuscation", 1)
 		return
 	}
-	//cl.logger.Printf("error establishing connection to %s (obfuscatedHeader=%t): %v", addr, obfuscatedHeaderFirst, err)
+	// cl.logger.Printf("error establishing connection to %s (obfuscatedHeader=%t): %v", addr, obfuscatedHeaderFirst, err)
 	if cl.config.HeaderObfuscationPolicy.RequirePreferred {
 		// We should have just tried with the preferred header obfuscation. If it was required,
 		// there's nothing else to try.
@@ -746,7 +745,7 @@ 	c, err = cl.establishOutgoingConnEx(t, addr, !obfuscatedHeaderFirst)
 	if err == nil {
 		torrent.Add("initiated conn with fallback header obfuscation", 1)
 	}
-	//cl.logger.Printf("error establishing fallback connection to %v: %v", addr, err)
+	// cl.logger.Printf("error establishing fallback connection to %v: %v", addr, err)
 	return
 }
 
diff --git a/client_test.go b/client_test.go
index 7a04c59120f6bb8bde59ccf3ff78897d1b8b6241..86023fb69b0c8aefe33e0536eb097ce824414d2d 100644
--- a/client_test.go
+++ b/client_test.go
@@ -648,7 +648,7 @@
 // Creates a file containing its own name as data. Make a metainfo from that, adds it to the given
 // client, and returns a magnet link.
 func makeMagnet(t *testing.T, cl *Client, dir string, name string) string {
-	os.MkdirAll(dir, 0770)
+	os.MkdirAll(dir, 0o770)
 	file, err := os.Create(filepath.Join(dir, name))
 	require.NoError(t, err)
 	file.Write([]byte(name))
@@ -688,7 +688,7 @@ func testSeederLeecherPair(t *testing.T, seeder func(*ClientConfig), leecher func(*ClientConfig)) {
 	cfg := TestingConfig(t)
 	cfg.Seed = true
 	cfg.DataDir = filepath.Join(cfg.DataDir, "server")
-	os.Mkdir(cfg.DataDir, 0755)
+	os.Mkdir(cfg.DataDir, 0o755)
 	seeder(cfg)
 	server, err := NewClient(cfg)
 	require.NoError(t, err)
diff --git a/cmd/torrent-create/main.go b/cmd/torrent-create/main.go
index 973d4e4fa269596e5430d7b867245dd62e641185..3177d6ce945b2dab7a9768d82010b205563afb6e 100644
--- a/cmd/torrent-create/main.go
+++ b/cmd/torrent-create/main.go
@@ -10,13 +10,11 @@ 	"github.com/anacrolix/torrent/bencode"
 	"github.com/anacrolix/torrent/metainfo"
 )
 
-var (
-	builtinAnnounceList = [][]string{
-		{"http://p4p.arenabg.com:1337/announce"},
-		{"udp://tracker.opentrackr.org:1337/announce"},
-		{"udp://tracker.openbittorrent.com:6969/announce"},
-	}
-)
+var builtinAnnounceList = [][]string{
+	{"http://p4p.arenabg.com:1337/announce"},
+	{"udp://tracker.opentrackr.org:1337/announce"},
+	{"udp://tracker.openbittorrent.com:6969/announce"},
+}
 
 func main() {
 	log.SetFlags(log.Flags() | log.Lshortfile)
diff --git a/cmd/torrent-pick/main.go b/cmd/torrent-pick/main.go
index e68121afc8166eb86df802e3cba287eb42f5c5c3..8dd5a773c24485ef1ff3f48e27e6c8c505ab54e1 100644
--- a/cmd/torrent-pick/main.go
+++ b/cmd/torrent-pick/main.go
@@ -78,7 +78,7 @@ }
 
 func main() {
 	log.SetFlags(log.LstdFlags | log.Lshortfile)
-	var rootGroup = struct {
+	rootGroup := struct {
 		Client    *torrent.ClientConfig `group:"Client Options"`
 		TestPeers []string              `long:"test-peer" description:"address of peer to inject to every torrent"`
 		Pick      string                `long:"pick" description:"filename to pick"`
diff --git a/cmd/torrent-verify/main.go b/cmd/torrent-verify/main.go
index 47c7f3a36096c981572388d2a83f522e6358871b..e945f12f6db82e6cca80cef9f54a48950d9f5e50 100644
--- a/cmd/torrent-verify/main.go
+++ b/cmd/torrent-verify/main.go
@@ -64,7 +64,7 @@ }
 
 func main() {
 	log.SetFlags(log.Flags() | log.Lshortfile)
-	var flags = struct {
+	flags := struct {
 		DataDir string
 		tagflag.StartPos
 		TorrentFile string
diff --git a/cmd/torrent/download.go b/cmd/torrent/download.go
index 198c0ba59c189d90984f92e09b6178f34229812b..a8b5bac4686977815d803eed2f9155d23d6f7e19 100644
--- a/cmd/torrent/download.go
+++ b/cmd/torrent/download.go
@@ -256,7 +256,7 @@ 	client, err := torrent.NewClient(clientConfig)
 	if err != nil {
 		return fmt.Errorf("creating client: %w", err)
 	}
-	var clientClose sync.Once //In certain situations, close was being called more than once.
+	var clientClose sync.Once // In certain situations, close was being called more than once.
 	defer clientClose.Do(func() { client.Close() })
 	go exitSignalHandlers(&stop)
 	go func() {
diff --git a/cmd/torrentfs/main.go b/cmd/torrentfs/main.go
index adce60248829c57302ceb3c7fadac063d0b0f0dd..b5e87e83fff8d487dc2774db6766e876117c65e3 100644
--- a/cmd/torrentfs/main.go
+++ b/cmd/torrentfs/main.go
@@ -24,28 +24,26 @@ 	torrentfs "github.com/anacrolix/torrent/fs"
 	"github.com/anacrolix/torrent/util/dirwatch"
 )
 
-var (
-	args = struct {
-		MetainfoDir string `help:"torrent files in this location describe the contents of the mounted filesystem"`
-		DownloadDir string `help:"location to save torrent data"`
-		MountDir    string `help:"location the torrent contents are made available"`
+var args = struct {
+	MetainfoDir string `help:"torrent files in this location describe the contents of the mounted filesystem"`
+	DownloadDir string `help:"location to save torrent data"`
+	MountDir    string `help:"location the torrent contents are made available"`
 
-		DisableTrackers bool
-		TestPeer        *net.TCPAddr
-		ReadaheadBytes  tagflag.Bytes
-		ListenAddr      *net.TCPAddr
-	}{
-		MetainfoDir: func() string {
-			_user, err := user.Current()
-			if err != nil {
-				panic(err)
-			}
-			return filepath.Join(_user.HomeDir, ".config/transmission/torrents")
-		}(),
-		ReadaheadBytes: 10 << 20,
-		ListenAddr:     &net.TCPAddr{},
-	}
-)
+	DisableTrackers bool
+	TestPeer        *net.TCPAddr
+	ReadaheadBytes  tagflag.Bytes
+	ListenAddr      *net.TCPAddr
+}{
+	MetainfoDir: func() string {
+		_user, err := user.Current()
+		if err != nil {
+			panic(err)
+		}
+		return filepath.Join(_user.HomeDir, ".config/transmission/torrents")
+	}(),
+	ReadaheadBytes: 10 << 20,
+	ListenAddr:     &net.TCPAddr{},
+}
 
 func exitSignalHandlers(fs *torrentfs.TorrentFS) {
 	c := make(chan os.Signal, 1)
diff --git a/config.go b/config.go
index 564149d31545cb2f2499d57690ed9f94f2769d85..5e9bd35682105dca89b5a4333cd88e0262b9c0f4 100644
--- a/config.go
+++ b/config.go
@@ -202,8 +202,8 @@ 		ListenPort:            42069,
 		Extensions:            defaultPeerExtensionBytes(),
 		AcceptPeerConnections: true,
 	}
-	//cc.ConnTracker.SetNoMaxEntries()
-	//cc.ConnTracker.Timeout = func(conntrack.Entry) time.Duration { return 0 }
+	// cc.ConnTracker.SetNoMaxEntries()
+	// cc.ConnTracker.Timeout = func(conntrack.Entry) time.Duration { return 0 }
 	return cc
 }
 
diff --git a/file_test.go b/file_test.go
index 3ad9aca7b0426d1102d5571a5cc91238ff58662a..e0df62b41ade8b9c8bf4a1868b4009c3fe6d3030 100644
--- a/file_test.go
+++ b/file_test.go
@@ -40,7 +40,6 @@ 	})
 }
 
 func TestFileBytesLeft(t *testing.T) {
-
 	testFileBytesLeft{
 		usualPieceSize:  3,
 		firstPieceIndex: 1,
diff --git a/fs/file_handle.go b/fs/file_handle.go
index 7a7265f3461f67c111b454f9def4c0cbd9e86f61..4759e5257b84700c638100a95168bb4e8614fe2d 100644
--- a/fs/file_handle.go
+++ b/fs/file_handle.go
@@ -45,7 +45,7 @@ 		me.fn.FS.event.Broadcast()
 		me.fn.FS.mu.Unlock()
 		var n int
 		r := missinggo.ContextedReader{r, ctx}
-		//log.Printf("reading %v bytes at %v", len(resp.Data), req.Offset)
+		// log.Printf("reading %v bytes at %v", len(resp.Data), req.Offset)
 		if true {
 			// A user reported on that on freebsd 12.2, the system requires that reads are
 			// completely filled. Their system only asks for 64KiB at a time. I've seen systems that
diff --git a/fs/filenode.go b/fs/filenode.go
index a7c807b4fe897d0f50d2c649cb6566f66706cd7b..8137a8cd875c0f765c1ffaae1832c9ea48c4c1e6 100644
--- a/fs/filenode.go
+++ b/fs/filenode.go
@@ -14,9 +14,7 @@ 	node
 	f *torrent.File
 }
 
-var (
-	_ fusefs.NodeOpener = fileNode{}
-)
+var _ fusefs.NodeOpener = fileNode{}
 
 func (fn fileNode) Attr(ctx context.Context, attr *fuse.Attr) error {
 	attr.Size = uint64(fn.f.Length())
diff --git a/fs/torrentfs.go b/fs/torrentfs.go
index aedab1af68d5d216883ffd244bbc93ab5dc9908e..2537094ec4b7246b19c7eaccd83bf02f609410db 100644
--- a/fs/torrentfs.go
+++ b/fs/torrentfs.go
@@ -15,12 +15,10 @@ 	"github.com/anacrolix/torrent/metainfo"
 )
 
 const (
-	defaultMode = 0555
+	defaultMode = 0o555
 )
 
-var (
-	torrentfsReadRequests = expvar.NewInt("torrentfsReadRequests")
-)
+var torrentfsReadRequests = expvar.NewInt("torrentfsReadRequests")
 
 type TorrentFS struct {
 	Client       *torrent.Client
@@ -55,9 +53,7 @@ type dirNode struct {
 	node
 }
 
-var (
-	_ fusefs.HandleReadDirAller = dirNode{}
-)
+var _ fusefs.HandleReadDirAller = dirNode{}
 
 func isSubPath(parent, child string) bool {
 	if parent == "" {
diff --git a/fs/torrentfs_test.go b/fs/torrentfs_test.go
index 5d644a143ebb2acded93246923e27598984872fe..071be0d5df7dec917332d27127f8880a92e67ce3 100644
--- a/fs/torrentfs_test.go
+++ b/fs/torrentfs_test.go
@@ -68,9 +68,9 @@ 	if err != nil {
 		return
 	}
 	tl.Completed = filepath.Join(tl.BaseDir, "completed")
-	os.Mkdir(tl.Completed, 0777)
+	os.Mkdir(tl.Completed, 0o777)
 	tl.MountDir = filepath.Join(tl.BaseDir, "mnt")
-	os.Mkdir(tl.MountDir, 0777)
+	os.Mkdir(tl.MountDir, 0o777)
 	testutil.CreateDummyTorrentData(tl.Completed)
 	tl.Metainfo = testutil.GreetingMetaInfo()
 	return
diff --git a/iplist/cmd/iplist/main.go b/iplist/cmd/iplist/main.go
index d7bfbeef4811c5f866b26c3f62806201f842170a..7117b461a135ce06d071976277f609d7d4a54647 100644
--- a/iplist/cmd/iplist/main.go
+++ b/iplist/cmd/iplist/main.go
@@ -12,7 +12,7 @@ 	"github.com/anacrolix/torrent/iplist"
 )
 
 func main() {
-	var flags = struct {
+	flags := struct {
 		tagflag.StartPos
 		Ips []net.IP
 	}{}
diff --git a/metainfo/hash.go b/metainfo/hash.go
index 0e258f3d16a17b3e30cf46275b7418c3f9332459..a1f688a7386d3eec1cb069a89a974f6e12638618 100644
--- a/metainfo/hash.go
+++ b/metainfo/hash.go
@@ -59,6 +59,7 @@
 func (h *Hash) UnmarshalText(b []byte) error {
 	return h.FromHexString(string(b))
 }
+
 func (h Hash) MarshalText() (text []byte, err error) {
 	return []byte(h.HexString()), nil
 }
diff --git a/metainfo/magnet_test.go b/metainfo/magnet_test.go
index 24db8fdba4b746867baaf7564f8f8649b56031cc..24ab15b18e7ba88dd4c2fb53d8d3a6dd6443bdcc 100644
--- a/metainfo/magnet_test.go
+++ b/metainfo/magnet_test.go
@@ -67,7 +67,6 @@ 	_, err = ParseMagnetUri(uri)
 	if err == nil {
 		t.Errorf("Failed to detect broken Magnet URI: %v", uri)
 	}
-
 }
 
 func TestMagnetize(t *testing.T) {
diff --git a/metainfo/nodes.go b/metainfo/nodes.go
index ae7fdbb85500b6fa2f96b11b6594eb540cbe94c3..06c3b3f379929731f061ce6c16854d9d70815e5b 100644
--- a/metainfo/nodes.go
+++ b/metainfo/nodes.go
@@ -10,9 +10,7 @@ )
 
 type Node string
 
-var (
-	_ bencode.Unmarshaler = (*Node)(nil)
-)
+var _ bencode.Unmarshaler = (*Node)(nil)
 
 func (n *Node) UnmarshalBencode(b []byte) (err error) {
 	var iface interface{}
diff --git a/metainfo/urllist.go b/metainfo/urllist.go
index 8171f1982636819855c06a30410513fcd7699a52..ed7c36d2e80be09aeac91d712f857c05c2ee1c4a 100644
--- a/metainfo/urllist.go
+++ b/metainfo/urllist.go
@@ -6,9 +6,7 @@ )
 
 type UrlList []string
 
-var (
-	_ bencode.Unmarshaler = (*UrlList)(nil)
-)
+var _ bencode.Unmarshaler = (*UrlList)(nil)
 
 func (me *UrlList) UnmarshalBencode(b []byte) error {
 	if len(b) == 0 {
diff --git a/mmap_span/mmap_span.go b/mmap_span/mmap_span.go
index 4195a0f0780a4b286e439d7291dd044eaf2222ee..6a6c8392edfd682c70aed07674e4122b81fcef53 100644
--- a/mmap_span/mmap_span.go
+++ b/mmap_span/mmap_span.go
@@ -44,11 +44,11 @@ 		l := int64(len(me.mMaps[i]))
 		i++
 		return l, true
 	})
-	//log.Printf("made mmapspan index: %v", me.segmentLocater)
+	// log.Printf("made mmapspan index: %v", me.segmentLocater)
 }
 
 func (ms *MMapSpan) ReadAt(p []byte, off int64) (n int, err error) {
-	//log.Printf("reading %v bytes at %v", len(p), off)
+	// log.Printf("reading %v bytes at %v", len(p), off)
 	ms.mu.RLock()
 	defer ms.mu.RUnlock()
 	n = ms.locateCopy(func(a, b []byte) (_, _ []byte) { return a, b }, p, off)
@@ -65,7 +65,7 @@
 func (ms *MMapSpan) locateCopy(copyArgs func(remainingArgument, mmapped []byte) (dst, src []byte), p []byte, off int64) (n int) {
 	ms.segmentLocater.Locate(segments.Extent{off, int64(len(p))}, func(i int, e segments.Extent) bool {
 		mMapBytes := ms.mMaps[i][e.Start:]
-		//log.Printf("got segment %v: %v, copying %v, %v", i, e, len(p), len(mMapBytes))
+		// log.Printf("got segment %v: %v, copying %v, %v", i, e, len(p), len(mMapBytes))
 		_n := copyBytes(copyArgs(p, mMapBytes))
 		p = p[_n:]
 		n += _n
diff --git a/mse/cmd/mse/main.go b/mse/cmd/mse/main.go
index 756f07e6d58019d0b6d51d467acfeb48f0f20bde..25f2e339ad2c0d4a283b350c88147172a9650351 100644
--- a/mse/cmd/mse/main.go
+++ b/mse/cmd/mse/main.go
@@ -20,7 +20,7 @@ 	}
 }
 
 func mainErr() error {
-	var args = struct {
+	args := struct {
 		CryptoMethod mse.CryptoMethod
 		Dial         *struct {
 			Network        string `arg:"positional"`
diff --git a/mse/mse_test.go b/mse/mse_test.go
index 33fd9c5edb23d61a749b775426e5307b3c51f032..c7e3bd573cb2e02d105bdfc8c32ec01d89a23afe 100644
--- a/mse/mse_test.go
+++ b/mse/mse_test.go
@@ -260,7 +260,7 @@ 		skeys = append(skeys, make([]byte, 20))
 	}
 	fillRand(b, skeys...)
 	initSkey := skeys[len(skeys)/2]
-	//c := qt.New(b)
+	// c := qt.New(b)
 	b.ReportAllocs()
 	b.ResetTimer()
 	for i := 0; i < b.N; i += 1 {
diff --git a/peerconn.go b/peerconn.go
index c85135dc2c6a6a901eade4e0f0723e7c82ee25a8..4b69463a8a969334a513e6837eef079fd84527dd 100644
--- a/peerconn.go
+++ b/peerconn.go
@@ -481,7 +481,6 @@ 	if !cn.lastStartedExpectingToReceiveChunks.IsZero() {
 		ret += time.Since(cn.lastStartedExpectingToReceiveChunks)
 	}
 	return
-
 }
 
 func (cn *PeerConn) onPeerSentCancel(r Request) {
@@ -961,7 +960,7 @@ 	}
 	value := &peerRequestState{}
 	c.peerRequests[r] = value
 	go c.peerRequestDataReader(r, value)
-	//c.tickleWriter()
+	// c.tickleWriter()
 	return nil
 }
 
@@ -1235,7 +1234,7 @@ 		}
 		if cb := c.callbacks.ReadExtendedHandshake; cb != nil {
 			cb(c, &d)
 		}
-		//c.logger.WithDefaultLevel(log.Debug).Printf("received extended handshake message:\n%s", spew.Sdump(d))
+		// c.logger.WithDefaultLevel(log.Debug).Printf("received extended handshake message:\n%s", spew.Sdump(d))
 		if d.Reqq != 0 {
 			c.PeerMaxRequests = d.Reqq
 		}
@@ -1346,7 +1345,7 @@ 	cl := t.cl
 
 	// Do we actually want this chunk?
 	if t.haveChunk(ppReq) {
-		//panic(fmt.Sprintf("%+v", ppReq))
+		// panic(fmt.Sprintf("%+v", ppReq))
 		chunksReceived.Add("wasted", 1)
 		c.allStats(add(1, func(cs *ConnStats) *Count { return &cs.ChunksReadWasted }))
 		return nil
diff --git a/peerconn_test.go b/peerconn_test.go
index 93bc7aa565c2523dedfd734b239e70889502f64b..e81b6343b0fdcdb401e808fe903fac59caa3e7d3 100644
--- a/peerconn_test.go
+++ b/peerconn_test.go
@@ -28,7 +28,7 @@ 	if err := c.t.setInfo(&metainfo.Info{Pieces: make([]byte, metainfo.HashSize*3)}); err != nil {
 		t.Log(err)
 	}
 	r, w := io.Pipe()
-	//c.r = r
+	// c.r = r
 	c.w = w
 	c.startWriter()
 	c.locker().Lock()
@@ -155,7 +155,7 @@ 	var (
 		tcpAddr = &net.TCPAddr{IP: net.IPv6loopback, Port: 4848}
 		udpAddr = &net.UDPAddr{IP: net.IPv6loopback, Port: 4848}
 	)
-	var testcases = []struct {
+	testcases := []struct {
 		conn *PeerConn
 		f    pp.PexPeerFlags
 	}{
@@ -181,7 +181,7 @@ 		tcpAddr     = &net.TCPAddr{IP: net.IPv6loopback, Port: 4848}
 		dialTcpAddr = &net.TCPAddr{IP: net.IPv6loopback, Port: 4747}
 		dialUdpAddr = &net.UDPAddr{IP: net.IPv6loopback, Port: 4747}
 	)
-	var testcases = []struct {
+	testcases := []struct {
 		t pexEventType
 		c *PeerConn
 		e pexEvent
diff --git a/piece.go b/piece.go
index 6b70a5b56407c4b6dc287f5d819d98599a47c4cc..bef5f59e3d676b92fa36bc2eedafebbe5c9f37d5 100644
--- a/piece.go
+++ b/piece.go
@@ -164,10 +164,10 @@ 	target := p.numVerifies + 1
 	if p.hashing {
 		target++
 	}
-	//log.Printf("target: %d", target)
+	// log.Printf("target: %d", target)
 	p.t.queuePieceCheck(p.index)
 	for {
-		//log.Printf("got %d verifies", p.numVerifies)
+		// log.Printf("got %d verifies", p.numVerifies)
 		if p.numVerifies >= target {
 			break
 		}
diff --git a/request-strategy/order.go b/request-strategy/order.go
index 7456649bb6c42da042f6250ff2f23a3a411fcd26..58d06b422553f698cad657e918ffee5340319664 100644
--- a/request-strategy/order.go
+++ b/request-strategy/order.go
@@ -330,7 +330,7 @@ 	}
 	sortPeersForPiece := func(req *RequestIndex) {
 		peersForPieceSorter.req = req
 		sort.Sort(&peersForPieceSorter)
-		//ensureValidSortedPeersForPieceRequests(&peersForPieceSorter)
+		// ensureValidSortedPeersForPieceRequests(&peersForPieceSorter)
 	}
 	// Chunks can be preassigned several times, if peers haven't been able to update their "actual"
 	// with "next" request state before another request strategy run occurs.
diff --git a/request-strategy/order_test.go b/request-strategy/order_test.go
index ba86f0cd1482d4b62863a7c255d156ff159e25a2..ce4a4e1a6ca45912adf99b4c6097551065c3640a 100644
--- a/request-strategy/order_test.go
+++ b/request-strategy/order_test.go
@@ -247,7 +247,8 @@ 			{
 				Request:           true,
 				NumPendingChunks:  9,
 				IterPendingChunks: chunkIterRange(9),
-			}},
+			},
+		},
 		Peers: []Peer{
 			firstStealer,
 			stealee,
diff --git a/requesting.go b/requesting.go
index 01c513aebb9839adbc563070f45fdfd95ec5ad04..77398643330de82d3a04e0d279f882deb9b8b6e4 100644
--- a/requesting.go
+++ b/requesting.go
@@ -116,8 +116,10 @@ 	copy(*(*[]byte)(unsafe.Pointer(&dst)), b)
 	return nil
 }
 
-type RequestIndex = request_strategy.RequestIndex
-type chunkIndexType = request_strategy.ChunkIndex
+type (
+	RequestIndex   = request_strategy.RequestIndex
+	chunkIndexType = request_strategy.ChunkIndex
+)
 
 type peerRequests struct {
 	requestIndexes       []RequestIndex
diff --git a/requesting_test.go b/requesting_test.go
index 8599086e75572380ef3dcc3ea6c9ba995b1d2246..dd54df5d61884a27eadf15d1ea79d364c272539a 100644
--- a/requesting_test.go
+++ b/requesting_test.go
@@ -28,7 +28,6 @@ func TestLogExampleRequestMapOrdering(t *testing.T) {
 	for k := range makeTypicalRequests() {
 		t.Log(k)
 	}
-
 }
 
 func TestRequestMapOrderingPersistent(t *testing.T) {
diff --git a/segments/segments_test.go b/segments/segments_test.go
index 8dcff6cc8a86faa162578f396d891d22a438fecb..9ce9164bf7f02423628d4b57f3e31715ce7ebdf3 100644
--- a/segments/segments_test.go
+++ b/segments/segments_test.go
@@ -67,7 +67,8 @@ 			{0, 1514},
 			{0, 1554},
 			{0, 1618},
 			{0, 1546},
-			{0, 8500}})
+			{0, 8500},
+		})
 	assertLocate(t, newLocater,
 		[]Length{1652, 1514, 1554, 1618, 1546, 129241752, 1537, 1536, 1551}, // 128737588
 		Extent{129236992, 16384},
@@ -76,7 +77,8 @@ 		[]Extent{
 			{129229108, 12644},
 			{0, 1537},
 			{0, 1536},
-			{0, 667}})
+			{0, 667},
+		})
 }
 
 func TestScan(t *testing.T) {
diff --git a/storage/bolt-piece-completion.go b/storage/bolt-piece-completion.go
index 52713ea8c10f726e629aedca392186fc4a9c09f9..442f57c58da9a8788b8b71f8d6aec73552199665 100644
--- a/storage/bolt-piece-completion.go
+++ b/storage/bolt-piece-completion.go
@@ -19,9 +19,7 @@ 	boltDbCompleteValue   = "c"
 	boltDbIncompleteValue = "i"
 )
 
-var (
-	completionBucketKey = []byte("completion")
-)
+var completionBucketKey = []byte("completion")
 
 type boltPieceCompletion struct {
 	db *bbolt.DB
@@ -30,9 +28,9 @@
 var _ PieceCompletion = (*boltPieceCompletion)(nil)
 
 func NewBoltPieceCompletion(dir string) (ret PieceCompletion, err error) {
-	os.MkdirAll(dir, 0750)
+	os.MkdirAll(dir, 0o750)
 	p := filepath.Join(dir, ".torrent.bolt.db")
-	db, err := bbolt.Open(p, 0660, &bbolt.Options{
+	db, err := bbolt.Open(p, 0o660, &bbolt.Options{
 		Timeout: time.Second,
 	})
 	if err != nil {
diff --git a/storage/bolt-piece.go b/storage/bolt-piece.go
index 12916ee5714e5f062c3eea0d78556151dd11b384..67e03bd9d41ab04a9f94bbd61423da837be187b2 100644
--- a/storage/bolt-piece.go
+++ b/storage/bolt-piece.go
@@ -51,6 +51,7 @@
 func (me *boltPiece) MarkNotComplete() error {
 	return me.pc().Set(me.pk(), false)
 }
+
 func (me *boltPiece) ReadAt(b []byte, off int64) (n int, err error) {
 	err = me.db.View(func(tx *bbolt.Tx) error {
 		db := tx.Bucket(dataBucketKey)
diff --git a/storage/bolt.go b/storage/bolt.go
index 72644c43527e05bdf8681601ab9559a8be6728fe..945b24995db936df6b401f3eb546c36c2d2d14d2 100644
--- a/storage/bolt.go
+++ b/storage/bolt.go
@@ -30,7 +30,7 @@ 	ih metainfo.Hash
 }
 
 func NewBoltDB(filePath string) ClientImplCloser {
-	db, err := bbolt.Open(filepath.Join(filePath, "bolt.db"), 0600, &bbolt.Options{
+	db, err := bbolt.Open(filepath.Join(filePath, "bolt.db"), 0o600, &bbolt.Options{
 		Timeout: time.Second,
 	})
 	expect.Nil(err)
diff --git a/storage/file.go b/storage/file.go
index bbfe6d66122a4eb2e8e42e88ccb15d222ff60dbd..d07dc7e9156d4a0b274b6f9e0dbf76ee66940e1c 100644
--- a/storage/file.go
+++ b/storage/file.go
@@ -126,7 +126,7 @@ // A helper to create zero-length files which won't appear for file-orientated storage since no
 // writes will ever occur to them (no torrent data is associated with a zero-length file). The
 // caller should make sure the file name provided is safe/sanitized.
 func CreateNativeZeroLengthFile(name string) error {
-	os.MkdirAll(filepath.Dir(name), 0777)
+	os.MkdirAll(filepath.Dir(name), 0o777)
 	var f io.Closer
 	f, err := os.Create(name)
 	if err != nil {
@@ -185,18 +185,18 @@ 	return
 }
 
 func (fst fileTorrentImplIO) WriteAt(p []byte, off int64) (n int, err error) {
-	//log.Printf("write at %v: %v bytes", off, len(p))
+	// log.Printf("write at %v: %v bytes", off, len(p))
 	fst.fts.segmentLocater.Locate(segments.Extent{off, int64(len(p))}, func(i int, e segments.Extent) bool {
 		name := fst.fts.files[i].path
-		os.MkdirAll(filepath.Dir(name), 0777)
+		os.MkdirAll(filepath.Dir(name), 0o777)
 		var f *os.File
-		f, err = os.OpenFile(name, os.O_WRONLY|os.O_CREATE, 0666)
+		f, err = os.OpenFile(name, os.O_WRONLY|os.O_CREATE, 0o666)
 		if err != nil {
 			return false
 		}
 		var n1 int
 		n1, err = f.WriteAt(p[:e.Length], e.Start)
-		//log.Printf("%v %v wrote %v: %v", i, e, n1, err)
+		// log.Printf("%v %v wrote %v: %v", i, e, n1, err)
 		closeErr := f.Close()
 		n += n1
 		p = p[n1:]
diff --git a/storage/mmap.go b/storage/mmap.go
index 1b1423f7a9e73904e4a7e9fcd44cb462ef9f2878..300d863510152a065a512dd3ee575cc1ad84566c 100644
--- a/storage/mmap.go
+++ b/storage/mmap.go
@@ -132,13 +132,13 @@ }
 
 func mmapFile(name string, size int64) (ret mmap.MMap, err error) {
 	dir := filepath.Dir(name)
-	err = os.MkdirAll(dir, 0750)
+	err = os.MkdirAll(dir, 0o750)
 	if err != nil {
 		err = fmt.Errorf("making directory %q: %s", dir, err)
 		return
 	}
 	var file *os.File
-	file, err = os.OpenFile(name, os.O_CREATE|os.O_RDWR, 0666)
+	file, err = os.OpenFile(name, os.O_CREATE|os.O_RDWR, 0o666)
 	if err != nil {
 		return
 	}
diff --git a/storage/safe-path_test.go b/storage/safe-path_test.go
index 008cf8a73073bba9853b97495c3cbe1cfca5825c..674da8fc023b42d06655b57d5fb00123ba17e74b 100644
--- a/storage/safe-path_test.go
+++ b/storage/safe-path_test.go
@@ -24,8 +24,10 @@ 	// absolute paths (and thus presumably clobbering earlier "makers").
 	{input: []string{"a", filepath.FromSlash(`b/..`)}, expectErr: false},
 	{input: []string{"a", filepath.FromSlash(`b/../../..`)}, expectErr: true},
 	{input: []string{"a", filepath.FromSlash(`b/../.././..`)}, expectErr: true},
-	{input: []string{
-		filepath.FromSlash(`NewSuperHeroMovie-2019-English-720p.avi /../../../../../Roaming/Microsoft/Windows/Start Menu/Programs/Startup/test3.exe`)},
+	{
+		input: []string{
+			filepath.FromSlash(`NewSuperHeroMovie-2019-English-720p.avi /../../../../../Roaming/Microsoft/Windows/Start Menu/Programs/Startup/test3.exe`),
+		},
 		expectErr: true,
 	},
 }
diff --git a/storage/sqlite/sqlite-storage_test.go b/storage/sqlite/sqlite-storage_test.go
index 43c743e39423afddf0f4bfb836b2b19a0936b850..66293cfad3258172f8b75b2b77c2e2f46522a396 100644
--- a/storage/sqlite/sqlite-storage_test.go
+++ b/storage/sqlite/sqlite-storage_test.go
@@ -49,7 +49,7 @@ 			b.Run("Direct", func(b *testing.B) {
 				var opts NewDirectStorageOpts
 				opts.Memory = memory
 				opts.Capacity = capacity
-				//opts.GcBlobs = true
+				// opts.GcBlobs = true
 				opts.BlobFlushInterval = time.Second
 				opts.NoTriggers = noTriggers
 				directBench := func(b *testing.B) {
diff --git a/t.go b/t.go
index a7f9889289b63a83533fbfb4ed8b4c96987935a5..580a3bc91c9cf789156431c9a24f405e8d77da90 100644
--- a/t.go
+++ b/t.go
@@ -232,7 +232,6 @@ 			PiecePriorityNone,
 		})
 		offset += fi.Length
 	}
-
 }
 
 // Returns handles to the files in the torrent. This requires that the Info is
diff --git a/test/issue377_test.go b/test/issue377_test.go
index 01caaed680ca783a1dc05c2e40eddce31d903d4f..48e5abfbf3e15ebf000a90be98f3d3402bc507a9 100644
--- a/test/issue377_test.go
+++ b/test/issue377_test.go
@@ -98,7 +98,7 @@ 		}() {
 		}
 	}
 	// TODO: Check that PeerConns fastEnabled matches seederFast?
-	//select {}
+	// select {}
 }
 
 type pieceState struct {
diff --git a/test/transfer_test.go b/test/transfer_test.go
index a5573d72d4d66115d2142e9ea49a815659cf1fd6..3e3f77a7f747fc4b7b64257d39a1b7aec95dfb0e 100644
--- a/test/transfer_test.go
+++ b/test/transfer_test.go
@@ -68,7 +68,7 @@ 	greetingTempDir, mi := testutil.GreetingTestTorrent()
 	defer os.RemoveAll(greetingTempDir)
 	// Create seeder and a Torrent.
 	cfg := torrent.TestingConfig(t)
-	//cfg.Debug = true
+	// cfg.Debug = true
 	cfg.Seed = true
 	// Some test instances don't like this being on, even when there's no cache involved.
 	cfg.DropMutuallyCompletePeers = false
@@ -116,7 +116,7 @@ 	if ps.LeecherDownloadRateLimiter != nil {
 		cfg.DownloadRateLimiter = ps.LeecherDownloadRateLimiter
 	}
 	cfg.Seed = false
-	//cfg.Debug = true
+	// cfg.Debug = true
 	if ps.ConfigureLeecher.Config != nil {
 		ps.ConfigureLeecher.Config(cfg)
 	}
@@ -180,7 +180,7 @@ 	assert.NotEmpty(t, seederTorrent.PeerConns())
 	leecherPeerConns := leecherTorrent.PeerConns()
 	if cfg.DropMutuallyCompletePeers {
 		// I don't think we can assume it will be empty already, due to timing.
-		//assert.Empty(t, leecherPeerConns)
+		// assert.Empty(t, leecherPeerConns)
 	} else {
 		assert.NotEmpty(t, leecherPeerConns)
 	}
@@ -296,8 +296,8 @@ 		// These tests don't work well with more than 1 connection to the seeder.
 		ConfigureLeecher: ConfigureClient{
 			Config: func(cfg *torrent.ClientConfig) {
 				cfg.DropDuplicatePeerIds = true
-				//cfg.DisableIPv6 = true
-				//cfg.DisableUTP = true
+				// cfg.DisableIPv6 = true
+				// cfg.DisableUTP = true
 			},
 		},
 	})
diff --git a/torrent.go b/torrent.go
index 104ed962c164f9964b3571df231f43caec0d571b..c8025aae8bbb8f0cb6291236fc57f9b0c9e3fd3c 100644
--- a/torrent.go
+++ b/torrent.go
@@ -209,7 +209,6 @@ 	}
 
 	// Add active peers to the list
 	for conn := range t.conns {
-
 		ks = append(ks, PeerInfo{
 			Id:     conn.PeerID,
 			Addr:   conn.RemoteAddr,
@@ -888,10 +887,10 @@ 	p := t.piece(piece)
 	p.waitNoPendingWrites()
 	storagePiece := t.pieces[piece].Storage()
 
-	//Does the backend want to do its own hashing?
+	// Does the backend want to do its own hashing?
 	if i, ok := storagePiece.PieceImpl.(storage.SelfHashing); ok {
 		var sum metainfo.Hash
-		//log.Printf("A piece decided to self-hash: %d", piece)
+		// log.Printf("A piece decided to self-hash: %d", piece)
 		sum, err = i.SelfHash()
 		missinggo.CopyExact(&ret, sum)
 		return
@@ -1506,7 +1505,6 @@ 			)
 		}
 	}()
 	return wst
-
 }
 
 func (t *Torrent) startScrapingTracker(_url string) {
diff --git a/tracker/http/http_test.go b/tracker/http/http_test.go
index 878ca0586828af4da0115536eb1cf75ecbf13872..fce77c05e10e242b276df4721497d9f368e4040f 100644
--- a/tracker/http/http_test.go
+++ b/tracker/http/http_test.go
@@ -58,7 +58,8 @@ func TestSetAnnounceInfohashParamWithSpaces(t *testing.T) {
 	someUrl := &url.URL{}
 	ihBytes := [20]uint8{
 		0x2b, 0x76, 0xa, 0xa1, 0x78, 0x93, 0x20, 0x30, 0xc8, 0x47,
-		0xdc, 0xdf, 0x8e, 0xae, 0xbf, 0x56, 0xa, 0x1b, 0xd1, 0x6c}
+		0xdc, 0xdf, 0x8e, 0xae, 0xbf, 0x56, 0xa, 0x1b, 0xd1, 0x6c,
+	}
 	setAnnounceParams(
 		someUrl,
 		&udp.AnnounceRequest{
diff --git a/tracker/tracker.go b/tracker/tracker.go
index edc84dcc941125df40be01ef68e1d3b4bcc6a602..f058f63bb2a13d451ebda091d21126b3d0b8cb67 100644
--- a/tracker/tracker.go
+++ b/tracker/tracker.go
@@ -28,9 +28,7 @@ type Peer = trHttp.Peer
 
 type AnnounceEvent = udp.AnnounceEvent
 
-var (
-	ErrBadScheme = errors.New("unknown scheme")
-)
+var ErrBadScheme = errors.New("unknown scheme")
 
 type Announce struct {
 	TrackerUrl string
diff --git a/tracker_scraper.go b/tracker_scraper.go
index d4bce60a8552ff3d4ff5ef5ebd8bfca7fe2a3ff6..9ec295893c2ed0993dad42284667a0bb3a6e29aa 100644
--- a/tracker_scraper.go
+++ b/tracker_scraper.go
@@ -112,7 +112,6 @@
 // Return how long to wait before trying again. For most errors, we return 5
 // minutes, a relatively quick turn around for DNS changes.
 func (me *trackerScraper) announce(ctx context.Context, event tracker.AnnounceEvent) (ret trackerAnnounceResult) {
-
 	defer func() {
 		ret.Completed = time.Now()
 	}()
@@ -190,7 +189,6 @@ 	}
 }
 
 func (me *trackerScraper) Run() {
-
 	defer me.announceStopped()
 
 	ctx, cancel := context.WithCancel(context.Background())
diff --git a/webtorrent/tracker_client.go b/webtorrent/tracker_client.go
index d75b9f9bbd5973335acc7ea1cbfec84530028669..f4136c6094487f2f3230f2d7d83065e54e9f51cb 100644
--- a/webtorrent/tracker_client.go
+++ b/webtorrent/tracker_client.go
@@ -150,7 +150,6 @@ 	return nil
 }
 
 func (tc *TrackerClient) announceOffers() {
-
 	// tc.Announce grabs a lock on tc.outboundOffers. It also handles the case where outboundOffers
 	// is nil. Take ownership of outboundOffers here.
 	tc.mu.Lock()
@@ -256,7 +255,7 @@ 		_, message, err := tracker.ReadMessage()
 		if err != nil {
 			return fmt.Errorf("read message error: %w", err)
 		}
-		//tc.Logger.WithDefaultLevel(log.Debug).Printf("received message from tracker: %q", message)
+		// tc.Logger.WithDefaultLevel(log.Debug).Printf("received message from tracker: %q", message)
 
 		var ar AnnounceResponse
 		if err := json.Unmarshal(message, &ar); err != nil {
@@ -337,7 +336,7 @@ 	if !ok {
 		tc.Logger.WithDefaultLevel(log.Warning).Printf("could not find offer for id %+q", offerId)
 		return
 	}
-	//tc.Logger.WithDefaultLevel(log.Debug).Printf("offer %q got answer %v", offerId, answer)
+	// tc.Logger.WithDefaultLevel(log.Debug).Printf("offer %q got answer %v", offerId, answer)
 	metrics.Add("outbound offers answered", 1)
 	err := offer.setAnswer(answer, func(dc datachannel.ReadWriteCloser) {
 		metrics.Add("outbound offers answered with datachannel", 1)