diff --git a/core/scripts/chaincli/command/keeper/upkeep.go b/core/scripts/chaincli/command/keeper/upkeep.go
index 8e2bc8bd993..c615bbf1aec 100644
--- a/core/scripts/chaincli/command/keeper/upkeep.go
+++ b/core/scripts/chaincli/command/keeper/upkeep.go
@@ -82,14 +82,11 @@ var ocr2UpkeepReportHistoryCmd = &cobra.Command{
 		hdlr := handler.NewBaseHandler(cfg)
 
 		var hashes []string
-		var err error
-		var path string
-
-		path, err = cmd.Flags().GetString("csv")
+		path, err := cmd.Flags().GetString("csv")
 		if err == nil && len(path) != 0 {
-			rec, err := readCsvFile(path)
-			if err != nil {
-				log.Fatal(err)
+			rec, err2 := readCsvFile(path)
+			if err2 != nil {
+				log.Fatal(err2)
 			}
 
 			if len(rec) < 1 {
@@ -107,7 +104,7 @@ var ocr2UpkeepReportHistoryCmd = &cobra.Command{
 			}
 		}
 
-		if err := handler.OCR2AutomationReports(hdlr, hashes); err != nil {
+		if err = handler.OCR2AutomationReports(hdlr, hashes); err != nil {
 			log.Fatalf("failed to collect transaction data: %s", err)
 		}
 	},
diff --git a/core/scripts/chaincli/handler/handler.go b/core/scripts/chaincli/handler/handler.go
index f72e94605d4..6423df3aa23 100644
--- a/core/scripts/chaincli/handler/handler.go
+++ b/core/scripts/chaincli/handler/handler.go
@@ -411,44 +411,44 @@ func (h *baseHandler) launchChainlinkNode(ctx context.Context, port int, contain
 
 		if writeLogs {
 			var rdr io.ReadCloser
-			rdr, err := dockerClient.ContainerLogs(ctx, nodeContainerResp.ID, types.ContainerLogsOptions{
+			rdr, err2 := dockerClient.ContainerLogs(ctx, nodeContainerResp.ID, types.ContainerLogsOptions{
 				ShowStderr: true,
 				Timestamps: true,
 			})
-			if err != nil {
+			if err2 != nil {
 				rdr.Close()
-				log.Fatal("Failed to collect logs from container: ", err)
+				log.Fatal("Failed to collect logs from container: ", err2)
 			}
 
-			stdErr, err := os.OpenFile(fmt.Sprintf("./%s-stderr.log", nodeContainerResp.ID), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0755)
-			if err != nil {
+			stdErr, err2 := os.OpenFile(fmt.Sprintf("./%s-stderr.log", nodeContainerResp.ID), os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0755)
+			if err2 != nil {
 				rdr.Close()
 				stdErr.Close()
-				log.Fatal("Failed to open file: ", err)
+				log.Fatal("Failed to open file: ", err2)
 			}
 
-			if _, err := stdcopy.StdCopy(io.Discard, stdErr, rdr); err != nil {
+			if _, err2 := stdcopy.StdCopy(io.Discard, stdErr, rdr); err2 != nil {
 				rdr.Close()
 				stdErr.Close()
-				log.Fatal("Failed to write logs to file: ", err)
+				log.Fatal("Failed to write logs to file: ", err2)
 			}
 
 			rdr.Close()
 			stdErr.Close()
 		}
 
-		if err = dockerClient.ContainerStop(ctx, nodeContainerResp.ID, container.StopOptions{}); err != nil {
-			log.Fatal("Failed to stop node container: ", err)
+		if err2 := dockerClient.ContainerStop(ctx, nodeContainerResp.ID, container.StopOptions{}); err2 != nil {
+			log.Fatal("Failed to stop node container: ", err2)
 		}
-		if err = dockerClient.ContainerRemove(ctx, nodeContainerResp.ID, types.ContainerRemoveOptions{}); err != nil {
-			log.Fatal("Failed to remove node container: ", err)
+		if err2 := dockerClient.ContainerRemove(ctx, nodeContainerResp.ID, types.ContainerRemoveOptions{}); err2 != nil {
+			log.Fatal("Failed to remove node container: ", err2)
 		}
 
-		if err = dockerClient.ContainerStop(ctx, dbContainerResp.ID, container.StopOptions{}); err != nil {
-			log.Fatal("Failed to stop DB container: ", err)
+		if err2 := dockerClient.ContainerStop(ctx, dbContainerResp.ID, container.StopOptions{}); err2 != nil {
+			log.Fatal("Failed to stop DB container: ", err2)
 		}
-		if err = dockerClient.ContainerRemove(ctx, dbContainerResp.ID, types.ContainerRemoveOptions{}); err != nil {
-			log.Fatal("Failed to remove DB container: ", err)
+		if err2 := dockerClient.ContainerRemove(ctx, dbContainerResp.ID, types.ContainerRemoveOptions{}); err2 != nil {
+			log.Fatal("Failed to remove DB container: ", err2)
 		}
 	}, nil
 }
diff --git a/core/scripts/chaincli/handler/keeper.go b/core/scripts/chaincli/handler/keeper.go
index ad8bd93649c..a5fb505adb4 100644
--- a/core/scripts/chaincli/handler/keeper.go
+++ b/core/scripts/chaincli/handler/keeper.go
@@ -528,13 +528,11 @@ func (k *Keeper) deployUpkeeps(ctx context.Context, registryAddr common.Address,
 		var registerUpkeepTx *types.Transaction
 		var logUpkeepCounter *log_upkeep_counter_wrapper.LogUpkeepCounter
 		var checkData []byte
-		var err error
+
 		switch k.cfg.UpkeepType {
 		case config.Conditional:
 			checkData = []byte(k.cfg.UpkeepCheckData)
-			if err != nil {
-				log.Fatal(err)
-			}
+			var err error
 			if k.cfg.UpkeepAverageEligibilityCadence > 0 {
 				upkeepAddr, deployUpkeepTx, _, err = upkeep.DeployUpkeepPerformCounterRestrictive(
 					k.buildTxOpts(ctx),
@@ -570,9 +568,7 @@ func (k *Keeper) deployUpkeeps(ctx context.Context, registryAddr common.Address,
 			}
 		case config.Mercury:
 			checkData = []byte(k.cfg.UpkeepCheckData)
-			if err != nil {
-				log.Fatal(err)
-			}
+			var err error
 			if k.cfg.VerifiableLoadTest {
 				upkeepAddr, deployUpkeepTx, _, err = verifiable_load_streams_lookup_upkeep_wrapper.DeployVerifiableLoadStreamsLookupUpkeep(
 					k.buildTxOpts(ctx),
@@ -603,6 +599,7 @@ func (k *Keeper) deployUpkeeps(ctx context.Context, registryAddr common.Address,
 				log.Fatal(i, upkeepAddr.Hex(), ": RegisterUpkeep failed - ", err)
 			}
 		case config.LogTrigger:
+			var err error
 			upkeepAddr, deployUpkeepTx, logUpkeepCounter, err = log_upkeep_counter_wrapper.DeployLogUpkeepCounter(
 				k.buildTxOpts(ctx),
 				k.client,
@@ -637,7 +634,7 @@ func (k *Keeper) deployUpkeeps(ctx context.Context, registryAddr common.Address,
 			if err != nil {
 				log.Fatal("failed to start log upkeep counter", err)
 			}
-			if err := k.waitTx(ctx, logUpkeepStartTx); err != nil {
+			if err = k.waitTx(ctx, logUpkeepStartTx); err != nil {
 				log.Fatalf("Log upkeep Start() failed for upkeepId: %s, error is %s", upkeepAddr.Hex(), err.Error())
 			}
 			log.Println(i, upkeepAddr.Hex(), ": Log upkeep successfully started - ", helpers.ExplorerLink(k.cfg.ChainID, logUpkeepStartTx.Hash()))
@@ -653,32 +650,34 @@ func (k *Keeper) deployUpkeeps(ctx context.Context, registryAddr common.Address,
 		upkeepAddrs = append(upkeepAddrs, upkeepAddr)
 	}
 
-	var err error
 	var upkeepGetter activeUpkeepGetter
 	upkeepCount := big.NewInt(k.cfg.UpkeepCount) // second arg in GetActiveUpkeepIds (on registry)
-	switch k.cfg.RegistryVersion {
-	case keeper.RegistryVersion_1_1:
-		panic("not supported 1.1 registry")
-	case keeper.RegistryVersion_1_2:
-		upkeepGetter, err = registry12.NewKeeperRegistry(
-			registryAddr,
-			k.client,
-		)
-	case keeper.RegistryVersion_2_0:
-		upkeepGetter, err = registry20.NewKeeperRegistry(
-			registryAddr,
-			k.client,
-		)
-	case keeper.RegistryVersion_2_1:
-		upkeepGetter, err = iregistry21.NewIKeeperRegistryMaster(
-			registryAddr,
-			k.client,
-		)
-	default:
-		panic("unexpected registry address")
-	}
-	if err != nil {
-		log.Fatal("Registry failed: ", err)
+	{
+		var err error
+		switch k.cfg.RegistryVersion {
+		case keeper.RegistryVersion_1_1:
+			panic("not supported 1.1 registry")
+		case keeper.RegistryVersion_1_2:
+			upkeepGetter, err = registry12.NewKeeperRegistry(
+				registryAddr,
+				k.client,
+			)
+		case keeper.RegistryVersion_2_0:
+			upkeepGetter, err = registry20.NewKeeperRegistry(
+				registryAddr,
+				k.client,
+			)
+		case keeper.RegistryVersion_2_1:
+			upkeepGetter, err = iregistry21.NewIKeeperRegistryMaster(
+				registryAddr,
+				k.client,
+			)
+		default:
+			panic("unexpected registry address")
+		}
+		if err != nil {
+			log.Fatal("Registry failed: ", err)
+		}
 	}
 
 	activeUpkeepIds := k.getActiveUpkeepIds(ctx, upkeepGetter, big.NewInt(existingCount), upkeepCount)
@@ -724,22 +723,24 @@ func (k *Keeper) deployUpkeeps(ctx context.Context, registryAddr common.Address,
 		}
 
 		for _, id := range activeUpkeepIds {
-			tx, err := reg21.SetUpkeepPrivilegeConfig(k.buildTxOpts(ctx), id, adminBytes)
-			if err != nil {
-				log.Fatalf("failed to upkeep privilege config: %v", err)
+			tx, err2 := reg21.SetUpkeepPrivilegeConfig(k.buildTxOpts(ctx), id, adminBytes)
+			if err2 != nil {
+				log.Fatalf("failed to upkeep privilege config: %v", err2)
 			}
-			err = k.waitTx(ctx, tx)
-			if err != nil {
-				log.Fatalf("failed to wait for tx: %v", err)
-			} else {
-				log.Printf("upkeep privilege config is set for %s", id.String())
+			err2 = k.waitTx(ctx, tx)
+			if err2 != nil {
+				log.Fatalf("failed to wait for tx: %v", err2)
 			}
+			log.Printf("upkeep privilege config is set for %s", id.String())
 
-			info, err := reg21.GetUpkeep(nil, id)
-			if err != nil {
-				log.Fatalf("failed to fetch upkeep id %s from registry 2.1: %v", id, err)
+			info, err2 := reg21.GetUpkeep(nil, id)
+			if err2 != nil {
+				log.Fatalf("failed to fetch upkeep id %s from registry 2.1: %v", id, err2)
+			}
+			min, err2 := reg21.GetMinBalanceForUpkeep(nil, id)
+			if err2 != nil {
+				log.Fatalf("failed to fetch upkeep id %s from registry 2.1: %v", id, err2)
 			}
-			min, err := reg21.GetMinBalanceForUpkeep(nil, id)
 			log.Printf("    Balance: %s", info.Balance)
 			log.Printf("Min Balance: %s", min.String())
 		}
@@ -757,7 +758,7 @@ func (k *Keeper) setKeepers(ctx context.Context, cls []cmd.HTTPClient, deployer
 			log.Fatal("SetKeepers failed: ", err)
 		}
 
-		if err := k.waitTx(ctx, setKeepersTx); err != nil {
+		if err = k.waitTx(ctx, setKeepersTx); err != nil {
 			log.Fatalf("SetKeepers failed, error is: %s", err.Error())
 		}
 
@@ -777,24 +778,6 @@ func (k *Keeper) keepers() ([]common.Address, []common.Address) {
 	return addrs, fromAddrs
 }
 
-// createKeeperJobOnExistingNode connect to existing node to create keeper job
-func (k *Keeper) createKeeperJobOnExistingNode(urlStr, email, password, registryAddr, nodeAddr string) error {
-	lggr, closeLggr := logger.NewLogger()
-	logger.Sugared(lggr).ErrorIfFn(closeLggr, "Failed to close logger")
-
-	cl, err := authenticate(urlStr, email, password, lggr)
-	if err != nil {
-		return err
-	}
-
-	if err = k.createKeeperJob(cl, registryAddr, nodeAddr); err != nil {
-		log.Println("Failed to create keeper job: ", err)
-		return err
-	}
-
-	return nil
-}
-
 type activeUpkeepGetter interface {
 	Address() common.Address
 	GetActiveUpkeepIDs(opts *bind.CallOpts, startIndex *big.Int, maxCount *big.Int) ([]*big.Int, error)
diff --git a/core/scripts/chaincli/handler/keeper_launch.go b/core/scripts/chaincli/handler/keeper_launch.go
index 22b67763945..ca0d5c403f1 100644
--- a/core/scripts/chaincli/handler/keeper_launch.go
+++ b/core/scripts/chaincli/handler/keeper_launch.go
@@ -100,14 +100,12 @@ func (k *Keeper) LaunchAndTest(ctx context.Context, withdraw, printLogs, force,
 
 		if len(k.cfg.KeeperKeys) > 0 {
 			// import key if exists
-			var err error
 			nodeAddrHex, err = k.addKeyToKeeper(cl, k.cfg.KeeperKeys[i])
 			if err != nil {
 				log.Fatal("could not add key to keeper", err)
 			}
 		} else {
 			// get node's default wallet address
-			var err error
 			nodeAddrHex, err = getNodeAddress(cl)
 			if err != nil {
 				log.Println("Failed to get node addr: ", err)
@@ -220,35 +218,35 @@ func (k *Keeper) LaunchAndTest(ctx context.Context, withdraw, printLogs, force,
 
 // cancelAndWithdrawActiveUpkeeps cancels all active upkeeps and withdraws funds for registry 1.2
 func (k *Keeper) cancelAndWithdrawActiveUpkeeps(ctx context.Context, activeUpkeepIds []*big.Int, canceller canceller) error {
-	var err error
 	for i := 0; i < len(activeUpkeepIds); i++ {
-		var tx *ethtypes.Transaction
 		upkeepId := activeUpkeepIds[i]
-		if tx, err = canceller.CancelUpkeep(k.buildTxOpts(ctx), upkeepId); err != nil {
+		tx, err := canceller.CancelUpkeep(k.buildTxOpts(ctx), upkeepId)
+		if err != nil {
 			return fmt.Errorf("failed to cancel upkeep %s: %s", upkeepId.String(), err)
 		}
 
-		if err := k.waitTx(ctx, tx); err != nil {
+		if err = k.waitTx(ctx, tx); err != nil {
 			log.Fatalf("failed to cancel upkeep for upkeepId: %s, error is: %s", upkeepId.String(), err.Error())
 		}
 
-		if tx, err = canceller.WithdrawFunds(k.buildTxOpts(ctx), upkeepId, k.fromAddr); err != nil {
+		tx, err = canceller.WithdrawFunds(k.buildTxOpts(ctx), upkeepId, k.fromAddr)
+		if err != nil {
 			return fmt.Errorf("failed to withdraw upkeep %s: %s", upkeepId.String(), err)
 		}
 
-		if err := k.waitTx(ctx, tx); err != nil {
+		if err = k.waitTx(ctx, tx); err != nil {
 			log.Fatalf("failed to withdraw upkeep for upkeepId: %s, error is: %s", upkeepId.String(), err.Error())
 		}
 
 		log.Printf("Upkeep %s successfully canceled and refunded: ", upkeepId.String())
 	}
 
-	var tx *ethtypes.Transaction
-	if tx, err = canceller.RecoverFunds(k.buildTxOpts(ctx)); err != nil {
+	tx, err := canceller.RecoverFunds(k.buildTxOpts(ctx))
+	if err != nil {
 		return fmt.Errorf("failed to recover funds: %s", err)
 	}
 
-	if err := k.waitTx(ctx, tx); err != nil {
+	if err = k.waitTx(ctx, tx); err != nil {
 		log.Fatalf("failed to recover funds, error is: %s", err.Error())
 	}
 
@@ -264,7 +262,7 @@ func (k *Keeper) cancelAndWithdrawUpkeeps(ctx context.Context, upkeepCount *big.
 			return fmt.Errorf("failed to cancel upkeep %d: %s", i, err)
 		}
 
-		if err := k.waitTx(ctx, tx); err != nil {
+		if err = k.waitTx(ctx, tx); err != nil {
 			log.Fatalf("failed to cancel upkeep, error is: %s", err.Error())
 		}
 
@@ -272,7 +270,7 @@ func (k *Keeper) cancelAndWithdrawUpkeeps(ctx context.Context, upkeepCount *big.
 			return fmt.Errorf("failed to withdraw upkeep %d: %s", i, err)
 		}
 
-		if err := k.waitTx(ctx, tx); err != nil {
+		if err = k.waitTx(ctx, tx); err != nil {
 			log.Fatalf("failed to withdraw upkeep, error is: %s", err.Error())
 		}
 
@@ -284,7 +282,7 @@ func (k *Keeper) cancelAndWithdrawUpkeeps(ctx context.Context, upkeepCount *big.
 		return fmt.Errorf("failed to recover funds: %s", err)
 	}
 
-	if err := k.waitTx(ctx, tx); err != nil {
+	if err = k.waitTx(ctx, tx); err != nil {
 		log.Fatalf("failed to recover funds, error is: %s", err.Error())
 	}
 
diff --git a/core/scripts/chaincli/handler/ocr2_config.go b/core/scripts/chaincli/handler/ocr2_config.go
index 21b2ad414a3..caa96112ea8 100644
--- a/core/scripts/chaincli/handler/ocr2_config.go
+++ b/core/scripts/chaincli/handler/ocr2_config.go
@@ -54,7 +54,7 @@ func OCR2GetConfig(hdlr *baseHandler, registry_addr string) error {
 
 func configFromBlock(bl *types.Block, addr common.Address, detail keeper_registry_wrapper2_0.LatestConfigDetails) (*confighelper.PublicConfig, error) {
 	for _, tx := range bl.Transactions() {
-		if tx.To() != nil && bytes.Compare(tx.To()[:], addr[:]) == 0 {
+		if tx.To() != nil && bytes.Equal(tx.To()[:], addr[:]) {
 			// this is our transaction
 			// txRes, txErr, err := getTransactionDetailForHashes(hdlr, []string{tx})
 			ocr2Tx, err := NewBaseOCR2Tx(tx)
diff --git a/core/scripts/chaincli/handler/report.go b/core/scripts/chaincli/handler/report.go
index 10970b5f03b..1dcbb21ee83 100644
--- a/core/scripts/chaincli/handler/report.go
+++ b/core/scripts/chaincli/handler/report.go
@@ -85,24 +85,26 @@ func OCR2AutomationReports(hdlr *baseHandler, txs []string) error {
 	}
 
 	txRes, txErr, err = getSimulationsForTxs(hdlr, simBatch)
+	if err != nil {
+		return err
+	}
 	for i := range txRes {
 		if txErr[i] == nil {
 			continue
 		}
 
-		err, ok := txErr[i].(JsonError)
+		err2, ok := txErr[i].(JsonError) //nolint:errorlint
 		if ok {
-			decoded, err := hexutil.Decode(err.ErrorData().(string))
+			decoded, err := hexutil.Decode(err2.ErrorData().(string))
 			if err != nil {
 				elements[i].Err = err.Error()
 				continue
 			}
 
 			elements[i].Err = ocr2Txs[i].DecodeError(decoded)
-		} else if err != nil {
-			elements[i].Err = err.Error()
+		} else if err2 != nil {
+			elements[i].Err = err2.Error()
 		}
-
 	}
 
 	data := make([][]string, len(elements))
@@ -275,7 +277,7 @@ func (t *OCR2Transaction) DecodeError(b []byte) string {
 		}
 	}
 
-	return fmt.Sprintf("%s", j)
+	return j
 }
 
 func NewOCR2TransmitTx(raw map[string]interface{}) (*OCR2TransmitTx, error) {
diff --git a/core/scripts/common/avalanche.go b/core/scripts/common/avalanche.go
index c9c53779905..8699463c365 100644
--- a/core/scripts/common/avalanche.go
+++ b/core/scripts/common/avalanche.go
@@ -79,8 +79,8 @@ func (b *AvaBloom) UnmarshalText(input []byte) error {
 // bloomValues returns the bytes (index-value pairs) to set for the given data
 func bloomValues(data []byte, hashbuf []byte) (uint, byte, uint, byte, uint, byte) {
 	sha := crypto.NewKeccakState()
-	sha.Write(data)
-	sha.Read(hashbuf)
+	sha.Write(data)   //nolint:errcheck
+	sha.Read(hashbuf) //nolint:errcheck
 	// The actual bits to flip
 	v1 := byte(1 << (hashbuf[1] & 0x7))
 	v2 := byte(1 << (hashbuf[3] & 0x7))
@@ -259,7 +259,7 @@ func (h *AvaHeader) Hash() common.Hash {
 func rlpHash(x interface{}) (h common.Hash) {
 	sha := crypto.NewKeccakState()
 	sha.Reset()
-	rlp.Encode(sha, x)
-	sha.Read(h[:])
+	rlp.Encode(sha, x) //nolint:errcheck
+	sha.Read(h[:])     //nolint:errcheck
 	return h
 }
diff --git a/core/scripts/common/helpers.go b/core/scripts/common/helpers.go
index b5a3b1ed943..9d2d06c89d0 100644
--- a/core/scripts/common/helpers.go
+++ b/core/scripts/common/helpers.go
@@ -395,12 +395,12 @@ func FundNode(e Environment, address string, fundingAmount *big.Int) {
 	var gasLimit uint64
 	if IsArbitrumChainID(e.ChainID) {
 		to := common.HexToAddress(address)
-		estimated, err := e.Ec.EstimateGas(context.Background(), ethereum.CallMsg{
+		estimated, err2 := e.Ec.EstimateGas(context.Background(), ethereum.CallMsg{
 			From:  e.Owner.From,
 			To:    &to,
 			Value: fundingAmount,
 		})
-		PanicErr(err)
+		PanicErr(err2)
 		gasLimit = estimated
 	} else {
 		gasLimit = uint64(21_000)
@@ -461,7 +461,7 @@ func GetRlpHeaders(env Environment, blockNumbers []*big.Int, getParentBlocks boo
 
 	hashes = make([]string, 0)
 
-	var offset *big.Int = big.NewInt(0)
+	offset := big.NewInt(0)
 	if getParentBlocks {
 		offset = big.NewInt(1)
 	}
@@ -475,15 +475,15 @@ func GetRlpHeaders(env Environment, blockNumbers []*big.Int, getParentBlocks boo
 			var h AvaHeader
 			// Get child block since it's the one that has the parent hash in its header.
 			nextBlockNum := new(big.Int).Set(blockNum).Add(blockNum, offset)
-			err := env.Jc.CallContext(context.Background(), &h, "eth_getBlockByNumber", hexutil.EncodeBig(nextBlockNum), false)
-			if err != nil {
-				return nil, hashes, fmt.Errorf("failed to get header: %+v", err)
+			err2 := env.Jc.CallContext(context.Background(), &h, "eth_getBlockByNumber", hexutil.EncodeBig(nextBlockNum), false)
+			if err2 != nil {
+				return nil, hashes, fmt.Errorf("failed to get header: %+v", err2)
 			}
 			// We can still use vanilla go-ethereum rlp.EncodeToBytes, see e.g
 			// https://github.com/ava-labs/coreth/blob/e3ca41bf5295a9a7ca1aeaf29d541fcbb94f79b1/core/types/hashing.go#L49-L57.
-			rlpHeader, err = rlp.EncodeToBytes(h)
-			if err != nil {
-				return nil, hashes, fmt.Errorf("failed to encode rlp: %+v", err)
+			rlpHeader, err2 = rlp.EncodeToBytes(h)
+			if err2 != nil {
+				return nil, hashes, fmt.Errorf("failed to encode rlp: %+v", err2)
 			}
 
 			hashes = append(hashes, h.Hash().String())
@@ -509,16 +509,16 @@ func GetRlpHeaders(env Environment, blockNumbers []*big.Int, getParentBlocks boo
 
 		} else {
 			// Get child block since it's the one that has the parent hash in its header.
-			h, err := env.Ec.HeaderByNumber(
+			h, err2 := env.Ec.HeaderByNumber(
 				context.Background(),
 				new(big.Int).Set(blockNum).Add(blockNum, offset),
 			)
-			if err != nil {
-				return nil, hashes, fmt.Errorf("failed to get header: %+v", err)
+			if err2 != nil {
+				return nil, hashes, fmt.Errorf("failed to get header: %+v", err2)
 			}
-			rlpHeader, err = rlp.EncodeToBytes(h)
-			if err != nil {
-				return nil, hashes, fmt.Errorf("failed to encode rlp: %+v", err)
+			rlpHeader, err2 = rlp.EncodeToBytes(h)
+			if err2 != nil {
+				return nil, hashes, fmt.Errorf("failed to encode rlp: %+v", err2)
 			}
 
 			hashes = append(hashes, h.Hash().String())
diff --git a/core/scripts/common/vrf/model/model.go b/core/scripts/common/vrf/model/model.go
index 0972c47e618..1b4e59fe4f3 100644
--- a/core/scripts/common/vrf/model/model.go
+++ b/core/scripts/common/vrf/model/model.go
@@ -21,7 +21,6 @@ type Node struct {
 	NumberOfSendingKeysToCreate int
 	SendingKeyFundingAmount     *big.Int
 	VrfKeys                     []string
-	jobSpec                     string
 }
 
 type SendingKey struct {
diff --git a/core/scripts/common/vrf/setup-envs/main.go b/core/scripts/common/vrf/setup-envs/main.go
index e9ea252e4c4..598238bebef 100644
--- a/core/scripts/common/vrf/setup-envs/main.go
+++ b/core/scripts/common/vrf/setup-envs/main.go
@@ -50,7 +50,6 @@ func newApp(remoteNodeURL string, writer io.Writer) (*clcmd.Shell, *cli.App) {
 var (
 	checkMarkEmoji = "✅"
 	xEmoji         = "❌"
-	infoEmoji      = "ℹ️"
 )
 
 func main() {
@@ -142,7 +141,7 @@ func main() {
 
 	output := &bytes.Buffer{}
 	for key, node := range nodesMap {
-
+		node := node
 		client, app := connectToNode(&node.URL, output, node.CredsFile)
 		ethKeys := createETHKeysIfNeeded(client, app, output, numEthKeys, &node.URL, maxGasPriceGwei)
 		if key == model.VRFPrimaryNodeName {
@@ -242,6 +241,7 @@ func main() {
 		}
 
 		for key, node := range nodesMap {
+			node := node
 			client, app := connectToNode(&node.URL, output, node.CredsFile)
 
 			//GET ALL JOBS
@@ -318,7 +318,7 @@ func getVRFKeys(client *clcmd.Shell, app *cli.App, output *bytes.Buffer) []prese
 }
 
 func createJob(jobSpec string, client *clcmd.Shell, app *cli.App, output *bytes.Buffer) {
-	if err := os.WriteFile("job-spec.toml", []byte(jobSpec), 0666); err != nil {
+	if err := os.WriteFile("job-spec.toml", []byte(jobSpec), 0666); err != nil { //nolint:gosec
 		helpers.PanicErr(err)
 	}
 	job := presenters.JobResource{}
@@ -332,7 +332,7 @@ func createJob(jobSpec string, client *clcmd.Shell, app *cli.App, output *bytes.
 }
 
 func exportVRFKey(client *clcmd.Shell, app *cli.App, vrfKey presenters.VRFKeyResource, output *bytes.Buffer) {
-	if err := os.WriteFile("vrf-key-password.txt", []byte("twochains"), 0666); err != nil {
+	if err := os.WriteFile("vrf-key-password.txt", []byte("twochains"), 0666); err != nil { //nolint:gosec
 		helpers.PanicErr(err)
 	}
 	flagSet := flag.NewFlagSet("blah", flag.ExitOnError)
@@ -346,7 +346,7 @@ func exportVRFKey(client *clcmd.Shell, app *cli.App, vrfKey presenters.VRFKeyRes
 }
 
 func importVRFKey(client *clcmd.Shell, app *cli.App, output *bytes.Buffer) {
-	if err := os.WriteFile("vrf-key-password.txt", []byte("twochains"), 0666); err != nil {
+	if err := os.WriteFile("vrf-key-password.txt", []byte("twochains"), 0666); err != nil { //nolint:gosec
 		helpers.PanicErr(err)
 	}
 	flagSet := flag.NewFlagSet("blah", flag.ExitOnError)
@@ -465,12 +465,8 @@ func createVRFKeyIfNeeded(client *clcmd.Shell, app *cli.App, output *bytes.Buffe
 		}(), ", "))
 	}
 	fmt.Println()
-	for _, vrfKey := range vrfKeys {
-		allVRFKeys = append(allVRFKeys, vrfKey)
-	}
-	for _, nk := range newKeys {
-		allVRFKeys = append(allVRFKeys, nk)
-	}
+	allVRFKeys = append(allVRFKeys, vrfKeys...)
+	allVRFKeys = append(allVRFKeys, newKeys...)
 	return allVRFKeys
 }
 
@@ -526,11 +522,7 @@ func createETHKeysIfNeeded(client *clcmd.Shell, app *cli.App, output *bytes.Buff
 	}
 	output.Reset()
 	fmt.Println()
-	for _, ethKey := range ethKeys {
-		allETHKeysNode = append(allETHKeysNode, ethKey)
-	}
-	for _, nk := range newKeys {
-		allETHKeysNode = append(allETHKeysNode, nk)
-	}
+	allETHKeysNode = append(allETHKeysNode, ethKeys...)
+	allETHKeysNode = append(allETHKeysNode, newKeys...)
 	return allETHKeysNode
 }
diff --git a/core/scripts/functions/src/delete_jobs.go b/core/scripts/functions/src/delete_jobs.go
index 632a239a62b..4fac1a4a772 100644
--- a/core/scripts/functions/src/delete_jobs.go
+++ b/core/scripts/functions/src/delete_jobs.go
@@ -62,7 +62,7 @@ func (g *deleteJobs) Run(args []string) {
 		output.Reset()
 
 		fileFs := flag.NewFlagSet("test", flag.ExitOnError)
-		client.ListJobs(cli.NewContext(app, fileFs, nil))
+		err = client.ListJobs(cli.NewContext(app, fileFs, nil))
 		helpers.PanicErr(err)
 
 		var parsed []JobSpec
@@ -73,7 +73,8 @@ func (g *deleteJobs) Run(args []string) {
 			if jobSpec.BootstrapSpec.ContractID == *contractAddress || jobSpec.OffChainReporting2OracleSpec.ContractID == *contractAddress {
 				fmt.Println("Deleting job ID:", jobSpec.Id, "name:", jobSpec.Name)
 				set := flag.NewFlagSet("test", flag.ExitOnError)
-				set.Parse([]string{jobSpec.Id})
+				err = set.Parse([]string{jobSpec.Id})
+				helpers.PanicErr(err)
 				err = client.DeleteJob(cli.NewContext(app, set, nil))
 				helpers.PanicErr(err)
 			}
diff --git a/core/scripts/functions/src/deploy_jobspecs_cmd.go b/core/scripts/functions/src/deploy_jobspecs_cmd.go
index 0039aaa4601..e892370cc22 100644
--- a/core/scripts/functions/src/deploy_jobspecs_cmd.go
+++ b/core/scripts/functions/src/deploy_jobspecs_cmd.go
@@ -27,18 +27,18 @@ func (g *deployJobSpecs) Name() string {
 func (g *deployJobSpecs) Run(args []string) {
 	fs := flag.NewFlagSet(g.Name(), flag.ContinueOnError)
 	nodesFile := fs.String("nodes", "", "a file containing nodes urls, logins and passwords")
-	err := fs.Parse(args)
-	if err != nil || nodesFile == nil || *nodesFile == "" {
+
+	if err := fs.Parse(args); err != nil || nodesFile == nil || *nodesFile == "" {
 		fs.Usage()
 		os.Exit(1)
 	}
 
 	nodes := mustReadNodesList(*nodesFile)
-	for _, node := range nodes {
+	for _, n := range nodes {
 		output := &bytes.Buffer{}
-		client, app := newApp(node, output)
+		client, app := newApp(n, output)
 
-		fmt.Println("Logging in:", node.url)
+		fmt.Println("Logging in:", n.url)
 		loginFs := flag.NewFlagSet("test", flag.ContinueOnError)
 		loginFs.Bool("bypass-version-check", true, "")
 		loginCtx := cli.NewContext(app, loginFs, nil)
@@ -46,18 +46,19 @@ func (g *deployJobSpecs) Run(args []string) {
 		helpers.PanicErr(err)
 		output.Reset()
 
-		tomlPath := filepath.Join(artefactsDir, node.url.Host+".toml")
+		tomlPath := filepath.Join(artefactsDir, n.url.Host+".toml")
 		tomlPath, err = filepath.Abs(tomlPath)
 		if err != nil {
 			helpers.PanicErr(err)
 		}
 		fmt.Println("Deploying jobspec:", tomlPath)
-		if _, err := os.Stat(tomlPath); err != nil {
+		if _, err = os.Stat(tomlPath); err != nil {
 			helpers.PanicErr(errors.New("toml file does not exist"))
 		}
 
 		fileFs := flag.NewFlagSet("test", flag.ExitOnError)
-		fileFs.Parse([]string{tomlPath})
+		err = fileFs.Parse([]string{tomlPath})
+		helpers.PanicErr(err)
 		err = client.CreateJob(cli.NewContext(app, fileFs, nil))
 		helpers.PanicErr(err)
 		output.Reset()
diff --git a/core/scripts/functions/src/fetching.go b/core/scripts/functions/src/fetching.go
index cbe491fff5e..2e0841b49de 100644
--- a/core/scripts/functions/src/fetching.go
+++ b/core/scripts/functions/src/fetching.go
@@ -24,11 +24,11 @@ type ocr2Bundle struct {
 }
 
 func mustFetchNodesKeys(chainID int64, nodes []*node) (nca []NodeKeys) {
-	for _, node := range nodes {
+	for _, n := range nodes {
 		output := &bytes.Buffer{}
-		client, app := newApp(node, output)
+		client, app := newApp(n, output)
 
-		fmt.Println("Logging in:", node.url)
+		fmt.Println("Logging in:", n.url)
 		loginFs := flag.NewFlagSet("test", flag.ContinueOnError)
 		loginFs.Bool("bypass-version-check", true, "")
 		loginCtx := cli.NewContext(app, loginFs, nil)
@@ -68,7 +68,7 @@ func mustFetchNodesKeys(chainID int64, nodes []*node) (nca []NodeKeys) {
 		if ocr2BundleIndex == -1 {
 			helpers.PanicErr(errors.New("node must have EVM OCR2 bundle"))
 		}
-		ocr2Bundle := ocr2Bundles[ocr2BundleIndex]
+		ocr2Bndl := ocr2Bundles[ocr2BundleIndex]
 		output.Reset()
 
 		err = client.ListCSAKeys(&cli.Context{
@@ -84,10 +84,10 @@ func mustFetchNodesKeys(chainID int64, nodes []*node) (nca []NodeKeys) {
 		nc := NodeKeys{
 			EthAddress:            ethAddress,
 			P2PPeerID:             peerID,
-			OCR2BundleID:          ocr2Bundle.ID,
-			OCR2ConfigPublicKey:   strings.TrimPrefix(ocr2Bundle.ConfigPublicKey, "ocr2cfg_evm_"),
-			OCR2OnchainPublicKey:  strings.TrimPrefix(ocr2Bundle.OnchainPublicKey, "ocr2on_evm_"),
-			OCR2OffchainPublicKey: strings.TrimPrefix(ocr2Bundle.OffchainPublicKey, "ocr2off_evm_"),
+			OCR2BundleID:          ocr2Bndl.ID,
+			OCR2ConfigPublicKey:   strings.TrimPrefix(ocr2Bndl.ConfigPublicKey, "ocr2cfg_evm_"),
+			OCR2OnchainPublicKey:  strings.TrimPrefix(ocr2Bndl.OnchainPublicKey, "ocr2on_evm_"),
+			OCR2OffchainPublicKey: strings.TrimPrefix(ocr2Bndl.OffchainPublicKey, "ocr2off_evm_"),
 			CSAPublicKey:          csaPubKey,
 		}
 
diff --git a/core/scripts/functions/src/generate_ocr2_config_cmd.go b/core/scripts/functions/src/generate_ocr2_config_cmd.go
index 1cfddf4413c..7ac3b68d11d 100644
--- a/core/scripts/functions/src/generate_ocr2_config_cmd.go
+++ b/core/scripts/functions/src/generate_ocr2_config_cmd.go
@@ -134,8 +134,7 @@ func (g *generateOCR2Config) Run(args []string) {
 	keysFile := fs.String("keys", "", "a file containing nodes public keys")
 	configFile := fs.String("config", "", "a file containing JSON config")
 	chainID := fs.Int64("chainid", 80001, "chain id")
-	err := fs.Parse(args)
-	if err != nil || (*nodesFile == "" && *keysFile == "") || *configFile == "" || chainID == nil {
+	if err := fs.Parse(args); err != nil || (*nodesFile == "" && *keysFile == "") || *configFile == "" || chainID == nil {
 		fs.Usage()
 		os.Exit(1)
 	}
diff --git a/core/scripts/gateway/client/send_request.go b/core/scripts/gateway/client/send_request.go
index 8ab4e8bce79..eeb85ff0dcb 100644
--- a/core/scripts/gateway/client/send_request.go
+++ b/core/scripts/gateway/client/send_request.go
@@ -52,7 +52,6 @@ func main() {
 
 	var s4SetPayload []byte
 	if *methodName == functions.MethodSecretsSet {
-		var err error
 		s4SetPayload, err = os.ReadFile(*s4SetPayloadFile)
 		if err != nil {
 			fmt.Println("error reading S4 payload file", err)
@@ -70,23 +69,21 @@ func main() {
 			Payload:    s4SetPayload,
 			Expiration: time.Now().UnixMilli() + *s4SetExpirationPeriod,
 		}
-		signature, err := envelope.Sign(key)
-		if err != nil {
-			fmt.Println("error signing S4 envelope", err)
+		signature, err2 := envelope.Sign(key)
+		if err2 != nil {
+			fmt.Println("error signing S4 envelope", err2)
 			return
 		}
 
-		s4SetPayload := functions.SecretsSetRequest{
+		payloadJSON, err2 = json.Marshal(functions.SecretsSetRequest{
 			SlotID:     envelope.SlotID,
 			Version:    envelope.Version,
 			Expiration: envelope.Expiration,
 			Payload:    s4SetPayload,
 			Signature:  signature,
-		}
-
-		payloadJSON, err = json.Marshal(s4SetPayload)
-		if err != nil {
-			fmt.Println("error marshaling S4 payload", err)
+		})
+		if err2 != nil {
+			fmt.Println("error marshaling S4 payload", err2)
 			return
 		}
 	}
@@ -122,27 +119,27 @@ func main() {
 	client := &http.Client{}
 
 	sendRequest := func() {
-		req, err := createRequest()
-		if err != nil {
-			fmt.Println("error creating a request", err)
+		req, err2 := createRequest()
+		if err2 != nil {
+			fmt.Println("error creating a request", err2)
 			return
 		}
 
-		resp, err := client.Do(req)
-		if err != nil {
-			fmt.Println("error sending a request", err)
+		resp, err2 := client.Do(req)
+		if err2 != nil {
+			fmt.Println("error sending a request", err2)
 			return
 		}
 		defer resp.Body.Close()
 
-		body, err := io.ReadAll(resp.Body)
-		if err != nil {
-			fmt.Println("error sending a request", err)
+		body, err2 := io.ReadAll(resp.Body)
+		if err2 != nil {
+			fmt.Println("error sending a request", err2)
 			return
 		}
 
 		var prettyJSON bytes.Buffer
-		if err := json.Indent(&prettyJSON, body, "", "  "); err != nil {
+		if err2 = json.Indent(&prettyJSON, body, "", "  "); err2 != nil {
 			fmt.Println(string(body))
 		} else {
 			fmt.Println(prettyJSON.String())
diff --git a/core/scripts/gateway/connector/run_connector.go b/core/scripts/gateway/connector/run_connector.go
index 248162ef822..c6ad187461c 100644
--- a/core/scripts/gateway/connector/run_connector.go
+++ b/core/scripts/gateway/connector/run_connector.go
@@ -31,7 +31,10 @@ type client struct {
 
 func (h *client) HandleGatewayMessage(ctx context.Context, gatewayId string, msg *api.Message) {
 	h.lggr.Infof("received message from gateway %s. Echoing back.", gatewayId)
-	h.connector.SendToGateway(context.Background(), gatewayId, msg)
+	err := h.connector.SendToGateway(ctx, gatewayId, msg)
+	if err != nil {
+		h.lggr.Errorw("failed to send to gateway", "id", gatewayId, "err", err)
+	}
 }
 
 func (h *client) Sign(data ...[]byte) ([]byte, error) {
@@ -70,8 +73,16 @@ func main() {
 	client.connector = connector
 
 	ctx, _ := signal.NotifyContext(context.Background(), os.Interrupt)
-	connector.Start(ctx)
+	err = connector.Start(ctx)
+	if err != nil {
+		fmt.Println("error staring connector:", err)
+		return
+	}
 
 	<-ctx.Done()
-	connector.Close()
+	err = connector.Close()
+	if err != nil {
+		fmt.Println("error closing connector:", err)
+		return
+	}
 }
diff --git a/core/scripts/gateway/run_gateway.go b/core/scripts/gateway/run_gateway.go
index 1f0230bb8ad..e30c43bb8af 100644
--- a/core/scripts/gateway/run_gateway.go
+++ b/core/scripts/gateway/run_gateway.go
@@ -56,8 +56,16 @@ func main() {
 	}
 
 	ctx, _ := signal.NotifyContext(context.Background(), os.Interrupt)
-	gw.Start(ctx)
+	err = gw.Start(ctx)
+	if err != nil {
+		fmt.Println("error staring gateway:", err)
+		return
+	}
 
 	<-ctx.Done()
-	gw.Close()
+	err = gw.Close()
+	if err != nil {
+		fmt.Println("error closing gateway:", err)
+		return
+	}
 }
diff --git a/core/scripts/ocr2vrf/setup_ocr2vrf.go b/core/scripts/ocr2vrf/setup_ocr2vrf.go
index ab43dc0180f..1094b823b4e 100644
--- a/core/scripts/ocr2vrf/setup_ocr2vrf.go
+++ b/core/scripts/ocr2vrf/setup_ocr2vrf.go
@@ -232,9 +232,7 @@ func setupOCR2VRFNodes(e helpers.Environment) {
 			transmitters[i+1] = f.String()
 		}
 	} else {
-		for _, t := range transmitters[1:] {
-			nodesToFund = append(nodesToFund, t)
-		}
+		nodesToFund = append(nodesToFund, transmitters[1:]...)
 	}
 
 	var payees []common.Address
diff --git a/core/scripts/ocr2vrf/util.go b/core/scripts/ocr2vrf/util.go
index 4ec78472e50..ef71327b52b 100644
--- a/core/scripts/ocr2vrf/util.go
+++ b/core/scripts/ocr2vrf/util.go
@@ -306,14 +306,6 @@ func findSubscriptionID(e helpers.Environment, vrfCoordinatorAddr string) *big.I
 	return subscriptionIterator.Event.SubId
 }
 
-func registerMigratableCoordinator(e helpers.Environment, coordinatorAddress, migratableCoordinatorAddress string) {
-	coordinator := newVRFCoordinator(common.HexToAddress(coordinatorAddress), e.Ec)
-
-	tx, err := coordinator.RegisterMigratableCoordinator(e.Owner, common.HexToAddress(migratableCoordinatorAddress))
-	helpers.PanicErr(err)
-	helpers.ConfirmTXMined(context.Background(), e.Ec, tx, e.ChainID)
-}
-
 func addConsumer(e helpers.Environment, vrfCoordinatorAddr, consumerAddr string, subId *big.Int) {
 	coordinator := newVRFCoordinator(common.HexToAddress(vrfCoordinatorAddr), e.Ec)
 
@@ -330,34 +322,6 @@ func setPayees(e helpers.Environment, vrfBeaconAddr string, transmitters, payees
 	helpers.ConfirmTXMined(context.Background(), e.Ec, tx, e.ChainID)
 }
 
-func setBeaconBilling(e helpers.Environment, vrfBeaconAddr string, maximumGasPrice, reasonableGasPrice, observationPayment,
-	transmissionPayment, accountingGas uint64) {
-	beacon := newVRFBeacon(common.HexToAddress(vrfBeaconAddr), e.Ec)
-
-	tx, err := beacon.SetBilling(e.Owner, maximumGasPrice, reasonableGasPrice, observationPayment, transmissionPayment, big.NewInt(0).SetUint64(accountingGas))
-	helpers.PanicErr(err)
-	helpers.ConfirmTXMined(context.Background(), e.Ec, tx, e.ChainID)
-}
-
-func setCoordinatorBilling(e helpers.Environment, vrfCoordinatorAddr string, useReasonableGasPrice bool, unusedGasPenaltyPercent uint8,
-	stalenessSeconds, redeemableRequestGasOverhead, callbackRequestGasOverhead, premiumPercentage, reasonableGasPriceStalenessBlocks uint32,
-	fallbackWeiPerUnitLink *big.Int) {
-	coordinator := newVRFCoordinator(common.HexToAddress(vrfCoordinatorAddr), e.Ec)
-
-	tx, err := coordinator.SetCoordinatorConfig(e.Owner, vrf_coordinator.VRFBeaconTypesCoordinatorConfig{
-		UseReasonableGasPrice:             useReasonableGasPrice,
-		UnusedGasPenaltyPercent:           unusedGasPenaltyPercent,
-		StalenessSeconds:                  stalenessSeconds,
-		RedeemableRequestGasOverhead:      redeemableRequestGasOverhead,
-		CallbackRequestGasOverhead:        callbackRequestGasOverhead,
-		PremiumPercentage:                 uint8(premiumPercentage),
-		ReasonableGasPriceStalenessBlocks: reasonableGasPriceStalenessBlocks,
-		FallbackWeiPerUnitLink:            fallbackWeiPerUnitLink,
-	})
-	helpers.PanicErr(err)
-	helpers.ConfirmTXMined(context.Background(), e.Ec, tx, e.ChainID)
-}
-
 func eoaFundSubscription(e helpers.Environment, coordinatorAddress, linkAddress string, amount, subID *big.Int) {
 	linkToken, err := link_token_interface.NewLinkToken(common.HexToAddress(linkAddress), e.Ec)
 	helpers.PanicErr(err)
diff --git a/core/scripts/vrfv2/testnet/main.go b/core/scripts/vrfv2/testnet/main.go
index 5856256504b..4607c09e6e0 100644
--- a/core/scripts/vrfv2/testnet/main.go
+++ b/core/scripts/vrfv2/testnet/main.go
@@ -1088,9 +1088,8 @@ func main() {
 				return true
 			} else if strings.Contains(err.Error(), "execution reverted") {
 				return false
-			} else {
-				panic(err)
 			}
+			panic(err)
 		}
 
 		result := helpers.BinarySearch(assets.Ether(int64(*start*2)).ToInt(), big.NewInt(0), isWithdrawable)
diff --git a/core/scripts/vrfv2/testnet/v2scripts/super_scripts.go b/core/scripts/vrfv2/testnet/v2scripts/super_scripts.go
index 4a1c1fcec41..2608873fcfd 100644
--- a/core/scripts/vrfv2/testnet/v2scripts/super_scripts.go
+++ b/core/scripts/vrfv2/testnet/v2scripts/super_scripts.go
@@ -20,6 +20,7 @@ import (
 	"github.com/smartcontractkit/chainlink/core/scripts/common/vrf/util"
 
 	evmtypes "github.com/ethereum/go-ethereum/core/types"
+
 	helpers "github.com/smartcontractkit/chainlink/core/scripts/common"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/generated/link_token_interface"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/generated/vrf_coordinator_v2"
@@ -297,7 +298,7 @@ func VRFV2DeployUniverse(
 		tx, err := vrfOwner.SetAuthorizedSenders(e.Owner, authorizedSendersSlice)
 		helpers.PanicErr(err)
 		helpers.ConfirmTXMined(context.Background(), e.Ec, tx, e.ChainID, "vrf owner set authorized senders")
-		fmt.Printf("\nTransfering ownership of coordinator: %v, VRF Owner %v\n", contractAddresses.CoordinatorAddress, vrfOwnerAddress.String())
+		fmt.Printf("\nTransferring ownership of coordinator: %v, VRF Owner %v\n", contractAddresses.CoordinatorAddress, vrfOwnerAddress.String())
 		tx, err = coordinator.TransferOwnership(e.Owner, vrfOwnerAddress)
 		helpers.PanicErr(err)
 		helpers.ConfirmTXMined(context.Background(), e.Ec, tx, e.ChainID, "transfer ownership to", vrfOwnerAddress.String())
@@ -320,9 +321,8 @@ func VRFV2DeployUniverse(
 		func() string {
 			if keys := nodesMap[model.VRFPrimaryNodeName].SendingKeys; len(keys) > 0 {
 				return keys[0].Address
-			} else {
-				return common.HexToAddress("0x0").String()
 			}
+			return common.HexToAddress("0x0").String()
 		}(),
 		contractAddresses.CoordinatorAddress,
 		contractAddresses.CoordinatorAddress,
@@ -347,9 +347,8 @@ func VRFV2DeployUniverse(
 		func() string {
 			if keys := nodesMap[model.VRFPrimaryNodeName].SendingKeys; len(keys) > 0 {
 				return keys[0].Address
-			} else {
-				return common.HexToAddress("0x0").String()
 			}
+			return common.HexToAddress("0x0").String()
 		}(),
 		contractAddresses.CoordinatorAddress,
 		contractAddresses.CoordinatorAddress,
diff --git a/core/scripts/vrfv2plus/testnet/main.go b/core/scripts/vrfv2plus/testnet/main.go
index 6b1ef585a5a..f9c6ea7e2dc 100644
--- a/core/scripts/vrfv2plus/testnet/main.go
+++ b/core/scripts/vrfv2plus/testnet/main.go
@@ -1046,9 +1046,8 @@ func main() {
 				return true
 			} else if strings.Contains(err.Error(), "execution reverted") {
 				return false
-			} else {
-				panic(err)
 			}
+			panic(err)
 		}
 
 		result := helpers.BinarySearch(assets.Ether(int64(*start*2)).ToInt(), big.NewInt(0), isWithdrawable)
diff --git a/core/scripts/vrfv2plus/testnet/proofs.go b/core/scripts/vrfv2plus/testnet/proofs.go
index 126ac2d6c5a..306d237caf4 100644
--- a/core/scripts/vrfv2plus/testnet/proofs.go
+++ b/core/scripts/vrfv2plus/testnet/proofs.go
@@ -11,13 +11,14 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/shopspring/decimal"
+
 	helpers "github.com/smartcontractkit/chainlink/core/scripts/common"
 	"github.com/smartcontractkit/chainlink/v2/core/services/keystore/keys/vrfkey"
 	"github.com/smartcontractkit/chainlink/v2/core/services/vrf/extraargs"
 	"github.com/smartcontractkit/chainlink/v2/core/services/vrf/proof"
 )
 
-var vrfProofTemplate string = `{
+var vrfProofTemplate = `{
 	pk: [
 		%s,
 		%s
@@ -42,7 +43,7 @@ var vrfProofTemplate string = `{
 }
 `
 
-var rcTemplate string = `{
+var rcTemplate = `{
 	blockNum: %d,
 	subId: %d,
 	callbackGasLimit: %d,
diff --git a/core/scripts/vrfv2plus/testnet/v2plusscripts/super_scripts.go b/core/scripts/vrfv2plus/testnet/v2plusscripts/super_scripts.go
index 50584d885a2..21d76c42048 100644
--- a/core/scripts/vrfv2plus/testnet/v2plusscripts/super_scripts.go
+++ b/core/scripts/vrfv2plus/testnet/v2plusscripts/super_scripts.go
@@ -202,9 +202,9 @@ func SmokeTestVRF(e helpers.Environment) {
 	var provingKeyRegisteredLog *vrf_coordinator_v2_5.VRFCoordinatorV25ProvingKeyRegistered
 	for _, log := range registerReceipt.Logs {
 		if log.Address == coordinatorAddress {
-			var err error
-			provingKeyRegisteredLog, err = coordinator.ParseProvingKeyRegistered(*log)
-			if err != nil {
+			var err2 error
+			provingKeyRegisteredLog, err2 = coordinator.ParseProvingKeyRegistered(*log)
+			if err2 != nil {
 				continue
 			}
 		}
@@ -214,9 +214,8 @@ func SmokeTestVRF(e helpers.Environment) {
 	}
 	if !bytes.Equal(provingKeyRegisteredLog.KeyHash[:], keyHash[:]) {
 		panic(fmt.Sprintf("unexpected key hash registered %s, expected %s", hexutil.Encode(provingKeyRegisteredLog.KeyHash[:]), hexutil.Encode(keyHash[:])))
-	} else {
-		fmt.Println("key hash registered:", hexutil.Encode(provingKeyRegisteredLog.KeyHash[:]))
 	}
+	fmt.Println("key hash registered:", hexutil.Encode(provingKeyRegisteredLog.KeyHash[:]))
 
 	fmt.Println("\nProving key registered, getting proving key hashes from deployed contract...")
 	_, _, provingKeyHashes, configErr := coordinator.GetRequestConfig(nil)
@@ -268,6 +267,7 @@ func SmokeTestVRF(e helpers.Environment) {
 	consumer, err := vrf_v2plus_sub_owner.NewVRFV2PlusExternalSubOwnerExample(consumerAddress, e.Ec)
 	helpers.PanicErr(err)
 	tx, err = consumer.RequestRandomWords(e.Owner, subID, 100_000, 3, 3, provingKeyRegisteredLog.KeyHash, false)
+	helpers.PanicErr(err)
 	receipt := helpers.ConfirmTXMined(context.Background(), e.Ec, tx, e.ChainID, "request random words from", consumerAddress.String())
 	fmt.Println("request blockhash:", receipt.BlockHash)
 
@@ -275,9 +275,9 @@ func SmokeTestVRF(e helpers.Environment) {
 	var rwrLog *vrf_coordinator_v2_5.VRFCoordinatorV25RandomWordsRequested
 	for _, log := range receipt.Logs {
 		if log.Address == coordinatorAddress {
-			var err error
-			rwrLog, err = coordinator.ParseRandomWordsRequested(*log)
-			if err != nil {
+			var err2 error
+			rwrLog, err2 = coordinator.ParseRandomWordsRequested(*log)
+			if err2 != nil {
 				continue
 			}
 		}
@@ -396,13 +396,13 @@ func SmokeTestBHS(e helpers.Environment) {
 	if seReceipt.Status != 1 {
 		fmt.Println("storeEarliest failed")
 		os.Exit(1)
-	} else {
-		fmt.Println("storeEarliest succeeded, checking BH is there")
-		bh, err := bhs.GetBlockhash(nil, seReceipt.BlockNumber.Sub(seReceipt.BlockNumber, big.NewInt(256)))
-		helpers.PanicErr(err)
-		fmt.Println("blockhash stored by storeEarliest:", hexutil.Encode(bh[:]))
-		anchorBlockNumber = seReceipt.BlockNumber
 	}
+	fmt.Println("storeEarliest succeeded, checking BH is there")
+	bh, err := bhs.GetBlockhash(nil, seReceipt.BlockNumber.Sub(seReceipt.BlockNumber, big.NewInt(256)))
+	helpers.PanicErr(err)
+	fmt.Println("blockhash stored by storeEarliest:", hexutil.Encode(bh[:]))
+	anchorBlockNumber = seReceipt.BlockNumber
+
 	if anchorBlockNumber == nil {
 		panic("no anchor block number")
 	}
@@ -417,12 +417,11 @@ func SmokeTestBHS(e helpers.Environment) {
 	if sReceipt.Status != 1 {
 		fmt.Println("store failed")
 		os.Exit(1)
-	} else {
-		fmt.Println("store succeeded, checking BH is there")
-		bh, err := bhs.GetBlockhash(nil, toStore)
-		helpers.PanicErr(err)
-		fmt.Println("blockhash stored by store:", hexutil.Encode(bh[:]))
 	}
+	fmt.Println("store succeeded, checking BH is there")
+	bh, err = bhs.GetBlockhash(nil, toStore)
+	helpers.PanicErr(err)
+	fmt.Println("blockhash stored by store:", hexutil.Encode(bh[:]))
 
 	fmt.Println("\nexecuting storeVerifyHeader")
 	headers, _, err := helpers.GetRlpHeaders(e, []*big.Int{anchorBlockNumber}, false)
@@ -435,12 +434,11 @@ func SmokeTestBHS(e helpers.Environment) {
 	if svhReceipt.Status != 1 {
 		fmt.Println("storeVerifyHeader failed")
 		os.Exit(1)
-	} else {
-		fmt.Println("storeVerifyHeader succeeded, checking BH is there")
-		bh, err := bhs.GetBlockhash(nil, toStore)
-		helpers.PanicErr(err)
-		fmt.Println("blockhash stored by storeVerifyHeader:", hexutil.Encode(bh[:]))
 	}
+	fmt.Println("storeVerifyHeader succeeded, checking BH is there")
+	bh, err = bhs.GetBlockhash(nil, toStore)
+	helpers.PanicErr(err)
+	fmt.Println("blockhash stored by storeVerifyHeader:", hexutil.Encode(bh[:]))
 }
 
 func sendTx(e helpers.Environment, to common.Address, data []byte) (*types.Receipt, common.Hash) {
@@ -501,7 +499,6 @@ func DeployUniverseViaCLI(e helpers.Environment) {
 	fallbackWeiPerUnitLink := decimal.RequireFromString(*fallbackWeiPerUnitLinkString).BigInt()
 	subscriptionBalanceJuels := decimal.RequireFromString(*subscriptionBalanceJuelsString).BigInt()
 	subscriptionBalanceNativeWei := decimal.RequireFromString(*subscriptionBalanceNativeWeiString).BigInt()
-	fundingAmount := decimal.RequireFromString(*nodeSendingKeyFundingAmount).BigInt()
 
 	feeConfig := vrf_coordinator_v2_5.VRFCoordinatorV25FeeConfig{
 		FulfillmentFlatFeeLinkPPM:   uint32(*flatFeeLinkPPM),
@@ -712,9 +709,8 @@ func VRFV2PlusDeployUniverse(e helpers.Environment,
 		func() string {
 			if keys := nodesMap[model.VRFPrimaryNodeName].SendingKeys; len(keys) > 0 {
 				return keys[0].Address
-			} else {
-				return common.HexToAddress("0x0").String()
 			}
+			return common.HexToAddress("0x0").String()
 		}(),
 		contractAddresses.CoordinatorAddress,
 		contractAddresses.CoordinatorAddress,
@@ -733,9 +729,8 @@ func VRFV2PlusDeployUniverse(e helpers.Environment,
 		func() string {
 			if keys := nodesMap[model.VRFPrimaryNodeName].SendingKeys; len(keys) > 0 {
 				return keys[0].Address
-			} else {
-				return common.HexToAddress("0x0").String()
 			}
+			return common.HexToAddress("0x0").String()
 		}(),
 		contractAddresses.CoordinatorAddress,
 		contractAddresses.CoordinatorAddress,
diff --git a/core/scripts/vrfv2plus/testnet/v2plusscripts/util.go b/core/scripts/vrfv2plus/testnet/v2plusscripts/util.go
index ebe881a9951..7598c6f398f 100644
--- a/core/scripts/vrfv2plus/testnet/v2plusscripts/util.go
+++ b/core/scripts/vrfv2plus/testnet/v2plusscripts/util.go
@@ -4,7 +4,6 @@ import (
 	"context"
 	"encoding/hex"
 	"fmt"
-	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/generated/vrf_v2plus_load_test_with_metrics"
 	"math/big"
 
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
@@ -17,6 +16,7 @@ import (
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/generated/blockhash_store"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/generated/link_token_interface"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/generated/vrf_coordinator_v2_5"
+	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/generated/vrf_v2plus_load_test_with_metrics"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/generated/vrf_v2plus_sub_owner"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/generated/vrfv2plus_wrapper"
 	"github.com/smartcontractkit/chainlink/v2/core/gethwrappers/generated/vrfv2plus_wrapper_consumer_example"