[spam][crazy][fiction][random] Non-Canon MCBoss Spinoffs

[Undescribed Horrific Abuse, One Victim & Survivor of Many]

These are the bandaids I am using to run gaiad over a socks proxy such as tor.

Use like:
$ all_proxy=socks5h://127.0.0.1:9050 gaiad start

I also tweaked config.toml to reduce the peers and increase the timeouts.

p2p/netaddress.go: add socks support
p2p/transport.go: remove checks for duplicate remote ips
blockchain/v0/pool.go: reduce block queue size and increase timeout

Users could find it useful to further adjust the values in
blockchain/v0/pool.go to impact syncing bandwidth and stability.

Making changes like these to blockchain/v0/pool.go can provide for running a
node on a very slow link which previously was prevented. See
https://github.com/cometbft/cometbft/issues/1595

diff --git a/p2p/netaddress.go b/p2p/netaddress.go
index b8e0c2419..329e21bef 100644
--- a/p2p/netaddress.go
+++ b/p2p/netaddress.go
@@ -5,6 +5,7 @@
 package p2p

 import (
+	"context"
 	"encoding/hex"
 	"errors"
 	"flag"
@@ -15,6 +16,7 @@ import (
 	"time"

 	tmp2p "github.com/tendermint/tendermint/proto/tendermint/p2p"
+	"golang.org/x/net/proxy"
 )

 // EmptyNetAddress defines the string representation of an empty NetAddress
@@ -231,18 +233,24 @@ func (na *NetAddress) DialString() string {
 	)
 }

-// Dial calls net.Dial on the address.
+// Dial calls proxy.Dial on the address.
 func (na *NetAddress) Dial() (net.Conn, error) {
-	conn, err := net.Dial("tcp", na.DialString())
+	ctx := context.Background()
+	conn, err := proxy.Dial(ctx, "tcp", na.DialString())
+	//conn, err := net.Dial("tcp", na.DialString())
 	if err != nil {
 		return nil, err
 	}
 	return conn, nil
 }

-// DialTimeout calls net.DialTimeout on the address.
+// DialTimeout calls proxyDial on the address with a timeout context.
 func (na *NetAddress) DialTimeout(timeout time.Duration) (net.Conn, error) {
-	conn, err := net.DialTimeout("tcp", na.DialString(), timeout)
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+	//ctx := context.Background()
+	conn, err := proxy.Dial(ctx, "tcp", na.DialString())
+	//conn, err := net.DialTimeout("tcp", na.DialString(), timeout)
 	if err != nil {
 		return nil, err
 	}
diff --git a/p2p/transport.go b/p2p/transport.go
index 416c94694..f237f3ea0 100644
--- a/p2p/transport.go
+++ b/p2p/transport.go
@@ -90,11 +90,11 @@ func ConnDuplicateIPFilter() ConnFilterFunc {
 	return func(cs ConnSet, c net.Conn, ips []net.IP) error {
 		for _, ip := range ips {
 			if cs.HasIP(ip) {
-				return ErrRejected{
-					conn:        c,
-					err:         fmt.Errorf("ip<%v> already connected", ip),
-					isDuplicate: true,
-				}
+				return nil//ErrRejected{ // proxied connections all trigger this
from the proxy's ip
+				//	conn:        c,
+				//	err:         fmt.Errorf("ip<%v> already connected", ip),
+				//	isDuplicate: true,
+				//}
 			}
 		}

@@ -367,9 +367,9 @@ func (mt *MultiplexTransport) filterConn(c
net.Conn) (err error) {
 	}()

 	// Reject if connection is already present.
-	if mt.conns.Has(c) {
-		return ErrRejected{conn: c, isDuplicate: true}
-	}
+	//if mt.conns.Has(c) {
+	//	return ErrRejected{conn: c, isDuplicate: true}
+	//}

 	// Resolve ips for incoming conn.
 	ips, err := resolveIPs(mt.resolver, c)
diff --git a/blockchain/v0/pool.go b/blockchain/v0/pool.go
index b3a09b1dc..d8f066698 100644
--- a/blockchain/v0/pool.go
+++ b/blockchain/v0/pool.go
@@ -29,10 +29,10 @@ eg, L = latency = 0.1s

 const (
 	requestIntervalMS         = 2
-	maxTotalRequesters        = 600
+	maxTotalRequesters        = 6 // 600
 	maxPendingRequests        = maxTotalRequesters
 	maxPendingRequestsPerPeer = 20
-	requestRetrySeconds       = 30
+	requestRetrySeconds       = 30000 // 30 // retrying wipes the
request information which makes it think a delayed block is from an
invalid peer

 	// Minimum recv rate to ensure we're receiving blocks from a peer fast
 	// enough. If a peer is not sending us data at at least that rate, we
@@ -40,13 +40,13 @@ const (
 	//
 	// Assuming a DSL connection (not a good choice) 128 Kbps (upload) ~ 15 KB/s,
 	// sending data across atlantic ~ 7.5 KB/s.
-	minRecvRate = 7680
+	minRecvRate = 768 // 7680

 	// Maximum difference between current and new block's height.
 	maxDiffBetweenCurrentAndReceivedBlockHeight = 100
 )

-var peerTimeout = 15 * time.Second // not const so we can override with tests
+var peerTimeout = 150 * time.Second // 15 * time.Second // not const
so we can override with tests

 /*
 	Peers self report their heights when we join the block pool.