diff --git a/cmd/geth/admin.go b/cmd/geth/admin.go
index 949a7bde0..15923c366 100644
--- a/cmd/geth/admin.go
+++ b/cmd/geth/admin.go
@@ -126,7 +126,7 @@ func (js *jsre) pendingTransactions(call otto.FunctionCall) otto.Value {
 	// Add the accouns to a new set
 	accountSet := set.New()
 	for _, account := range accounts {
-		accountSet.Add(common.BytesToAddress(account.Address))
+		accountSet.Add(account.Address)
 	}
 
 	//ltxs := make([]*tx, len(txs))
diff --git a/crypto/crypto.go b/crypto/crypto.go
index 2b1628124..ff817b0fa 100644
--- a/crypto/crypto.go
+++ b/crypto/crypto.go
@@ -185,7 +185,7 @@ func ImportBlockTestKey(privKeyBytes []byte) error {
 	ecKey := ToECDSA(privKeyBytes)
 	key := &Key{
 		Id:         uuid.NewRandom(),
-		Address:    PubkeyToAddress(ecKey.PublicKey),
+		Address:    common.BytesToAddress(PubkeyToAddress(ecKey.PublicKey)),
 		PrivateKey: ecKey,
 	}
 	err := ks.StoreKey(key, "")
diff --git a/crypto/key.go b/crypto/key.go
index 1af69d795..0c5ce4254 100644
--- a/crypto/key.go
+++ b/crypto/key.go
@@ -48,47 +48,47 @@ type Key struct {
 }
 
 type plainKeyJSON struct {
-	Version    string
-	Id         string
-	Address    string
-	PrivateKey string
+	Address    string `json:"address"`
+	PrivateKey string `json:"privatekey"`
+	Id         string `json:"id"`
+	Version    string `json:"version"`
 }
 
 type encryptedKeyJSON struct {
-	Version string
-	Id      string
-	Address string
-	Crypto  cipherJSON
+	Address string `json:"address"`
+	Crypto  cryptoJSON
+	Id      string `json:"id"`
+	Version string `json:"version"`
 }
 
-type cipherJSON struct {
-	MAC        string
-	Salt       string
-	IV         string
-	KeyHeader  keyHeaderJSON
-	CipherText string
+type cryptoJSON struct {
+	Cipher       string           `json:"cipher"`
+	CipherText   string           `json:"ciphertext"`
+	CipherParams cipherparamsJSON `json:"cipherparams"`
+	KDF          string           `json:"kdf"`
+	KDFParams    scryptParamsJSON `json:"kdfparams"`
+	MAC          string           `json:"mac"`
+	Version      string           `json:"version"`
 }
 
-type keyHeaderJSON struct {
-	Version   string
-	Kdf       string
-	KdfParams scryptParamsJSON
+type cipherparamsJSON struct {
+	IV string `json:"iv"`
 }
 
 type scryptParamsJSON struct {
-	N       int
-	R       int
-	P       int
-	DkLen   int
-	SaltLen int
+	N     int    `json:"n"`
+	R     int    `json:"r"`
+	P     int    `json:"p"`
+	DkLen int    `json:"dklen"`
+	Salt  string `json:"salt"`
 }
 
 func (k *Key) MarshalJSON() (j []byte, err error) {
 	jStruct := plainKeyJSON{
-		version,
-		k.Id.String(),
 		hex.EncodeToString(k.Address[:]),
 		hex.EncodeToString(FromECDSA(k.PrivateKey)),
+		k.Id.String(),
+		version,
 	}
 	j, err = json.Marshal(jStruct)
 	return j, err
diff --git a/crypto/key_store_passphrase.go b/crypto/key_store_passphrase.go
index 2e7929cee..d9a5a81f9 100644
--- a/crypto/key_store_passphrase.go
+++ b/crypto/key_store_passphrase.go
@@ -143,41 +143,36 @@ func (ks keyStorePassphrase) StoreKey(key *Key, auth string) (err error) {
 	cipherText := make([]byte, len(toEncrypt))
 	AES128CBCEncrypter.CryptBlocks(cipherText, toEncrypt)
 
-	paramsJSON := scryptParamsJSON{
-		N:       scryptN,
-		R:       scryptr,
-		P:       scryptp,
-		DkLen:   scryptdkLen,
-		SaltLen: 32,
+	mac := Sha3(derivedKey[16:32], cipherText)
+
+	scryptParamsJSON := scryptParamsJSON{
+		N:     scryptN,
+		R:     scryptr,
+		P:     scryptp,
+		DkLen: scryptdkLen,
+		Salt:  hex.EncodeToString(salt),
 	}
 
-	keyHeaderJSON := keyHeaderJSON{
-		Version:   keyHeaderVersion,
-		Kdf:       keyHeaderKDF,
-		KdfParams: paramsJSON,
+	cipherParamsJSON := cipherparamsJSON{
+		IV: hex.EncodeToString(iv),
 	}
 
-	keyHeaderJSONStr, err := json.Marshal(keyHeaderJSON)
-	if err != nil {
-		return err
+	cryptoStruct := cryptoJSON{
+		Cipher:       "aes-128-cbc",
+		CipherText:   hex.EncodeToString(cipherText),
+		CipherParams: cipherParamsJSON,
+		KDF:          "scrypt",
+		KDFParams:    scryptParamsJSON,
+		MAC:          hex.EncodeToString(mac),
+		Version:      "1",
 	}
-
-	mac := Sha3(keyHeaderJSONStr, derivedKey[16:32], cipherText)
-
-	cipherStruct := cipherJSON{
-		hex.EncodeToString(mac),
-		hex.EncodeToString(salt),
-		hex.EncodeToString(iv),
-		keyHeaderJSON,
-		hex.EncodeToString(cipherText),
-	}
-	keyStruct := encryptedKeyJSON{
-		version,
-		key.Id.String(),
+	encryptedKeyJSON := encryptedKeyJSON{
 		hex.EncodeToString(key.Address[:]),
-		cipherStruct,
+		cryptoStruct,
+		key.Id.String(),
+		version,
 	}
-	keyJSON, err := json.Marshal(keyStruct)
+	keyJSON, err := json.Marshal(encryptedKeyJSON)
 	if err != nil {
 		return err
 	}
@@ -212,33 +207,25 @@ func DecryptKey(ks keyStorePassphrase, keyAddr common.Address, auth string) (key
 		return nil, nil, err
 	}
 
-	salt, err := hex.DecodeString(keyProtected.Crypto.Salt)
+	iv, err := hex.DecodeString(keyProtected.Crypto.CipherParams.IV)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	iv, err := hex.DecodeString(keyProtected.Crypto.IV)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	keyHeader := keyProtected.Crypto.KeyHeader
 	cipherText, err := hex.DecodeString(keyProtected.Crypto.CipherText)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	// used in MAC
-	keyHeaderJSONStr, err := json.Marshal(keyHeader)
+	salt, err := hex.DecodeString(keyProtected.Crypto.KDFParams.Salt)
 	if err != nil {
 		return nil, nil, err
 	}
 
-	// TODO: make this more generic when we support different KDF params / key versions
-	n := keyHeader.KdfParams.N
-	r := keyHeader.KdfParams.R
-	p := keyHeader.KdfParams.P
-	dkLen := keyHeader.KdfParams.DkLen
+	n := keyProtected.Crypto.KDFParams.N
+	r := keyProtected.Crypto.KDFParams.R
+	p := keyProtected.Crypto.KDFParams.P
+	dkLen := keyProtected.Crypto.KDFParams.DkLen
 
 	authArray := []byte(auth)
 	derivedKey, err := scrypt.Key(authArray, salt, n, r, p, dkLen)
@@ -246,7 +233,7 @@ func DecryptKey(ks keyStorePassphrase, keyAddr common.Address, auth string) (key
 		return nil, nil, err
 	}
 
-	calculatedMAC := Sha3(keyHeaderJSONStr, derivedKey[16:32], cipherText)
+	calculatedMAC := Sha3(derivedKey[16:32], cipherText)
 	if !bytes.Equal(calculatedMAC, mac) {
 		err = errors.New("Decryption failed: MAC mismatch")
 		return nil, nil, err
diff --git a/miner/worker.go b/miner/worker.go
index 8698bb90d..f737be507 100644
--- a/miner/worker.go
+++ b/miner/worker.go
@@ -474,7 +474,7 @@ func gasprice(price *big.Int, pct int64) *big.Int {
 func accountAddressesSet(accounts []accounts.Account) *set.Set {
 	accountSet := set.New()
 	for _, account := range accounts {
-		accountSet.Add(common.BytesToAddress(account.Address))
+		accountSet.Add(account.Address)
 	}
 	return accountSet
 }
diff --git a/tests/block_test_util.go b/tests/block_test_util.go
index 093c9be0c..ae2ae4033 100644
--- a/tests/block_test_util.go
+++ b/tests/block_test_util.go
@@ -113,7 +113,7 @@ func (t *BlockTest) InsertPreState(ethereum *eth.Ethereum) (*state.StateDB, erro
 		if acct.PrivateKey != "" {
 			privkey, err := hex.DecodeString(strings.TrimPrefix(acct.PrivateKey, "0x"))
 			err = crypto.ImportBlockTestKey(privkey)
-			err = ethereum.AccountManager().TimedUnlock(addr, "", 999999*time.Second)
+			err = ethereum.AccountManager().TimedUnlock(common.BytesToAddress(addr), "", 999999*time.Second)
 			if err != nil {
 				return nil, err
 			}
diff --git a/xeth/xeth.go b/xeth/xeth.go
index 28ca05f47..0fe68d175 100644
--- a/xeth/xeth.go
+++ b/xeth/xeth.go
@@ -817,7 +817,7 @@ func (self *XEth) ConfirmTransaction(tx string) bool {
 }
 
 func (self *XEth) doSign(from common.Address, hash common.Hash, didUnlock bool) ([]byte, error) {
-	sig, err := self.backend.AccountManager().Sign(accounts.Account{Address: from.Bytes()}, hash.Bytes())
+	sig, err := self.backend.AccountManager().Sign(accounts.Account{Address: from}, hash.Bytes())
 	if err == accounts.ErrLocked {
 		if didUnlock {
 			return nil, fmt.Errorf("signer account still locked after successful unlock")