diff --git a/bitaddress.org.html b/bitaddress.org.html
index 11803a4..b7b6341 100644
--- a/bitaddress.org.html
+++ b/bitaddress.org.html
@@ -23,6 +23,7 @@
 	window.BigInteger		BSD License
 	window.QRCode			MIT License
 	window.Bitcoin			MIT License
+	window.Crypto_scrypt    MIT License
 
 	The bitaddress.org software is available under The MIT License (MIT)
 	Copyright (c) 2011-2012 bitaddress.org
@@ -574,6 +575,588 @@
 				return (num << cnt) | (num >>> (32 - cnt));
 			}
 		})();
+
+		/*!
+		* Crypto-JS v2.0.0
+		* http://code.google.com/p/crypto-js/
+		* Copyright (c) 2009, Jeff Mott. All rights reserved.
+		* http://code.google.com/p/crypto-js/wiki/License
+		*/
+		(function(){
+		
+		// Shortcuts
+		var C = Crypto,
+		    util = C.util,
+		    charenc = C.charenc,
+		    UTF8 = charenc.UTF8,
+		    Binary = charenc.Binary;
+		
+		C.PBKDF2 = function (password, salt, keylen, options) {
+		
+			// Convert to byte arrays
+			if (password.constructor == String) password = UTF8.stringToBytes(password);
+			if (salt.constructor == String) salt = UTF8.stringToBytes(salt);
+			/* else, assume byte arrays already */
+		
+			// Defaults
+			var hasher = options && options.hasher || C.SHA1,
+			    iterations = options && options.iterations || 1;
+		
+			// Pseudo-random function
+			function PRF(password, salt) {
+				return C.HMAC(hasher, salt, password, { asBytes: true });
+			}
+		
+			// Generate key
+			var derivedKeyBytes = [],
+			    blockindex = 1;
+			while (derivedKeyBytes.length < keylen) {
+				var block = PRF(password, salt.concat(util.wordsToBytes([blockindex])));
+				for (var u = block, i = 1; i < iterations; i++) {
+					u = PRF(password, u);
+					for (var j = 0; j < block.length; j++) block[j] ^= u[j];
+				}
+				derivedKeyBytes = derivedKeyBytes.concat(block);
+				blockindex++;
+			}
+		
+			// Truncate excess bytes
+			derivedKeyBytes.length = keylen;
+		
+			return options && options.asBytes ? derivedKeyBytes :
+			       options && options.asString ? Binary.bytesToString(derivedKeyBytes) :
+			       util.bytesToHex(derivedKeyBytes);
+		
+		};
+		
+		})();
+
+		(function(){
+		
+		// Shortcuts
+		var C = Crypto,
+		    util = C.util,
+		    charenc = C.charenc,
+		    UTF8 = charenc.UTF8,
+		    Binary = charenc.Binary;
+		
+		C.HMAC = function (hasher, message, key, options) {
+		
+			// Convert to byte arrays
+			if (message.constructor == String) message = UTF8.stringToBytes(message);
+			if (key.constructor == String) key = UTF8.stringToBytes(key);
+			/* else, assume byte arrays already */
+		
+			// Allow arbitrary length keys
+			if (key.length > hasher._blocksize * 4)
+				key = hasher(key, { asBytes: true });
+		
+			// XOR keys with pad constants
+			var okey = key.slice(0),
+			    ikey = key.slice(0);
+			for (var i = 0; i < hasher._blocksize * 4; i++) {
+				okey[i] ^= 0x5C;
+				ikey[i] ^= 0x36;
+			}
+		
+			var hmacbytes = hasher(okey.concat(hasher(ikey.concat(message), { asBytes: true })), { asBytes: true });
+		
+			return options && options.asBytes ? hmacbytes :
+			       options && options.asString ? Binary.bytesToString(hmacbytes) :
+			       util.bytesToHex(hmacbytes);
+		
+		};
+		
+		})();
+
+		/*!
+		* Crypto-JS v2.0.0
+		* http://code.google.com/p/crypto-js/
+		* Copyright (c) 2009, Jeff Mott. All rights reserved.
+		* http://code.google.com/p/crypto-js/wiki/License
+		*/
+		(function(){
+		
+		// Shortcuts
+		var C = Crypto,
+		    util = C.util,
+		    charenc = C.charenc,
+		    UTF8 = charenc.UTF8;
+		
+		// Precomputed SBOX
+		var SBOX = [ 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5,
+		             0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
+		             0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
+		             0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
+		             0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc,
+		             0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
+		             0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a,
+		             0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
+		             0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0,
+		             0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
+		             0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b,
+		             0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
+		             0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85,
+		             0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
+		             0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5,
+		             0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
+		             0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17,
+		             0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
+		             0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88,
+		             0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
+		             0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c,
+		             0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
+		             0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9,
+		             0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
+		             0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6,
+		             0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
+		             0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e,
+		             0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
+		             0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94,
+		             0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
+		             0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68,
+		             0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 ];
+		
+		// Compute inverse SBOX lookup table
+		for (var INVSBOX = [], i = 0; i < 256; i++) INVSBOX[SBOX[i]] = i;
+		
+		// Compute multiplication in GF(2^8) lookup tables
+		var MULT2 = [],
+		    MULT3 = [],
+		    MULT9 = [],
+		    MULTB = [],
+		    MULTD = [],
+		    MULTE = [];
+		
+		function xtime(a, b) {
+			for (var result = 0, i = 0; i < 8; i++) {
+				if (b & 1) result ^= a;
+				var hiBitSet = a & 0x80;
+				a = (a << 1) & 0xFF;
+				if (hiBitSet) a ^= 0x1b;
+				b >>>= 1;
+			}
+			return result;
+		}
+		
+		for (var i = 0; i < 256; i++) {
+			MULT2[i] = xtime(i,2);
+			MULT3[i] = xtime(i,3);
+			MULT9[i] = xtime(i,9);
+			MULTB[i] = xtime(i,0xB);
+			MULTD[i] = xtime(i,0xD);
+			MULTE[i] = xtime(i,0xE);
+		}
+		
+		// Precomputed RCon lookup
+		var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];
+		
+		// Inner state
+		var state = [[], [], [], []],
+		    keylength,
+		    nrounds,
+		    keyschedule;
+		
+		var AES = C.AES = {
+		
+			/**
+			 * Public API
+			 */
+		
+			encrypt: function (message, password, options) {
+		
+				options = options || {};
+		
+				// Determine mode
+				var mode = options.mode;
+		
+				// Allow mode to override options
+				if (mode.fixOptions) mode.fixOptions(options);
+		
+				var
+		
+					// Convert to bytes if message is a string
+					m = (
+						message.constructor == String ?
+						UTF8.stringToBytes(message) :
+						message
+					),
+		
+					// Generate random IV
+					iv = options.iv || util.randomBytes(AES._blocksize * 4),
+		
+					// Generate key
+					k = (
+						password.constructor == String ?
+						// Derive key from pass-phrase
+						C.PBKDF2(password, iv, 32, { asBytes: true }) :
+						// else, assume byte array representing cryptographic key
+						password
+					);
+		
+				// Encrypt
+				AES._init(k);
+				mode.encrypt(AES, m, iv);
+		
+				// Return ciphertext
+				m = options.iv ? m : iv.concat(m);
+				return (options && options.asBytes) ? m : util.bytesToBase64(m);
+		
+			},
+		
+			decrypt: function (ciphertext, password, options) {
+		
+				options = options || {};
+		
+				// Determine mode
+				var mode = options.mode;
+		
+				// Allow mode to override options
+				if (mode.fixOptions) mode.fixOptions(options);
+		
+				var
+		
+					// Convert to bytes if ciphertext is a string
+					c = (
+						ciphertext.constructor == String ?
+						util.base64ToBytes(ciphertext):
+					    ciphertext
+					),
+		
+					// Separate IV and message
+					iv = options.iv || null /*c.splice(0, AES._blocksize * 4)*/,
+		
+					// Generate key
+					k = (
+						password.constructor == String ?
+						// Derive key from pass-phrase
+						C.PBKDF2(password, iv, 32, { asBytes: true }) :
+						// else, assume byte array representing cryptographic key
+						password
+					);
+		
+				// Decrypt
+				AES._init(k);
+				mode.decrypt(AES, c, iv);
+		
+				// Return plaintext
+				return (options && options.asBytes) ? c : UTF8.bytesToString(c);
+		
+			},
+		
+		
+			/**
+			 * Package private methods and properties
+			 */
+		
+			_blocksize: 4,
+		
+			_encryptblock: function (m, offset) {
+		
+				// Set input
+				for (var row = 0; row < AES._blocksize; row++) {
+					for (var col = 0; col < 4; col++)
+						state[row][col] = m[offset + col * 4 + row];
+				}
+		
+				// Add round key
+				for (var row = 0; row < 4; row++) {
+					for (var col = 0; col < 4; col++)
+						state[row][col] ^= keyschedule[col][row];
+				}
+		
+				for (var round = 1; round < nrounds; round++) {
+		
+					// Sub bytes
+					for (var row = 0; row < 4; row++) {
+						for (var col = 0; col < 4; col++)
+							state[row][col] = SBOX[state[row][col]];
+					}
+		
+					// Shift rows
+					state[1].push(state[1].shift());
+					state[2].push(state[2].shift());
+					state[2].push(state[2].shift());
+					state[3].unshift(state[3].pop());
+		
+					// Mix columns
+					for (var col = 0; col < 4; col++) {
+		
+						var s0 = state[0][col],
+						    s1 = state[1][col],
+						    s2 = state[2][col],
+						    s3 = state[3][col];
+		
+						state[0][col] = MULT2[s0] ^ MULT3[s1] ^ s2 ^ s3;
+						state[1][col] = s0 ^ MULT2[s1] ^ MULT3[s2] ^ s3;
+						state[2][col] = s0 ^ s1 ^ MULT2[s2] ^ MULT3[s3];
+						state[3][col] = MULT3[s0] ^ s1 ^ s2 ^ MULT2[s3];
+		
+					}
+		
+					// Add round key
+					for (var row = 0; row < 4; row++) {
+						for (var col = 0; col < 4; col++)
+							state[row][col] ^= keyschedule[round * 4 + col][row];
+					}
+		
+				}
+		
+				// Sub bytes
+				for (var row = 0; row < 4; row++) {
+					for (var col = 0; col < 4; col++)
+						state[row][col] = SBOX[state[row][col]];
+				}
+		
+				// Shift rows
+				state[1].push(state[1].shift());
+				state[2].push(state[2].shift());
+				state[2].push(state[2].shift());
+				state[3].unshift(state[3].pop());
+		
+				// Add round key
+				for (var row = 0; row < 4; row++) {
+					for (var col = 0; col < 4; col++)
+						state[row][col] ^= keyschedule[nrounds * 4 + col][row];
+				}
+		
+				// Set output
+				for (var row = 0; row < AES._blocksize; row++) {
+					for (var col = 0; col < 4; col++)
+						m[offset + col * 4 + row] = state[row][col];
+				}
+		
+			},
+		
+			_decryptblock: function (c, offset) {
+		
+				// Set input
+				for (var row = 0; row < AES._blocksize; row++) {
+					for (var col = 0; col < 4; col++)
+						state[row][col] = c[offset + col * 4 + row];
+				}
+		
+				// Add round key
+				for (var row = 0; row < 4; row++) {
+					for (var col = 0; col < 4; col++)
+						state[row][col] ^= keyschedule[nrounds * 4 + col][row];
+				}
+		
+				for (var round = 1; round < nrounds; round++) {
+		
+					// Inv shift rows
+					state[1].unshift(state[1].pop());
+					state[2].push(state[2].shift());
+					state[2].push(state[2].shift());
+					state[3].push(state[3].shift());
+		
+					// Inv sub bytes
+					for (var row = 0; row < 4; row++) {
+						for (var col = 0; col < 4; col++)
+							state[row][col] = INVSBOX[state[row][col]];
+					}
+		
+					// Add round key
+					for (var row = 0; row < 4; row++) {
+						for (var col = 0; col < 4; col++)
+							state[row][col] ^= keyschedule[(nrounds - round) * 4 + col][row];
+					}
+		
+					// Inv mix columns
+					for (var col = 0; col < 4; col++) {
+		
+						var s0 = state[0][col],
+						    s1 = state[1][col],
+						    s2 = state[2][col],
+						    s3 = state[3][col];
+		
+						state[0][col] = MULTE[s0] ^ MULTB[s1] ^ MULTD[s2] ^ MULT9[s3];
+						state[1][col] = MULT9[s0] ^ MULTE[s1] ^ MULTB[s2] ^ MULTD[s3];
+						state[2][col] = MULTD[s0] ^ MULT9[s1] ^ MULTE[s2] ^ MULTB[s3];
+						state[3][col] = MULTB[s0] ^ MULTD[s1] ^ MULT9[s2] ^ MULTE[s3];
+		
+					}
+		
+				}
+		
+				// Inv shift rows
+				state[1].unshift(state[1].pop());
+				state[2].push(state[2].shift());
+				state[2].push(state[2].shift());
+				state[3].push(state[3].shift());
+		
+				// Inv sub bytes
+				for (var row = 0; row < 4; row++) {
+					for (var col = 0; col < 4; col++)
+						state[row][col] = INVSBOX[state[row][col]];
+				}
+		
+				// Add round key
+				for (var row = 0; row < 4; row++) {
+					for (var col = 0; col < 4; col++)
+						state[row][col] ^= keyschedule[col][row];
+				}
+		
+				// Set output
+				for (var row = 0; row < AES._blocksize; row++) {
+					for (var col = 0; col < 4; col++)
+						c[offset + col * 4 + row] = state[row][col];
+				}
+		
+			},
+		
+		
+			/**
+			 * Private methods
+			 */
+		
+			_init: function (k) {
+				keylength = k.length / 4;
+				nrounds = keylength + 6;
+				AES._keyexpansion(k);
+			},
+		
+			// Generate a key schedule
+			_keyexpansion: function (k) {
+		
+				keyschedule = [];
+		
+				for (var row = 0; row < keylength; row++) {
+					keyschedule[row] = [
+						k[row * 4],
+						k[row * 4 + 1],
+						k[row * 4 + 2],
+						k[row * 4 + 3]
+					];
+				}
+		
+				for (var row = keylength; row < AES._blocksize * (nrounds + 1); row++) {
+		
+					var temp = [
+						keyschedule[row - 1][0],
+						keyschedule[row - 1][1],
+						keyschedule[row - 1][2],
+						keyschedule[row - 1][3]
+					];
+		
+					if (row % keylength == 0) {
+		
+						// Rot word
+						temp.push(temp.shift());
+		
+						// Sub word
+						temp[0] = SBOX[temp[0]];
+						temp[1] = SBOX[temp[1]];
+						temp[2] = SBOX[temp[2]];
+						temp[3] = SBOX[temp[3]];
+		
+						temp[0] ^= RCON[row / keylength];
+		
+					} else if (keylength > 6 && row % keylength == 4) {
+		
+						// Sub word
+						temp[0] = SBOX[temp[0]];
+						temp[1] = SBOX[temp[1]];
+						temp[2] = SBOX[temp[2]];
+						temp[3] = SBOX[temp[3]];
+		
+					}
+		
+					keyschedule[row] = [
+						keyschedule[row - keylength][0] ^ temp[0],
+						keyschedule[row - keylength][1] ^ temp[1],
+						keyschedule[row - keylength][2] ^ temp[2],
+						keyschedule[row - keylength][3] ^ temp[3]
+					];
+		
+				}
+		
+			}
+		
+		};
+		
+		})();
+
+		/*!
+		 * Crypto-JS contribution from Simon Greatrix
+		 */
+		
+		(function(C){
+		
+		// Create pad namespace
+		var C_pad = C.pad = {};
+		
+		// No-operation padding, used for stream ciphers
+		C_pad.NoPadding = {
+		        pad : function (cipher,message) {},
+		        unpad : function (cipher,message) {}
+		    };
+		
+		// Create mode namespace
+		var C_mode = C.mode = {};
+		
+		/**
+		 * Mode base "class".
+		 */
+		var Mode = C_mode.Mode = function (padding) {
+		    if (padding) {
+		        this._padding = padding;
+		    }
+		};
+		
+		Mode.prototype = {
+		    encrypt: function (cipher, m, iv) {
+		        this._padding.pad(cipher, m);
+		        this._doEncrypt(cipher, m, iv);
+		    },
+		
+		    decrypt: function (cipher, m, iv) {
+		        this._doDecrypt(cipher, m, iv);
+		        this._padding.unpad(cipher, m);
+		    },
+		
+		    // Default padding
+		    _padding: C_pad.iso7816
+		};
+		
+		
+		/**
+		 * Electronic Code Book mode.
+		 * 
+		 * ECB applies the cipher directly against each block of the input.
+		 * 
+		 * ECB does not require an initialization vector.
+		 */
+		var ECB = C_mode.ECB = function () {
+		    // Call parent constructor
+		    Mode.apply(this, arguments);
+		};
+		
+		// Inherit from Mode
+		var ECB_prototype = ECB.prototype = new Mode;
+		
+		// Concrete steps for Mode template
+		ECB_prototype._doEncrypt = function (cipher, m, iv) {
+		    var blockSizeInBytes = cipher._blocksize * 4;
+		    // Encrypt each block
+		    for (var offset = 0; offset < m.length; offset += blockSizeInBytes) {
+		        cipher._encryptblock(m, offset);
+		    }
+		};
+		ECB_prototype._doDecrypt = function (cipher, c, iv) {
+		    var blockSizeInBytes = cipher._blocksize * 4;
+		    // Decrypt each block
+		    for (var offset = 0; offset < c.length; offset += blockSizeInBytes) {
+		        cipher._decryptblock(c, offset);
+		    }
+		};
+		
+		// ECB never uses an IV
+		ECB_prototype.fixOptions = function (options) {
+		    options.iv = [];
+		};
+		
+		})(Crypto);
 	</script>
 	
 	<script type="text/javascript">
