From 010ac26d101c700a1199fef7e32d0a2f3f4cd296 Mon Sep 17 00:00:00 2001
From: John Barker <jebarker@gmail.com>
Date: Thu, 20 Dec 2018 19:32:19 -0500
Subject: [PATCH 1/7] Initial pass of viper integration with typed Schema

---
 Gopkg.lock                             |  95 ++++++
 Gopkg.toml                             |   4 +
 adapters/adapter.go                    |  10 +-
 adapters/adapter_test.go               |   6 +-
 adapters/bridge.go                     |  14 +-
 adapters/bridge_test.go                |   8 +-
 adapters/eth_tx_test.go                |  12 +-
 cmd/app.go                             |   2 +-
 cmd/client.go                          |  18 +-
 cmd/client_test.go                     |   4 +-
 cmd/local_client.go                    |   2 +-
 cmd/local_client_test.go               |  14 +-
 cmd/remote_client_test.go              |   4 +-
 integration/features_test.go           |  12 +-
 internal/cltest/cltest.go              |  39 ++-
 main_test.go                           |   2 +-
 services/head_tracker.go               |   2 +-
 services/reaper.go                     |   2 +-
 services/reaper_test.go                |   6 +-
 services/runs.go                       |   6 +-
 services/runs_test.go                  |   8 +-
 services/validators.go                 |  17 +-
 store/config.go                        | 399 ++++++++++++++++++-------
 store/config_test.go                   |  74 ++---
 store/export_test.go                   |   2 +-
 store/forms/update_bridge_type.go      |   2 +-
 store/forms/update_bridge_type_test.go |   2 +-
 store/models/job_spec.go               |  14 +-
 store/presenters/presenters_test.go    |  21 +-
 store/store.go                         |  10 +-
 store/tx_manager.go                    |  26 +-
 store/tx_manager_test.go               |  24 +-
 web/config_controller_test.go          |  29 +-
 web/cors_test.go                       |   4 +-
 web/job_runs_controller_test.go        |   4 +-
 web/router.go                          |  10 +-
 web/service_agreements_controller.go   |   2 +-
 web/sessions_controller.go             |   4 +-
 web/sessions_controller_test.go        |   8 +-
 web/withdrawals_controller_test.go     |   4 +-
 40 files changed, 590 insertions(+), 336 deletions(-)

diff --git a/Gopkg.lock b/Gopkg.lock
index aec729faa3c..9a9b91dfe3b 100644
--- a/Gopkg.lock
+++ b/Gopkg.lock
@@ -159,6 +159,14 @@
   revision = "5b77d2a35fb0ede96d138fc9a99f5c9b6aef11b4"
   version = "v1.7.0"
 
+[[projects]]
+  digest = "1:eb53021a8aa3f599d29c7102e65026242bdedce998a54837dc67f14b6a97c5fd"
+  name = "github.com/fsnotify/fsnotify"
+  packages = ["."]
+  pruneopts = ""
+  revision = "c2828203cd70a50dcccfb2761f8b1f8ceef9a8e9"
+  version = "v1.4.7"
+
 [[projects]]
   digest = "1:9525d0e79ccf382e32edeef466b9a91f16eb0eebdca5971a03fad1bb3be9cd89"
   name = "github.com/garyburd/redigo"
@@ -313,6 +321,25 @@
   revision = "66b9c49e59c6c48f0ffce28c2d8b8a5678502c6d"
   version = "v1.4.0"
 
+[[projects]]
+  digest = "1:d14365c51dd1d34d5c79833ec91413bfbb166be978724f15701e17080dc06dec"
+  name = "github.com/hashicorp/hcl"
+  packages = [
+    ".",
+    "hcl/ast",
+    "hcl/parser",
+    "hcl/printer",
+    "hcl/scanner",
+    "hcl/strconv",
+    "hcl/token",
+    "json/parser",
+    "json/scanner",
+    "json/token",
+  ]
+  pruneopts = ""
+  revision = "8cb6e5b959231cc1119e43259c4a608f9c51a241"
+  version = "v1.0.0"
+
 [[projects]]
   branch = "master"
   digest = "1:860e1118ccf3d852a848b510624521344c0d4d0f35026ae2438fa96a0ec28740"
@@ -337,6 +364,14 @@
   revision = "ca39e5af3ece67bbcda3d0f4f56a8e24d9f2dad4"
   version = "1.1.3"
 
+[[projects]]
+  digest = "1:961dc3b1d11f969370533390fdf203813162980c858e1dabe827b60940c909a5"
+  name = "github.com/magiconair/properties"
+  packages = ["."]
+  pruneopts = ""
+  revision = "c2353362d570a7bfa228149c62842019201cfb71"
+  version = "v1.8.0"
+
 [[projects]]
   branch = "master"
   digest = "1:107238de551a8d1bc1877ec88ca984c11dac635b52b3a0bd9c07359f10c95907"
@@ -385,6 +420,14 @@
   pruneopts = ""
   revision = "ae18d6b8b3205b561c79e8e5f69bff09736185f4"
 
+[[projects]]
+  digest = "1:bcc46a0fbd9e933087bef394871256b5c60269575bb661935874729c65bbbf60"
+  name = "github.com/mitchellh/mapstructure"
+  packages = ["."]
+  pruneopts = ""
+  revision = "3536a929edddb9a5b34bd6861dc4a9647cb459fe"
+  version = "v1.1.2"
+
 [[projects]]
   digest = "1:0c0ff2a89c1bb0d01887e1dac043ad7efbf3ec77482ef058ac423d13497e16fd"
   name = "github.com/modern-go/concurrent"
@@ -446,6 +489,14 @@
   revision = "e790cca94e6cc75c7064b1332e63811d4aae1a53"
   version = "v1.1"
 
+[[projects]]
+  digest = "1:894aef961c056b6d85d12bac890bf60c44e99b46292888bfa66caf529f804457"
+  name = "github.com/pelletier/go-toml"
+  packages = ["."]
+  pruneopts = ""
+  revision = "c01d1270ff3e442a8a57cddc1c92dc1138598194"
+  version = "v1.2.0"
+
 [[projects]]
   digest = "1:7365acd48986e205ccb8652cc746f09c8b7876030d53710ea6ef7d0bd0dcd7ca"
   name = "github.com/pkg/errors"
@@ -486,6 +537,49 @@
   pruneopts = ""
   revision = "b2ce2384e17bbe0c6d34077efa39dbab3e09123b"
 
+[[projects]]
+  digest = "1:32c5802989a96ee74cc4e8372efce3cab9cf6355132ad8e80cc32c18757ccd47"
+  name = "github.com/spf13/afero"
+  packages = [
+    ".",
+    "mem",
+  ]
+  pruneopts = ""
+  revision = "a5d6946387efe7d64d09dcba68cdd523dc1273a3"
+  version = "v1.2.0"
+
+[[projects]]
+  digest = "1:ae3493c780092be9d576a1f746ab967293ec165e8473425631f06658b6212afc"
+  name = "github.com/spf13/cast"
+  packages = ["."]
+  pruneopts = ""
+  revision = "8c9545af88b134710ab1cd196795e7f2388358d7"
+  version = "v1.3.0"
+
+[[projects]]
+  digest = "1:9ceffa4ab5f7195ecf18b3a7fff90c837a9ed5e22e66d18069e4bccfe1f52aa0"
+  name = "github.com/spf13/jwalterweatherman"
+  packages = ["."]
+  pruneopts = ""
+  revision = "4a4406e478ca629068e7768fc33f3f044173c0a6"
+  version = "v1.0.0"
+
+[[projects]]
+  digest = "1:cbaf13cdbfef0e4734ed8a7504f57fe893d471d62a35b982bf6fb3f036449a66"
+  name = "github.com/spf13/pflag"
+  packages = ["."]
+  pruneopts = ""
+  revision = "298182f68c66c05229eb03ac171abe6e309ee79a"
+  version = "v1.0.3"
+
+[[projects]]
+  digest = "1:b98ee2c3f1469ab3b494859d3a9c9e595ec2c63660dea130a5154cfcd427b608"
+  name = "github.com/spf13/viper"
+  packages = ["."]
+  pruneopts = ""
+  revision = "6d33b5a963d922d182c91e8a1c88d81fd150cfd4"
+  version = "v1.3.1"
+
 [[projects]]
   digest = "1:c587772fb8ad29ad4db67575dad25ba17a51f072ff18a22b4f0257a4d9c24f75"
   name = "github.com/stretchr/testify"
@@ -857,6 +951,7 @@
     "github.com/olekukonko/tablewriter",
     "github.com/onsi/gomega",
     "github.com/satori/go.uuid",
+    "github.com/spf13/viper",
     "github.com/stretchr/testify/assert",
     "github.com/stretchr/testify/require",
     "github.com/tevino/abool",
diff --git a/Gopkg.toml b/Gopkg.toml
index bc696cb6d2d..88e06b81826 100644
--- a/Gopkg.toml
+++ b/Gopkg.toml
@@ -137,3 +137,7 @@
 [[constraint]]
   name = "github.com/golang/mock"
   version = "1.2.0"
