cmd, common, node, rpc: rework naming convention to canonical one

cmd/geth/js_test.go

@@ -96,7 +96,7 @@ func testREPL(t *testing.T, config func(*eth.Config)) (string, *testjethre, *nod
 		t.Fatal(err)
 	}
 	// Create a networkless protocol stack
-	stack, err := node.New(&node.Config{PrivateKey: testNodeKey, Name: "test", NoDiscovery: true, IpcPath: fmt.Sprintf("geth-test-%d.ipc", rand.Int63())})
+	stack, err := node.New(&node.Config{PrivateKey: testNodeKey, Name: "test", NoDiscovery: true, IPCPath: fmt.Sprintf("geth-test-%d.ipc", rand.Int63())})
 	if err != nil {
 		t.Fatalf("failed to create node: %v", err)
 	}
@@ -142,7 +142,7 @@ func testREPL(t *testing.T, config func(*eth.Config)) (string, *testjethre, *nod
 	stack.Service(&ethereum)
 
 	assetPath := filepath.Join(os.Getenv("GOPATH"), "src", "github.com", "ethereum", "go-ethereum", "cmd", "mist", "assets", "ext")
-	client, err := utils.NewRemoteRPCClientFromString("ipc:" + stack.IpcEndpoint())
+	client, err := utils.NewRemoteRPCClientFromString("ipc:" + stack.IPCEndpoint())
 	if err != nil {
 		t.Fatalf("failed to attach to node: %v", err)
 	}

cmd/geth/main.go

@@ -312,7 +312,7 @@ JavaScript API. See https://github.com/ethereum/go-ethereum/wiki/Javascipt-Conso
 		utils.WSListenAddrFlag,
 		utils.WSPortFlag,
 		utils.WSApiFlag,
-		utils.WSCORSDomainFlag,
+		utils.WSAllowedDomainsFlag,
 		utils.IPCDisabledFlag,
 		utils.IPCApiFlag,
 		utils.IPCPathFlag,
@@ -425,7 +425,7 @@ func console(ctx *cli.Context) {
 	startNode(ctx, node)
 
 	// Attach to the newly started node, and either execute script or become interactive
-	client, err := utils.NewRemoteRPCClientFromString("ipc:" + node.IpcEndpoint())
+	client, err := utils.NewRemoteRPCClientFromString("ipc:" + node.IPCEndpoint())
 	if err != nil {
 		utils.Fatalf("Failed to attach to the inproc geth: %v", err)
 	}
@@ -451,7 +451,7 @@ func execScripts(ctx *cli.Context) {
 	startNode(ctx, node)
 
 	// Attach to the newly started node and execute the given scripts
-	client, err := utils.NewRemoteRPCClientFromString("ipc:" + node.IpcEndpoint())
+	client, err := utils.NewRemoteRPCClientFromString("ipc:" + node.IPCEndpoint())
 	if err != nil {
 		utils.Fatalf("Failed to attach to the inproc geth: %v", err)
 	}

cmd/geth/monitorcmd.go

@@ -36,7 +36,7 @@ import (
 var (
 	monitorCommandAttachFlag = cli.StringFlag{
 		Name:  "attach",
-		Value: "ipc:" + node.DefaultIpcEndpoint(),
+		Value: "ipc:" + node.DefaultIPCEndpoint(),
 		Usage: "API endpoint to attach to",
 	}
 	monitorCommandRowsFlag = cli.IntFlag{

cmd/geth/usage.go

@@ -93,7 +93,7 @@ var AppHelpFlagGroups = []flagGroup{
 			utils.WSListenAddrFlag,
 			utils.WSPortFlag,
 			utils.WSApiFlag,
-			utils.WSCORSDomainFlag,
+			utils.WSAllowedDomainsFlag,
 			utils.IPCDisabledFlag,
 			utils.IPCApiFlag,
 			utils.IPCPathFlag,

cmd/gethrpctest/main.go

@@ -93,13 +93,13 @@ func main() {
 func MakeSystemNode(keydir string, privkey string, test *tests.BlockTest) (*node.Node, error) {
 	// Create a networkless protocol stack
 	stack, err := node.New(&node.Config{
-		IpcPath:     node.DefaultIpcEndpoint(),
+		IPCPath:     node.DefaultIPCEndpoint(),
-		HttpHost:    common.DefaultHttpHost,
+		HTTPHost:    common.DefaultHTTPHost,
-		HttpPort:    common.DefaultHttpPort,
+		HTTPPort:    common.DefaultHTTPPort,
-		HttpModules: []string{"admin", "db", "eth", "debug", "miner", "net", "shh", "txpool", "personal", "web3"},
+		HTTPModules: []string{"admin", "db", "eth", "debug", "miner", "net", "shh", "txpool", "personal", "web3"},
-		WsHost:      common.DefaultWsHost,
+		WSHost:      common.DefaultWSHost,
-		WsPort:      common.DefaultWsPort,
+		WSPort:      common.DefaultWSPort,
-		WsModules:   []string{"admin", "db", "eth", "debug", "miner", "net", "shh", "txpool", "personal", "web3"},
+		WSModules:   []string{"admin", "db", "eth", "debug", "miner", "net", "shh", "txpool", "personal", "web3"},
 		NoDiscovery: true,
 	})
 	if err != nil {

cmd/utils/client.go

@@ -33,7 +33,7 @@ func NewRemoteRPCClient(ctx *cli.Context) (rpc.Client, error) {
 		return NewRemoteRPCClientFromString(endpoint)
 	}
 	// use IPC by default
-	return rpc.NewIPCClient(node.DefaultIpcEndpoint())
+	return rpc.NewIPCClient(node.DefaultIPCEndpoint())
 }
 
 // NewRemoteRPCClientFromString returns a RPC client which connects to the given

cmd/utils/flags.go

@@ -232,12 +232,12 @@ var (
 	RPCListenAddrFlag = cli.StringFlag{
 		Name:  "rpcaddr",
 		Usage: "HTTP-RPC server listening interface",
-		Value: common.DefaultHttpHost,
+		Value: common.DefaultHTTPHost,
 	}
 	RPCPortFlag = cli.IntFlag{
 		Name:  "rpcport",
 		Usage: "HTTP-RPC server listening port",
-		Value: common.DefaultHttpPort,
+		Value: common.DefaultHTTPPort,
 	}
 	RPCCORSDomainFlag = cli.StringFlag{
 		Name:  "rpccorsdomain",
@@ -247,7 +247,7 @@ var (
 	RPCApiFlag = cli.StringFlag{
 		Name:  "rpcapi",
 		Usage: "API's offered over the HTTP-RPC interface",
-		Value: rpc.DefaultHttpRpcApis,
+		Value: rpc.DefaultHTTPApis,
 	}
 	IPCDisabledFlag = cli.BoolFlag{
 		Name:  "ipcdisable",
@@ -256,12 +256,12 @@ var (
 	IPCApiFlag = cli.StringFlag{
 		Name:  "ipcapi",
 		Usage: "API's offered over the IPC-RPC interface",
-		Value: rpc.DefaultIpcApis,
+		Value: rpc.DefaultIPCApis,
 	}
 	IPCPathFlag = DirectoryFlag{
 		Name:  "ipcpath",
 		Usage: "Filename for IPC socket/pipe within the datadir (explicit paths escape it)",
-		Value: DirectoryString{common.DefaultIpcSocket},
+		Value: DirectoryString{common.DefaultIPCSocket},
 	}
 	WSEnabledFlag = cli.BoolFlag{
 		Name:  "ws",
@@ -270,21 +270,21 @@ var (
 	WSListenAddrFlag = cli.StringFlag{
 		Name:  "wsaddr",
 		Usage: "WS-RPC server listening interface",
-		Value: common.DefaultWsHost,
+		Value: common.DefaultWSHost,
 	}
 	WSPortFlag = cli.IntFlag{
 		Name:  "wsport",
 		Usage: "WS-RPC server listening port",
-		Value: common.DefaultWsPort,
+		Value: common.DefaultWSPort,
 	}
 	WSApiFlag = cli.StringFlag{
 		Name:  "wsapi",
 		Usage: "API's offered over the WS-RPC interface",
-		Value: rpc.DefaultHttpRpcApis,
+		Value: rpc.DefaultHTTPApis,
 	}
-	WSCORSDomainFlag = cli.StringFlag{
+	WSAllowedDomainsFlag = cli.StringFlag{
-		Name:  "wscorsdomain",
+		Name:  "wsdomains",
-		Usage: "Domains from which to accept websockets requests",
+		Usage: "Domains from which to accept websockets requests (can be spoofed)",
 		Value: "",
 	}
 	ExecFlag = cli.StringFlag{
@@ -393,9 +393,9 @@ func MustMakeDataDir(ctx *cli.Context) string {
 	return ""
 }
 
-// MakeIpcPath creates an IPC path configuration from the set command line flags,
+// MakeIPCPath creates an IPC path configuration from the set command line flags,
 // returning an empty string if IPC was explicitly disabled, or the set path.
-func MakeIpcPath(ctx *cli.Context) string {
+func MakeIPCPath(ctx *cli.Context) string {
 	if ctx.GlobalBool(IPCDisabledFlag.Name) {
 		return ""
 	}
@@ -481,18 +481,18 @@ func MakeNAT(ctx *cli.Context) nat.Interface {
 	return natif
 }
 
-// MakeHttpRpcHost creates the HTTP RPC listener interface string from the set
+// MakeHTTPRpcHost creates the HTTP RPC listener interface string from the set
 // command line flags, returning empty if the HTTP endpoint is disabled.
-func MakeHttpRpcHost(ctx *cli.Context) string {
+func MakeHTTPRpcHost(ctx *cli.Context) string {
 	if !ctx.GlobalBool(RPCEnabledFlag.Name) {
 		return ""
 	}
 	return ctx.GlobalString(RPCListenAddrFlag.Name)
 }
 
-// MakeWsRpcHost creates the WebSocket RPC listener interface string from the set
+// MakeWSRpcHost creates the WebSocket RPC listener interface string from the set
 // command line flags, returning empty if the HTTP endpoint is disabled.
-func MakeWsRpcHost(ctx *cli.Context) string {
+func MakeWSRpcHost(ctx *cli.Context) string {
 	if !ctx.GlobalBool(WSEnabledFlag.Name) {
 		return ""
 	}
@@ -616,15 +616,15 @@ func MakeSystemNode(name, version string, extra []byte, ctx *cli.Context) *node.
 		NAT:             MakeNAT(ctx),
 		MaxPeers:        ctx.GlobalInt(MaxPeersFlag.Name),
 		MaxPendingPeers: ctx.GlobalInt(MaxPendingPeersFlag.Name),
-		IpcPath:         MakeIpcPath(ctx),
+		IPCPath:         MakeIPCPath(ctx),
-		HttpHost:        MakeHttpRpcHost(ctx),
+		HTTPHost:        MakeHTTPRpcHost(ctx),
-		HttpPort:        ctx.GlobalInt(RPCPortFlag.Name),
+		HTTPPort:        ctx.GlobalInt(RPCPortFlag.Name),
-		HttpCors:        ctx.GlobalString(RPCCORSDomainFlag.Name),
+		HTTPCors:        ctx.GlobalString(RPCCORSDomainFlag.Name),
-		HttpModules:     strings.Split(ctx.GlobalString(RPCApiFlag.Name), ","),
+		HTTPModules:     strings.Split(ctx.GlobalString(RPCApiFlag.Name), ","),
-		WsHost:          MakeWsRpcHost(ctx),
+		WSHost:          MakeWSRpcHost(ctx),
-		WsPort:          ctx.GlobalInt(WSPortFlag.Name),
+		WSPort:          ctx.GlobalInt(WSPortFlag.Name),
-		WsCors:          ctx.GlobalString(WSCORSDomainFlag.Name),
+		WSDomains:       ctx.GlobalString(WSAllowedDomainsFlag.Name),
-		WsModules:       strings.Split(ctx.GlobalString(WSApiFlag.Name), ","),
+		WSModules:       strings.Split(ctx.GlobalString(WSApiFlag.Name), ","),
 	}
 	// Configure the Ethereum service
 	accman := MakeAccountManager(ctx)

common/defaults.go

@@ -22,11 +22,11 @@ import (
 )
 
 const (
-	DefaultIpcSocket = "geth.ipc"  // Default (relative) name of the IPC RPC socket
+	DefaultIPCSocket = "geth.ipc"  // Default (relative) name of the IPC RPC socket
-	DefaultHttpHost  = "localhost" // Default host interface for the HTTP RPC server
+	DefaultHTTPHost  = "localhost" // Default host interface for the HTTP RPC server
-	DefaultHttpPort  = 8545        // Default TCP port for the HTTP RPC server
+	DefaultHTTPPort  = 8545        // Default TCP port for the HTTP RPC server
-	DefaultWsHost    = "localhost" // Default host interface for the websocket RPC server
+	DefaultWSHost    = "localhost" // Default host interface for the websocket RPC server
-	DefaultWsPort    = 8546        // Default TCP port for the websocket RPC server
+	DefaultWSPort    = 8546        // Default TCP port for the websocket RPC server
 )
 
 // DefaultDataDir is the default data directory to use for the databases and other

node/config.go

@@ -53,11 +53,11 @@ type Config struct {
 	// in memory.
 	DataDir string
 
-	// IpcPath is the requested location to place the IPC endpoint. If the path is
+	// IPCPath is the requested location to place the IPC endpoint. If the path is
 	// a simple file name, it is placed inside the data directory (or on the root
 	// pipe path on Windows), whereas if it's a resolvable path name (absolute or
 	// relative), then that specific path is enforced. An empty path disables IPC.
-	IpcPath string
+	IPCPath string
 
 	// This field should be a valid secp256k1 private key that will be used for both
 	// remote peer identification as well as network traffic encryption. If no key
@@ -99,104 +99,104 @@ type Config struct {
 	// Zero defaults to preset values.
 	MaxPendingPeers int
 
-	// HttpHost is the host interface on which to start the HTTP RPC server. If this
+	// HTTPHost is the host interface on which to start the HTTP RPC server. If this
 	// field is empty, no HTTP API endpoint will be started.
-	HttpHost string
+	HTTPHost string
 
-	// HttpPort is the TCP port number on which to start the HTTP RPC server. The
+	// HTTPPort is the TCP port number on which to start the HTTP RPC server. The
 	// default zero value is/ valid and will pick a port number randomly (useful
 	// for ephemeral nodes).
-	HttpPort int
+	HTTPPort int
 
-	// HttpCors is the Cross-Origin Resource Sharing header to send to requesting
+	// HTTPCors is the Cross-Origin Resource Sharing header to send to requesting
 	// clients. Please be aware that CORS is a browser enforced security, it's fully
 	// useless for custom HTTP clients.
-	HttpCors string
+	HTTPCors string
 
-	// HttpModules is a list of API modules to expose via the HTTP RPC interface.
+	// HTTPModules is a list of API modules to expose via the HTTP RPC interface.
 	// If the module list is empty, all RPC API endpoints designated public will be
 	// exposed.
-	HttpModules []string
+	HTTPModules []string
 
-	// WsHost is the host interface on which to start the websocket RPC server. If
+	// WSHost is the host interface on which to start the websocket RPC server. If
 	// this field is empty, no websocket API endpoint will be started.
-	WsHost string
+	WSHost string
 
-	// WsPort is the TCP port number on which to start the websocket RPC server. The
+	// WSPort is the TCP port number on which to start the websocket RPC server. The
 	// default zero value is/ valid and will pick a port number randomly (useful for
 	// ephemeral nodes).
-	WsPort int
+	WSPort int
 
-	// WsCors is the Cross-Origin Resource Sharing header to send to requesting clients.
+	// WSDomains is the list of domain to accept websocket requests from. Please be
-	// Please be aware that CORS is a browser enforced security, it's fully useless
+	// aware that the server can only act upon the HTTP request the client sends and
-	// for custom websocket clients.
+	// cannot verify the validity of the request header.
-	WsCors string
+	WSDomains string
 
-	// WsModules is a list of API modules to expose via the websocket RPC interface.
+	// WSModules is a list of API modules to expose via the websocket RPC interface.
 	// If the module list is empty, all RPC API endpoints designated public will be
 	// exposed.
-	WsModules []string
+	WSModules []string
 }
 
-// IpcEndpoint resolves an IPC endpoint based on a configured value, taking into
+// IPCEndpoint resolves an IPC endpoint based on a configured value, taking into
 // account the set data folders as well as the designated platform we're currently
 // running on.
-func (c *Config) IpcEndpoint() string {
+func (c *Config) IPCEndpoint() string {
 	// Short circuit if IPC has not been enabled
-	if c.IpcPath == "" {
+	if c.IPCPath == "" {
 		return ""
 	}
 	// On windows we can only use plain top-level pipes
 	if runtime.GOOS == "windows" {
-		if strings.HasPrefix(c.IpcPath, `\\.\pipe\`) {
+		if strings.HasPrefix(c.IPCPath, `\\.\pipe\`) {
-			return c.IpcPath
+			return c.IPCPath
 		}
-		return `\\.\pipe\` + c.IpcPath
+		return `\\.\pipe\` + c.IPCPath
 	}
 	// Resolve names into the data directory full paths otherwise
-	if filepath.Base(c.IpcPath) == c.IpcPath {
+	if filepath.Base(c.IPCPath) == c.IPCPath {
 		if c.DataDir == "" {
-			return filepath.Join(os.TempDir(), c.IpcPath)
+			return filepath.Join(os.TempDir(), c.IPCPath)
 		}
-		return filepath.Join(c.DataDir, c.IpcPath)
+		return filepath.Join(c.DataDir, c.IPCPath)
 	}
-	return c.IpcPath
+	return c.IPCPath
 }
 
-// DefaultIpcEndpoint returns the IPC path used by default.
+// DefaultIPCEndpoint returns the IPC path used by default.
-func DefaultIpcEndpoint() string {
+func DefaultIPCEndpoint() string {
-	config := &Config{DataDir: common.DefaultDataDir(), IpcPath: common.DefaultIpcSocket}
+	config := &Config{DataDir: common.DefaultDataDir(), IPCPath: common.DefaultIPCSocket}
-	return config.IpcEndpoint()
+	return config.IPCEndpoint()
 }
 
-// HttpEndpoint resolves an HTTP endpoint based on the configured host interface
+// HTTPEndpoint resolves an HTTP endpoint based on the configured host interface
 // and port parameters.
-func (c *Config) HttpEndpoint() string {
+func (c *Config) HTTPEndpoint() string {
-	if c.HttpHost == "" {
+	if c.HTTPHost == "" {
 		return ""
 	}
-	return fmt.Sprintf("%s:%d", c.HttpHost, c.HttpPort)
+	return fmt.Sprintf("%s:%d", c.HTTPHost, c.HTTPPort)
 }
 
-// DefaultHttpEndpoint returns the HTTP endpoint used by default.
+// DefaultHTTPEndpoint returns the HTTP endpoint used by default.
-func DefaultHttpEndpoint() string {
+func DefaultHTTPEndpoint() string {
-	config := &Config{HttpHost: common.DefaultHttpHost, HttpPort: common.DefaultHttpPort}
+	config := &Config{HTTPHost: common.DefaultHTTPHost, HTTPPort: common.DefaultHTTPPort}
-	return config.HttpEndpoint()
+	return config.HTTPEndpoint()
 }
 
-// WsEndpoint resolves an websocket endpoint based on the configured host interface
+// WSEndpoint resolves an websocket endpoint based on the configured host interface
 // and port parameters.
-func (c *Config) WsEndpoint() string {
+func (c *Config) WSEndpoint() string {
-	if c.WsHost == "" {
+	if c.WSHost == "" {
 		return ""
 	}
-	return fmt.Sprintf("%s:%d", c.WsHost, c.WsPort)
+	return fmt.Sprintf("%s:%d", c.WSHost, c.WSPort)
 }
 
-// DefaultWsEndpoint returns the websocket endpoint used by default.
+// DefaultWSEndpoint returns the websocket endpoint used by default.
-func DefaultWsEndpoint() string {
+func DefaultWSEndpoint() string {
-	config := &Config{WsHost: common.DefaultWsHost, WsPort: common.DefaultWsPort}
+	config := &Config{WSHost: common.DefaultWSHost, WSPort: common.DefaultWSPort}
-	return config.WsEndpoint()
+	return config.WSEndpoint()
 }
 
 // NodeKey retrieves the currently configured private key of the node, checking

node/config_test.go

@@ -63,10 +63,10 @@ func TestDatadirCreation(t *testing.T) {
 
 // Tests that IPC paths are correctly resolved to valid endpoints of different
 // platforms.
-func TestIpcPathResolution(t *testing.T) {
+func TestIPCPathResolution(t *testing.T) {
 	var tests = []struct {
 		DataDir  string
-		IpcPath  string
+		IPCPath  string
 		Windows  bool
 		Endpoint string
 	}{
@@ -85,7 +85,7 @@ func TestIpcPathResolution(t *testing.T) {
 	for i, test := range tests {
 		// Only run when platform/test match
 		if (runtime.GOOS == "windows") == test.Windows {
-			if endpoint := (&Config{DataDir: test.DataDir, IpcPath: test.IpcPath}).IpcEndpoint(); endpoint != test.Endpoint {
+			if endpoint := (&Config{DataDir: test.DataDir, IPCPath: test.IPCPath}).IPCEndpoint(); endpoint != test.Endpoint {
 				t.Errorf("test %d: IPC endpoint mismatch: have %s, want %s", i, endpoint, test.Endpoint)
 			}
 		}

node/node.go

@@ -68,7 +68,7 @@ type Node struct {
 
 	wsEndpoint  string       // Websocket endpoint (interface + port) to listen at (empty = websocket disabled)
 	wsWhitelist []string     // Websocket RPC modules to allow through this endpoint
-	wsCors      string       // Websocket RPC Cross-Origin Resource Sharing header
+	wsDomains   string       // Websocket RPC allowed origin domains
 	wsListener  net.Listener // Websocket RPC listener socket to server API requests
 	wsHandler   *rpc.Server  // Websocket RPC request handler to process the API requests
 
@@ -107,13 +107,13 @@ func New(conf *Config) (*Node, error) {
 			MaxPendingPeers: conf.MaxPendingPeers,
 		},
 		serviceFuncs:  []ServiceConstructor{},
-		ipcEndpoint:   conf.IpcEndpoint(),
+		ipcEndpoint:   conf.IPCEndpoint(),
-		httpEndpoint:  conf.HttpEndpoint(),
+		httpEndpoint:  conf.HTTPEndpoint(),
-		httpWhitelist: conf.HttpModules,
+		httpWhitelist: conf.HTTPModules,
-		httpCors:      conf.HttpCors,
+		httpCors:      conf.HTTPCors,
-		wsEndpoint:    conf.WsEndpoint(),
+		wsEndpoint:    conf.WSEndpoint(),
-		wsWhitelist:   conf.WsModules,
+		wsWhitelist:   conf.WSModules,
-		wsCors:        conf.WsCors,
+		wsDomains:     conf.WSDomains,
 		eventmux:      new(event.TypeMux),
 	}, nil
 }
@@ -224,7 +224,7 @@ func (n *Node) startRPC(services map[reflect.Type]Service) error {
 		n.stopIPC()
 		return err
 	}
-	if err := n.startWS(n.wsEndpoint, apis, n.wsWhitelist, n.wsCors); err != nil {
+	if err := n.startWS(n.wsEndpoint, apis, n.wsWhitelist, n.wsDomains); err != nil {
 		n.stopHTTP()
 		n.stopIPC()
 		return err
@@ -388,7 +388,7 @@ func (n *Node) startWS(endpoint string, apis []rpc.API, modules []string, cors s
 	n.wsEndpoint = endpoint
 	n.wsListener = listener
 	n.wsHandler = handler
-	n.wsCors = cors
+	n.wsDomains = cors
 
 	return nil
 }
@@ -501,8 +501,8 @@ func (n *Node) DataDir() string {
 	return n.datadir
 }
 
-// IpcEndpoint retrieves the current IPC endpoint used by the protocol stack.
+// IPCEndpoint retrieves the current IPC endpoint used by the protocol stack.
-func (n *Node) IpcEndpoint() string {
+func (n *Node) IPCEndpoint() string {
 	return n.ipcEndpoint
 }
 

node/node_test.go

@@ -37,7 +37,7 @@ var (
 
 func testNodeConfig() *Config {
 	return &Config{
-		IpcPath:    fmt.Sprintf("test-%d.ipc", rand.Int63()),
+		IPCPath:    fmt.Sprintf("test-%d.ipc", rand.Int63()),
 		PrivateKey: testNodeKey,
 		Name:       "test node",
 	}
@@ -541,7 +541,7 @@ func TestAPIGather(t *testing.T) {
 	defer stack.Stop()
 
 	// Connect to the RPC server and verify the various registered endpoints
-	ipcClient, err := rpc.NewIPCClient(stack.IpcEndpoint())
+	ipcClient, err := rpc.NewIPCClient(stack.IPCEndpoint())
 	if err != nil {
 		t.Fatalf("failed to connect to the IPC API server: %v", err)
 	}

rpc/server.go

@@ -33,8 +33,8 @@ import (
 const (
 	stopPendingRequestTimeout = 3 * time.Second // give pending requests stopPendingRequestTimeout the time to finish when the server is stopped
 
-	DefaultIpcApis     = "admin,eth,debug,miner,net,shh,txpool,personal,web3"
+	DefaultIPCApis  = "admin,eth,debug,miner,net,shh,txpool,personal,web3"
-	DefaultHttpRpcApis = "eth,net,web3"
+	DefaultHTTPApis = "eth,net,web3"
 )
 
 // NewServer will create a new server instance with no registered handlers.