@@ -3570,7 +4153,7 @@
 
 			// Version
 			hash.unshift(this.version);
-			var checksum = Crypto.SHA256(Crypto.SHA256(hash, { asBytes: true }), { asBytes: true });
+			var checksum = Bitcoin.Util.dsha256(hash);
 			var bytes = hash.concat(checksum.slice(0, 4));
 			return Bitcoin.Base58.encode(bytes);
 		};
@@ -3585,7 +4168,7 @@
 		Bitcoin.Address.decodeString = function (string) {
 			var bytes = Bitcoin.Base58.decode(string);
 			var hash = bytes.slice(0, 21);
-			var checksum = Crypto.SHA256(Crypto.SHA256(hash, { asBytes: true }), { asBytes: true });
+			var checksum = Bitcoin.Util.dsha256(hash);
 
 			if (checksum[0] != bytes[21] ||
 			checksum[1] != bytes[22] ||
@@ -3816,7 +4399,7 @@
 			ECKey.prototype.getBitcoinWalletImportFormat = function () {
 				var bytes = this.getBitcoinPrivateKeyByteArray();
 				bytes.unshift(ECKey.privateKeyPrefix); // prepend 0x80 byte
-				var checksum = Crypto.SHA256(Crypto.SHA256(bytes, { asBytes: true }), { asBytes: true });
+				var checksum = Bitcoin.Util.dsha256(bytes);
 				bytes = bytes.concat(checksum.slice(0, 4));
 				var privWif = Bitcoin.Base58.encode(bytes);
 				return privWif;
@@ -3827,7 +4410,7 @@
 				var bytes = this.getBitcoinPrivateKeyByteArray();
 				bytes.unshift(ECKey.privateKeyPrefix); // prepend 0x80 byte	
 				bytes.push(0x01);    // append 0x01 byte for compressed format
-				var checksum = Crypto.SHA256(Crypto.SHA256(bytes, { asBytes: true }), { asBytes: true });
+				var checksum = Bitcoin.Util.dsha256(bytes);
 				bytes = bytes.concat(checksum.slice(0, 4));
 				var privWifComp = Bitcoin.Base58.encode(bytes);
 				return privWifComp;
@@ -3949,10 +4532,309 @@
 			},
 			sha256ripe160: function (data) {
 				return Crypto.RIPEMD160(Crypto.SHA256(data, { asBytes: true }), { asBytes: true });
+			},
+			dsha256: function (data) {
+				return Crypto.SHA256(Crypto.SHA256(data, { asBytes: true }), { asBytes: true });
 			}
 		};
 	</script>
 
+	<script type="text/javascript">
+		/*
+		* Copyright (c) 2010-2011 Intalio Pte, All Rights Reserved
+		* 
+		* Permission is hereby granted, free of charge, to any person obtaining a copy
+		* of this software and associated documentation files (the "Software"), to deal
+		* in the Software without restriction, including without limitation the rights
+		* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+		* copies of the Software, and to permit persons to whom the Software is
+		* furnished to do so, subject to the following conditions:
+		* 
+		* The above copyright notice and this permission notice shall be included in
+		* all copies or substantial portions of the Software.
+		* 
+		* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+		* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+		* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+		* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+		* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+		* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+		* THE SOFTWARE.
+		*/
+		// https://github.com/cheongwy/node-scrypt-js
+		(function() {
+		
+		var MAX_VALUE = 2147483647;
+		var workerUrl = null;
+		
+		//function scrypt(byte[] passwd, byte[] salt, int N, int r, int p, int dkLen)
+		/*
+		 * N = Cpu cost
+		 * r = Memory cost
+		 * p = parallelization cost
+		 * 
+		 */
+		window.Crypto_scrypt = function(passwd, salt, N, r, p, dkLen, callback) {
+		    if (N == 0 || (N & (N - 1)) != 0) throw Error("N must be > 0 and a power of 2");
+		
+		    if (N > MAX_VALUE / 128 / r) throw Error("Parameter N is too large");
+		    if (r > MAX_VALUE / 128 / p) throw Error("Parameter r is too large");
+		
+			var PBKDF2_opts = {iterations: 1, hasher: Crypto.SHA256, asBytes: true};
+		
+		    var B = Crypto.PBKDF2(passwd, salt, p * 128 * r, PBKDF2_opts);
+		    
+			try {
+				var i = 0;
+				var worksDone = 0;
+				var makeWorker = function() {
+					if (!workerUrl) {
+						var code = '('+scryptCore.toString()+')()';
+						var blob;
+						try {
+							blob = new Blob([code], {type: "text/javascript"});
+						} catch(e) {
+							window.BlobBuilder = window.BlobBuilder || window.WebKitBlobBuilder || window.MozBlobBuilder || window.MSBlobBuilder;
+							blob = new BlobBuilder();
+							blob.append(code);
+							blob = blob.getBlob("text/javascript");
+						}
+						workerUrl = URL.createObjectURL(blob);
+					}
+					var worker = new Worker(workerUrl);
+					worker.onmessage = function(event) {
+						var Bi = event.data[0], Bslice = event.data[1];
+						worksDone++;
+	
+						if (i < p) {
+							worker.postMessage([N, r, p, B, i++]);
+						}
+	
+						var length = Bslice.length, destPos = Bi * 128 * r, srcPos = 0;
+						while (length--) {
+							B[destPos++] = Bslice[srcPos++];
+						}
+	
+						if (worksDone == p) {
+							callback(Crypto.PBKDF2(passwd, B, dkLen, PBKDF2_opts));
+						}
+					};
+					return worker;
+				};
+				var workers = [makeWorker(), makeWorker()];
+				workers[0].postMessage([N, r, p, B, i++]);
+				if (p > 1) {
+					workers[1].postMessage([N, r, p, B, i++]);
+				}
+			} catch (e) {
+				scryptCore();
+				callback(Crypto.PBKDF2(passwd, B, dkLen, PBKDF2_opts));
+			}
+
+			// using this function to enclose everything needed to create a worker (but also invokable directly for synchronous use)
+			function scryptCore() {
+				var XY = [], V = [];
+
+				if (typeof B === 'undefined') {
+					onmessage = function(event) {
+						var data = event.data;
+						var N = data[0], r = data[1], p = data[2], B = data[3], i = data[4];
+					
+						var Bslice = [];
+						arraycopy32(B, i * 128 * r, Bslice, 0, 128 * r);
+						smix(Bslice, 0, r, N, V, XY);
+					
+						postMessage([i, Bslice]);
+					};
+				} else {
+					for(var i = 0; i < p; i++) {
+						smix(B, i * 128 * r, r, N, V, XY);
+					}
+				}
+				
+				function smix(B, Bi, r, N, V, XY) {
+					var Xi = 0;
+					var Yi = 128 * r;
+					var i;
+				
+					arraycopy32(B, Bi, XY, Xi, Yi);
+					
+					for (i = 0; i < N; i++) {
+						arraycopy32(XY, Xi, V, i * Yi, Yi);
+						blockmix_salsa8(XY, Xi, Yi, r);
+					}
+				
+					for (i = 0; i < N; i++) {
+						var j = integerify(XY, Xi, r) & (N - 1);
+						blockxor(V, j * Yi, XY, Xi, Yi);
+						blockmix_salsa8(XY, Xi, Yi, r);
+					}
+				
+					arraycopy32(XY, Xi, B, Bi, Yi);
+				}
+				
+				function blockmix_salsa8(BY, Bi, Yi, r) {
+					var X = [];
+					var i;
+				
+					arraycopy32(BY, Bi + (2 * r - 1) * 64, X, 0, 64);
+					
+					for (i = 0; i < 2 * r; i++) {
+						blockxor(BY, i * 64, X, 0, 64);
+						salsa20_8(X);
+						arraycopy32(X, 0, BY, Yi + (i * 64), 64);
+					}
+				
+					for (i = 0; i < r; i++) {
+						arraycopy32(BY, Yi + (i * 2) * 64, BY, Bi + (i * 64), 64);
+					}
+				
+					for (i = 0; i < r; i++) {
+						arraycopy32(BY, Yi + (i * 2 + 1) * 64, BY, Bi + (i + r) * 64, 64);
+					}
+				}
+				
+				function R(a, b) {
+					return (a << b) | (a >>> (32 - b));
+				}
+				
+				function salsa20_8(B) {
+					var B32 = new Array(32);
+					var x   = new Array(32);
+					var i;
+				
+					for (i = 0; i < 16; i++) {
+						B32[i]  = (B[i * 4 + 0] & 0xff) << 0;
+						B32[i] |= (B[i * 4 + 1] & 0xff) << 8;
+						B32[i] |= (B[i * 4 + 2] & 0xff) << 16;
+						B32[i] |= (B[i * 4 + 3] & 0xff) << 24;
+					}
+				
+					arraycopy(B32, 0, x, 0, 16);
+				
+					for (i = 8; i > 0; i -= 2) {
+						x[ 4] ^= R(x[ 0]+x[12], 7);  x[ 8] ^= R(x[ 4]+x[ 0], 9);
+						x[12] ^= R(x[ 8]+x[ 4],13);  x[ 0] ^= R(x[12]+x[ 8],18);
+						x[ 9] ^= R(x[ 5]+x[ 1], 7);  x[13] ^= R(x[ 9]+x[ 5], 9);
+						x[ 1] ^= R(x[13]+x[ 9],13);  x[ 5] ^= R(x[ 1]+x[13],18);
+						x[14] ^= R(x[10]+x[ 6], 7);  x[ 2] ^= R(x[14]+x[10], 9);
+						x[ 6] ^= R(x[ 2]+x[14],13);  x[10] ^= R(x[ 6]+x[ 2],18);
+						x[ 3] ^= R(x[15]+x[11], 7);  x[ 7] ^= R(x[ 3]+x[15], 9);
+						x[11] ^= R(x[ 7]+x[ 3],13);  x[15] ^= R(x[11]+x[ 7],18);
+						x[ 1] ^= R(x[ 0]+x[ 3], 7);  x[ 2] ^= R(x[ 1]+x[ 0], 9);
+						x[ 3] ^= R(x[ 2]+x[ 1],13);  x[ 0] ^= R(x[ 3]+x[ 2],18);
+						x[ 6] ^= R(x[ 5]+x[ 4], 7);  x[ 7] ^= R(x[ 6]+x[ 5], 9);
+						x[ 4] ^= R(x[ 7]+x[ 6],13);  x[ 5] ^= R(x[ 4]+x[ 7],18);
+						x[11] ^= R(x[10]+x[ 9], 7);  x[ 8] ^= R(x[11]+x[10], 9);
+						x[ 9] ^= R(x[ 8]+x[11],13);  x[10] ^= R(x[ 9]+x[ 8],18);
+						x[12] ^= R(x[15]+x[14], 7);  x[13] ^= R(x[12]+x[15], 9);
+						x[14] ^= R(x[13]+x[12],13);  x[15] ^= R(x[14]+x[13],18);
+					}
+				
+					for (i = 0; i < 16; ++i) B32[i] = x[i] + B32[i];
+					
+					for (i = 0; i < 16; i++) {
+						var bi = i * 4;
+						B[bi + 0] = (B32[i] >> 0  & 0xff);
+						B[bi + 1] = (B32[i] >> 8  & 0xff);
+						B[bi + 2] = (B32[i] >> 16 & 0xff);
+						B[bi + 3] = (B32[i] >> 24 & 0xff);
+					}
+				}
+				
+				function blockxor(S, Si, D, Di, len) {
+					var i = len>>6;
+					while (i--) {
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+						D[Di++] ^= S[Si++]; D[Di++] ^= S[Si++];
+					}		
+				}
+				
+				function integerify(B, bi, r) {
+					var n;
+					
+					bi += (2 * r - 1) * 64;
+				
+					n  = (B[bi + 0] & 0xff) << 0;
+					n |= (B[bi + 1] & 0xff) << 8;
+					n |= (B[bi + 2] & 0xff) << 16;
+					n |= (B[bi + 3] & 0xff) << 24;
+				
+					return n;
+				}
+				
+				function arraycopy(src, srcPos, dest, destPos, length) {
+					 while (length-- ){
+						 dest[destPos++] = src[srcPos++];
+					 }	
+				}
+
+				function arraycopy32(src, srcPos, dest, destPos, length) {
+					var i = length>>5;
+					while(i--) {
+						dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++];
+						dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++];
+						dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++];
+						dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++];
+						 
+						dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++];
+						dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++];
+						dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++];
+						dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++];	
+						
+						dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++];
+						dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++];
+						dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++];
+						dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++];
+						 
+						dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++];
+						dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++];
+						dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++];
+						dest[destPos++] = src[srcPos++]; dest[destPos++] = src[srcPos++];			
+					}
+				}
+			} // scryptCore
+		}; // window.Crypto_scrypt
+		})();
+	</script>
+
 	<style type="text/css">
 		.more { background: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAABEAAAARCAYAAAA7bUf6AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAABx0RVh0U29mdHdhcmUAQWRvYmUgRmlyZXdvcmtzIENTNXG14zYAAAAWdEVYdENyZWF0aW9uIFRpbWUAMDEvMDIvMTLltnQyAAAB1UlEQVQ4jYWTS04bQRCGv3q0x8gMYJCwknCGLDgLVwiH4grhLFaUXdhkQ0A8pBg/FOLpnmbhMYzxRKlNS1Vdf/31V5XknGnb+eXJCBjzbzu9OLu+azu845Opysej4wHmshF4uJ2TUrb3CV0gIBAKRboC5C2vdkDE9fdty6/xDegvXz+NgDbFUejZ+PjDgExmtpxS9vYwMe5u5iyX8RRoa5Ic+C4qx9KUN1MGu4E618yqJ5axAp44KA7ZL3eYzp/HKdVIw7WK8d6BuDvcod9TQlBEIOXEdPlElSoUJabIIs4Z7h9yNDwgqOMayLXw7epHVIBggrsgspZPUBQyiCgugRQji7TAVDF1XB2TlQoOYCqovkmpopS9fcoiM3ue0rOCYf8IU8NklWxiiOQ3EPXtWagIqo6KYWYEc4IGvMViA6RrnCJKVS9B8ypRHG1YKNa0Ur+C+MPt/I2BKWVZUO4FgvQ47PcptEDF+T2Z8TiZUMWIyGtpd+Bze5VTSqP57O/4YG+AN/RXbSiPkwmL5z/be/L+mM4vT2JKeUW7EXD1erMz/Lo4u77f0K9DDhdA1XG11jh9vWBb99Z9gAg5QZ2hzpmUa0RSW4f/gqSY0s3Vz+tufEjvHS8Tg6BXC7qVbQAAAABJRU5ErkJggg==)
 					no-repeat left center; width: 17px; height: 17px; display: inline-block; float: right; }