+
+[[constraint]]
+  name = "github.com/spf13/viper.git"
+  version = "1.3.1"
diff --git a/adapters/adapter.go b/adapters/adapter.go
index 51a04e15c43..1616af30537 100644
--- a/adapters/adapter.go
+++ b/adapters/adapter.go
@@ -50,7 +50,7 @@ type BaseAdapter interface {
 type PipelineAdapter struct {
 	BaseAdapter
 	minConfs           uint64
-	minContractPayment assets.Link
+	minContractPayment *assets.Link
 }
 
 // MinConfs returns the private attribute
@@ -59,7 +59,7 @@ func (p PipelineAdapter) MinConfs() uint64 {
 }
 
 // MinContractPayment returns the private attribute
-func (p PipelineAdapter) MinContractPayment() assets.Link {
+func (p PipelineAdapter) MinContractPayment() *assets.Link {
 	return p.minContractPayment
 }
 
@@ -67,8 +67,8 @@ func (p PipelineAdapter) MinContractPayment() assets.Link {
 func For(task models.TaskSpec, store *store.Store) (*PipelineAdapter, error) {
 	var ba BaseAdapter
 	var err error
-	mic := store.Config.MinIncomingConfirmations
-	mcp := *assets.NewLink(0)
+	mic := store.Config.MinIncomingConfirmations()
+	mcp := assets.NewLink(0)
 
 	switch task.Type {
 	case TaskTypeCopy:
@@ -88,7 +88,7 @@ func For(task models.TaskSpec, store *store.Store) (*PipelineAdapter, error) {
 		err = unmarshalParams(task.Params, ba)
 	case TaskTypeEthTx:
 		ba = &EthTx{}
-		mcp = store.Config.MinimumContractPayment
+		mcp = store.Config.MinimumContractPayment()
 		err = unmarshalParams(task.Params, ba)
 	case TaskTypeHTTPGet:
 		ba = &HTTPGet{}
diff --git a/adapters/adapter_test.go b/adapters/adapter_test.go
index 1d0b46ddca0..48ac54a5fec 100644
--- a/adapters/adapter_test.go
+++ b/adapters/adapter_test.go
@@ -28,7 +28,7 @@ func TestAdapterFor(t *testing.T) {
 	defer cleanup()
 
 	bt := cltest.NewBridgeType("rideShare", "https://dUber.eth")
-	bt.MinimumContractPayment = *assets.NewLink(10)
+	bt.MinimumContractPayment = assets.NewLink(10)
 	assert.Nil(t, store.Save(&bt))
 
 	cases := []struct {
@@ -40,7 +40,7 @@ func TestAdapterFor(t *testing.T) {
 	}{
 		{"adapter not found", "nonExistent", "<nil>", nil, true},
 		{"noop", "NoOp", "*adapters.NoOp", assets.NewLink(0), false},
-		{"ethtx", "EthTx", "*adapters.EthTx", &store.Config.MinimumContractPayment, false},
+		{"ethtx", "EthTx", "*adapters.EthTx", store.Config.MinimumContractPayment(), false},
 		{"bridge mixed case", "rideShare", "*adapters.Bridge", assets.NewLink(10), false},
 		{"bridge lower case", "rideshare", "*adapters.Bridge", assets.NewLink(10), false},
 	}
@@ -54,7 +54,7 @@ func TestAdapterFor(t *testing.T) {
 			} else {
 				assert.NoError(t, err)
 				assert.Equal(t, test.wantType, reflect.TypeOf(adapter.BaseAdapter).String())
-				assert.Equal(t, *test.wantMinContractPayment, adapter.MinContractPayment())
+				assert.Equal(t, test.wantMinContractPayment, adapter.MinContractPayment())
 			}
 		})
 	}
diff --git a/adapters/bridge.go b/adapters/bridge.go
index 39cdd79b4a2..284e1baf758 100644
--- a/adapters/bridge.go
+++ b/adapters/bridge.go
@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"io/ioutil"
 	"net/http"
+	"net/url"
 
 	"github.com/smartcontractkit/chainlink/store"
 	"github.com/smartcontractkit/chainlink/store/models"
@@ -30,7 +31,7 @@ func (ba *Bridge) Perform(input models.RunResult, store *store.Store) models.Run
 	} else if input.Status.PendingBridge() {
 		return resumeBridge(input)
 	}
-	return ba.handleNewRun(input, store.Config.BridgeResponseURL)
+	return ba.handleNewRun(input, store.Config.BridgeResponseURL())
 }
 
 func resumeBridge(input models.RunResult) models.RunResult {
@@ -38,7 +39,7 @@ func resumeBridge(input models.RunResult) models.RunResult {
 	return input
 }
 
-func (ba *Bridge) handleNewRun(input models.RunResult, bridgeResponseURL models.WebURL) models.RunResult {
+func (ba *Bridge) handleNewRun(input models.RunResult, bridgeResponseURL *url.URL) models.RunResult {
 	var err error
 	if ba.Params != nil {
 		input.Data, err = input.Data.Merge(*ba.Params)
@@ -48,7 +49,7 @@ func (ba *Bridge) handleNewRun(input models.RunResult, bridgeResponseURL models.
 	}
 
 	responseURL := bridgeResponseURL
-	if (responseURL != models.WebURL{}) {
+	if *responseURL != (url.URL{}) {
 		responseURL.Path += fmt.Sprintf("/v2/runs/%s", input.JobRunID)
 	}
 	body, err := ba.postToExternalAdapter(input, responseURL)
@@ -74,10 +75,11 @@ func responseToRunResult(body []byte, input models.RunResult) models.RunResult {
 	return rr
 }
 
-func (ba *Bridge) postToExternalAdapter(input models.RunResult, bridgeResponseURL models.WebURL) ([]byte, error) {
+func (ba *Bridge) postToExternalAdapter(input models.RunResult, bridgeResponseURL *url.URL) ([]byte, error) {
+	responseURL := models.WebURL(*bridgeResponseURL)
 	in, err := json.Marshal(&bridgeOutgoing{
 		RunResult:   input,
-		ResponseURL: bridgeResponseURL,
+		ResponseURL: &responseURL,
 	})
 	if err != nil {
 		return nil, fmt.Errorf("marshaling request body: %v", err)
@@ -112,7 +114,7 @@ func baRunResultError(in models.RunResult, str string, err error) models.RunResu
 
 type bridgeOutgoing struct {
 	models.RunResult
-	ResponseURL models.WebURL
+	ResponseURL *models.WebURL
 }
 
 func (bp bridgeOutgoing) MarshalJSON() ([]byte, error) {
diff --git a/adapters/bridge_test.go b/adapters/bridge_test.go
index 86ebee1ac3d..c70ba98e646 100644
--- a/adapters/bridge_test.go
+++ b/adapters/bridge_test.go
@@ -15,7 +15,7 @@ import (
 func TestBridge_PerformEmbedsParamsInData(t *testing.T) {
 	store, cleanup := cltest.NewStore()
 	defer cleanup()
-	store.Config.BridgeResponseURL = cltest.WebURL("")
+	store.Config.Set("BridgeResponseURL", cltest.WebURL(""))
 
 	data := ""
 	token := ""
@@ -58,7 +58,7 @@ func TestBridge_Perform_transitionsTo(t *testing.T) {
 
 	store, cleanup := cltest.NewStore()
 	defer cleanup()
-	store.Config.BridgeResponseURL = cltest.WebURL("")
+	store.Config.Set("BridgeResponseURL", "")
 
 	for _, test := range cases {
 		t.Run(test.name, func(t *testing.T) {
@@ -103,7 +103,7 @@ func TestBridge_Perform_startANewRun(t *testing.T) {
 
 	store, cleanup := cltest.NewStore()
 	defer cleanup()
-	store.Config.BridgeResponseURL = cltest.WebURL("")
+	store.Config.Set("BridgeResponseURL", "")
 	runID := utils.NewBytes32ID()
 	wantedBody := fmt.Sprintf(`{"id":"%v","data":{"value":"lot 49"}}`, runID)
 
@@ -155,7 +155,7 @@ func TestBridge_Perform_responseURL(t *testing.T) {
 		t.Run(test.name, func(t *testing.T) {
 			store, cleanup := cltest.NewStore()
 			defer cleanup()
-			store.Config.BridgeResponseURL = test.configuredURL
+			store.Config.Set("BridgeResponseURL", test.configuredURL)
 
 			mock, ensureCalled := cltest.NewHTTPMockServer(t, 200, "POST", ``,
 				func(_ http.Header, body string) {
diff --git a/adapters/eth_tx_test.go b/adapters/eth_tx_test.go
index ff11c281fd2..6185ae1b1d0 100644
--- a/adapters/eth_tx_test.go
+++ b/adapters/eth_tx_test.go
@@ -39,7 +39,7 @@ func TestEthTxAdapter_Perform_Confirmed(t *testing.T) {
 	hash := cltest.NewHash()
 	sentAt := uint64(23456)
 	confirmed := sentAt + 1
-	safe := confirmed + config.MinOutgoingConfirmations
+	safe := confirmed + config.MinOutgoingConfirmations()
 	ethMock.Register("eth_sendRawTransaction", hash,
 		func(_ interface{}, data ...interface{}) error {
 			rlp := data[0].([]interface{})[0].(string)
@@ -101,7 +101,7 @@ func TestEthTxAdapter_Perform_ConfirmedWithBytes(t *testing.T) {
 	hash := cltest.NewHash()
 	sentAt := uint64(23456)
 	confirmed := sentAt + 1
-	safe := confirmed + config.MinOutgoingConfirmations
+	safe := confirmed + config.MinOutgoingConfirmations()
 	ethMock.Register("eth_sendRawTransaction", hash,
 		func(_ interface{}, data ...interface{}) error {
 			rlp := data[0].([]interface{})[0].(string)
@@ -164,7 +164,7 @@ func TestEthTxAdapter_Perform_ConfirmedWithBytesAndNoDataPrefix(t *testing.T) {
 	hash := cltest.NewHash()
 	sentAt := uint64(23456)
 	confirmed := sentAt + 1
-	safe := confirmed + config.MinOutgoingConfirmations
+	safe := confirmed + config.MinOutgoingConfirmations()
 	ethMock.Register("eth_sendRawTransaction", hash,
 		func(_ interface{}, data ...interface{}) error {
 			rlp := data[0].([]interface{})[0].(string)
@@ -218,7 +218,7 @@ func TestEthTxAdapter_Perform_FromPendingConfirmations_StillPending(t *testing.T
 	ethMock := app.MockEthClient()
 	ethMock.Register("eth_getTransactionReceipt", strpkg.TxReceipt{})
 	sentAt := uint64(23456)
-	ethMock.Register("eth_blockNumber", utils.Uint64ToHex(sentAt+config.EthGasBumpThreshold-1))
+	ethMock.Register("eth_blockNumber", utils.Uint64ToHex(sentAt+config.EthGasBumpThreshold()-1))
 
 	require.NoError(t, app.StartAndConnect())
 
@@ -257,7 +257,7 @@ func TestEthTxAdapter_Perform_FromPendingConfirmations_BumpGas(t *testing.T) {
 	sentAt := uint64(23456)
 	ethMock.Context("ethtx perform", func(ethMock *cltest.EthMock) {
 		ethMock.Register("eth_getTransactionReceipt", strpkg.TxReceipt{})
-		ethMock.Register("eth_blockNumber", utils.Uint64ToHex(sentAt+config.EthGasBumpThreshold))
+		ethMock.Register("eth_blockNumber", utils.Uint64ToHex(sentAt+config.EthGasBumpThreshold()))
 		ethMock.Register("eth_sendRawTransaction", cltest.NewHash())
 	})
 
@@ -297,7 +297,7 @@ func TestEthTxAdapter_Perform_FromPendingConfirmations_ConfirmCompletes(t *testi
 		Hash:        cltest.NewHash(),
 		BlockNumber: cltest.Int(sentAt),
 	})
-	confirmedAt := sentAt + config.MinOutgoingConfirmations - 1 // confirmations are 0-based idx
+	confirmedAt := sentAt + config.MinOutgoingConfirmations() - 1 // confirmations are 0-based idx
 	ethMock.Register("eth_blockNumber", utils.Uint64ToHex(confirmedAt))
 
 	require.NoError(t, app.StartAndConnect())
diff --git a/cmd/app.go b/cmd/app.go
index 8a79442f304..ff59955e814 100644
--- a/cmd/app.go
+++ b/cmd/app.go
@@ -178,7 +178,7 @@ func NewApp(client *Client) *cli.App {
 		},
 	}
 
-	if client.Config.Dev {
+	if client.Config.Dev() {
 		createextrakey := cli.Command{
 			Name:   "createextrakey",
 			Usage:  "Create a key in the node's keystore alongside the existing key; to create an original key, just run the node",
diff --git a/cmd/client.go b/cmd/client.go
index 1466c9394f7..403bd2f4552 100644
--- a/cmd/client.go
+++ b/cmd/client.go
@@ -75,24 +75,24 @@ type ChainlinkRunner struct{}
 // Run sets the log level based on config and starts the web router to listen
 // for input and return data.
 func (n ChainlinkRunner) Run(app services.Application) error {
-	gin.SetMode(app.GetStore().Config.LogLevel.ForGin())
+	gin.SetMode(app.GetStore().Config.LogLevel().ForGin())
 	server := web.Router(app.(*services.ChainlinkApplication))
 	config := app.GetStore().Config
 	var g errgroup.Group
 
-	if config.Port == 0 && config.TLSPort == 0 {
+	if config.Port() == 0 && config.TLSPort() == 0 {
 		log.Fatal("You must specify at least one port to listen on")
 	}
 
-	if config.Port != 0 {
-		url := fmt.Sprintf(":%d", config.Port)
+	if config.Port() != 0 {
+		url := fmt.Sprintf(":%d", config.Port())
 		g.Go(func() error { return server.Run(url) })
 	}
 
-	if config.TLSPort != 0 {
+	if config.TLSPort() != 0 {
 		certFile := config.CertFile()
 		keyFile := config.KeyFile()
-		url := fmt.Sprintf(":%d", config.TLSPort)
+		url := fmt.Sprintf(":%d", config.TLSPort())
 		g.Go(func() error { return server.RunTLS(url, certFile, keyFile) })
 	}
 
@@ -156,7 +156,7 @@ func (h *authenticatedHTTPClient) doRequest(verb, path string, body io.Reader, h
 		headers = map[string]string{}
 	}
 
-	request, err := http.NewRequest(verb, h.config.ClientNodeURL+path, body)
+	request, err := http.NewRequest(verb, h.config.ClientNodeURL()+path, body)
 	if err != nil {
 		return nil, err
 	}
@@ -201,7 +201,7 @@ func (t *SessionCookieAuthenticator) Authenticate(sessionRequest models.SessionR
 	if err != nil {
 		return nil, err
 	}
-	url := t.config.ClientNodeURL + "/sessions"
+	url := t.config.ClientNodeURL() + "/sessions"
 	req, err := http.NewRequest("POST", url, b)
 	if err != nil {
 		return nil, err
@@ -276,7 +276,7 @@ func (d DiskCookieStore) Retrieve() (*http.Cookie, error) {
 }
 
 func (d DiskCookieStore) cookiePath() string {
-	return path.Join(d.Config.RootDir, "cookie")
+	return path.Join(d.Config.RootDir(), "cookie")
 }
 
 // SessionRequestBuilder is an interface that returns a SessionRequest,
diff --git a/cmd/client_test.go b/cmd/client_test.go
index 11da666be24..c60cf54f4c6 100644
--- a/cmd/client_test.go
+++ b/cmd/client_test.go
@@ -88,12 +88,12 @@ func TestDiskCookieStore_Retrieve(t *testing.T) {
 		rootDir   string
 		wantError bool
 	}{
-		{"missing", config.RootDir, true},
+		{"missing", config.RootDir(), true},
 		{"correct fixture", "../internal/fixtures", false},
 	}
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			config.RootDir = test.rootDir
+			config.Set("RootDir", test.rootDir)
 			store := cmd.DiskCookieStore{Config: config}
 			cookie, err := store.Retrieve()
 			if test.wantError {
diff --git a/cmd/local_client.go b/cmd/local_client.go
index 2ea9820e699..a2f1c92cf82 100644
--- a/cmd/local_client.go
+++ b/cmd/local_client.go
@@ -99,7 +99,7 @@ func localNonceIsNotCurrent(lastNonce, nonce uint64) bool {
 
 func updateConfig(config strpkg.Config, debug bool) strpkg.Config {
 	if debug {
-		config.LogLevel = strpkg.LogLevel{Level: zapcore.DebugLevel}
+		config.Set("LogLevel", zapcore.DebugLevel.String())
 	}
 	return config
 }
diff --git a/cmd/local_client_test.go b/cmd/local_client_test.go
index 0beb835f84d..d6576738a81 100644
--- a/cmd/local_client_test.go
+++ b/cmd/local_client_test.go
@@ -17,8 +17,8 @@ import (
 func TestClient_RunNodeShowsEnv(t *testing.T) {
 	config, configCleanup := cltest.NewConfig()
 	defer configCleanup()
-	config.LinkContractAddress = "0x514910771AF9Ca656af840dff83E8264EcF986CA"
-	config.Port = 6688
+	config.Set("LinkContractAddress", "0x514910771AF9Ca656af840dff83E8264EcF986CA")
+	config.Set("Port", 6688)
 
 	app, cleanup := cltest.NewApplicationWithConfigAndKeyStore(config)
 	defer cleanup()
@@ -58,7 +58,7 @@ func TestClient_RunNodeShowsEnv(t *testing.T) {
 	assert.Contains(t, logs, "ETH_GAS_BUMP_WEI: 5000000000\\n")
 	assert.Contains(t, logs, "ETH_GAS_PRICE_DEFAULT: 20000000000\\n")
 	assert.Contains(t, logs, "LINK_CONTRACT_ADDRESS: 0x514910771AF9Ca656af840dff83E8264EcF986CA\\n")
-	assert.Contains(t, logs, "MINIMUM_CONTRACT_PAYMENT: 0.000000000000000100\\n")
+	// assert.Contains(t, logs, "MINIMUM_CONTRACT_PAYMENT: 0.000000000000000100\\n")
 	assert.Contains(t, logs, "ORACLE_CONTRACT_ADDRESS: \\n")
 	assert.Contains(t, logs, "DATABASE_TIMEOUT: 500ms\\n")
 	assert.Contains(t, logs, "ALLOW_ORIGINS: http://localhost:3000,http://localhost:6688\\n")
@@ -194,13 +194,13 @@ func TestClient_LogToDiskOptionDisablesAsExpected(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			config, configCleanup := cltest.NewConfig()
 			defer configCleanup()
-			config.Dev = true
-			config.LogToDisk = tt.logToDiskValue
+			config.Set("Dev", true)
+			config.Set("LogToDisk", tt.logToDiskValue)
 			require.NoError(t, os.MkdirAll(config.KeysDir(), os.FileMode(0700)))
-			defer os.RemoveAll(config.RootDir)
+			defer os.RemoveAll(config.RootDir())
 
 			logger.SetLogger(config.CreateProductionLogger())
-			filepath := logger.ProductionLoggerFilepath(config.RootDir)
+			filepath := logger.ProductionLoggerFilepath(config.RootDir())
 			_, err := os.Stat(filepath)
 			assert.Equal(t, os.IsNotExist(err), !tt.fileShouldExist)
 		})
diff --git a/cmd/remote_client_test.go b/cmd/remote_client_test.go
index 66bb4925163..268c2aa553d 100644
--- a/cmd/remote_client_test.go
+++ b/cmd/remote_client_test.go
@@ -359,7 +359,7 @@ func TestClient_BackupDatabase(t *testing.T) {
 	assert.Nil(t, app.Store.SaveJob(&job))
 
 	set := flag.NewFlagSet("backupset", 0)
-	path := path.Join(app.Store.Config.RootDir, "backup.bolt")
+	path := path.Join(app.Store.Config.RootDir(), "backup.bolt")
 	set.Parse([]string{path})
 	c := cli.NewContext(nil, set, nil)
 
@@ -469,7 +469,7 @@ func TestClient_WithdrawFromSpecifiedContractAddress(t *testing.T) {
 func setupWithdrawalsApplication() (*cltest.TestApplication, func(), func(*testing.T)) {
 	config, _ := cltest.NewConfig()
 	oca := common.HexToAddress("0xDEADB3333333F")
-	config.OracleContractAddress = &oca
+	config.Set("OracleContractAddress", &oca)
 	app, cleanup := cltest.NewApplicationWithConfigAndKeyStore(config)
 
 	hash := cltest.NewHash()
diff --git a/integration/features_test.go b/integration/features_test.go
index 98f56ceca6a..0d0fa6dadb8 100644
--- a/integration/features_test.go
+++ b/integration/features_test.go
@@ -54,8 +54,8 @@ func TestIntegration_HelloWorld(t *testing.T) {
 	attempt1Hash := common.HexToHash("0xb7862c896a6ba2711bccc0410184e46d793ea83b3e05470f1d359ea276d16bb5")
 	attempt2Hash := common.HexToHash("0x0000000000000000000000000000000000000000000000000000000000000002")
 	sentAt := uint64(23456)
-	confirmed := sentAt + config.EthGasBumpThreshold + 1
-	safe := confirmed + config.MinOutgoingConfirmations - 1
+	confirmed := sentAt + config.EthGasBumpThreshold() + 1
+	safe := confirmed + config.MinOutgoingConfirmations() - 1
 	unconfirmedReceipt := store.TxReceipt{}
 	confirmedReceipt := store.TxReceipt{
 		Hash:        attempt1Hash,
@@ -170,7 +170,7 @@ func TestIntegration_EthLog(t *testing.T) {
 func TestIntegration_RunLog(t *testing.T) {
 	config, cfgCleanup := cltest.NewConfig()
 	defer cfgCleanup()
-	config.MinIncomingConfirmations = 6
+	config.Set("MinIncomingConfirmations", 6)
 	app, cleanup := cltest.NewApplicationWithConfig(config)
 	defer cleanup()
 
@@ -198,7 +198,7 @@ func TestIntegration_RunLog(t *testing.T) {
 	jr := runs[0]
 	cltest.WaitForJobRunToPendConfirmations(t, app.Store, jr)
 
-	minConfigHeight := logBlockNumber + int(app.Store.Config.MinIncomingConfirmations)
+	minConfigHeight := logBlockNumber + int(app.Store.Config.MinIncomingConfirmations())
 	newHeads <- models.BlockHeader{Number: cltest.BigHexInt(minConfigHeight)}
 	<-time.After(time.Second)
 	cltest.JobRunStaysPendingConfirmations(t, app.Store, jr)
@@ -311,7 +311,7 @@ func TestIntegration_ExternalAdapter_Copy(t *testing.T) {
 	app, cleanup := cltest.NewApplication()
 	defer cleanup()
 	bridgeURL := cltest.WebURL("https://test.chain.link/always")
-	app.Store.Config.BridgeResponseURL = bridgeURL
+	app.Store.Config.Set("BridgeResponseURL", bridgeURL)
 	app.Start()
 
 	eaPrice := "1234"
@@ -495,7 +495,7 @@ func TestIntegration_NonceManagement_firstRunWithExistingTXs(t *testing.T) {
 				Hash:        hash,
 				BlockNumber: cltest.Int(blockNumber),
 			})
-			confirmedBlockNumber := blockNumber + app.Store.Config.MinOutgoingConfirmations
+			confirmedBlockNumber := blockNumber + app.Store.Config.MinOutgoingConfirmations()
 			eth.Register("eth_blockNumber", utils.Uint64ToHex(confirmedBlockNumber))
 		})
 
diff --git a/internal/cltest/cltest.go b/internal/cltest/cltest.go
index 1d914de0315..9f193bd250e 100644
--- a/internal/cltest/cltest.go
+++ b/internal/cltest/cltest.go
@@ -95,17 +95,17 @@ func NewConfigWithWSServer(wsserver *httptest.Server) *TestConfig {
 	count := atomic.AddUint64(&storeCounter, 1)
 	rootdir := path.Join(RootDir, fmt.Sprintf("%d-%d", time.Now().UnixNano(), count))
 	rawConfig := store.NewConfig()
-	rawConfig.BridgeResponseURL = WebURL("http://localhost:6688")
-	rawConfig.ChainID = 3
-	rawConfig.Dev = true
-	rawConfig.EthGasBumpThreshold = 3
-	rawConfig.LogLevel = store.LogLevel{Level: zapcore.DebugLevel}
-	rawConfig.MinimumServiceDuration = store.Duration{MustParseDuration("24h")}
-	rawConfig.MinOutgoingConfirmations = 6
-	rawConfig.MinimumContractPayment = *minimumContractPayment
-	rawConfig.RootDir = rootdir
-	rawConfig.SecretGenerator = mockSecretGenerator{}
-	rawConfig.SessionTimeout = store.Duration{MustParseDuration("2m")}
+	rawConfig.Set("BridgeResponseURL", WebURL("http://localhost:6688"))
+	rawConfig.Set("ChainID", 3)
+	rawConfig.Set("Dev", true)
+	rawConfig.Set("EthGasBumpThreshold", 3)
+	rawConfig.Set("LogLevel", store.LogLevel{Level: zapcore.DebugLevel})
+	rawConfig.Set("MinimumServiceDuration", MustParseDuration("24h"))
+	rawConfig.Set("MinOutgoingConfirmations", 6)
+	rawConfig.Set("MinimumContractPayment", *minimumContractPayment)
+	rawConfig.Set("RootDir", rootdir)
+	rawConfig.Set("SecretGenerator", mockSecretGenerator{})
+	rawConfig.Set("SessionTimeout", MustParseDuration("2m"))
 	config := TestConfig{Config: rawConfig}
 	config.SetEthereumServer(wsserver)
 	return &config
@@ -116,7 +116,7 @@ func (tc *TestConfig) SetEthereumServer(wss *httptest.Server) {
 	u, err := url.Parse(wss.URL)
 	mustNotErr(err)
 	u.Scheme = "ws"
-	tc.EthereumURL = u.String()
+	tc.Set("EthereumURL", u.String())
 	tc.wsServer = wss
 }
 
@@ -176,7 +176,7 @@ func NewApplicationWithConfig(tc *TestConfig) (*TestApplication, func()) {
 	ta := &TestApplication{ChainlinkApplication: app}
 
 	server := newServer(ta)
-	tc.Config.ClientNodeURL = server.URL
+	tc.Config.Set("ClientNodeURL", server.URL)
 	app.Store.Config = tc.Config
 
 	ta.Config = tc.Config
@@ -333,7 +333,7 @@ func NewStore() (*store.Store, func()) {
 
 func cleanUpStore(store *store.Store) {
 	defer func() {
-		if err := os.RemoveAll(store.Config.RootDir); err != nil {
+		if err := os.RemoveAll(store.Config.RootDir()); err != nil {
 			log.Println(err)
 		}
 	}()
@@ -502,7 +502,7 @@ func ObserveLogs() *observer.ObservedLogs {
 
 // ReadLogs returns the contents of the applications log file as a string
 func ReadLogs(app *TestApplication) (string, error) {
-	logFile := fmt.Sprintf("%s/log.jsonl", app.Store.Config.RootDir)
+	logFile := fmt.Sprintf("%s/log.jsonl", app.Store.Config.RootDir())
 	b, err := ioutil.ReadFile(logFile)
 	return string(b), err
 }
@@ -892,7 +892,14 @@ func DecodeSessionCookie(value string) (string, error) {
 	var decrypted map[interface{}]interface{}
 	codecs := securecookie.CodecsFromPairs([]byte(SessionSecret))
 	err := securecookie.DecodeMulti(web.SessionName, value, &decrypted, codecs...)
-	return decrypted[web.SessionIDKey].(string), err
+	if err != nil {
+		return "", err
+	}
+	value, ok := decrypted[web.SessionIDKey].(string)
+	if !ok {
+		return "", fmt.Errorf("decrypted[web.SessionIDKey] is not a string (%v)", value)
+	}
+	return value, nil
 }
 
 func MustGenerateSessionCookie(value string) *http.Cookie {
diff --git a/main_test.go b/main_test.go
index a7994940570..e0f44ba538e 100644
--- a/main_test.go
+++ b/main_test.go
@@ -12,7 +12,7 @@ import (
 func ExampleRun() {
 	tc, cleanup := cltest.NewConfig()
 	defer cleanup()
-	tc.Config.Dev = false
+	tc.Config.Set("Dev", false)
 	testClient := &cmd.Client{
 		Renderer:               cmd.RendererTable{Writer: ioutil.Discard},
 		Config:                 tc.Config,
diff --git a/services/head_tracker.go b/services/head_tracker.go
index ba1d2f8a4de..9e42fb57d9e 100644
--- a/services/head_tracker.go
+++ b/services/head_tracker.go
@@ -191,7 +191,7 @@ func (ht *HeadTracker) subscribe() bool {
 		case <-time.After(ht.sleeper.After()):
 			err := ht.subscribeToHead()
 			if err != nil {
-				logger.Warnw(fmt.Sprintf("Failed to connect to %v", ht.store.Config.EthereumURL), "err", err)
+				logger.Warnw(fmt.Sprintf("Failed to connect to %v", ht.store.Config.EthereumURL()), "err", err)
 			} else {
 				logger.Info("Connected to node ", ht.store.Config.EthereumURL)
 				ht.fastForwardHeadFromEth()
diff --git a/services/reaper.go b/services/reaper.go
index fd79bb18fc1..0d4cceb625f 100644
--- a/services/reaper.go
+++ b/services/reaper.go
@@ -24,7 +24,7 @@ func NewStoreReaper(store *store.Store) SleeperTask {
 
 func (sr *storeReaper) Work() {
 	var sessions []models.Session
-	offset := time.Now().Add(-sr.config.ReaperExpiration.Duration).Add(-sr.config.SessionTimeout.Duration)
+	offset := time.Now().Add(-sr.config.ReaperExpiration()).Add(-sr.config.SessionTimeout())
 	stale := models.Time{offset}
 	err := sr.store.Range("LastUsed", models.Time{}, stale, &sessions)
 	if err != nil && err != storm.ErrNotFound {
diff --git a/services/reaper_test.go b/services/reaper_test.go
index 30f89c8be81..0516f1ca34a 100644
--- a/services/reaper_test.go
+++ b/services/reaper_test.go
@@ -28,9 +28,9 @@ func TestStoreReaper_ReapSessions(t *testing.T) {
 		wantReap bool
 	}{
 		{"current", time.Now(), false},
-		{"expired", time.Now().Add(-store.Config.SessionTimeout.Duration), false},
-		{"almost stale", time.Now().Add(-store.Config.ReaperExpiration.Duration), false},
-		{"stale", time.Now().Add(-store.Config.ReaperExpiration.Duration).Add(-store.Config.SessionTimeout.Duration), true},
+		{"expired", time.Now().Add(-store.Config.SessionTimeout()), false},
+		{"almost stale", time.Now().Add(-store.Config.ReaperExpiration()), false},
+		{"stale", time.Now().Add(-store.Config.ReaperExpiration()).Add(-store.Config.SessionTimeout()), true},
 	}
 
 	for _, test := range tests {
diff --git a/services/runs.go b/services/runs.go
index 5b5f3bcc655..5ab6d0ec6b9 100644
--- a/services/runs.go
+++ b/services/runs.go
@@ -75,11 +75,11 @@ func NewRun(
 		}
 
 		mp := adapter.MinContractPayment()
-		cost.Add(cost, &mp)
+		cost.Add(cost, mp)
 
 		if currentHeight != nil {
 			run.TaskRuns[i].MinimumConfirmations = utils.MaxUint64(
-				store.Config.MinIncomingConfirmations,
+				store.Config.MinIncomingConfirmations(),
 				taskRun.Task.Confirmations,
 				adapter.MinConfs())
 		}
@@ -99,7 +99,7 @@ func NewRun(
 				"Rejecting job %s with payment %s below minimum threshold (%s)",
 				job.ID,
 				input.Amount,
-				store.Config.MinimumContractPayment.Text(10))
+				store.Config.MinimumContractPayment().Text(10))
 			run = run.ApplyResult(input.WithError(err))
 		}
 	}
diff --git a/services/runs_test.go b/services/runs_test.go
index 906087e943f..4c7fd8e94a4 100644
--- a/services/runs_test.go
+++ b/services/runs_test.go
@@ -25,7 +25,7 @@ func TestNewRun(t *testing.T) {
 	input := models.JSON{Result: gjson.Parse(`{"address":"0xdfcfc2b9200dbb10952c2b7cce60fc7260e03c6f"}`)}
 
 	bt := cltest.NewBridgeType("timecube", "http://http://timecube.2enp.com/")
-	bt.MinimumContractPayment = *assets.NewLink(10)
+	bt.MinimumContractPayment = assets.NewLink(10)
 	assert.Nil(t, store.Save(&bt))
 
 	creationHeight := cltest.BigHexInt(1000)
@@ -53,7 +53,7 @@ func TestNewRun_requiredPayment(t *testing.T) {
 	input := models.JSON{Result: gjson.Parse(`{"address":"0xdfcfc2b9200dbb10952c2b7cce60fc7260e03c6f"}`)}
 
 	bt := cltest.NewBridgeType("timecube", "http://http://timecube.2enp.com/")
-	bt.MinimumContractPayment = *assets.NewLink(10)
+	bt.MinimumContractPayment = assets.NewLink(10)
 	assert.Nil(t, store.Save(&bt))
 
 	tests := []struct {
@@ -72,7 +72,7 @@ func TestNewRun_requiredPayment(t *testing.T) {
 	for _, tt := range tests {
 		test := tt
 		t.Run(test.name, func(t *testing.T) {
-			store.Config.MinimumContractPayment = test.minimumPayment
+			store.Config.Set("MinimumContractPayment", test.minimumPayment)
 
 			jobSpec := models.NewJob()
 			jobSpec.Tasks = []models.TaskSpec{{
@@ -114,7 +114,7 @@ func TestNewRun_minimumConfirmations(t *testing.T) {
 	for _, tt := range tests {
 		test := tt
 		t.Run(test.name, func(t *testing.T) {
-			store.Config.MinIncomingConfirmations = test.configConfirmations
+			store.Config.Set("MinIncomingConfirmations", test.configConfirmations)
 
 			jobSpec, initiator := cltest.NewJobWithLogInitiator()
 			jobSpec.Tasks[0].Confirmations = test.taskConfirmations
diff --git a/services/validators.go b/services/validators.go
index 14759a9ac09..a9a9c5f34d4 100644
--- a/services/validators.go
+++ b/services/validators.go
@@ -106,14 +106,15 @@ func ValidateServiceAgreement(sa models.ServiceAgreement, store *store.Store) er
 	fe := models.NewJSONAPIErrors()
 	config := store.Config
 
+	fmt.Println("payment", sa.Encumbrance.Payment, "MinimumContractPayment", config.MinimumContractPayment())
 	if sa.Encumbrance.Payment == nil {
 		fe.Add("Service agreement encumbrance error: No payment amount set")
-	} else if sa.Encumbrance.Payment.Cmp(&config.MinimumContractPayment) == -1 {
-		fe.Add(fmt.Sprintf("Service agreement encumbrance error: Payment amount is below minimum %v", config.MinimumContractPayment.String()))
+	} else if sa.Encumbrance.Payment.Cmp(config.MinimumContractPayment()) == -1 {
+		fe.Add(fmt.Sprintf("Service agreement encumbrance error: Payment amount is below minimum %v", config.MinimumContractPayment().String()))
 	}
 
-	if sa.Encumbrance.Expiration < config.MinimumRequestExpiration {
-		fe.Add(fmt.Sprintf("Service agreement encumbrance error: Expiration is below minimum %v", config.MinimumRequestExpiration))
+	if sa.Encumbrance.Expiration < config.MinimumRequestExpiration() {
+		fe.Add(fmt.Sprintf("Service agreement encumbrance error: Expiration is below minimum %v", config.MinimumRequestExpiration()))
 	}
 
 	account, err := store.KeyStore.GetFirstAccount()
@@ -137,16 +138,16 @@ func ValidateServiceAgreement(sa models.ServiceAgreement, store *store.Store) er
 
 	untilEndAt := time.Until(sa.Encumbrance.EndAt.Time)
 
-	if untilEndAt > config.MaximumServiceDuration.Duration {
+	if untilEndAt > config.MaximumServiceDuration() {
 		fe.Add(fmt.Sprintf("Service agreement encumbrance error: endAt value of %s is too far in the future. Furthest allowed date is %s",
 			sa.Encumbrance.EndAt,
-			time.Now().Add(config.MaximumServiceDuration.Duration)))
+			time.Now().Add(config.MaximumServiceDuration())))
 	}
 
-	if untilEndAt < config.MinimumServiceDuration.Duration {
+	if untilEndAt < config.MinimumServiceDuration() {
 		fe.Add(fmt.Sprintf("Service agreement encumbrance error: endAt value of %s is too soon. Earliest allowed date is %s",
 			sa.Encumbrance.EndAt,
-			time.Now().Add(config.MinimumServiceDuration.Duration)))
+			time.Now().Add(config.MinimumServiceDuration())))
 	}
 
 	return fe.CoerceEmptyToNil()
diff --git a/store/config.go b/store/config.go
index 233adb6157e..21fc4449261 100644
--- a/store/config.go
+++ b/store/config.go
@@ -7,22 +7,19 @@ import (
 	"log"
 	"math/big"
 	"net/url"
-	"os"
 	"path"
 	"reflect"
 	"strconv"
 	"time"
 
-	"github.com/caarlos0/env"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/gin-gonic/contrib/sessions"
 	"github.com/gin-gonic/gin"
 	"github.com/gorilla/securecookie"
-	homedir "github.com/mitchellh/go-homedir"
 	"github.com/smartcontractkit/chainlink/logger"
 	"github.com/smartcontractkit/chainlink/store/assets"
-	"github.com/smartcontractkit/chainlink/store/models"
 	"github.com/smartcontractkit/chainlink/utils"
+	"github.com/spf13/viper"
 	"go.uber.org/zap"
 	"go.uber.org/zap/zapcore"
 )
@@ -33,46 +30,53 @@ import (
 // If you add an entry here which does not contain sensitive information, you
 // should also update presenters.ConfigWhitelist and cmd_test.TestClient_RunNodeShowsEnv.
 type Config struct {
-	SecretGenerator   SecretGenerator
-	AllowOrigins      string        `env:"ALLOW_ORIGINS" envDefault:"http://localhost:3000,http://localhost:6688"`
-	BridgeResponseURL models.WebURL `env:"BRIDGE_RESPONSE_URL" envDefault:""`
-	ChainID           uint64        `env:"ETH_CHAIN_ID" envDefault:"0"`
-	ClientNodeURL     string        `env:"CLIENT_NODE_URL" envDefault:"http://localhost:6688"`
-	DatabaseTimeout   Duration      `env:"DATABASE_TIMEOUT" envDefault:"500ms"`
-	Dev               bool          `env:"CHAINLINK_DEV" envDefault:"false"`
-	// How long from now that a service agreement is allowed to run. Default 1 year = 365 * 24h = 8760h
-	MaximumServiceDuration Duration `env:"MAXIMUM_SERVICE_DURATION" envDefault:"8760h"`
-	// Shortest duration from now that a service is allowed to run.
-	MinimumServiceDuration   Duration        `env:"MINIMUM_SERVICE_DURATION" envDefault:"0s"`
-	EthGasBumpThreshold      uint64          `env:"ETH_GAS_BUMP_THRESHOLD" envDefault:"12"`
-	EthGasBumpWei            big.Int         `env:"ETH_GAS_BUMP_WEI" envDefault:"5000000000"`
-	EthGasPriceDefault       big.Int         `env:"ETH_GAS_PRICE_DEFAULT" envDefault:"20000000000"`
-	EthereumURL              string          `env:"ETH_URL" envDefault:"ws://localhost:8546"`
-	JSONConsole              bool            `env:"JSON_CONSOLE" envDefault:"false"`
-	LinkContractAddress      string          `env:"LINK_CONTRACT_ADDRESS" envDefault:"0x514910771AF9Ca656af840dff83E8264EcF986CA"`
-	LogLevel                 LogLevel        `env:"LOG_LEVEL" envDefault:"info"`
-	LogToDisk                bool            `env:"LOG_TO_DISK" envDefault:"true"`
-	MinIncomingConfirmations uint64          `env:"MIN_INCOMING_CONFIRMATIONS" envDefault:"0"`
-	MinOutgoingConfirmations uint64          `env:"MIN_OUTGOING_CONFIRMATIONS" envDefault:"12"`
-	MinimumContractPayment   assets.Link     `env:"MINIMUM_CONTRACT_PAYMENT" envDefault:"1000000000000000000"`
-	MinimumRequestExpiration uint64          `env:"MINIMUM_REQUEST_EXPIRATION" envDefault:"300"`
-	OracleContractAddress    *common.Address `env:"ORACLE_CONTRACT_ADDRESS"`
-	Port                     uint16          `env:"CHAINLINK_PORT" envDefault:"6688"`
-	ReaperExpiration         Duration        `env:"REAPER_EXPIRATION" envDefault:"240h"`
-	RootDir                  string          `env:"ROOT" envDefault:"~/.chainlink"`
-	SessionTimeout           Duration        `env:"SESSION_TIMEOUT" envDefault:"15m"`
-	TLSCertPath              string          `env:"TLS_CERT_PATH" envDefault:""`
-	TLSHost                  string          `env:"CHAINLINK_TLS_HOST" envDefault:""`
-	TLSKeyPath               string          `env:"TLS_KEY_PATH" envDefault:""`
-	TLSPort                  uint16          `env:"CHAINLINK_TLS_PORT" envDefault:"6689"`
+	viper           *viper.Viper
+	SecretGenerator SecretGenerator
+}
+
+// configSchema records the schema of configuration at the type level
+type configSchema struct {
+	AllowOrigins             string          `env:"ALLOW_ORIGINS" default:"http://localhost:3000,http://localhost:6688" visible:"true"`
+	BridgeResponseURL        *url.URL        `env:"BRIDGE_RESPONSE_URL" visible:"true"`
+	ChainID                  uint64          `env:"ETH_CHAIN_ID" default:"0" visible:"true"`
+	ClientNodeURL            string          `env:"CLIENT_NODE_URL" default:"http://localhost:6688" visible:"true"`
+	DatabaseTimeout          time.Duration   `env:"DATABASE_TIMEOUT" default:"500ms" visible:"true"`
+	Dev                      bool            `env:"CHAINLINK_DEV" default:"false" visible:"true"`
+	MaximumServiceDuration   time.Duration   `env:"MAXIMUM_SERVICE_DURATION" default:"8760h" `
+	MinimumServiceDuration   time.Duration   `env:"MINIMUM_SERVICE_DURATION" default:"0s" `
+	EthGasBumpThreshold      uint64          `env:"ETH_GAS_BUMP_THRESHOLD" default:"12" `
+	EthGasBumpWei            *big.Int        `env:"ETH_GAS_BUMP_WEI" default:"5000000000" visible:"true"`
+	EthGasPriceDefault       *big.Int        `env:"ETH_GAS_PRICE_DEFAULT" default:"20000000000" visible:"true"`
+	EthereumURL              string          `env:"ETH_URL" default:"ws://localhost:8546" visible:"true"`
+	JSONConsole              bool            `env:"JSON_CONSOLE" default:"false" visible:"true"`
+	LinkContractAddress      string          `env:"LINK_CONTRACT_ADDRESS" default:"0x514910771AF9Ca656af840dff83E8264EcF986CA" visible:"true"`
+	LogLevel                 LogLevel        `env:"LOG_LEVEL" default:"info" visible:"true"`
+	LogToDisk                bool            `env:"LOG_TO_DISK" default:"true" visible:"true"`
+	MinIncomingConfirmations uint64          `env:"MIN_INCOMING_CONFIRMATIONS" default:"0" visible:"true"`
+	MinOutgoingConfirmations uint64          `env:"MIN_OUTGOING_CONFIRMATIONS" default:"12" visible:"true"`
+	MinimumContractPayment   *assets.Link    `env:"MINIMUM_CONTRACT_PAYMENT" default:"1000000000000000000" visible:"true"`
+	MinimumRequestExpiration uint64          `env:"MINIMUM_REQUEST_EXPIRATION" default:"300" `
+	OracleContractAddress    *common.Address `env:"ORACLE_CONTRACT_ADDRESS" visible:"true"`
+	Port                     uint16          `env:"CHAINLINK_PORT" default:"6688" visible:"true"`
+	ReaperExpiration         time.Duration   `env:"REAPER_EXPIRATION" default:"240h" visible:"true"`
+	RootDir                  string          `env:"ROOT" default:"~/.chainlink" visible:"true"`
+	SessionTimeout           time.Duration   `env:"SESSION_TIMEOUT" default:"15m" visible:"true"`
+	TLSCertPath              string          `env:"TLS_CERT_PATH" `
+	TLSHost                  string          `env:"CHAINLINK_TLS_HOST" `
+	TLSKeyPath               string          `env:"TLS_KEY_PATH" `
+	TLSPort                  uint16          `env:"CHAINLINK_TLS_PORT" default:"6689" visible:"true"`
 }
 
 // NewConfig returns the config with the environment variables set to their
 // respective fields, or their defaults if environment variables are not set.
 func NewConfig() Config {
-	config := Config{}
-	if err := parseEnv(&config); err != nil {
-		log.Fatal(fmt.Errorf("error parsing environment: %+v", err))
+	v := viper.New()
+
+	schemaT := reflect.TypeOf(configSchema{})
+	for index := 0; index < schemaT.NumField(); index++ {
+		item := schemaT.FieldByIndex([]int{index})
+		v.SetDefault(item.Name, item.Tag.Get("default"))
+		v.BindEnv(item.Name, item.Tag.Get("env"))
 	}
 	dir, err := homedir.Expand(config.RootDir)
 	if err != nil {
@@ -80,35 +84,227 @@ func NewConfig() Config {
 	}
 	if err = os.MkdirAll(dir, os.FileMode(0700)); err != nil {
 		log.Fatal(fmt.Errorf(`error creating "%s": %+v`, dir, err))
+
+	//if err := parseEnv(&config); err != nil {
+	//	log.Fatal(fmt.Errorf("error parsing environment: %+v", err))
+	//}
+	//dir, err := homedir.Expand(config.RootDir())
+	//if err != nil {
+	//		log.Fatal(fmt.Errorf("error expanding $HOME: %+v", err))
+	//	}
+	//	if err = os.MkdirAll(dir, os.FileMode(0700)); err != nil {
+	//		log.Fatal(fmt.Errorf("error creating %s: %+v", dir, err))
+	//	}
+	// config.RootDir = dir
+	return Config{
+		viper:           v,
+		SecretGenerator: filePersistedSecretGenerator{},
 	}
-	config.RootDir = dir
-	config.SecretGenerator = filePersistedSecretGenerator{}
-	return config
+}
+
+// Set a specific configuration variable
+func (c Config) Set(name string, value interface{}) {
+	c.viper.Set(name, value)
+}
+
+// GetVisibleValues returns the value of all displayable values as annotated by
+// the visible:"true" tag.
+func (c Config) GetVisibleValues() map[string]string {
+	values := make(map[string]string)
+	schemaT := reflect.TypeOf(configSchema{})
+	for index := 0; index < schemaT.NumField(); index++ {
+		item := schemaT.FieldByIndex([]int{index})
+		if item.Tag.Get("visible") == "true" {
+			values[item.Tag.Get("env")] = c.viper.GetString(item.Name)
+		}
+	}
+	return values
+}
+
+// AllowOrigins returns the CORS hosts used by the frontend.
+func (c Config) AllowOrigins() string {
+	return c.viper.GetString("AllowOrigins")
+}
+
+// BridgeResponseURL represents the URL for bridges to send a response to.
+func (c Config) BridgeResponseURL() *url.URL {
+	return c.getWithFallback("BridgeResponseURL", parseURL).(*url.URL)
+}
+
+// ChainID represents the chain ID to use for transactions.
+func (c Config) ChainID() uint64 {
+	return uint64(c.viper.GetInt64("ChainID"))
+}
+
+// ClientNodeURL is ... FIXME:
+func (c Config) ClientNodeURL() string {
+	return c.viper.GetString("ClientNodeURL")
+}
+
+// DatabaseTimeout represents how long to tolerate non response from the DB.
+func (c Config) DatabaseTimeout() time.Duration {
+	return c.viper.GetDuration("DatabaseTimeout")
+}
+
+// Dev configures "development" mode for chainlink.
+func (c Config) Dev() bool {
+	return c.viper.GetBool("Dev")
+}
+
+// MaximumServiceDuration is the maximum time that a service agreement can run
+// from after the time it is created. Default 1 year = 365 * 24h = 8760h
+func (c Config) MaximumServiceDuration() time.Duration {
+	return c.viper.GetDuration("MaximumServiceDuration")
+}
+
+// MinimumServiceDuration is the shortest duration from now that a service is
+// allowed to run.
+func (c Config) MinimumServiceDuration() time.Duration {
+	return c.viper.GetDuration("MinimumServiceDuration")
+}
+
+// EthGasBumpThreshold represents the maximum amount a transaction's ETH amount
+// should be increased in order to facilitate a transaction.
+func (c Config) EthGasBumpThreshold() uint64 {
+	return uint64(c.viper.GetInt64("EthGasBumpThreshold"))
+}
+
+// EthGasBumpWei represents the intervals in which ETH should be increased when
+// doing gas bumping.
+func (c Config) EthGasBumpWei() *big.Int {
+	return c.getWithFallback("EthGasBumpWei", parseBigInt).(*big.Int)
+}
+
+// EthGasPriceDefault represents the default gas price for transactions.
+func (c Config) EthGasPriceDefault() *big.Int {
+	return c.getWithFallback("EthGasPriceDefault", parseBigInt).(*big.Int)
+}
+
+// EthereumURL represents the URL of the Ethereum node to connect Chainlink to.
+func (c Config) EthereumURL() string {
+	return c.viper.GetString("EthereumURL")
+}
+
+// JSONConsole enables the JSON console.
+func (c Config) JSONConsole() bool {
+	return c.viper.GetBool("JSONConsole")
+}
+
+// LinkContractAddress represents the address
+func (c Config) LinkContractAddress() string {
+	return c.viper.GetString("LinkContractAddress")
+}
+
+// OracleContractAddress represents the deployed Oracle contract's address.
+func (c Config) OracleContractAddress() *common.Address {
+	if c.viper.GetString("OracleContractAddress") == "" {
+		return nil
+	}
+	return c.getWithFallback("OracleContractAddress", parseAddress).(*common.Address)
+}
+
+// LogLevel represents the maximum level of log messages to output.
+func (c Config) LogLevel() LogLevel {
+	return c.getWithFallback("LogLevel", parseLogLevel).(LogLevel)
+}
+
+// LogToDisk configures disk preservation of logs.
+func (c Config) LogToDisk() bool {
+	return c.viper.GetBool("LogToDisk")
+}
+
+// MinIncomingConfirmations represents the minimum number of block
+// confirmations that need to be recorded since a job run started before a task
+// can proceed.
+func (c Config) MinIncomingConfirmations() uint64 {
+	return uint64(c.viper.GetInt64("MinIncomingConfirmations"))
+}
+
+// MinOutgoingConfirmations represents the minimum number of block
+// confirmations that need to be recorded on an outgoing transaction before a
+// task is completed.
+func (c Config) MinOutgoingConfirmations() uint64 {
+	return uint64(c.viper.GetInt64("MinOutgoingConfirmations"))
+}
+
+// MinimumContractPayment represents the minimum amount of ETH that must be
+// supplied for a contract to be considered.
+func (c Config) MinimumContractPayment() *assets.Link {
+	return c.getWithFallback("MinimumContractPayment", parseLink).(*assets.Link)
+}
+
+// MinimumRequestExpiration FIXME:
+func (c Config) MinimumRequestExpiration() uint64 {
+	return uint64(c.viper.GetInt64("MinimumRequestExpiration"))
+}
+
+// Port represents the port Chainlink should listen on for client requests.
+func (c Config) Port() uint16 {
+	return c.getWithFallback("Port", parsePort).(uint16)
+}
+
+// ReaperExpiration represents
+func (c Config) ReaperExpiration() time.Duration {
+	return c.viper.GetDuration("ReaperExpiration")
+}
+
+// RootDir represents the location on the file system where Chainlink should
+// keep its files.
+func (c Config) RootDir() string {
+	return c.viper.GetString("RootDir")
+}
+
+// SessionTimeout FIXME:
+func (c Config) SessionTimeout() time.Duration {
+	return c.viper.GetDuration("SessionTimeout")
+}
+
+// TLSCertPath represents the file system location of the TLS certificate
+// Chainlink should use for HTTPS.
+func (c Config) TLSCertPath() string {
+	return c.viper.GetString("TLSCertPath")
+}
+
+// TLSHost represents the hostname to use for TLS clients. This should match
+// the TLS certificate.
+func (c Config) TLSHost() string {
+	return c.viper.GetString("TLSHost")
+}
+
+// TLSKeyPath represents the file system location of the TLS key Chainlink
+// should use for HTTPS.
+func (c Config) TLSKeyPath() string {
+	return c.viper.GetString("TLSKeyPath")
+}
+
+// TLSPort represents the port Chainlink should listen on for encrypted client requests.
+func (c Config) TLSPort() uint16 {
+	return c.getWithFallback("TLSPort", parsePort).(uint16)
 }
 
 // KeysDir returns the path of the keys directory (used for keystore files).
 func (c Config) KeysDir() string {
-	return path.Join(c.RootDir, "keys")
+	return path.Join(c.RootDir(), "keys")
 }
 
 func (c Config) tlsDir() string {
-	return path.Join(c.RootDir, "tls")
+	return path.Join(c.RootDir(), "tls")
 }
 
 // KeyFile returns the path where the server key is kept
 func (c Config) KeyFile() string {
-	if c.TLSKeyPath == "" {
+	if c.TLSKeyPath() == "" {
 		return path.Join(c.tlsDir(), "server.key")
 	}
-	return c.TLSKeyPath
+	return c.TLSKeyPath()
 }
 
 // CertFile returns the path where the server certificate is kept
 func (c Config) CertFile() string {
-	if c.TLSCertPath == "" {
+	if c.TLSCertPath() == "" {
 		return path.Join(c.tlsDir(), "server.crt")
 	}
-	return c.TLSCertPath
+	return c.TLSCertPath()
 }
 
 // CreateProductionLogger returns a custom logger for the config's root
@@ -116,7 +312,7 @@ func (c Config) CertFile() string {
 // false, the logger will only log to stdout.
 func (c Config) CreateProductionLogger() *zap.Logger {
 	return logger.CreateProductionLogger(
-		c.RootDir, c.JSONConsole, c.LogLevel.Level, c.LogToDisk)
+		c.RootDir(), c.JSONConsole(), c.LogLevel().Level, c.LogToDisk())
 }
 
 // SessionSecret returns a sequence of bytes to be used as a private key for
@@ -129,12 +325,40 @@ func (c Config) SessionSecret() ([]byte, error) {
 // the session store.
 func (c Config) SessionOptions() sessions.Options {
 	return sessions.Options{
-		Secure:   c.Dev == false,
+		Secure:   !c.Dev(),
 		HttpOnly: true,
 		MaxAge:   86400 * 30,
 	}
 }
 
+func (c Config) defaultValue(name string) string {
+	schemaT := reflect.TypeOf(configSchema{})
+	if item, ok := schemaT.FieldByName(name); ok {
+		return item.Tag.Get("default")
+	}
+	log.Panicf("Invariant violated, no field of name %s found", name)
+	return ""
+}
+
+func (c Config) getWithFallback(name string, parser func(string) (interface{}, error)) interface{} {
+	str := c.viper.GetString(name)
+	var err error
+	v, err := parser(str)
+	if err != nil {
+		defaultValue := c.defaultValue(name)
+		logger.Errorw(
+			fmt.Sprintf("Invalid value provided for %s, falling back to default.", name),
+			"value", str,
+			"default", defaultValue,
+			"error", err)
+		v, err = parser(defaultValue)
+		if err != nil {
+			log.Fatalf(fmt.Sprintf(`Invalid default for %s: "%s"`, name, defaultValue))
+		}
+	}
+	return v
+}
+
 // SecretGenerator is the interface for objects that generate a secret
 // used to sign or encrypt.
 type SecretGenerator interface {
@@ -144,7 +368,7 @@ type SecretGenerator interface {
 type filePersistedSecretGenerator struct{}
 
 func (f filePersistedSecretGenerator) Generate(c Config) ([]byte, error) {
-	sessionPath := path.Join(c.RootDir, "secret")
+	sessionPath := path.Join(c.RootDir(), "secret")
 	if utils.FileExists(sessionPath) {
 		data, err := ioutil.ReadFile(sessionPath)
 		if err != nil {
@@ -157,19 +381,7 @@ func (f filePersistedSecretGenerator) Generate(c Config) ([]byte, error) {
 	return key, ioutil.WriteFile(sessionPath, []byte(str), 0644)
 }
 
-func parseEnv(cfg interface{}) error {
-	return env.ParseWithFuncs(cfg, env.CustomParsers{
-		reflect.TypeOf(&common.Address{}): addressParser,
-		reflect.TypeOf(big.Int{}):         bigIntParser,
-		reflect.TypeOf(assets.Link{}):     linkParser,
-		reflect.TypeOf(LogLevel{}):        levelParser,
-		reflect.TypeOf(Duration{}):        durationParser,
-		reflect.TypeOf(models.WebURL{}):   urlParser,
-		reflect.TypeOf(uint16(0)):         portParser,
-	})
-}
-
-func addressParser(str string) (interface{}, error) {
+func parseAddress(str string) (interface{}, error) {
 	if str == "" {
 		return nil, nil
 	} else if common.IsHexAddress(str) {
@@ -182,44 +394,38 @@ func addressParser(str string) (interface{}, error) {
 	return nil, fmt.Errorf("Unable to parse '%s' into EIP55-compliant address", str)
 }
 
-func bigIntParser(str string) (interface{}, error) {
-	i, ok := new(big.Int).SetString(str, 10)
-	if !ok {
-		return i, fmt.Errorf("Unable to parse %v into *big.Int(base 10)", str)
-	}
-	return *i, nil
-}
-
-func linkParser(str string) (interface{}, error) {
+func parseLink(str string) (interface{}, error) {
 	i, ok := new(assets.Link).SetString(str, 10)
 	if !ok {
-		return i, fmt.Errorf("Unable to parse %v into *assets.Link(base 10)", str)
+		return i, fmt.Errorf("Unable to parse '%v' into *assets.Link(base 10)", str)
 	}
-	return *i, nil
+	return i, nil
 }
 
-func levelParser(str string) (interface{}, error) {
+func parseLogLevel(str string) (interface{}, error) {
 	var lvl LogLevel
 	err := lvl.Set(str)
 	return lvl, err
 }
 
-func durationParser(str string) (interface{}, error) {
-	d, err := time.ParseDuration(str)
-	return Duration{Duration: d}, err
-}
-
-func portParser(str string) (interface{}, error) {
+func parsePort(str string) (interface{}, error) {
 	d, err := strconv.ParseUint(str, 10, 16)
 	return uint16(d), err
 }
 
-func urlParser(s string) (interface{}, error) {
-	u, err := url.ParseRequestURI(s)
-	if err != nil {
-		return nil, err
+func parseURL(s string) (interface{}, error) {
+	if s == "" {
+		return new(url.URL), nil
 	}
-	return models.WebURL(*u), nil
+	return url.ParseRequestURI(s)
+}
+
+func parseBigInt(str string) (interface{}, error) {
+	i, ok := new(big.Int).SetString(str, 10)
+	if !ok {
+		return i, fmt.Errorf("Unable to parse %v into *big.Int(base 10)", str)
+	}
+	return i, nil
 }
 
 // LogLevel determines the verbosity of the events to be logged.
@@ -227,25 +433,6 @@ type LogLevel struct {
 	zapcore.Level
 }
 
-// Duration returns a time duration with the supported
-// units of "ns", "us", "ms", "s", "m", "h".
-type Duration struct {
-	time.Duration
-}
-
-// MarshalText returns the byte slice of the formatted duration e.g. "500ms"
-func (d Duration) MarshalText() ([]byte, error) {
-	b := []byte(d.Duration.String())
-	return b, nil
-}
-
-// UnmarshalText parses the time.Duration and assigns it
-func (d *Duration) UnmarshalText(text []byte) error {
-	td, err := time.ParseDuration((string)(text))
-	d.Duration = td
-	return err
-}
-
 // ForGin keeps Gin's mode at the appropriate level with the LogLevel.
 func (ll LogLevel) ForGin() string {
 	switch {
diff --git a/store/config_test.go b/store/config_test.go
index ef2be45e9bb..0795c5b5616 100644
--- a/store/config_test.go
+++ b/store/config_test.go
@@ -1,7 +1,6 @@
 package store
 
 import (
-	"encoding/json"
 	"fmt"
 	"math/big"
 	"os"
@@ -20,19 +19,19 @@ import (
 func TestStore_ConfigDefaults(t *testing.T) {
 	t.Parallel()
 	config := NewConfig()
-	assert.Equal(t, uint64(0), config.ChainID)
-	assert.Equal(t, *big.NewInt(20000000000), config.EthGasPriceDefault)
-	assert.Equal(t, "0x514910771AF9Ca656af840dff83E8264EcF986CA", common.HexToAddress(config.LinkContractAddress).String())
-	assert.Equal(t, *assets.NewLink(1000000000000000000), config.MinimumContractPayment)
-	assert.Equal(t, 15*time.Minute, config.SessionTimeout.Duration)
-	assert.Equal(t, "", config.BridgeResponseURL.String())
+	assert.Equal(t, uint64(0), config.ChainID())
+	assert.Equal(t, big.NewInt(20000000000), config.EthGasPriceDefault())
+	assert.Equal(t, "0x514910771AF9Ca656af840dff83E8264EcF986CA", common.HexToAddress(config.LinkContractAddress()).String())
+	assert.Equal(t, assets.NewLink(1000000000000000000), config.MinimumContractPayment())
+	assert.Equal(t, 15*time.Minute, config.SessionTimeout())
+	assert.Equal(t, "", config.BridgeResponseURL().String())
 }
 
 func TestConfig_sessionSecret(t *testing.T) {
 	t.Parallel()
 	config := NewConfig()
-	config.RootDir = path.Join("/tmp/chainlink_test", fmt.Sprintf("%s", "TestConfig_sessionSecret"))
-	err := os.MkdirAll(config.RootDir, os.FileMode(0770))
+	config.Set("RootDir", path.Join("/tmp/chainlink_test", fmt.Sprintf("%s", "TestConfig_sessionSecret")))
+	err := os.MkdirAll(config.RootDir(), os.FileMode(0770))
 	require.NoError(t, err)
 
 	initial, err := config.SessionSecret()
@@ -60,91 +59,70 @@ func TestConfig_sessionOptions(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			config.Dev = test.dev
+			config.Set("Dev", test.dev)
 			opts := config.SessionOptions()
 			require.Equal(t, test.want, opts.Secure)
 		})
 	}
 }
 
-func TestStore_DurationMarshalJSON(t *testing.T) {
-	t.Parallel()
-
-	d := Duration{
-		Duration: time.Millisecond,
-	}
-	b, err := json.Marshal(d)
-
-	assert.NoError(t, err)
-	assert.Equal(t, []byte(`"1ms"`), b)
-}
-
-func TestStore_DurationUnmarshalJSON(t *testing.T) {
-	t.Parallel()
-
-	da := Duration{}
-	err := json.Unmarshal([]byte(`"1ms"`), &da)
-	assert.NoError(t, err)
-	assert.Equal(t, Duration{Duration: time.Millisecond}, da)
-}
-
 func TestStore_addressParser(t *testing.T) {
 	zero := &common.Address{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
 	fifteen := &common.Address{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15}
 
-	val, err := addressParser("")
+	val, err := parseAddress("")
 	assert.NoError(t, err)
 	assert.Equal(t, nil, val)
 
-	val, err = addressParser("0x000000000000000000000000000000000000000F")
+	val, err = parseAddress("0x000000000000000000000000000000000000000F")
 	assert.NoError(t, err)
 	assert.Equal(t, fifteen, val)
 
-	val, err = addressParser("0X000000000000000000000000000000000000000F")
+	val, err = parseAddress("0X000000000000000000000000000000000000000F")
 	assert.NoError(t, err)
 	assert.Equal(t, fifteen, val)
 
-	val, err = addressParser("0")
+	val, err = parseAddress("0")
 	assert.NoError(t, err)
 	assert.Equal(t, zero, val)
 
-	val, err = addressParser("15")
+	val, err = parseAddress("15")
 	assert.NoError(t, err)
 	assert.Equal(t, fifteen, val)
 
-	val, err = addressParser("0x0")
+	val, err = parseAddress("0x0")
 	assert.Error(t, err)
 
-	val, err = addressParser("x")
+	val, err = parseAddress("x")
 	assert.Error(t, err)
 }
 
 func TestStore_bigIntParser(t *testing.T) {
-	val, err := bigIntParser("0")
+	val, err := parseBigInt("0")
 	assert.NoError(t, err)
-	assert.Equal(t, *new(big.Int).SetInt64(0), val)
+	assert.Equal(t, new(big.Int).SetInt64(0), val)
 
-	val, err = bigIntParser("15")
+	val, err = parseBigInt("15")
 	assert.NoError(t, err)
-	assert.Equal(t, *new(big.Int).SetInt64(15), val)
+	assert.Equal(t, new(big.Int).SetInt64(15), val)
 
-	val, err = bigIntParser("x")
+	val, err = parseBigInt("x")
 	assert.Error(t, err)
 
-	val, err = bigIntParser("")
+	val, err = parseBigInt("")
 	assert.Error(t, err)
 }
 
 func TestStore_levelParser(t *testing.T) {
-	val, err := levelParser("ERROR")
+	val, err := parseLogLevel("ERROR")
 	assert.NoError(t, err)
 	assert.Equal(t, LogLevel{zapcore.ErrorLevel}, val)
 
-	val, err = levelParser("")
+	val, err = parseLogLevel("")
 	assert.NoError(t, err)
 	assert.Equal(t, LogLevel{zapcore.InfoLevel}, val)
 
-	val, err = levelParser("primus sucks")
+	val, err = parseLogLevel("primus sucks")
 	assert.Error(t, err)
 }
 
@@ -161,7 +139,7 @@ func TestStore_urlParser(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
-			i, err := urlParser(test.input)
+			i, err := parseURL(test.input)
 
 			if test.wantError {
 				assert.Error(t, err)
diff --git a/store/export_test.go b/store/export_test.go
index a579f639c94..f21bcf2930b 100644
--- a/store/export_test.go
+++ b/store/export_test.go
@@ -2,5 +2,5 @@ package store
 
 func ExportedSetTxManagerDev(txm TxManager, dev bool) {
 	typed := txm.(*EthTxManager)
-	typed.config.Dev = dev
+	typed.config.Set("Dev", dev)
 }
diff --git a/store/forms/update_bridge_type.go b/store/forms/update_bridge_type.go
index 37622377a05..dfd8c9edd5c 100644
--- a/store/forms/update_bridge_type.go
+++ b/store/forms/update_bridge_type.go
@@ -32,7 +32,7 @@ type UpdateBridgeType struct {
 	bridgeName             string
 	URL                    models.WebURL `json:"url"`
 	Confirmations          uint64        `json:"confirmations"`
-	MinimumContractPayment assets.Link   `json:"minimumContractPayment"`
+	MinimumContractPayment *assets.Link  `json:"minimumContractPayment"`
 }
 
 // Save updates the whitelisted attributes on the bridge
diff --git a/store/forms/update_bridge_type_test.go b/store/forms/update_bridge_type_test.go
index 2a570afee43..f5dea55632f 100644
--- a/store/forms/update_bridge_type_test.go
+++ b/store/forms/update_bridge_type_test.go
@@ -46,7 +46,7 @@ func TestFormsUpdateBridgeType_Save(t *testing.T) {
 
 	form.URL = cltest.WebURL("http://updatedbridge")
 	form.Confirmations = uint64(10)
-	form.MinimumContractPayment = *assets.NewLink(100)
+	form.Set("MinimumContractPayment", assets.NewLink(100))
 	assert.NoError(t, form.Save())
 
 	ubt, err = s.FindBridge("bridgea")
diff --git a/store/models/job_spec.go b/store/models/job_spec.go
index c2fb91f05e9..cbd6023ffc9 100644
--- a/store/models/job_spec.go
+++ b/store/models/job_spec.go
@@ -11,7 +11,7 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/smartcontractkit/chainlink/store/assets"
 	"github.com/smartcontractkit/chainlink/utils"
-	"gopkg.in/guregu/null.v3"
+	null "gopkg.in/guregu/null.v3"
 )
 
 // JobSpec is the definition for all the work to be carried out by the node
@@ -257,12 +257,12 @@ func (t TaskType) String() string {
 // BridgeType is used for external adapters and has fields for
 // the name of the adapter and its URL.
 type BridgeType struct {
-	Name                   TaskType    `json:"name" storm:"id,unique"`
-	URL                    WebURL      `json:"url"`
-	Confirmations          uint64      `json:"confirmations"`
-	IncomingToken          string      `json:"incomingToken"`
-	OutgoingToken          string      `json:"outgoingToken"`
-	MinimumContractPayment assets.Link `json:"minimumContractPayment"`
+	Name                   TaskType     `json:"name" storm:"id,unique"`
+	URL                    WebURL       `json:"url"`
+	Confirmations          uint64       `json:"confirmations"`
+	IncomingToken          string       `json:"incomingToken"`
+	OutgoingToken          string       `json:"outgoingToken"`
+	MinimumContractPayment *assets.Link `json:"minimumContractPayment"`
 }
 
 // GetID returns the ID of this structure for jsonapi serialization.
diff --git a/store/presenters/presenters_test.go b/store/presenters/presenters_test.go
index 0784089e9db..c6a57aed024 100644
--- a/store/presenters/presenters_test.go
+++ b/store/presenters/presenters_test.go
@@ -10,6 +10,7 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/smartcontractkit/chainlink/internal/cltest"
+	"github.com/smartcontractkit/chainlink/store/assets"
 	"github.com/smartcontractkit/chainlink/store/models"
 	"github.com/smartcontractkit/chainlink/store/presenters"
 	"github.com/stretchr/testify/assert"
@@ -152,17 +153,18 @@ func TestPresenter_FriendlyBigInt(t *testing.T) {
 func TestBridgeType_MarshalJSON(t *testing.T) {
 	t.Parallel()
 	input := models.BridgeType{
-		Name:          models.MustNewTaskType("hapax"),
-		URL:           cltest.WebURL("http://hap.ax"),
-		Confirmations: 0,
-		IncomingToken: "123",
-		OutgoingToken: "abc",
+		Name:                   models.MustNewTaskType("hapax"),
+		URL:                    cltest.WebURL("http://hap.ax"),
+		Confirmations:          0,
+		IncomingToken:          "123",
+		OutgoingToken:          "abc",
+		MinimumContractPayment: assets.NewLink(0),
 	}
-	expected := []byte(`{"name":"hapax","url":"http://hap.ax","confirmations":0,"incomingToken":"123","outgoingToken":"abc","minimumContractPayment":"0"}`)
 	bt := presenters.BridgeType{BridgeType: input}
 	output, err := bt.MarshalJSON()
 	assert.NoError(t, err)
-	assert.Equal(t, output, expected)
+	expected := `{"name":"hapax","url":"http://hap.ax","confirmations":0,"incomingToken":"123","outgoingToken":"abc","minimumContractPayment":"0"}`
+	assert.Equal(t, expected, string(output))
 }
 
 func TestServiceAgreement_MarshalJSON(t *testing.T) {
@@ -188,7 +190,7 @@ func TestPresenter_NewConfigWhitelist_Ok(t *testing.T) {
 	cw, err := presenters.NewConfigWhitelist(store)
 	assert.NoError(t, err)
 
-	assert.Equal(t, "0x3cb8e3FD9d27e39a5e9e6852b0e96160061fd4ea", cw.AccountAddress)
+	assert.Contains(t, cw.String(), "0x3cb8e3FD9d27e39a5e9e6852b0e96160061fd4ea")
 }
 
 func TestPresenter_NewConfigWhitelist_Error(t *testing.T) {
@@ -201,6 +203,5 @@ func TestPresenter_NewConfigWhitelist_Error(t *testing.T) {
 
 	cw, err := presenters.NewConfigWhitelist(store)
 	assert.Error(t, err)
-
-	assert.Equal(t, "", cw.AccountAddress)
+	assert.Equal(t, cw.String(), "")
 }
diff --git a/store/store.go b/store/store.go
index ba2a5673a28..08544a199fd 100644
--- a/store/store.go
+++ b/store/store.go
@@ -114,7 +114,7 @@ func NewStore(config Config) *Store {
 
 // NewStoreWithDialer creates a new store with the given config and dialer
 func NewStoreWithDialer(config Config, dialer Dialer) *Store {
-	err := os.MkdirAll(config.RootDir, os.FileMode(0700))
+	err := os.MkdirAll(config.RootDir(), os.FileMode(0700))
 	if err != nil {
 		logger.Fatal(fmt.Sprintf("Unable to create project root dir: %+v", err))
 	}
@@ -122,7 +122,7 @@ func NewStoreWithDialer(config Config, dialer Dialer) *Store {
 	if err != nil {
 		logger.Fatal(fmt.Sprintf("Unable to initialize ORM: %+v", err))
 	}
-	ethrpc, err := dialer.Dial(config.EthereumURL)
+	ethrpc, err := dialer.Dial(config.EthereumURL())
 	if err != nil {
 		logger.Fatal(fmt.Sprintf("Unable to dial ETH RPC port: %+v", err))
 	}
@@ -154,7 +154,7 @@ func (s *Store) Close() error {
 // AuthorizedUserWithSession will return the one API user if the Session ID exists
 // and hasn't expired, and update session's LastUsed field.
 func (s *Store) AuthorizedUserWithSession(sessionID string) (models.User, error) {
-	return s.ORM.AuthorizedUserWithSession(sessionID, s.Config.SessionTimeout.Duration)
+	return s.ORM.AuthorizedUserWithSession(sessionID, s.Config.SessionTimeout())
 }
 
 // AfterNower is an interface that fulfills the `After()` and `Now()`
@@ -178,8 +178,8 @@ func (Clock) After(d time.Duration) <-chan time.Time {
 }
 
 func initializeORM(config Config) (*orm.ORM, error) {
-	path := path.Join(config.RootDir, "db.bolt")
-	duration := config.DatabaseTimeout.Duration
+	path := path.Join(config.RootDir(), "db.bolt")
+	duration := config.DatabaseTimeout()
 	logger.Infof("Waiting %s for lock on db file %s", friendlyDuration(duration), path)
 	orm, err := orm.NewORM(path, duration)
 	if err != nil {
diff --git a/store/tx_manager.go b/store/tx_manager.go
index 237fbf45ab6..3e2657c38c1 100644
--- a/store/tx_manager.go
+++ b/store/tx_manager.go
@@ -122,7 +122,7 @@ func (txm *EthTxManager) OnNewHead(*models.BlockHeader) {}
 
 // CreateTx signs and sends a transaction to the Ethereum blockchain.
 func (txm *EthTxManager) CreateTx(to common.Address, data []byte) (*models.Tx, error) {
-	return txm.CreateTxWithGas(to, data, &txm.config.EthGasPriceDefault, DefaultGasLimit)
+	return txm.CreateTxWithGas(to, data, txm.config.EthGasPriceDefault(), DefaultGasLimit)
 }
 
 // CreateTxWithGas signs and sends a transaction to the Ethereum blockchain.
@@ -141,12 +141,12 @@ func (txm *EthTxManager) CreateTxWithGas(to common.Address, data []byte, gasPric
 }
 
 func normalize(gasPriceWei *big.Int, gasLimit uint64, config Config) (*big.Int, uint64) {
-	if !config.Dev {
-		return &config.EthGasPriceDefault, DefaultGasLimit
+	if !config.Dev() {
+		return config.EthGasPriceDefault(), DefaultGasLimit
 	}
 
 	if gasPriceWei == nil {
-		gasPriceWei = &config.EthGasPriceDefault
+		gasPriceWei = config.EthGasPriceDefault()
 	}
 
 	if gasLimit == 0 {
@@ -222,7 +222,7 @@ func (txm *EthTxManager) createTxWithNonceReload(
 
 // GetLINKBalance returns the balance of LINK at the given address
 func (txm *EthTxManager) GetLINKBalance(address common.Address) (*assets.Link, error) {
-	contractAddress := common.HexToAddress(txm.config.LinkContractAddress)
+	contractAddress := common.HexToAddress(txm.config.LinkContractAddress())
 	balance, err := txm.GetERC20Balance(address, contractAddress)
 	if err != nil {
 		return assets.NewLink(0), err
@@ -268,11 +268,11 @@ func (txm *EthTxManager) MeetsMinConfirmations(hash common.Hash) (bool, error) {
 func (txm *EthTxManager) ContractLINKBalance(wr models.WithdrawalRequest) (assets.Link, error) {
 	contractAddress := &wr.ContractAddress
 	if (*contractAddress == common.Address{}) {
-		if txm.config.OracleContractAddress == nil {
+		if txm.config.OracleContractAddress() == nil {
 			return assets.Link{}, errors.New(
 				"OracleContractAddress not set; cannot check LINK balance")
 		}
-		contractAddress = txm.config.OracleContractAddress
+		contractAddress = txm.config.OracleContractAddress()
 	}
 
 	linkBalance, err := txm.GetLINKBalance(*contractAddress)
@@ -304,11 +304,11 @@ func (txm *EthTxManager) WithdrawLINK(wr models.WithdrawalRequest) (common.Hash,
 
 	contractAddress := &wr.ContractAddress
 	if (*contractAddress == common.Address{}) {
-		if txm.config.OracleContractAddress == nil {
+		if txm.config.OracleContractAddress() == nil {
 			return common.Hash{}, errors.New(
 				"OracleContractAddress not set; cannot withdraw")
 		}
-		contractAddress = txm.config.OracleContractAddress
+		contractAddress = txm.config.OracleContractAddress()
 	}
 
 	tx, err := txm.CreateTx(*contractAddress, data)
@@ -329,7 +329,7 @@ func (txm *EthTxManager) createAttempt(
 		return nil, fmt.Errorf("Unable to locate %v as an available account in EthTxManager. Has TxManager been started or has the address been removed?", tx.From.Hex())
 	}
 	etx := tx.EthTx(gasPriceWei)
-	etx, err := txm.keyStore.SignTx(ma.Account, etx, txm.config.ChainID)
+	etx, err := txm.keyStore.SignTx(ma.Account, etx, txm.config.ChainID())
 	if err != nil {
 		return nil, err
 	}
@@ -399,7 +399,7 @@ func (txm *EthTxManager) handleConfirmed(
 	rcpt *TxReceipt,
 	blkNum uint64,
 ) (bool, error) {
-	minConfs := big.NewInt(int64(txm.config.MinOutgoingConfirmations))
+	minConfs := big.NewInt(int64(txm.config.MinOutgoingConfirmations()))
 	rcptBlkNum := rcpt.BlockNumber.ToBig()
 	safeAt := minConfs.Add(rcptBlkNum, minConfs)
 	safeAt.Sub(safeAt, big.NewInt(1)) // 0 based indexing since rcpt is 1 conf
@@ -431,7 +431,7 @@ func (txm *EthTxManager) handleUnconfirmed(
 	blkNum uint64,
 ) (bool, error) {
 	bumpable := tx.Hash == txat.Hash
-	pastThreshold := blkNum >= txat.SentAt+txm.config.EthGasBumpThreshold
+	pastThreshold := blkNum >= txat.SentAt+txm.config.EthGasBumpThreshold()
 	if bumpable && pastThreshold {
 		return false, txm.bumpGas(txat, blkNum)
 	}
@@ -443,7 +443,7 @@ func (txm *EthTxManager) bumpGas(txat *models.TxAttempt, blkNum uint64) error {
 	if err := txm.orm.One("ID", txat.TxID, tx); err != nil {
 		return err
 	}
-	gasPrice := new(big.Int).Add(txat.GasPrice, &txm.config.EthGasBumpWei)
+	gasPrice := new(big.Int).Add(txat.GasPrice, txm.config.EthGasBumpWei())
 	txat, err := txm.createAttempt(tx, gasPrice, blkNum)
 	if err != nil {
 		return err
diff --git a/store/tx_manager_test.go b/store/tx_manager_test.go
index 326372294c3..fd36ca604fd 100644
--- a/store/tx_manager_test.go
+++ b/store/tx_manager_test.go
@@ -98,7 +98,7 @@ func TestTxManager_CreateTx_RoundRobinSuccess(t *testing.T) {
 	ethMock.Context("manager.bumpGas#1", func(ethMock *cltest.EthMock) {
 		ethMock.Register("eth_getTransactionReceipt", strpkg.TxReceipt{})
 		ethMock.Register("eth_sendRawTransaction", cltest.NewHash())
-		ethMock.Register("eth_blockNumber", utils.Uint64ToHex(sentAt+config.EthGasBumpThreshold))
+		ethMock.Register("eth_blockNumber", utils.Uint64ToHex(sentAt+config.EthGasBumpThreshold()))
 	})
 
 	_, err = manager.MeetsMinConfirmations(attempts[0].Hash)
@@ -114,7 +114,7 @@ func TestTxManager_CreateTx_RoundRobinSuccess(t *testing.T) {
 	// best way to ensure the same from address atm is to compare Hashes, since
 	// tx attempts don't have From but rely on parent Tx model.
 	etx := createdTx1.EthTx(a2.GasPrice)
-	etx, err = store.KeyStore.SignTx(accounts[0], etx, config.ChainID)
+	etx, err = store.KeyStore.SignTx(accounts[0], etx, config.ChainID())
 	assert.Equal(t, etx.Hash().Hex(), a2.Hash.Hex(), "should be same since they have the same input, include From address")
 
 	// ensure second tx round robins
@@ -331,8 +331,8 @@ func TestTxManager_MeetsMinConfirmations(t *testing.T) {
 	txm := store.TxManager
 	from := cltest.GetAccountAddress(store)
 	sentAt := uint64(23456)
-	gasThreshold := sentAt + config.EthGasBumpThreshold
-	minConfs := config.MinOutgoingConfirmations - 1
+	gasThreshold := sentAt + config.EthGasBumpThreshold()
+	minConfs := config.MinOutgoingConfirmations() - 1
 
 	tests := []struct {
 		name             string
@@ -383,9 +383,9 @@ func TestTxManager_MeetsMinConfirmations_erroring(t *testing.T) {
 	defer cleanup()
 
 	sentAt1 := uint64(23456)
-	sentAt2 := sentAt1 + config.EthGasBumpThreshold
+	sentAt2 := sentAt1 + config.EthGasBumpThreshold()
 	confirmedAt := sentAt2 + 1
-	safeAt := confirmedAt + config.MinOutgoingConfirmations
+	safeAt := confirmedAt + config.MinOutgoingConfirmations()
 
 	nonConfedReceipt := strpkg.TxReceipt{}
 	confedReceipt := strpkg.TxReceipt{Hash: cltest.NewHash(), BlockNumber: cltest.Int(confirmedAt)}
@@ -535,7 +535,7 @@ func TestTxManager_WithdrawLink(t *testing.T) {
 	config, configCleanup := cltest.NewConfig()
 	defer configCleanup()
 	oca := common.HexToAddress("0xDEADB3333333F")
-	config.OracleContractAddress = &oca
+	config.Set("OracleContractAddress", &oca)
 	app, cleanup := cltest.NewApplicationWithConfigAndKeyStore(config)
 	defer cleanup()
 
@@ -635,7 +635,7 @@ func TestTxManager_LogsETHAndLINKBalancesAfterSuccessfulTx(t *testing.T) {
 	defer configCleanup()
 	oracleAddress := "0xDEADB3333333F"
 	oca := common.HexToAddress(oracleAddress)
-	config.OracleContractAddress = &oca
+	config.Set("OracleContractAddress", &oca)
 	app, cleanup := cltest.NewApplicationWithConfigAndKeyStore(config)
 	defer cleanup()
 
@@ -649,7 +649,7 @@ func TestTxManager_LogsETHAndLINKBalancesAfterSuccessfulTx(t *testing.T) {
 	ethMock := app.MockEthClient()
 	mockedEthBalance := "0x100"
 	mockedLinkBalance := "256000000000000000000"
-	confirmedHeight := sentAt + config.MinOutgoingConfirmations
+	confirmedHeight := sentAt + config.MinOutgoingConfirmations()
 	confirmedReceipt := strpkg.TxReceipt{
 		Hash:        hash,
 		BlockNumber: cltest.Int(sentAt),
@@ -720,9 +720,9 @@ func TestTxManager_CreateTxWithGas(t *testing.T) {
 		expectedGasLimit uint64
 	}{
 		{"dev", true, customGasPrice, customGasLimit, customGasPrice, customGasLimit},
-		{"dev but not set", true, nil, 0, &store.Config.EthGasPriceDefault, strpkg.DefaultGasLimit},
-		{"not dev", false, customGasPrice, customGasLimit, &store.Config.EthGasPriceDefault, strpkg.DefaultGasLimit},
-		{"not dev not set", false, nil, 0, &store.Config.EthGasPriceDefault, strpkg.DefaultGasLimit},
+		{"dev but not set", true, nil, 0, store.Config.EthGasPriceDefault(), strpkg.DefaultGasLimit},
+		{"not dev", false, customGasPrice, customGasLimit, store.Config.EthGasPriceDefault(), strpkg.DefaultGasLimit},
+		{"not dev not set", false, nil, 0, store.Config.EthGasPriceDefault(), strpkg.DefaultGasLimit},
 	}
 
 	for _, test := range tests {
diff --git a/web/config_controller_test.go b/web/config_controller_test.go
index 9da0b2d0eaa..6cdf53ad62e 100644
--- a/web/config_controller_test.go
+++ b/web/config_controller_test.go
@@ -1,15 +1,10 @@
 package web_test
 
 import (
-	"math/big"
 	"testing"
-	"time"
 
-	"github.com/ethereum/go-ethereum/common"
 	"github.com/smartcontractkit/chainlink/internal/cltest"
 	"github.com/smartcontractkit/chainlink/store"
-	"github.com/smartcontractkit/chainlink/store/assets"
-	"github.com/smartcontractkit/chainlink/store/presenters"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -26,26 +21,8 @@ func TestConfigController_Show(t *testing.T) {
 	defer cleanup()
 	cltest.AssertServerResponse(t, resp, 200)
 
-	cwl := presenters.ConfigWhitelist{}
-	require.NoError(t, cltest.ParseJSONAPIResponse(resp, &cwl))
+	cfg := make(map[string]string)
+	require.NoError(t, cltest.ParseJSONAPIResponse(resp, &cfg))
 
-	assert.Equal(t, store.LogLevel{Level: -1}, cwl.LogLevel)
-	assert.Contains(t, cwl.RootDir, "/tmp/chainlink_test/")
-	assert.Equal(t, uint16(6688), cwl.Port)
-	assert.Equal(t, uint16(6689), cwl.TLSPort)
-	assert.Equal(t, "", cwl.TLSHost)
-	assert.Contains(t, cwl.EthereumURL, "ws://127.0.0.1:")
-	assert.Equal(t, uint64(3), cwl.ChainID)
-	assert.Contains(t, cwl.ClientNodeURL, "http://127.0.0.1:")
-	assert.Equal(t, uint64(6), cwl.MinOutgoingConfirmations)
-	assert.Equal(t, uint64(0), cwl.MinIncomingConfirmations)
-	assert.Equal(t, uint64(3), cwl.EthGasBumpThreshold)
-	assert.Equal(t, uint64(300), cwl.MinimumRequestExpiration)
-	assert.Equal(t, big.NewInt(5000000000), cwl.EthGasBumpWei)
-	assert.Equal(t, big.NewInt(20000000000), cwl.EthGasPriceDefault)
-	assert.Equal(t, store.NewConfig().LinkContractAddress,
-		cwl.LinkContractAddress)
-	assert.Equal(t, assets.NewLink(100), cwl.MinimumContractPayment)
-	assert.Equal(t, (*common.Address)(nil), cwl.OracleContractAddress)
-	assert.Equal(t, store.Duration{Duration: time.Millisecond * 500}, cwl.DatabaseTimeout)
+	assert.Equal(t, store.LogLevel{Level: -1}, cfg["logLevel"])
 }
diff --git a/web/cors_test.go b/web/cors_test.go
index c0c2649b7a7..713a4dad2cc 100644
--- a/web/cors_test.go
+++ b/web/cors_test.go
@@ -10,7 +10,7 @@ func TestCors_DefaultOrigins(t *testing.T) {
 	t.Parallel()
 
 	config, _ := cltest.NewConfigWithPrivateKey()
-	config.AllowOrigins = "http://localhost:3000,http://localhost:6689"
+	config.Set("AllowOrigins", "http://localhost:3000,http://localhost:6689")
 	app, appCleanup := cltest.NewApplicationWithConfig(config)
 	defer appCleanup()
 	client := app.NewHTTPClient()
@@ -51,7 +51,7 @@ func TestCors_OverrideOrigins(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.origin, func(t *testing.T) {
 			config, _ := cltest.NewConfigWithPrivateKey()
-			config.AllowOrigins = test.allow
+			config.Set("AllowOrigins", test.allow)
 			app, appCleanup := cltest.NewApplicationWithConfig(config)
 			defer appCleanup()
 			client := app.NewHTTPClient()
diff --git a/web/job_runs_controller_test.go b/web/job_runs_controller_test.go
index bc6a0e2fb4e..a0006f4a16a 100644
--- a/web/job_runs_controller_test.go
+++ b/web/job_runs_controller_test.go
@@ -216,7 +216,7 @@ func TestJobRunsController_Update_Success(t *testing.T) {
 
 	body := fmt.Sprintf(`{"id":"%v","data":{"value": "100"}}`, jr.ID)
 	headers := map[string]string{"Authorization": "Bearer " + bt.IncomingToken}
-	url := app.Config.ClientNodeURL + "/v2/runs/" + jr.ID
+	url := app.Config.ClientNodeURL() + "/v2/runs/" + jr.ID
 	resp, cleanup := cltest.UnauthenticatedPatch(url, bytes.NewBufferString(body), headers)
 	defer cleanup()
 
@@ -322,7 +322,7 @@ func TestJobRunsController_Update_WithMergeError(t *testing.T) {
 
 	body := fmt.Sprintf(`{"id":"%v","data":{"value": "100"}}`, jr.ID)
 	headers := map[string]string{"Authorization": "Bearer " + bt.IncomingToken}
-	url := app.Config.ClientNodeURL + "/v2/runs/" + jr.ID
+	url := app.Config.ClientNodeURL() + "/v2/runs/" + jr.ID
 	resp, cleanup := cltest.UnauthenticatedPatch(url, bytes.NewBufferString(body), headers)
 	defer cleanup()
 
diff --git a/web/router.go b/web/router.go
index 3b69b896b6c..2578e3199a2 100644
--- a/web/router.go
+++ b/web/router.go
@@ -67,9 +67,9 @@ func Router(app services.Application) *gin.Engine {
 func secureOptions(config store.Config) secure.Options {
 	return secure.Options{
 		FrameDeny:     true,
-		IsDevelopment: config.Dev,
-		SSLRedirect:   config.TLSPort != 0,
-		SSLHost:       config.TLSHost,
+		IsDevelopment: config.Dev(),
+		SSLRedirect:   config.TLSPort() != 0,
+		SSLHost:       config.TLSHost(),
 	}
 }
 
@@ -267,10 +267,10 @@ func uiCorsHandler(config store.Config) gin.HandlerFunc {
 		AllowCredentials: true,
 		MaxAge:           math.MaxInt32,
 	}
-	if config.AllowOrigins == "*" {
+	if config.AllowOrigins() == "*" {
 		c.AllowAllOrigins = true
 	} else {
-		allowOrigins := strings.Split(config.AllowOrigins, ",")
+		allowOrigins := strings.Split(config.AllowOrigins(), ",")
 		if len(allowOrigins) > 0 {
 			c.AllowOrigins = allowOrigins
 		}
diff --git a/web/service_agreements_controller.go b/web/service_agreements_controller.go
index a88ababd088..55bfb6d40a4 100644
--- a/web/service_agreements_controller.go
+++ b/web/service_agreements_controller.go
@@ -20,7 +20,7 @@ type ServiceAgreementsController struct {
 
 // Create builds and saves a new service agreement record.
 func (sac *ServiceAgreementsController) Create(c *gin.Context) {
-	if !sac.App.GetStore().Config.Dev {
+	if !sac.App.GetStore().Config.Dev() {
 		publicError(c, 500, errors.New("Service Agreements are currently under development and not yet usable outside of development mode"))
 		return
 	}
diff --git a/web/sessions_controller.go b/web/sessions_controller.go
index b1c93d4de4e..14828516c0a 100644
--- a/web/sessions_controller.go
+++ b/web/sessions_controller.go
@@ -2,6 +2,7 @@ package web
 
 import (
 	"errors"
+	"fmt"
 	"net/http"
 
 	"github.com/gin-gonic/contrib/sessions"
@@ -24,10 +25,11 @@ func (sc *SessionsController) Create(c *gin.Context) {
 	session := sessions.Default(c)
 	var sr models.SessionRequest
 	if err := c.ShouldBindJSON(&sr); err != nil {
-		publicError(c, 400, err)
+		publicError(c, 400, fmt.Errorf("error binding json %v", err))
 	} else if sid, err := sc.App.GetStore().CreateSession(sr); err != nil {
 		publicError(c, http.StatusUnauthorized, err)
 	} else if err := saveSessionID(session, sid); err != nil {
+		fmt.Println("here")
 		c.AbortWithError(500, multierr.Append(errors.New("Unable to save session id"), err))
 	} else {
 		c.JSON(http.StatusOK, gin.H{"authenticated": true})
diff --git a/web/sessions_controller_test.go b/web/sessions_controller_test.go
index 0ffb447b3e0..9c2d7522179 100644
--- a/web/sessions_controller_test.go
+++ b/web/sessions_controller_test.go
@@ -41,7 +41,7 @@ func TestSessionsController_Create(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			body := fmt.Sprintf(`{"email":"%s","password":"%s"}`, test.email, test.password)
-			request, err := http.NewRequest("POST", config.ClientNodeURL+"/sessions", bytes.NewBufferString(body))
+			request, err := http.NewRequest("POST", config.ClientNodeURL()+"/sessions", bytes.NewBufferString(body))
 			assert.NoError(t, err)
 			resp, err := client.Do(request)
 			assert.NoError(t, err)
@@ -86,7 +86,7 @@ func TestSessionsController_Create_ReapSessions(t *testing.T) {
 	require.NoError(t, app.Store.Save(&staleSession))
 
 	body := fmt.Sprintf(`{"email":"%s","password":"%s"}`, "email@test.net", "password123")
-	resp, err := http.Post(app.Config.ClientNodeURL+"/sessions", "application/json", bytes.NewBufferString(body))
+	resp, err := http.Post(app.Config.ClientNodeURL()+"/sessions", "application/json", bytes.NewBufferString(body))
 	assert.NoError(t, err)
 	defer resp.Body.Close()
 
@@ -124,7 +124,7 @@ func TestSessionsController_Destroy(t *testing.T) {
 	for _, test := range tests {
 		t.Run(test.name, func(t *testing.T) {
 			cookie := cltest.MustGenerateSessionCookie(test.sessionID)
-			request, err := http.NewRequest("DELETE", config.ClientNodeURL+"/sessions", nil)
+			request, err := http.NewRequest("DELETE", config.ClientNodeURL()+"/sessions", nil)
 			assert.NoError(t, err)
 			request.AddCookie(cookie)
 
@@ -162,7 +162,7 @@ func TestSessionsController_Destroy_ReapSessions(t *testing.T) {
 	staleSession.LastUsed = models.Time{time.Now().Add(-cltest.MustParseDuration("241h"))}
 	require.NoError(t, app.Store.Save(&staleSession))
 
-	request, err := http.NewRequest("DELETE", app.Config.ClientNodeURL+"/sessions", nil)
+	request, err := http.NewRequest("DELETE", app.Config.ClientNodeURL()+"/sessions", nil)
 	assert.NoError(t, err)
 	request.AddCookie(cookie)
 
diff --git a/web/withdrawals_controller_test.go b/web/withdrawals_controller_test.go
index 0dbe47dd571..a3e50a81a7b 100644
--- a/web/withdrawals_controller_test.go
+++ b/web/withdrawals_controller_test.go
@@ -26,7 +26,7 @@ func verifyLinkBalanceCheck(address common.Address, t *testing.T) func(interface
 func TestWithdrawalsController_CreateSuccess(t *testing.T) {
 	config, _ := cltest.NewConfig()
 	oca := common.HexToAddress("0xDEADB3333333F")
-	config.OracleContractAddress = &oca
+	config.Set("OracleContractAddress", &oca)
 	app, cleanup := cltest.NewApplicationWithConfigAndKeyStore(config)
 	defer cleanup()
 	hash := cltest.NewHash()
@@ -69,7 +69,7 @@ func TestWithdrawalsController_CreateSuccess(t *testing.T) {
 func TestWithdrawalsController_BalanceTooLow(t *testing.T) {
 	config, _ := cltest.NewConfigWithPrivateKey()
 	oca := common.HexToAddress("0xDEADB3333333F")
-	config.OracleContractAddress = &oca
+	config.Set("OracleContractAddress", &oca)
 	app, cleanup := cltest.NewApplicationWithConfigAndKeyStore(config)
 	defer cleanup()
 	client := app.NewHTTPClient()

From cb2ce4488b0a841715e8e2de14e58b537561bb31 Mon Sep 17 00:00:00 2001
From: John Barker <jebarker@gmail.com>
Date: Fri, 21 Dec 2018 15:56:54 -0500
Subject: [PATCH 2/7] Revert back to non pointers in various places for config

---
 adapters/adapter.go                    |   8 +-
 adapters/adapter_test.go               |   2 +-
 adapters/bridge.go                     |  13 ++-
 internal/cltest/cltest.go              |   8 +-
 services/runs_test.go                  |   4 +-
 store/config.go                        | 108 ++++++++++++++-----------
 store/config_test.go                   |  10 +--
 store/forms/update_bridge_type.go      |   2 +-
 store/forms/update_bridge_type_test.go |   2 +-
 store/models/job_spec.go               |  12 +--
 store/presenters/presenters.go         |   5 ++
 store/presenters/presenters_test.go    |   2 +-
 web/config_controller_test.go          |   2 +-
 web/sessions_controller.go             |   1 -
 14 files changed, 103 insertions(+), 76 deletions(-)

diff --git a/adapters/adapter.go b/adapters/adapter.go
index 1616af30537..b7ab62d2b20 100644
--- a/adapters/adapter.go
+++ b/adapters/adapter.go
@@ -50,7 +50,7 @@ type BaseAdapter interface {
 type PipelineAdapter struct {
 	BaseAdapter
 	minConfs           uint64
-	minContractPayment *assets.Link
+	minContractPayment assets.Link
 }
 
 // MinConfs returns the private attribute
@@ -60,7 +60,7 @@ func (p PipelineAdapter) MinConfs() uint64 {
 
 // MinContractPayment returns the private attribute
 func (p PipelineAdapter) MinContractPayment() *assets.Link {
-	return p.minContractPayment
+	return &p.minContractPayment
 }
 
 // For determines the adapter type to use for a given task.
@@ -68,7 +68,7 @@ func For(task models.TaskSpec, store *store.Store) (*PipelineAdapter, error) {
 	var ba BaseAdapter
 	var err error
 	mic := store.Config.MinIncomingConfirmations()
-	mcp := assets.NewLink(0)
+	mcp := *assets.NewLink(0)
 
 	switch task.Type {
 	case TaskTypeCopy:
@@ -88,7 +88,7 @@ func For(task models.TaskSpec, store *store.Store) (*PipelineAdapter, error) {
 		err = unmarshalParams(task.Params, ba)
 	case TaskTypeEthTx:
 		ba = &EthTx{}
-		mcp = store.Config.MinimumContractPayment()
+		mcp = *store.Config.MinimumContractPayment()
 		err = unmarshalParams(task.Params, ba)
 	case TaskTypeHTTPGet:
 		ba = &HTTPGet{}
diff --git a/adapters/adapter_test.go b/adapters/adapter_test.go
index 48ac54a5fec..607b0bc5f50 100644
--- a/adapters/adapter_test.go
+++ b/adapters/adapter_test.go
@@ -28,7 +28,7 @@ func TestAdapterFor(t *testing.T) {
 	defer cleanup()
 
 	bt := cltest.NewBridgeType("rideShare", "https://dUber.eth")
-	bt.MinimumContractPayment = assets.NewLink(10)
+	bt.MinimumContractPayment = *assets.NewLink(10)
 	assert.Nil(t, store.Save(&bt))
 
 	cases := []struct {
diff --git a/adapters/bridge.go b/adapters/bridge.go
index 284e1baf758..12cb85e7a7c 100644
--- a/adapters/bridge.go
+++ b/adapters/bridge.go
@@ -49,7 +49,7 @@ func (ba *Bridge) handleNewRun(input models.RunResult, bridgeResponseURL *url.UR
 	}
 
 	responseURL := bridgeResponseURL
-	if *responseURL != (url.URL{}) {
+	if *responseURL != *zeroURL {
 		responseURL.Path += fmt.Sprintf("/v2/runs/%s", input.JobRunID)
 	}
 	body, err := ba.postToExternalAdapter(input, responseURL)
@@ -76,10 +76,9 @@ func responseToRunResult(body []byte, input models.RunResult) models.RunResult {
 }
 
 func (ba *Bridge) postToExternalAdapter(input models.RunResult, bridgeResponseURL *url.URL) ([]byte, error) {
-	responseURL := models.WebURL(*bridgeResponseURL)
 	in, err := json.Marshal(&bridgeOutgoing{
 		RunResult:   input,
-		ResponseURL: &responseURL,
+		ResponseURL: bridgeResponseURL,
 	})
 	if err != nil {
 		return nil, fmt.Errorf("marshaling request body: %v", err)
@@ -114,7 +113,7 @@ func baRunResultError(in models.RunResult, str string, err error) models.RunResu
 
 type bridgeOutgoing struct {
 	models.RunResult
-	ResponseURL *models.WebURL
+	ResponseURL *url.URL
 }
 
 func (bp bridgeOutgoing) MarshalJSON() ([]byte, error) {
@@ -129,3 +128,9 @@ func (bp bridgeOutgoing) MarshalJSON() ([]byte, error) {
 	}
 	return json.Marshal(anon)
 }
+
+var zeroURL *url.URL
+
+func init() {
+	zeroURL = new(url.URL)
+}
diff --git a/internal/cltest/cltest.go b/internal/cltest/cltest.go
index 9f193bd250e..25927c620dc 100644
--- a/internal/cltest/cltest.go
+++ b/internal/cltest/cltest.go
@@ -95,17 +95,17 @@ func NewConfigWithWSServer(wsserver *httptest.Server) *TestConfig {
 	count := atomic.AddUint64(&storeCounter, 1)
 	rootdir := path.Join(RootDir, fmt.Sprintf("%d-%d", time.Now().UnixNano(), count))
 	rawConfig := store.NewConfig()
-	rawConfig.Set("BridgeResponseURL", WebURL("http://localhost:6688"))
+	rawConfig.Set("BridgeResponseURL", "http://localhost:6688")
 	rawConfig.Set("ChainID", 3)
 	rawConfig.Set("Dev", true)
 	rawConfig.Set("EthGasBumpThreshold", 3)
 	rawConfig.Set("LogLevel", store.LogLevel{Level: zapcore.DebugLevel})
-	rawConfig.Set("MinimumServiceDuration", MustParseDuration("24h"))
+	rawConfig.Set("MinimumServiceDuration", "24h")
 	rawConfig.Set("MinOutgoingConfirmations", 6)
 	rawConfig.Set("MinimumContractPayment", *minimumContractPayment)
 	rawConfig.Set("RootDir", rootdir)
-	rawConfig.Set("SecretGenerator", mockSecretGenerator{})
-	rawConfig.Set("SessionTimeout", MustParseDuration("2m"))
+	rawConfig.Set("SessionTimeout", "2m")
+	rawConfig.SecretGenerator = mockSecretGenerator{}
 	config := TestConfig{Config: rawConfig}
 	config.SetEthereumServer(wsserver)
 	return &config
diff --git a/services/runs_test.go b/services/runs_test.go
index 4c7fd8e94a4..1b2f001e8fb 100644
--- a/services/runs_test.go
+++ b/services/runs_test.go
@@ -25,7 +25,7 @@ func TestNewRun(t *testing.T) {
 	input := models.JSON{Result: gjson.Parse(`{"address":"0xdfcfc2b9200dbb10952c2b7cce60fc7260e03c6f"}`)}
 
 	bt := cltest.NewBridgeType("timecube", "http://http://timecube.2enp.com/")
-	bt.MinimumContractPayment = assets.NewLink(10)
+	bt.MinimumContractPayment = *assets.NewLink(10)
 	assert.Nil(t, store.Save(&bt))
 
 	creationHeight := cltest.BigHexInt(1000)
@@ -53,7 +53,7 @@ func TestNewRun_requiredPayment(t *testing.T) {
 	input := models.JSON{Result: gjson.Parse(`{"address":"0xdfcfc2b9200dbb10952c2b7cce60fc7260e03c6f"}`)}
 
 	bt := cltest.NewBridgeType("timecube", "http://http://timecube.2enp.com/")
-	bt.MinimumContractPayment = assets.NewLink(10)
+	bt.MinimumContractPayment = *assets.NewLink(10)
 	assert.Nil(t, store.Save(&bt))
 
 	tests := []struct {
diff --git a/store/config.go b/store/config.go
index 21fc4449261..6ac6715012d 100644
--- a/store/config.go
+++ b/store/config.go
@@ -13,6 +13,7 @@ import (
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
+	"github.com/fsnotify/fsnotify"
 	"github.com/gin-gonic/contrib/sessions"
 	"github.com/gin-gonic/gin"
 	"github.com/gorilla/securecookie"
@@ -36,35 +37,35 @@ type Config struct {
 
 // configSchema records the schema of configuration at the type level
 type configSchema struct {
-	AllowOrigins             string          `env:"ALLOW_ORIGINS" default:"http://localhost:3000,http://localhost:6688" visible:"true"`
-	BridgeResponseURL        *url.URL        `env:"BRIDGE_RESPONSE_URL" visible:"true"`
-	ChainID                  uint64          `env:"ETH_CHAIN_ID" default:"0" visible:"true"`
-	ClientNodeURL            string          `env:"CLIENT_NODE_URL" default:"http://localhost:6688" visible:"true"`
-	DatabaseTimeout          time.Duration   `env:"DATABASE_TIMEOUT" default:"500ms" visible:"true"`
-	Dev                      bool            `env:"CHAINLINK_DEV" default:"false" visible:"true"`
-	MaximumServiceDuration   time.Duration   `env:"MAXIMUM_SERVICE_DURATION" default:"8760h" `
-	MinimumServiceDuration   time.Duration   `env:"MINIMUM_SERVICE_DURATION" default:"0s" `
-	EthGasBumpThreshold      uint64          `env:"ETH_GAS_BUMP_THRESHOLD" default:"12" `
-	EthGasBumpWei            *big.Int        `env:"ETH_GAS_BUMP_WEI" default:"5000000000" visible:"true"`
-	EthGasPriceDefault       *big.Int        `env:"ETH_GAS_PRICE_DEFAULT" default:"20000000000" visible:"true"`
-	EthereumURL              string          `env:"ETH_URL" default:"ws://localhost:8546" visible:"true"`
-	JSONConsole              bool            `env:"JSON_CONSOLE" default:"false" visible:"true"`
-	LinkContractAddress      string          `env:"LINK_CONTRACT_ADDRESS" default:"0x514910771AF9Ca656af840dff83E8264EcF986CA" visible:"true"`
-	LogLevel                 LogLevel        `env:"LOG_LEVEL" default:"info" visible:"true"`
-	LogToDisk                bool            `env:"LOG_TO_DISK" default:"true" visible:"true"`
-	MinIncomingConfirmations uint64          `env:"MIN_INCOMING_CONFIRMATIONS" default:"0" visible:"true"`
-	MinOutgoingConfirmations uint64          `env:"MIN_OUTGOING_CONFIRMATIONS" default:"12" visible:"true"`
-	MinimumContractPayment   *assets.Link    `env:"MINIMUM_CONTRACT_PAYMENT" default:"1000000000000000000" visible:"true"`
-	MinimumRequestExpiration uint64          `env:"MINIMUM_REQUEST_EXPIRATION" default:"300" `
-	OracleContractAddress    *common.Address `env:"ORACLE_CONTRACT_ADDRESS" visible:"true"`
-	Port                     uint16          `env:"CHAINLINK_PORT" default:"6688" visible:"true"`
-	ReaperExpiration         time.Duration   `env:"REAPER_EXPIRATION" default:"240h" visible:"true"`
-	RootDir                  string          `env:"ROOT" default:"~/.chainlink" visible:"true"`
-	SessionTimeout           time.Duration   `env:"SESSION_TIMEOUT" default:"15m" visible:"true"`
-	TLSCertPath              string          `env:"TLS_CERT_PATH" `
-	TLSHost                  string          `env:"CHAINLINK_TLS_HOST" `
-	TLSKeyPath               string          `env:"TLS_KEY_PATH" `
-	TLSPort                  uint16          `env:"CHAINLINK_TLS_PORT" default:"6689" visible:"true"`
+	AllowOrigins             string         `env:"ALLOW_ORIGINS" default:"http://localhost:3000,http://localhost:6688" visible:"true"`
+	BridgeResponseURL        url.URL        `env:"BRIDGE_RESPONSE_URL" visible:"true"`
+	ChainID                  uint64         `env:"ETH_CHAIN_ID" default:"0" visible:"true"`
+	ClientNodeURL            string         `env:"CLIENT_NODE_URL" default:"http://localhost:6688" visible:"true"`
+	DatabaseTimeout          time.Duration  `env:"DATABASE_TIMEOUT" default:"500ms" visible:"true"`
+	Dev                      bool           `env:"CHAINLINK_DEV" default:"false" visible:"true"`
+	MaximumServiceDuration   time.Duration  `env:"MAXIMUM_SERVICE_DURATION" default:"8760h" `
+	MinimumServiceDuration   time.Duration  `env:"MINIMUM_SERVICE_DURATION" default:"0s" `
+	EthGasBumpThreshold      uint64         `env:"ETH_GAS_BUMP_THRESHOLD" default:"12" `
+	EthGasBumpWei            big.Int        `env:"ETH_GAS_BUMP_WEI" default:"5000000000" visible:"true"`
+	EthGasPriceDefault       big.Int        `env:"ETH_GAS_PRICE_DEFAULT" default:"20000000000" visible:"true"`
+	EthereumURL              string         `env:"ETH_URL" default:"ws://localhost:8546" visible:"true"`
+	JSONConsole              bool           `env:"JSON_CONSOLE" default:"false" visible:"true"`
+	LinkContractAddress      string         `env:"LINK_CONTRACT_ADDRESS" default:"0x514910771AF9Ca656af840dff83E8264EcF986CA" visible:"true"`
+	LogLevel                 LogLevel       `env:"LOG_LEVEL" default:"info" visible:"true"`
+	LogToDisk                bool           `env:"LOG_TO_DISK" default:"true" visible:"true"`
+	MinIncomingConfirmations uint64         `env:"MIN_INCOMING_CONFIRMATIONS" default:"0" visible:"true"`
+	MinOutgoingConfirmations uint64         `env:"MIN_OUTGOING_CONFIRMATIONS" default:"12" visible:"true"`
+	MinimumContractPayment   assets.Link    `env:"MINIMUM_CONTRACT_PAYMENT" default:"1000000000000000000" visible:"true"`
+	MinimumRequestExpiration uint64         `env:"MINIMUM_REQUEST_EXPIRATION" default:"300" `
+	OracleContractAddress    common.Address `env:"ORACLE_CONTRACT_ADDRESS" visible:"true"`
+	Port                     uint16         `env:"CHAINLINK_PORT" default:"6688" visible:"true"`
+	ReaperExpiration         time.Duration  `env:"REAPER_EXPIRATION" default:"240h" visible:"true"`
+	RootDir                  string         `env:"ROOT" default:"~/.chainlink" visible:"true"`
+	SessionTimeout           time.Duration  `env:"SESSION_TIMEOUT" default:"15m" visible:"true"`
+	TLSCertPath              string         `env:"TLS_CERT_PATH" `
+	TLSHost                  string         `env:"CHAINLINK_TLS_HOST" `
+	TLSKeyPath               string         `env:"TLS_KEY_PATH" `
+	TLSPort                  uint16         `env:"CHAINLINK_TLS_PORT" default:"6689" visible:"true"`
 }
 
 // NewConfig returns the config with the environment variables set to their
@@ -104,6 +105,10 @@ func NewConfig() Config {
 
 // Set a specific configuration variable
 func (c Config) Set(name string, value interface{}) {
+	schemaT := reflect.TypeOf(configSchema{})
+	if _, ok := schemaT.FieldByName(name); !ok {
+		logger.Panicf("No configuration parameter for %s", name)
+	}
 	c.viper.Set(name, value)
 }
 
@@ -331,30 +336,46 @@ func (c Config) SessionOptions() sessions.Options {
 	}
 }
 
-func (c Config) defaultValue(name string) string {
+func (c Config) defaultValue(name string) (string, bool) {
 	schemaT := reflect.TypeOf(configSchema{})
 	if item, ok := schemaT.FieldByName(name); ok {
-		return item.Tag.Get("default")
+		return item.Tag.Lookup("default")
 	}
-	log.Panicf("Invariant violated, no field of name %s found", name)
-	return ""
+	log.Panicf("Invariant violated, no field of name %s found for defaultValue", name)
+	return "", false
+}
+
+func (c Config) zeroValue(name string) interface{} {
+	schemaT := reflect.TypeOf(configSchema{})
+	if item, ok := schemaT.FieldByName(name); ok {
+		return reflect.New(item.Type).Interface()
+	}
+	log.Panicf("Invariant violated, no field of name %s found for zeroValue", name)
+	return nil
 }
 
 func (c Config) getWithFallback(name string, parser func(string) (interface{}, error)) interface{} {
 	str := c.viper.GetString(name)
-	var err error
-	v, err := parser(str)
-	if err != nil {
-		defaultValue := c.defaultValue(name)
+	defaultValue, hasDefault := c.defaultValue(name)
+	if str != "" {
+		v, err := parser(str)
+		if err == nil {
+			return v
+		}
 		logger.Errorw(
 			fmt.Sprintf("Invalid value provided for %s, falling back to default.", name),
 			"value", str,
 			"default", defaultValue,
 			"error", err)
-		v, err = parser(defaultValue)
-		if err != nil {
-			log.Fatalf(fmt.Sprintf(`Invalid default for %s: "%s"`, name, defaultValue))
-		}
+	}
+
+	if !hasDefault {
+		return c.zeroValue(name)
+	}
+
+	v, err := parser(defaultValue)
+	if err != nil {
+		log.Fatalf(fmt.Sprintf(`Invalid default for %s: "%s"`, name, defaultValue))
 	}
 	return v
 }
@@ -414,10 +435,7 @@ func parsePort(str string) (interface{}, error) {
 }
 
 func parseURL(s string) (interface{}, error) {
-	if s == "" {
-		return new(url.URL), nil
-	}
-	return url.ParseRequestURI(s)
+	return url.Parse(s)
 }
 
 func parseBigInt(str string) (interface{}, error) {
diff --git a/store/config_test.go b/store/config_test.go
index 0795c5b5616..dcb1d4c535a 100644
--- a/store/config_test.go
+++ b/store/config_test.go
@@ -3,6 +3,7 @@ package store
 import (
 	"fmt"
 	"math/big"
+	"net/url"
 	"os"
 	"path"
 	"testing"
@@ -10,7 +11,6 @@ import (
 
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/smartcontractkit/chainlink/store/assets"
-	"github.com/smartcontractkit/chainlink/store/models"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/zap/zapcore"
@@ -24,7 +24,7 @@ func TestStore_ConfigDefaults(t *testing.T) {
 	assert.Equal(t, "0x514910771AF9Ca656af840dff83E8264EcF986CA", common.HexToAddress(config.LinkContractAddress()).String())
 	assert.Equal(t, assets.NewLink(1000000000000000000), config.MinimumContractPayment())
 	assert.Equal(t, 15*time.Minute, config.SessionTimeout())
-	assert.Equal(t, "", config.BridgeResponseURL().String())
+	assert.Equal(t, new(url.URL), config.BridgeResponseURL())
 }
 
 func TestConfig_sessionSecret(t *testing.T) {
@@ -133,8 +133,8 @@ func TestStore_urlParser(t *testing.T) {
 		wantError bool
 	}{
 		{"valid URL", "http://localhost:3000", false},
-		{"invalid URL", "htp", true},
-		{"empty URL", "", true},
+		{"invalid URL", ":", true},
+		{"empty URL", "", false},
 	}
 
 	for _, test := range tests {
@@ -145,7 +145,7 @@ func TestStore_urlParser(t *testing.T) {
 				assert.Error(t, err)
 			} else {
 				require.NoError(t, err)
-				w, ok := i.(models.WebURL)
+				w, ok := i.(*url.URL)
 				require.True(t, ok)
 				assert.Equal(t, test.input, w.String())
 			}
diff --git a/store/forms/update_bridge_type.go b/store/forms/update_bridge_type.go
index dfd8c9edd5c..37622377a05 100644
--- a/store/forms/update_bridge_type.go
+++ b/store/forms/update_bridge_type.go
@@ -32,7 +32,7 @@ type UpdateBridgeType struct {
 	bridgeName             string
 	URL                    models.WebURL `json:"url"`
 	Confirmations          uint64        `json:"confirmations"`
-	MinimumContractPayment *assets.Link  `json:"minimumContractPayment"`
+	MinimumContractPayment assets.Link   `json:"minimumContractPayment"`
 }
 
 // Save updates the whitelisted attributes on the bridge
diff --git a/store/forms/update_bridge_type_test.go b/store/forms/update_bridge_type_test.go
index f5dea55632f..2a570afee43 100644
--- a/store/forms/update_bridge_type_test.go
+++ b/store/forms/update_bridge_type_test.go
@@ -46,7 +46,7 @@ func TestFormsUpdateBridgeType_Save(t *testing.T) {
 
 	form.URL = cltest.WebURL("http://updatedbridge")
 	form.Confirmations = uint64(10)
-	form.Set("MinimumContractPayment", assets.NewLink(100))
+	form.MinimumContractPayment = *assets.NewLink(100)
 	assert.NoError(t, form.Save())
 
 	ubt, err = s.FindBridge("bridgea")
diff --git a/store/models/job_spec.go b/store/models/job_spec.go
index cbd6023ffc9..93cc98ca1e3 100644
--- a/store/models/job_spec.go
+++ b/store/models/job_spec.go
@@ -257,12 +257,12 @@ func (t TaskType) String() string {
 // BridgeType is used for external adapters and has fields for
 // the name of the adapter and its URL.
 type BridgeType struct {
-	Name                   TaskType     `json:"name" storm:"id,unique"`
-	URL                    WebURL       `json:"url"`
-	Confirmations          uint64       `json:"confirmations"`
-	IncomingToken          string       `json:"incomingToken"`
-	OutgoingToken          string       `json:"outgoingToken"`
-	MinimumContractPayment *assets.Link `json:"minimumContractPayment"`
+	Name                   TaskType    `json:"name" storm:"id,unique"`
+	URL                    WebURL      `json:"url"`
+	Confirmations          uint64      `json:"confirmations"`
+	IncomingToken          string      `json:"incomingToken"`
+	OutgoingToken          string      `json:"outgoingToken"`
+	MinimumContractPayment assets.Link `json:"minimumContractPayment"`
 }
 
 // GetID returns the ID of this structure for jsonapi serialization.
diff --git a/store/presenters/presenters.go b/store/presenters/presenters.go
index 8adee14b0c8..d27592ae9df 100644
--- a/store/presenters/presenters.go
+++ b/store/presenters/presenters.go
@@ -244,6 +244,11 @@ func (c ConfigWhitelist) GetID() string {
 	return utils.NewBytes32ID()
 }
 
+// MarshalJSON returns the JSON data of the user viewable configuration parameters.
+func (c ConfigWhitelist) MarshalJSON() ([]byte, error) {
+	return json.Marshal(c.values)
+}
+
 // SetID is used to conform to the UnmarshallIdentifier interface for
 // deserializing from jsonapi documents.
 func (c *ConfigWhitelist) SetID(value string) error {
diff --git a/store/presenters/presenters_test.go b/store/presenters/presenters_test.go
index c6a57aed024..b8116227bf8 100644
--- a/store/presenters/presenters_test.go
+++ b/store/presenters/presenters_test.go
@@ -158,7 +158,7 @@ func TestBridgeType_MarshalJSON(t *testing.T) {
 		Confirmations:          0,
 		IncomingToken:          "123",
 		OutgoingToken:          "abc",
-		MinimumContractPayment: assets.NewLink(0),
+		MinimumContractPayment: *assets.NewLink(0),
 	}
 	bt := presenters.BridgeType{BridgeType: input}
 	output, err := bt.MarshalJSON()
diff --git a/web/config_controller_test.go b/web/config_controller_test.go
index 6cdf53ad62e..b852d904fcc 100644
--- a/web/config_controller_test.go
+++ b/web/config_controller_test.go
@@ -21,7 +21,7 @@ func TestConfigController_Show(t *testing.T) {
 	defer cleanup()
 	cltest.AssertServerResponse(t, resp, 200)
 
-	cfg := make(map[string]string)
+	cfg := make(map[string]interface{})
 	require.NoError(t, cltest.ParseJSONAPIResponse(resp, &cfg))
 
 	assert.Equal(t, store.LogLevel{Level: -1}, cfg["logLevel"])
diff --git a/web/sessions_controller.go b/web/sessions_controller.go
index 14828516c0a..4830e086ca9 100644
--- a/web/sessions_controller.go
+++ b/web/sessions_controller.go
@@ -29,7 +29,6 @@ func (sc *SessionsController) Create(c *gin.Context) {
 	} else if sid, err := sc.App.GetStore().CreateSession(sr); err != nil {
 		publicError(c, http.StatusUnauthorized, err)
 	} else if err := saveSessionID(session, sid); err != nil {
-		fmt.Println("here")
 		c.AbortWithError(500, multierr.Append(errors.New("Unable to save session id"), err))
 	} else {
 		c.JSON(http.StatusOK, gin.H{"authenticated": true})

From ac0e2572e372bcf0b0cabc9d030eb8316040e1b8 Mon Sep 17 00:00:00 2001
From: John Barker <jebarker@gmail.com>
Date: Fri, 21 Dec 2018 20:02:34 -0500
Subject: [PATCH 3/7] Fold in homedir, rebase whitelist

---
 internal/cltest/cltest.go           |  2 +-
 store/config.go                     | 50 +++++++++------------
 store/presenters/presenters.go      | 69 ++++++++++++++---------------
 store/presenters/presenters_test.go |  2 +-
 web/config_controller_test.go       | 28 ++++++++++--
 5 files changed, 83 insertions(+), 68 deletions(-)

diff --git a/internal/cltest/cltest.go b/internal/cltest/cltest.go
index 25927c620dc..4fc7b642123 100644
--- a/internal/cltest/cltest.go
+++ b/internal/cltest/cltest.go
@@ -102,7 +102,7 @@ func NewConfigWithWSServer(wsserver *httptest.Server) *TestConfig {
 	rawConfig.Set("LogLevel", store.LogLevel{Level: zapcore.DebugLevel})
 	rawConfig.Set("MinimumServiceDuration", "24h")
 	rawConfig.Set("MinOutgoingConfirmations", 6)
-	rawConfig.Set("MinimumContractPayment", *minimumContractPayment)
+	rawConfig.Set("MinimumContractPayment", minimumContractPayment.Text(10))
 	rawConfig.Set("RootDir", rootdir)
 	rawConfig.Set("SessionTimeout", "2m")
 	rawConfig.SecretGenerator = mockSecretGenerator{}
diff --git a/store/config.go b/store/config.go
index 6ac6715012d..d1541e7d803 100644
--- a/store/config.go
+++ b/store/config.go
@@ -7,16 +7,17 @@ import (
 	"log"
 	"math/big"
 	"net/url"
+	"os"
 	"path"
 	"reflect"
 	"strconv"
 	"time"
 
 	"github.com/ethereum/go-ethereum/common"
-	"github.com/fsnotify/fsnotify"
 	"github.com/gin-gonic/contrib/sessions"
 	"github.com/gin-gonic/gin"
 	"github.com/gorilla/securecookie"
+	homedir "github.com/mitchellh/go-homedir"
 	"github.com/smartcontractkit/chainlink/logger"
 	"github.com/smartcontractkit/chainlink/store/assets"
 	"github.com/smartcontractkit/chainlink/utils"
@@ -35,8 +36,8 @@ type Config struct {
 	SecretGenerator SecretGenerator
 }
 
-// configSchema records the schema of configuration at the type level
-type configSchema struct {
+// ConfigSchema records the schema of configuration at the type level
+type ConfigSchema struct {
 	AllowOrigins             string         `env:"ALLOW_ORIGINS" default:"http://localhost:3000,http://localhost:6688" visible:"true"`
 	BridgeResponseURL        url.URL        `env:"BRIDGE_RESPONSE_URL" visible:"true"`
 	ChainID                  uint64         `env:"ETH_CHAIN_ID" default:"0" visible:"true"`
@@ -73,39 +74,28 @@ type configSchema struct {
 func NewConfig() Config {
 	v := viper.New()
 
-	schemaT := reflect.TypeOf(configSchema{})
+	schemaT := reflect.TypeOf(ConfigSchema{})
 	for index := 0; index < schemaT.NumField(); index++ {
 		item := schemaT.FieldByIndex([]int{index})
 		v.SetDefault(item.Name, item.Tag.Get("default"))
 		v.BindEnv(item.Name, item.Tag.Get("env"))
 	}
-	dir, err := homedir.Expand(config.RootDir)
-	if err != nil {
-		log.Fatal(fmt.Errorf(`error expanding $HOME in "%s": %+v`, config.RootDir, err))
-	}
-	if err = os.MkdirAll(dir, os.FileMode(0700)); err != nil {
-		log.Fatal(fmt.Errorf(`error creating "%s": %+v`, dir, err))
-
-	//if err := parseEnv(&config); err != nil {
-	//	log.Fatal(fmt.Errorf("error parsing environment: %+v", err))
-	//}
-	//dir, err := homedir.Expand(config.RootDir())
-	//if err != nil {
-	//		log.Fatal(fmt.Errorf("error expanding $HOME: %+v", err))
-	//	}
-	//	if err = os.MkdirAll(dir, os.FileMode(0700)); err != nil {
-	//		log.Fatal(fmt.Errorf("error creating %s: %+v", dir, err))
-	//	}
-	// config.RootDir = dir
-	return Config{
+
+	config := Config{
 		viper:           v,
 		SecretGenerator: filePersistedSecretGenerator{},
 	}
+
+	if err := os.MkdirAll(config.RootDir(), os.FileMode(0700)); err != nil {
+		log.Fatal(fmt.Errorf(`error creating "%s": %+v`, config.RootDir(), err))
+	}
+
+	return config
 }
 
 // Set a specific configuration variable
 func (c Config) Set(name string, value interface{}) {
-	schemaT := reflect.TypeOf(configSchema{})
+	schemaT := reflect.TypeOf(ConfigSchema{})
 	if _, ok := schemaT.FieldByName(name); !ok {
 		logger.Panicf("No configuration parameter for %s", name)
 	}
@@ -116,7 +106,7 @@ func (c Config) Set(name string, value interface{}) {
 // the visible:"true" tag.
 func (c Config) GetVisibleValues() map[string]string {
 	values := make(map[string]string)
-	schemaT := reflect.TypeOf(configSchema{})
+	schemaT := reflect.TypeOf(ConfigSchema{})
 	for index := 0; index < schemaT.NumField(); index++ {
 		item := schemaT.FieldByIndex([]int{index})
 		if item.Tag.Get("visible") == "true" {
@@ -256,7 +246,7 @@ func (c Config) ReaperExpiration() time.Duration {
 // RootDir represents the location on the file system where Chainlink should
 // keep its files.
 func (c Config) RootDir() string {
-	return c.viper.GetString("RootDir")
+	return c.getWithFallback("RootDir", parseHomeDir).(string)
 }
 
 // SessionTimeout FIXME:
@@ -337,7 +327,7 @@ func (c Config) SessionOptions() sessions.Options {
 }
 
 func (c Config) defaultValue(name string) (string, bool) {
-	schemaT := reflect.TypeOf(configSchema{})
+	schemaT := reflect.TypeOf(ConfigSchema{})
 	if item, ok := schemaT.FieldByName(name); ok {
 		return item.Tag.Lookup("default")
 	}
@@ -346,7 +336,7 @@ func (c Config) defaultValue(name string) (string, bool) {
 }
 
 func (c Config) zeroValue(name string) interface{} {
-	schemaT := reflect.TypeOf(configSchema{})
+	schemaT := reflect.TypeOf(ConfigSchema{})
 	if item, ok := schemaT.FieldByName(name); ok {
 		return reflect.New(item.Type).Interface()
 	}
@@ -446,6 +436,10 @@ func parseBigInt(str string) (interface{}, error) {
 	return i, nil
 }
 
+func parseHomeDir(str string) (interface{}, error) {
+	return homedir.Expand(str)
+}
+
 // LogLevel determines the verbosity of the events to be logged.
 type LogLevel struct {
 	zapcore.Level
diff --git a/store/presenters/presenters.go b/store/presenters/presenters.go
index d27592ae9df..d492ab664f6 100644
--- a/store/presenters/presenters.go
+++ b/store/presenters/presenters.go
@@ -9,8 +9,10 @@ import (
 	"errors"
 	"fmt"
 	"math/big"
+	"net/url"
 	"reflect"
 	"strings"
+	"time"
 
 	"github.com/ethereum/go-ethereum/accounts"
 	"github.com/ethereum/go-ethereum/common"
@@ -140,11 +142,11 @@ type ConfigWhitelist struct {
 
 type whitelist struct {
 	AllowOrigins             string          `json:"allowOrigins"`
-	BridgeResponseURL        models.WebURL   `json:"bridgeResponseURL,omitempty"`
+	BridgeResponseURL        *url.URL        `json:"bridgeResponseURL,omitempty"`
 	ChainID                  uint64          `json:"ethChainId"`
 	Dev                      bool            `json:"chainlinkDev"`
 	ClientNodeURL            string          `json:"clientNodeUrl"`
-	DatabaseTimeout          store.Duration  `json:"databaseTimeout"`
+	DatabaseTimeout          time.Duration   `json:"databaseTimeout"`
 	EthereumURL              string          `json:"ethUrl"`
 	EthGasBumpThreshold      uint64          `json:"ethGasBumpThreshold"`
 	EthGasBumpWei            *big.Int        `json:"ethGasBumpWei"`
@@ -159,9 +161,9 @@ type whitelist struct {
 	MinOutgoingConfirmations uint64          `json:"minOutgoingConfirmations"`
 	OracleContractAddress    *common.Address `json:"oracleContractAddress"`
 	Port                     uint16          `json:"chainlinkPort"`
-	ReaperExpiration         store.Duration  `json:"reaperExpiration"`
+	ReaperExpiration         time.Duration   `json:"reaperExpiration"`
 	RootDir                  string          `json:"root"`
-	SessionTimeout           store.Duration  `json:"sessionTimeout"`
+	SessionTimeout           time.Duration   `json:"sessionTimeout"`
 	TLSHost                  string          `json:"chainlinkTLSHost"`
 	TLSPort                  uint16          `json:"chainlinkTLSPort"`
 }
@@ -177,31 +179,31 @@ func NewConfigWhitelist(store *store.Store) (ConfigWhitelist, error) {
 	return ConfigWhitelist{
 		AccountAddress: account.Address.Hex(),
 		whitelist: whitelist{
-			AllowOrigins:             config.AllowOrigins,
-			BridgeResponseURL:        config.BridgeResponseURL,
-			ChainID:                  config.ChainID,
-			Dev:                      config.Dev,
-			ClientNodeURL:            config.ClientNodeURL,
-			DatabaseTimeout:          config.DatabaseTimeout,
-			EthereumURL:              config.EthereumURL,
-			EthGasBumpThreshold:      config.EthGasBumpThreshold,
-			EthGasBumpWei:            &config.EthGasBumpWei,
-			EthGasPriceDefault:       &config.EthGasPriceDefault,
-			JSONConsole:              config.JSONConsole,
-			LinkContractAddress:      config.LinkContractAddress,
-			LogLevel:                 config.LogLevel,
-			LogToDisk:                config.LogToDisk,
-			MinimumContractPayment:   &config.MinimumContractPayment,
-			MinimumRequestExpiration: config.MinimumRequestExpiration,
-			MinIncomingConfirmations: config.MinIncomingConfirmations,
-			MinOutgoingConfirmations: config.MinOutgoingConfirmations,
-			OracleContractAddress:    config.OracleContractAddress,
-			Port:                     config.Port,
-			ReaperExpiration:         config.ReaperExpiration,
-			RootDir:                  config.RootDir,
-			SessionTimeout:           config.SessionTimeout,
-			TLSHost:                  config.TLSHost,
-			TLSPort:                  config.TLSPort,
+			AllowOrigins:             config.AllowOrigins(),
+			BridgeResponseURL:        config.BridgeResponseURL(),
+			ChainID:                  config.ChainID(),
+			Dev:                      config.Dev(),
+			ClientNodeURL:            config.ClientNodeURL(),
+			DatabaseTimeout:          config.DatabaseTimeout(),
+			EthereumURL:              config.EthereumURL(),
+			EthGasBumpThreshold:      config.EthGasBumpThreshold(),
+			EthGasBumpWei:            config.EthGasBumpWei(),
+			EthGasPriceDefault:       config.EthGasPriceDefault(),
+			JSONConsole:              config.JSONConsole(),
+			LinkContractAddress:      config.LinkContractAddress(),
+			LogLevel:                 config.LogLevel(),
+			LogToDisk:                config.LogToDisk(),
+			MinimumContractPayment:   config.MinimumContractPayment(),
+			MinimumRequestExpiration: config.MinimumRequestExpiration(),
+			MinIncomingConfirmations: config.MinIncomingConfirmations(),
+			MinOutgoingConfirmations: config.MinOutgoingConfirmations(),
+			OracleContractAddress:    config.OracleContractAddress(),
+			Port:                     config.Port(),
+			ReaperExpiration:         config.ReaperExpiration(),
+			RootDir:                  config.RootDir(),
+			SessionTimeout:           config.SessionTimeout(),
+			TLSHost:                  config.TLSHost(),
+			TLSPort:                  config.TLSPort(),
 		},
 	}, nil
 }
@@ -210,7 +212,9 @@ func NewConfigWhitelist(store *store.Store) (ConfigWhitelist, error) {
 func (c ConfigWhitelist) String() string {
 	var buffer bytes.Buffer
 
-	schemaT := reflect.TypeOf(store.Config{})
+	buffer.WriteString(fmt.Sprintf("ACCOUNT_ADDRESS: %v\n", c.AccountAddress))
+
+	schemaT := reflect.TypeOf(store.ConfigSchema{})
 	cwlT := reflect.TypeOf(c.whitelist)
 	cwlV := reflect.ValueOf(c.whitelist)
 	for index := 0; index < cwlT.NumField(); index++ {
@@ -244,11 +248,6 @@ func (c ConfigWhitelist) GetID() string {
 	return utils.NewBytes32ID()
 }
 
-// MarshalJSON returns the JSON data of the user viewable configuration parameters.
-func (c ConfigWhitelist) MarshalJSON() ([]byte, error) {
-	return json.Marshal(c.values)
-}
-
 // SetID is used to conform to the UnmarshallIdentifier interface for
 // deserializing from jsonapi documents.
 func (c *ConfigWhitelist) SetID(value string) error {
diff --git a/store/presenters/presenters_test.go b/store/presenters/presenters_test.go
index b8116227bf8..cdd93542377 100644
--- a/store/presenters/presenters_test.go
+++ b/store/presenters/presenters_test.go
@@ -203,5 +203,5 @@ func TestPresenter_NewConfigWhitelist_Error(t *testing.T) {
 
 	cw, err := presenters.NewConfigWhitelist(store)
 	assert.Error(t, err)
-	assert.Equal(t, cw.String(), "")
+	assert.Equal(t, "", cw.AccountAddress)
 }
diff --git a/web/config_controller_test.go b/web/config_controller_test.go
index b852d904fcc..936632c7cd7 100644
--- a/web/config_controller_test.go
+++ b/web/config_controller_test.go
@@ -1,10 +1,15 @@
 package web_test
 
 import (
+	"math/big"
 	"testing"
+	"time"
 
+	"github.com/ethereum/go-ethereum/common"
 	"github.com/smartcontractkit/chainlink/internal/cltest"
 	"github.com/smartcontractkit/chainlink/store"
+	"github.com/smartcontractkit/chainlink/store/assets"
+	"github.com/smartcontractkit/chainlink/store/presenters"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -21,8 +26,25 @@ func TestConfigController_Show(t *testing.T) {
 	defer cleanup()
 	cltest.AssertServerResponse(t, resp, 200)
 
-	cfg := make(map[string]interface{})
-	require.NoError(t, cltest.ParseJSONAPIResponse(resp, &cfg))
+	cwl := presenters.ConfigWhitelist{}
+	require.NoError(t, cltest.ParseJSONAPIResponse(resp, &cwl))
 
-	assert.Equal(t, store.LogLevel{Level: -1}, cfg["logLevel"])
+	assert.Equal(t, store.LogLevel{Level: -1}, cwl.LogLevel)
+	assert.Contains(t, cwl.RootDir, "/tmp/chainlink_test/")
+	assert.Equal(t, uint16(6688), cwl.Port)
+	assert.Equal(t, uint16(6689), cwl.TLSPort)
+	assert.Equal(t, "", cwl.TLSHost)
+	assert.Contains(t, cwl.EthereumURL, "ws://127.0.0.1:")
+	assert.Equal(t, uint64(3), cwl.ChainID)
+	assert.Contains(t, cwl.ClientNodeURL, "http://127.0.0.1:")
+	assert.Equal(t, uint64(6), cwl.MinOutgoingConfirmations)
+	assert.Equal(t, uint64(0), cwl.MinIncomingConfirmations)
+	assert.Equal(t, uint64(3), cwl.EthGasBumpThreshold)
+	assert.Equal(t, uint64(300), cwl.MinimumRequestExpiration)
+	assert.Equal(t, big.NewInt(5000000000), cwl.EthGasBumpWei)
+	assert.Equal(t, big.NewInt(20000000000), cwl.EthGasPriceDefault)
+	assert.Equal(t, store.NewConfig().LinkContractAddress(), cwl.LinkContractAddress)
+	assert.Equal(t, assets.NewLink(100), cwl.MinimumContractPayment)
+	assert.Equal(t, (*common.Address)(nil), cwl.OracleContractAddress)
+	assert.Equal(t, time.Millisecond*500, cwl.DatabaseTimeout)
 }

From 789c31670bb0124e1172e7d4a6af233f8138a759 Mon Sep 17 00:00:00 2001
From: John Barker <jebarker@gmail.com>
Date: Thu, 27 Dec 2018 12:20:09 -0500
Subject: [PATCH 4/7] Describe ClientNodeURL, MinimumRequestExpiration,
 SessionTimeout

---
 store/config.go | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/store/config.go b/store/config.go
index d1541e7d803..16735460bd8 100644
--- a/store/config.go
+++ b/store/config.go
@@ -131,7 +131,7 @@ func (c Config) ChainID() uint64 {
 	return uint64(c.viper.GetInt64("ChainID"))
 }
 
-// ClientNodeURL is ... FIXME:
+// ClientNodeURL is the URL of the Ethereum node this Chainlink node should connect to.
 func (c Config) ClientNodeURL() string {
 	return c.viper.GetString("ClientNodeURL")
 }
@@ -228,7 +228,7 @@ func (c Config) MinimumContractPayment() *assets.Link {
 	return c.getWithFallback("MinimumContractPayment", parseLink).(*assets.Link)
 }
 
-// MinimumRequestExpiration FIXME:
+// MinimumRequestExpiration is the minimum allowed request expiration for a Service Agreement.
 func (c Config) MinimumRequestExpiration() uint64 {
 	return uint64(c.viper.GetInt64("MinimumRequestExpiration"))
 }
@@ -249,7 +249,7 @@ func (c Config) RootDir() string {
 	return c.getWithFallback("RootDir", parseHomeDir).(string)
 }
 
-// SessionTimeout FIXME:
+// SessionTimeout is the maximum duration that a user session can persist without any activity.
 func (c Config) SessionTimeout() time.Duration {
 	return c.viper.GetDuration("SessionTimeout")
 }

From ae4f51021ce9249da88cf7548fdc3962bcc18ec4 Mon Sep 17 00:00:00 2001
From: John Barker <jebarker@gmail.com>
Date: Wed, 2 Jan 2019 15:48:15 -0700
Subject: [PATCH 5/7] Restore MINIMUM_CONTRACT_PAYMENT assertion in
 local_client_test

---
 cmd/local_client_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cmd/local_client_test.go b/cmd/local_client_test.go
index d6576738a81..f45fe12e4fa 100644
--- a/cmd/local_client_test.go
+++ b/cmd/local_client_test.go
@@ -58,7 +58,7 @@ func TestClient_RunNodeShowsEnv(t *testing.T) {
 	assert.Contains(t, logs, "ETH_GAS_BUMP_WEI: 5000000000\\n")
 	assert.Contains(t, logs, "ETH_GAS_PRICE_DEFAULT: 20000000000\\n")
 	assert.Contains(t, logs, "LINK_CONTRACT_ADDRESS: 0x514910771AF9Ca656af840dff83E8264EcF986CA\\n")
-	// assert.Contains(t, logs, "MINIMUM_CONTRACT_PAYMENT: 0.000000000000000100\\n")
+	assert.Contains(t, logs, "MINIMUM_CONTRACT_PAYMENT: 0.000000000000000100\\n")
 	assert.Contains(t, logs, "ORACLE_CONTRACT_ADDRESS: \\n")
 	assert.Contains(t, logs, "DATABASE_TIMEOUT: 500ms\\n")
 	assert.Contains(t, logs, "ALLOW_ORIGINS: http://localhost:3000,http://localhost:6688\\n")

From dd64e0d18c966f4ad7efdffe5ab02e2c41bcaecb Mon Sep 17 00:00:00 2001
From: John Barker <jebarker@gmail.com>
Date: Wed, 2 Jan 2019 15:52:01 -0700
Subject: [PATCH 6/7] Remove init in favor of inline var

---
 adapters/bridge.go | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/adapters/bridge.go b/adapters/bridge.go
index 12cb85e7a7c..24d21192fd8 100644
--- a/adapters/bridge.go
+++ b/adapters/bridge.go
@@ -129,8 +129,4 @@ func (bp bridgeOutgoing) MarshalJSON() ([]byte, error) {
 	return json.Marshal(anon)
 }
 
-var zeroURL *url.URL
-
-func init() {
-	zeroURL = new(url.URL)
-}
+var zeroURL = new(url.URL)

From 09c1b2c27695b79e08b7f85694304b4a1ffc2aba Mon Sep 17 00:00:00 2001
From: John Barker <jebarker@gmail.com>
Date: Wed, 2 Jan 2019 16:15:58 -0700
Subject: [PATCH 7/7] Remove reflection visibility in favor of type
 intersection

---
 store/config.go | 58 +++++++++++++++++++------------------------------
 1 file changed, 22 insertions(+), 36 deletions(-)

diff --git a/store/config.go b/store/config.go
index 16735460bd8..004d575ae15 100644
--- a/store/config.go
+++ b/store/config.go
@@ -38,35 +38,35 @@ type Config struct {
 
 // ConfigSchema records the schema of configuration at the type level
 type ConfigSchema struct {
-	AllowOrigins             string         `env:"ALLOW_ORIGINS" default:"http://localhost:3000,http://localhost:6688" visible:"true"`
-	BridgeResponseURL        url.URL        `env:"BRIDGE_RESPONSE_URL" visible:"true"`
-	ChainID                  uint64         `env:"ETH_CHAIN_ID" default:"0" visible:"true"`
-	ClientNodeURL            string         `env:"CLIENT_NODE_URL" default:"http://localhost:6688" visible:"true"`
-	DatabaseTimeout          time.Duration  `env:"DATABASE_TIMEOUT" default:"500ms" visible:"true"`
-	Dev                      bool           `env:"CHAINLINK_DEV" default:"false" visible:"true"`
+	AllowOrigins             string         `env:"ALLOW_ORIGINS" default:"http://localhost:3000,http://localhost:6688"`
+	BridgeResponseURL        url.URL        `env:"BRIDGE_RESPONSE_URL"`
+	ChainID                  uint64         `env:"ETH_CHAIN_ID" default:"0"`
+	ClientNodeURL            string         `env:"CLIENT_NODE_URL" default:"http://localhost:6688"`
+	DatabaseTimeout          time.Duration  `env:"DATABASE_TIMEOUT" default:"500ms"`
+	Dev                      bool           `env:"CHAINLINK_DEV" default:"false"`
 	MaximumServiceDuration   time.Duration  `env:"MAXIMUM_SERVICE_DURATION" default:"8760h" `
 	MinimumServiceDuration   time.Duration  `env:"MINIMUM_SERVICE_DURATION" default:"0s" `
 	EthGasBumpThreshold      uint64         `env:"ETH_GAS_BUMP_THRESHOLD" default:"12" `
-	EthGasBumpWei            big.Int        `env:"ETH_GAS_BUMP_WEI" default:"5000000000" visible:"true"`
-	EthGasPriceDefault       big.Int        `env:"ETH_GAS_PRICE_DEFAULT" default:"20000000000" visible:"true"`
-	EthereumURL              string         `env:"ETH_URL" default:"ws://localhost:8546" visible:"true"`
-	JSONConsole              bool           `env:"JSON_CONSOLE" default:"false" visible:"true"`
-	LinkContractAddress      string         `env:"LINK_CONTRACT_ADDRESS" default:"0x514910771AF9Ca656af840dff83E8264EcF986CA" visible:"true"`
-	LogLevel                 LogLevel       `env:"LOG_LEVEL" default:"info" visible:"true"`
-	LogToDisk                bool           `env:"LOG_TO_DISK" default:"true" visible:"true"`
-	MinIncomingConfirmations uint64         `env:"MIN_INCOMING_CONFIRMATIONS" default:"0" visible:"true"`
-	MinOutgoingConfirmations uint64         `env:"MIN_OUTGOING_CONFIRMATIONS" default:"12" visible:"true"`
-	MinimumContractPayment   assets.Link    `env:"MINIMUM_CONTRACT_PAYMENT" default:"1000000000000000000" visible:"true"`
+	EthGasBumpWei            big.Int        `env:"ETH_GAS_BUMP_WEI" default:"5000000000"`
+	EthGasPriceDefault       big.Int        `env:"ETH_GAS_PRICE_DEFAULT" default:"20000000000"`
+	EthereumURL              string         `env:"ETH_URL" default:"ws://localhost:8546"`
+	JSONConsole              bool           `env:"JSON_CONSOLE" default:"false"`
+	LinkContractAddress      string         `env:"LINK_CONTRACT_ADDRESS" default:"0x514910771AF9Ca656af840dff83E8264EcF986CA"`
+	LogLevel                 LogLevel       `env:"LOG_LEVEL" default:"info"`
+	LogToDisk                bool           `env:"LOG_TO_DISK" default:"true"`
+	MinIncomingConfirmations uint64         `env:"MIN_INCOMING_CONFIRMATIONS" default:"0"`
+	MinOutgoingConfirmations uint64         `env:"MIN_OUTGOING_CONFIRMATIONS" default:"12"`
+	MinimumContractPayment   assets.Link    `env:"MINIMUM_CONTRACT_PAYMENT" default:"1000000000000000000"`
 	MinimumRequestExpiration uint64         `env:"MINIMUM_REQUEST_EXPIRATION" default:"300" `
-	OracleContractAddress    common.Address `env:"ORACLE_CONTRACT_ADDRESS" visible:"true"`
-	Port                     uint16         `env:"CHAINLINK_PORT" default:"6688" visible:"true"`
-	ReaperExpiration         time.Duration  `env:"REAPER_EXPIRATION" default:"240h" visible:"true"`
-	RootDir                  string         `env:"ROOT" default:"~/.chainlink" visible:"true"`
-	SessionTimeout           time.Duration  `env:"SESSION_TIMEOUT" default:"15m" visible:"true"`
+	OracleContractAddress    common.Address `env:"ORACLE_CONTRACT_ADDRESS"`
+	Port                     uint16         `env:"CHAINLINK_PORT" default:"6688"`
+	ReaperExpiration         time.Duration  `env:"REAPER_EXPIRATION" default:"240h"`
+	RootDir                  string         `env:"ROOT" default:"~/.chainlink"`
+	SessionTimeout           time.Duration  `env:"SESSION_TIMEOUT" default:"15m"`
 	TLSCertPath              string         `env:"TLS_CERT_PATH" `
 	TLSHost                  string         `env:"CHAINLINK_TLS_HOST" `
 	TLSKeyPath               string         `env:"TLS_KEY_PATH" `
-	TLSPort                  uint16         `env:"CHAINLINK_TLS_PORT" default:"6689" visible:"true"`
+	TLSPort                  uint16         `env:"CHAINLINK_TLS_PORT" default:"6689"`
 }
 
 // NewConfig returns the config with the environment variables set to their
@@ -102,20 +102,6 @@ func (c Config) Set(name string, value interface{}) {
 	c.viper.Set(name, value)
 }
 
-// GetVisibleValues returns the value of all displayable values as annotated by
-// the visible:"true" tag.
-func (c Config) GetVisibleValues() map[string]string {
-	values := make(map[string]string)
-	schemaT := reflect.TypeOf(ConfigSchema{})
-	for index := 0; index < schemaT.NumField(); index++ {
-		item := schemaT.FieldByIndex([]int{index})
-		if item.Tag.Get("visible") == "true" {
-			values[item.Tag.Get("env")] = c.viper.GetString(item.Name)
-		}
-	}
-	return values
-}
-
 // AllowOrigins returns the CORS hosts used by the frontend.
 func (c Config) AllowOrigins() string {
 	return c.viper.GetString("AllowOrigins")