refactor(all): remove term whitelist and blacklist (#1994)

Author: gzliudan

cmd/XDC/main.go

@@ -61,8 +61,8 @@ var (
 		utils.IdentityFlag,
 		utils.UnlockedAccountFlag,
 		utils.PasswordFileFlag,
-		utils.PeersWhitelistFlag,
-		utils.PeersBlacklistFlag,
+		utils.PeersAllowlistFlag,
+		utils.PeersDenylistFlag,
 		utils.BootnodesFlag,
 		utils.BootnodesV4Flag,
 		utils.BootnodesV5Flag,

cmd/puppeth/module_ethstats.go

@@ -157,7 +157,7 @@ func checkEthstats(client *sshClient, network string) (*ethstatsInfos, error) {
 	if port != 80 && port != 443 {
 		config += fmt.Sprintf(":%d", port)
 	}
-	// Retrieve the IP blacklist
+	// Retrieve the IP denylist
 	banned := strings.Split(infos.envvars["BANNED"], ",")
 
 	// Run a sanity check to see if the port is reachable

cmd/puppeth/wizard_ethstats.go

@@ -63,20 +63,20 @@ func (w *wizard) deployEthstats() {
 		fmt.Printf("What should be the secret password for the API? (default = %s)\n", infos.secret)
 		infos.secret = w.readDefaultString(infos.secret)
 	}
-	// Gather any blacklists to ban from reporting
+	// Gather any denylist to ban from reporting
 	if existed {
 		fmt.Println()
-		fmt.Printf("Keep existing IP %v blacklist (y/n)? (default = yes)\n", infos.banned)
+		fmt.Printf("Keep existing IP %v denylist (y/n)? (default = yes)\n", infos.banned)
 		if w.readDefaultString("y") != "y" {
 			// The user might want to clear the entire list, although generally probably not
 			fmt.Println()
-			fmt.Printf("Clear out blacklist and start over (y/n)? (default = no)\n")
+			fmt.Printf("Clear out denylist and start over (y/n)? (default = no)\n")
 			if w.readDefaultString("n") != "n" {
 				infos.banned = nil
 			}
 			// Offer the user to explicitly add/remove certain IP addresses
 			fmt.Println()
-			fmt.Println("Which additional IP addresses should be blacklisted?")
+			fmt.Println("Which additional IP addresses should be denylisted?")
 			for {
 				if ip := w.readIPAddress(); ip != "" {
 					infos.banned = append(infos.banned, ip)
@@ -85,7 +85,7 @@ func (w *wizard) deployEthstats() {
 				break
 			}
 			fmt.Println()
-			fmt.Println("Which IP addresses should not be blacklisted?")
+			fmt.Println("Which IP addresses should not be denylisted?")
 			for {
 				if ip := w.readIPAddress(); ip != "" {
 					for i, addr := range infos.banned {

cmd/utils/flags.go

@@ -629,15 +629,15 @@ var (
 		Value:    30303,
 		Category: flags.NetworkingCategory,
 	}
-	PeersWhitelistFlag = &cli.StringFlag{
-		Name:     "peers-whitelist",
-		Usage:    "Comma separated NodeID or enode URLs for peer whitelist (only connect to them)",
+	PeersAllowlistFlag = &cli.StringFlag{
+		Name:     "peers-allowlist",
+		Usage:    "Comma separated NodeID or enode URLs for peer allowlist (only connect to them)",
 		Value:    "",
 		Category: flags.NetworkingCategory,
 	}
-	PeersBlacklistFlag = &cli.StringFlag{
-		Name:     "peers-blacklist",
-		Usage:    "Comma separated NodeID or enode URLs for peer blacklist (will not connect to them)",
+	PeersDenylistFlag = &cli.StringFlag{
+		Name:     "peers-denylist",
+		Usage:    "Comma separated NodeID or enode URLs for peer denylist (will not connect to them)",
 		Value:    "",
 		Category: flags.NetworkingCategory,
 	}
@@ -918,66 +918,66 @@ func setNodeUserIdent(ctx *cli.Context, cfg *node.Config) {
 	}
 }
 
-func setWhiteBlackListPeers(ctx *cli.Context, cfg *p2p.Config) {
-	flags.CheckExclusive(ctx, PeersWhitelistFlag, PeersBlacklistFlag)
+func setAllowlistAndDenylistForPeers(ctx *cli.Context, cfg *p2p.Config) {
+	flags.CheckExclusive(ctx, PeersAllowlistFlag, PeersDenylistFlag)
 
-	// setup whitelist for peers
-	if ctx.IsSet(PeersWhitelistFlag.Name) {
-		urls := SplitAndTrim(ctx.String(PeersWhitelistFlag.Name))
-		cfg.WhitePeers = make(map[discover.NodeID]struct{}, len(urls))
+	// setup allowlist for peers
+	if ctx.IsSet(PeersAllowlistFlag.Name) {
+		urls := SplitAndTrim(ctx.String(PeersAllowlistFlag.Name))
+		cfg.AllowPeers = make(map[discover.NodeID]struct{}, len(urls))
 		for _, url := range urls {
 			if url != "" {
 				node1, err1 := discover.HexID(url)
 				if err1 == nil {
-					cfg.WhitePeers[node1] = struct{}{}
-					log.Info("Add peer to whitelist", "id", node1)
+					cfg.AllowPeers[node1] = struct{}{}
+					log.Info("Add peer to allowlist", "id", node1)
 					continue
 				}
 				node2, err2 := discover.ParseNode(url)
 				if err2 == nil {
-					cfg.WhitePeers[node2.ID] = struct{}{}
-					log.Info("Add peer to whitelist", "enode", url, "id", node2.ID)
+					cfg.AllowPeers[node2.ID] = struct{}{}
+					log.Info("Add peer to allowlist", "enode", url, "id", node2.ID)
 					continue
 				}
-				log.Crit("Invalid peer id for whitelist", "url", url, "err1", err1, "err2", err2)
+				log.Crit("Invalid peer id for allowlist", "url", url, "err1", err1, "err2", err2)
 			}
 		}
 	}
 
-	// setup blacklist for peers
-	if ctx.IsSet(PeersBlacklistFlag.Name) {
-		urls := SplitAndTrim(ctx.String(PeersBlacklistFlag.Name))
-		cfg.BlackPeers = make(map[discover.NodeID]struct{}, len(urls))
+	// setup denylist for peers
+	if ctx.IsSet(PeersDenylistFlag.Name) {
+		urls := SplitAndTrim(ctx.String(PeersDenylistFlag.Name))
+		cfg.DenyPeers = make(map[discover.NodeID]struct{}, len(urls))
 		for _, url := range urls {
 			if url != "" {
 				node1, err1 := discover.HexID(url)
 				if err1 == nil {
-					cfg.BlackPeers[node1] = struct{}{}
-					log.Info("Add peer to blacklist", "id", node1)
+					cfg.DenyPeers[node1] = struct{}{}
+					log.Info("Add peer to denylist", "id", node1)
 					continue
 				}
 				node2, err2 := discover.ParseNode(url)
 				if err2 == nil {
-					cfg.BlackPeers[node2.ID] = struct{}{}
-					log.Info("Add peer to blacklist", "enode", url, "id", node2.ID)
+					cfg.DenyPeers[node2.ID] = struct{}{}
+					log.Info("Add peer to denylist", "enode", url, "id", node2.ID)
 					continue
 				}
-				log.Crit("Invalid peer id for blacklist", "url", url, "err1", err1, "err2", err2)
+				log.Crit("Invalid peer id for denylist", "url", url, "err1", err1, "err2", err2)
 			}
 		}
 	}
 }
 
-// removeBlackPeers removes bootstrap nodes which is in peers blacklist
-func removeBlackPeers(cfg *p2p.Config) {
-	if len(cfg.BlackPeers) == 0 {
+// removeDenylistedPeers removes bootstrap nodes which is in peers denylist
+func removeDenylistedPeers(cfg *p2p.Config) {
+	if len(cfg.DenyPeers) == 0 {
 		return
 	}
 
 	filteredNodes := make([]*discover.Node, 0, len(cfg.BootstrapNodes))
 	for _, node := range cfg.BootstrapNodes {
-		if _, ok := cfg.BlackPeers[node.ID]; ok {
-			log.Info("Remove black peer", "enode", node, "id", node.ID)
+		if _, ok := cfg.DenyPeers[node.ID]; ok {
+			log.Info("Remove denylisted peer", "enode", node, "id", node.ID)
 			continue
 		}
 		filteredNodes = append(filteredNodes, node)
@@ -1280,8 +1280,8 @@ func SetP2PConfig(ctx *cli.Context, cfg *p2p.Config) {
 	setNAT(ctx, cfg)
 	setListenAddress(ctx, cfg)
 	setBootstrapNodes(ctx, cfg)
-	setWhiteBlackListPeers(ctx, cfg)
-	removeBlackPeers(cfg)
+	setAllowlistAndDenylistForPeers(ctx, cfg)
+	removeDenylistedPeers(cfg)
 	// setBootstrapNodesV5(ctx, cfg)
 
 	if ctx.IsSet(MaxPeersFlag.Name) {

common/constants.all.go

@@ -38,9 +38,9 @@ var (
 )
 
 type constant struct {
-	chainID           uint64
-	blackListHFNumber uint64
-	maxMasternodesV2  int // Last v1 masternodes
+	chainID          uint64
+	denylistHFNumber uint64
+	maxMasternodesV2 int // Last v1 masternodes
 
 	tip2019Block           *big.Int
 	tipSigning             *big.Int
@@ -75,13 +75,13 @@ type constant struct {
 
 	ignoreSignerCheckBlockArray map[uint64]struct{}
 
-	blacklist map[Address]struct{}
+	denylist map[Address]struct{}
 }
 
 // variables for specific networks, copy values from mainnet constant to pass tests
 var (
-	BlackListHFNumber = MainnetConstant.blackListHFNumber
-	MaxMasternodesV2  = MainnetConstant.maxMasternodesV2 // Last v1 masternodes
+	DenylistHFNumber = MainnetConstant.denylistHFNumber
+	MaxMasternodesV2 = MainnetConstant.maxMasternodesV2 // Last v1 masternodes
 
 	TIP2019Block           = MainnetConstant.tip2019Block
 	TIPSigning             = MainnetConstant.tipSigning
@@ -114,19 +114,19 @@ var (
 	LendingRegistrationSMC = MainnetConstant.lendingRegistrationSMC
 
 	ignoreSignerCheckBlockArray = MainnetConstant.ignoreSignerCheckBlockArray
-	blacklist                   = MainnetConstant.blacklist
+	denylist                    = MainnetConstant.denylist
 )
 
 func IsIgnoreSignerCheckBlock(blockNumber uint64) bool {
 	_, ok := ignoreSignerCheckBlockArray[blockNumber]
 	return ok
 }
 
-func IsInBlacklist(address *Address) bool {
+func IsInDenylist(address *Address) bool {
 	if address == nil {
 		return false
 	}
-	_, ok := blacklist[*address]
+	_, ok := denylist[*address]
 	return ok
 }
 
@@ -147,7 +147,7 @@ func CopyConstants(chainID uint64) {
 	}
 
 	MaxMasternodesV2 = c.maxMasternodesV2
-	BlackListHFNumber = c.blackListHFNumber
+	DenylistHFNumber = c.denylistHFNumber
 	TIP2019Block = c.tip2019Block
 	TIPSigning = c.tipSigning
 	TIPRandomize = c.tipRandomize
@@ -181,6 +181,6 @@ func CopyConstants(chainID uint64) {
 	clear(ignoreSignerCheckBlockArray)
 	maps.Copy(ignoreSignerCheckBlockArray, c.ignoreSignerCheckBlockArray)
 
-	clear(blacklist)
-	maps.Copy(blacklist, c.blacklist)
+	clear(denylist)
+	maps.Copy(denylist, c.denylist)
 }

common/constants.devnet.go

@@ -6,9 +6,9 @@ import (
 )
 
 var DevnetConstant = constant{
-	chainID:           551,
-	blackListHFNumber: 0,
-	maxMasternodesV2:  108,
+	chainID:          551,
+	denylistHFNumber: 0,
+	maxMasternodesV2: 108,
 
 	tip2019Block:           big.NewInt(0),
 	tipSigning:             big.NewInt(0),
@@ -48,7 +48,7 @@ var DevnetConstant = constant{
 		28270800: {},
 	},
 
-	blacklist: map[Address]struct{}{
+	denylist: map[Address]struct{}{
 		HexToAddress("0x5248bfb72fd4f234e062d3e9bb76f08643004fcd"): {},
 		HexToAddress("0x5ac26105b35ea8935be382863a70281ec7a985e9"): {},
 		HexToAddress("0x09c4f991a41e7ca0645d7dfbfee160b55e562ea4"): {},

common/constants.local.go

@@ -6,9 +6,9 @@ import (
 )
 
 var localConstant = constant{
-	chainID:           5151,
-	maxMasternodesV2:  108,
-	blackListHFNumber: 0,
+	chainID:          5151,
+	maxMasternodesV2: 108,
+	denylistHFNumber: 0,
 
 	tip2019Block:           big.NewInt(0),
 	tipSigning:             big.NewInt(0),
@@ -43,5 +43,5 @@ var localConstant = constant{
 
 	ignoreSignerCheckBlockArray: map[uint64]struct{}{},
 
-	blacklist: map[Address]struct{}{},
+	denylist: map[Address]struct{}{},
 }

common/constants.mainnet.go

@@ -6,9 +6,9 @@ import (
 )
 
 var MainnetConstant = constant{
-	chainID:           50,
-	blackListHFNumber: 38383838,
-	maxMasternodesV2:  108,
+	chainID:          50,
+	denylistHFNumber: 38383838,
+	maxMasternodesV2: 108,
 
 	tip2019Block:           big.NewInt(1),
 	tipSigning:             big.NewInt(3000000),
@@ -48,7 +48,7 @@ var MainnetConstant = constant{
 		28270800: {},
 	},
 
-	blacklist: map[Address]struct{}{
+	denylist: map[Address]struct{}{
 		HexToAddress("0x5248bfb72fd4f234e062d3e9bb76f08643004fcd"): {},
 		HexToAddress("0x5ac26105b35ea8935be382863a70281ec7a985e9"): {},
 		HexToAddress("0x09c4f991a41e7ca0645d7dfbfee160b55e562ea4"): {},

common/constants.testnet.go

@@ -6,9 +6,9 @@ import (
 )
 
 var TestnetConstant = constant{
-	chainID:           51,
-	blackListHFNumber: 23779191,
-	maxMasternodesV2:  15,
+	chainID:          51,
+	denylistHFNumber: 23779191,
+	maxMasternodesV2: 15,
 
 	tip2019Block:           big.NewInt(1),
 	tipSigning:             big.NewInt(3000000),
@@ -48,7 +48,7 @@ var TestnetConstant = constant{
 		28270800: {},
 	},
 
-	blacklist: map[Address]struct{}{
+	denylist: map[Address]struct{}{
 		HexToAddress("0x5248bfb72fd4f234e062d3e9bb76f08643004fcd"): {},
 		HexToAddress("0x5ac26105b35ea8935be382863a70281ec7a985e9"): {},
 		HexToAddress("0x09c4f991a41e7ca0645d7dfbfee160b55e562ea4"): {},

core/blockchain.go

@@ -1581,8 +1581,8 @@ func (bc *BlockChain) insertChain(chain types.Blocks, verifySeals bool) (int, []
 		}
 		// If the header is a banned one, straight out abort
 		if BadHashes[block.Hash()] {
-			bc.reportBlock(block, nil, ErrBlacklistedHash)
-			return it.index, events, coalescedLogs, ErrBlacklistedHash
+			bc.reportBlock(block, nil, ErrDenylistedHash)
+			return it.index, events, coalescedLogs, ErrDenylistedHash
 		}
 		// Retrieve the parent block and it's state to execute on top
 		start := time.Now()
@@ -1942,12 +1942,12 @@ func (bc *BlockChain) getResultBlock(block *types.Block, verifiedM2 bool) (*Resu
 	// If the chain is terminating, stop processing blocks
 	if bc.insertStopped() {
 		log.Debug("Premature abort during blocks processing")
-		return nil, ErrBlacklistedHash
+		return nil, errInsertionInterrupted
 	}
 	// If the header is a banned one, straight out abort
 	if BadHashes[block.Hash()] {
-		bc.reportBlock(block, nil, ErrBlacklistedHash)
-		return nil, ErrBlacklistedHash
+		bc.reportBlock(block, nil, ErrDenylistedHash)
+		return nil, ErrDenylistedHash
 	}
 	// Wait for the block's verification to complete
 	bstart := time.Now()