@@ -4318,7 +5200,9 @@
 			<div id="detailarea" class="walletarea">	
 				<div id="detailcommands" class="commands">
 					<span><label id="detaillabelenterprivatekey">Enter Private Key (any format)</label> <input type="text" id="detailprivkey" value="" onfocus="this.select();" onkeypress="if (event.keyCode == 13) ninja.wallets.detailwallet.viewDetails();" /></span>
+					<span><label id="detaillabelpassphrase">Enter BIP38 Passphrase</label> <input type="text" id="detailprivkeypassphrase" value="" onfocus="this.select();" onkeypress="if (event.keyCode == 13) ninja.wallets.detailwallet.viewDetails(true);" /></span>
 					<span><input type="button" id="detailview" value="View Details" onclick="ninja.wallets.detailwallet.viewDetails();" /></span>
+					<span><input type="button" id="detaildecrypt" value="Decrypt BIP38" onclick="ninja.wallets.detailwallet.viewDetails(true);" /></span>
 					<span class="print"><input type="button" name="print" id="detailprint" value="Print" onclick="window.print();" /></span>
 				</div>
 				<div id="detailkeyarea">
@@ -4417,6 +5301,11 @@
 							(/^c[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{51}$/.test(key)) :
 							(/^[LK][123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{51}$/.test(key));
 			},
+			// 58 base58 characters starting with 6P
+			isBIP38Format: function (key) {
+				key = key.toString();
+				return (/^6P[123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{56}$/.test(key));
+			},
 			// 64 characters [0-9A-F]
 			isHexFormat: function (key) {
 				key = key.toString();
@@ -4469,6 +5358,120 @@
 			anyPrivateKeyToECKey: function (privKey) {
 				var bytes = ninja.privateKey.anyPrivateKeyToByteArray(privKey);
 				return (bytes == null)? null : new Bitcoin.ECKey(bytes);
+			},
+			BIP38EncryptedKeyToByteArrayAsync: function (base58Encrypted, passphrase, callback) {
+				var hex;
+				try {
+					hex = Bitcoin.Base58.decode(base58Encrypted);
+				} catch (e) {
+					callback(new Error(ninja.translator.get("detailalertnotvalidprivatekey")));
+					return;
+				}
+
+				if (hex.length != 43) {
+					callback(new Error(ninja.translator.get("detailalertnotvalidprivatekey")));
+					return;
+				} else if (hex[0] != 0x01) {
+					callback(new Error(ninja.translator.get("detailalertnotvalidprivatekey")));
+					return;
+				}
+
+				var expChecksum = hex.slice(-4);
+				hex = hex.slice(0, -4);
+
+				var checksum = Bitcoin.Util.dsha256(hex);
+				if (checksum[0] != expChecksum[0] || checksum[1] != expChecksum[1] || checksum[2] != expChecksum[2] || checksum[3] != expChecksum[3]) {
+					callback(new Error(ninja.translator.get("detailalertnotvalidprivatekey")));
+					return;
+				}
+
+				var isCompPoint = false;
+				var isECMult = false;
+				var hasLotSeq = false;
+				if (hex[1] == 0x42) {
+					if (hex[2] == 0xe0) {
+						isCompPoint = true;
+					} else if (hex[2] != 0xc0) {
+						callback(new Error(ninja.translator.get("detailalertnotvalidprivatekey")));
+						return;
+					}
+				} else if (hex[1] == 0x43) {
+					isECMult = true;
+					isCompPoint = (hex[2] & 0x20) != 0;
+					hasLotSeq = (hex[2] & 0x04) != 0;
+					if ((hex[2] & 0x24) != hex[2]) {
+						callback(new Error(ninja.translator.get("detailalertnotvalidprivatekey")));
+						return;
+					}
+				} else {
+					callback(new Error(ninja.translator.get("detailalertnotvalidprivatekey")));
+					return;
+				}
+
+				var decrypted;
+				var AES_opts = {mode: new Crypto.mode.ECB(Crypto.pad.NoPadding), asBytes: true};
+
+				var verifyHashAndReturn = function() {
+					var tmpkey = new Bitcoin.ECKey(decrypted);
+					var base58AddrText = isCompPoint ? tmpkey.getBitcoinAddressCompressed() : tmpkey.getBitcoinAddress();
+					checksum = Bitcoin.Util.dsha256(base58AddrText);
+
+					if (checksum[0] != hex[3] || checksum[1] != hex[4] || checksum[2] != hex[5] || checksum[3] != hex[6]) {
+						callback(new Error(ninja.translator.get("bip38alertincorrectpassphrase")));
+						return;
+					}
+
+					callback(tmpkey.getBitcoinPrivateKeyByteArray());
+				};
+
+				if (!isECMult) {
+					var addresshash = hex.slice(3, 7);
+					Crypto_scrypt(passphrase, addresshash, 16384, 8, 8, 64, function(derivedBytes) {
+						var k = derivedBytes.slice(32, 32+32);
+						decrypted = Crypto.AES.decrypt(hex.slice(7, 7+32), k, AES_opts);
+						for (var x = 0; x < 32; x++) decrypted[x] ^= derivedBytes[x];
+						verifyHashAndReturn();
+					});
+				} else {
+					var ownerentropy = hex.slice(7, 7+8);
+					var ownersalt = !hasLotSeq ? ownerentropy : ownerentropy.slice(0, 4);
+					Crypto_scrypt(passphrase, ownersalt, 16384, 8, 8, 32, function(prefactorA) {
+						var passfactor;
+						if (!hasLotSeq) {
+							passfactor = prefactorA;
+						} else {
+							var prefactorB = prefactorA.concat(ownerentropy);
+							passfactor = Bitcoin.Util.dsha256(prefactorB);
+						}
+						var kp = new Bitcoin.ECKey(passfactor);
+						var passpoint = kp.getPubCompressed();
+
+						var encryptedpart2 = hex.slice(23, 23+16);
+
+						var addresshashplusownerentropy = hex.slice(3, 3+12);
+						Crypto_scrypt(passpoint, addresshashplusownerentropy, 1024, 1, 1, 64, function(derived) {
+							var k = derived.slice(32);
+
+							var unencryptedpart2 = Crypto.AES.decrypt(encryptedpart2, k, AES_opts);
+							for (var i = 0; i < 16; i++) { unencryptedpart2[i] ^= derived[i+16]; }
+
+							var encryptedpart1 = hex.slice(15, 15+8).concat(unencryptedpart2.slice(0, 0+8));
+							var unencryptedpart1 = Crypto.AES.decrypt(encryptedpart1, k, AES_opts);
+							for (var i = 0; i < 16; i++) { unencryptedpart1[i] ^= derived[i]; }
+
+							var seedb = unencryptedpart1.slice(0, 0+16).concat(unencryptedpart2.slice(8, 8+8));
+
+							var factorb = Bitcoin.Util.dsha256(seedb);
+
+							var ps = EllipticCurve.getSECCurveByName("secp256k1");
+							var privateKey = BigInteger.fromByteArrayUnsigned(passfactor).multiply(BigInteger.fromByteArrayUnsigned(factorb)).remainder(ps.getN());
+
+							decrypted = privateKey.toByteArrayUnsigned();
+							verifyHashAndReturn();
+						});
+					});
+				}
+
 			}
 		};
 
@@ -4714,7 +5717,8 @@
 					"vanityalertinvalidinputpublickeysmatch": "Invalid input. The Public Key of both entries match. You must input two different keys.",
 					"vanityalertinvalidinputcannotmultiple": "Invalid input. Cannot multiple two public keys. Select 'Add' to add two public keys to get a bitcoin address.",
 					"vanityprivatekeyonlyavailable": "Only available when combining two private keys",
-					"vanityalertinvalidinputprivatekeysmatch": "Invalid input. The Private Key of both entries match. You must input two different keys."
+					"vanityalertinvalidinputprivatekeysmatch": "Invalid input. The Private Key of both entries match. You must input two different keys.",
+					"bip38alertincorrectpassphrase": "Incorrect passphrase for this encrypted private key."
 				},
 
 				"es": {
@@ -4733,6 +5737,7 @@
 					"vanityalertinvalidinputcannotmultiple": "Invalid input. Cannot multiple two public keys. Select 'Add' to add two public keys to get a bitcoin address.", //TODO: please translate
 					"vanityprivatekeyonlyavailable": "Only available when combining two private keys", //TODO: please translate
 					"vanityalertinvalidinputprivatekeysmatch": "Invalid input. The Private Key of both entries match. You must input two different keys.", //TODO: please translate
+					"bip38alertincorrectpassphrase": "Incorrect passphrase for this encrypted private key.", //TODO: please translate
 
 					// header and menu html
 					"tagline": "Generador de carteras Bitcoin de código abierto en lado de cliente con Javascript",
@@ -4831,7 +5836,9 @@
 					"detailcompwifprefix": "'K' o 'L'",
 					"detaillabelprivhex": "Clave privada en formato hexadecimal (64 caracteres [0-9A-F]):",
 					"detaillabelprivb64": "Clave privada en base64 (44 caracteres):",
-					"detaillabelprivmini": "Clave privada en formato mini (22, 26 o 30 caracteres, empieza por 'S'):"
+					"detaillabelprivmini": "Clave privada en formato mini (22, 26 o 30 caracteres, empieza por 'S'):",
+					"detaillabelpassphrase": "BIP38 Passphrase", // TODO: please translate,
+					"detaildecrypt": "Decrypt BIP38", // TODO: please translate
 				}
 			}
 		};
@@ -5326,7 +6333,7 @@
 				document.getElementById("detailarea").style.display = "none";
 			},
 
-			viewDetails: function () {
+			viewDetails: function (bip38) {
 				var key = document.getElementById("detailprivkey").value.toString().replace(/^\s+|\s+$/g, ""); // trim white space
 				document.getElementById("detailprivkey").value = key;
 				var keyFormat = ninja.privateKey;
@@ -5339,8 +6346,13 @@
 					// hide Private Key Mini Format
 					document.getElementById("detailmini").style.display = "none";
 				}
-				var btcKey = ninja.privateKey.anyPrivateKeyToECKey(key);
-				if (btcKey == null) {
+				var btcKey = null;
+
+				if (!bip38) {
+					btcKey = ninja.privateKey.anyPrivateKeyToECKey(key);
+				}
+
+				if (btcKey == null && !bip38) {
 					// enforce a minimum passphrase length
 					if (key.length >= ninja.wallets.brainwallet.minPassphraseLength) {
 						// Deterministic Wallet confirm box to ask if user wants to SHA256 the input to get a private key
@@ -5358,7 +6370,8 @@
 						ninja.wallets.detailwallet.clear();
 					}
 				}
-				if (btcKey != undefined) {
+
+				var populateKeyDetails = function(btcKey) {
 					document.getElementById("detailpubkey").innerHTML = btcKey.getPubKeyHex();
 					document.getElementById("detailpubkeycomp").innerHTML = btcKey.getPubKeyHexCompressed();
 					document.getElementById("detailaddress").innerHTML = btcKey.getBitcoinAddress();
@@ -5373,6 +6386,26 @@
 						"detailqrcodeprivate": btcKey.getBitcoinWalletImportFormat(),
 						"detailqrcodeprivatecomp": btcKey.getBitcoinWalletImportFormatCompressed()
 					});
+				};
+				if (btcKey != undefined) {
+					populateKeyDetails(btcKey);
+				}
+
+				if (bip38) {
+					var passphrase = document.getElementById("detailprivkeypassphrase").value.toString().replace(/^\s+|\s+$/g, ""); // trim white space
+					if (passphrase == "") {
+						alert("Passphrase required for BIP38 key");
+						return;
+					}
+					ninja.privateKey.BIP38EncryptedKeyToByteArrayAsync(key, passphrase, function (btcKeyOrError) {
+						if (btcKeyOrError.message) {
+							alert(btcKeyOrError.message);
+							ninja.wallets.detailwallet.clear();
+						} else {
+							populateKeyDetails(new Bitcoin.ECKey(btcKeyOrError));
+						}
+					});
+					return;
 				}
 			},
 
@@ -5533,6 +6566,38 @@
 				if (btcKey.getBitcoinWalletImportFormat() != "5JrBLQseeZdYw4jWEAHmNxGMr5fxh9NJU3fUwnv4khfKcg2rJVh") {
 					alert("fail testMini30CharsToECKey");
 				}
+			},
+			testBip38: function() {
+				var tests = [["6PRVWUbkzzsbcVac2qwfssoUJAN1Xhrg6bNk8J7Nzm5H7kxEbn2Nh2ZoGg","TestingOneTwoThree","5KN7MzqK5wt2TP1fQCYyHBtDrXdJuXbUzm4A9rKAteGu3Qi5CVR"],
+				["6PRNFFkZc2NZ6dJqFfhRoFNMR9Lnyj7dYGrzdgXXVMXcxoKTePPX1dWByq","Satoshi","5HtasZ6ofTHP6HCwTqTkLDuLQisYPah7aUnSKfC7h4hMUVw2gi5"],
+				["6PYNKZ1EAgYgmQfmNVamxyXVWHzK5s6DGhwP4J5o44cvXdoY7sRzhtpUeo","TestingOneTwoThree","L44B5gGEpqEDRS9vVPz7QT35jcBG2r3CZwSwQ4fCewXAhAhqGVpP"],
+				["6PYLtMnXvfG3oJde97zRyLYFZCYizPU5T3LwgdYJz1fRhh16bU7u6PPmY7","Satoshi","KwYgW8gcxj1JWJXhPSu4Fqwzfhp5Yfi42mdYmMa4XqK7NJxXUSK7"],
+				["6PfQu77ygVyJLZjfvMLyhLMQbYnu5uguoJJ4kMCLqWwPEdfpwANVS76gTX","TestingOneTwoThree","5K4caxezwjGCGfnoPTZ8tMcJBLB7Jvyjv4xxeacadhq8nLisLR2"],
+				["6PfLGnQs6VZnrNpmVKfjotbnQuaJK4KZoPFrAjx1JMJUa1Ft8gnf5WxfKd","Satoshi","5KJ51SgxWaAYR13zd9ReMhJpwrcX47xTJh2D3fGPG9CM8vkv5sH"],
+				["6PgNBNNzDkKdhkT6uJntUXwwzQV8Rr2tZcbkDcuC9DZRsS6AtHts4Ypo1j","MOLON LABE","5JLdxTtcTHcfYcmJsNVy1v2PMDx432JPoYcBTVVRHpPaxUrdtf8"],
+				["6PgGWtx25kUg8QWvwuJAgorN6k9FbE25rv5dMRwu5SKMnfpfVe5mar2ngH",Crypto.charenc.UTF8.bytesToString([206,156,206,159,206,155,206,169,206,157,32,206,155,206,145,206,146,206,149])/*UTF-8 characters, encoded in source so they don't get corrupted*/,"5KMKKuUmAkiNbA3DazMQiLfDq47qs8MAEThm4yL8R2PhV1ov33D"]];
+				var testsDone = 0;
+				var runTest = function(test, i) {
+					ninja.privateKey.BIP38EncryptedKeyToByteArrayAsync(test[0], test[1], function(privBytes) {
+						if (privBytes.constructor == Error) {
+							alert('fail testBip38 #'+i+', error: '+privBytes.message);
+						} else {
+							var btcKey = new Bitcoin.ECKey(privBytes);
+							var wif = !test[2].substr(0,1).match(/[LK]/) ? btcKey.getBitcoinWalletImportFormat() : btcKey.getBitcoinWalletImportFormatCompressed();
+							if (wif != test[2]) {
+								alert("fail testBip38 #"+i);
+							} else {
+								console.log('pass testBip38 #'+i);
+							}
+						}
+						if (++testsDone == tests.length) {
+							alert('BIP38 tests finished');
+						}
+					});
+				}
+				for (var i = 0; i < tests.length; i++) {
+					runTest(tests[i], i);
+				}
 			}
 		};
 	</script>
@@ -5543,7 +6608,7 @@
 			for (var name in ninja.unitTests) {
 				ninja.unitTests[name]();
 			}
-			alert("running of unit tests complete");
+			alert("running of synchronous unit tests complete");
 		}
 
 		// change language