forked from novalabio/react-native-bip39
-
Notifications
You must be signed in to change notification settings - Fork 9
/
index.ts
161 lines (132 loc) · 4.26 KB
/
index.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
var unorm = require("unorm");
var assert = require("assert");
var pbkdf2 = require("react-native-fast-crypto").pbkdf2;
var createHash = require("create-hash");
import { generateSecureRandom } from "react-native-securerandom";
declare type RandomNumberGenerator = (
size: number,
callback: (err: Error | null, buf: Buffer) => void
) => void;
var DEFAULT_WORDLIST = require("../wordlists/en.json");
var SPANISH_WORDLIST = require("../wordlists/es.json");
async function mnemonicToSeed(mnemonic: string, password: string) {
var mnemonicBuffer = Buffer.from(mnemonic, "utf8");
var saltBuffer = Buffer.from(salt(password), "utf8");
return await pbkdf2.deriveAsync(
mnemonicBuffer,
saltBuffer,
2048,
64,
"sha512"
);
}
async function mnemonicToSeedHex(mnemonic: string, password: string) {
var seed = await mnemonicToSeed(mnemonic, password);
return seed.toString("hex");
}
function mnemonicToEntropy(mnemonic: string, wordlist: string[]) {
wordlist = wordlist || DEFAULT_WORDLIST;
var words = mnemonic.split(" ");
assert(words.length % 3 === 0, "Invalid mnemonic");
var belongToList = words.every(function (word) {
return wordlist.indexOf(word) > -1;
});
assert(belongToList, "Invalid mnemonic");
// convert word indices to 11 bit binary strings
var bits = words
.map(function (word) {
var index = wordlist.indexOf(word);
return lpad(index.toString(2), "0", 11);
})
.join("");
// split the binary string into ENT/CS
var dividerIndex = Math.floor(bits.length / 33) * 32;
var entropy = bits.slice(0, dividerIndex);
var checksum = bits.slice(dividerIndex);
// calculate the checksum and compare
var entropyBytes = (entropy.match(/(.{1,8})/g) as Array<string>).map(
function (bin) {
return parseInt(bin, 2);
}
);
var entropyBuffer = Buffer.from(entropyBytes);
var newChecksum = checksumBits(entropyBuffer);
assert(newChecksum === checksum, "Invalid mnemonic checksum");
return entropyBuffer.toString("hex");
}
function entropyToMnemonic(entropy: string, wordlist: string[]) {
wordlist = wordlist || DEFAULT_WORDLIST;
var entropyBuffer = Buffer.from(entropy, "hex");
var entropyBits = bytesToBinary([].slice.call(entropyBuffer));
var checksum = checksumBits(entropyBuffer);
var bits = entropyBits + checksum;
var chunks = bits.match(/(.{1,11})/g);
var words = chunks.map(function (binary: string) {
var index = parseInt(binary, 2);
return wordlist[index];
});
return words.join(" ");
}
function generateMnemonic(
strength?: number,
rng?: RandomNumberGenerator,
wordlist?: string[]
) {
return new Promise((resolve, reject) => {
strength = strength || 128;
rng = rng || generateSecureRandom;
generateSecureRandom(strength / 8)
.then((bytes) => {
if (!wordlist) {
throw new Error("No wordlist");
}
const hexBuffer = Buffer.from(bytes).toString("hex");
resolve(entropyToMnemonic(hexBuffer, wordlist));
})
.catch((err) => {
reject(err);
});
});
}
function validateMnemonic(mnemonic: string, wordlist: string[]) {
try {
mnemonicToEntropy(mnemonic, wordlist);
} catch (e) {
return false;
}
return true;
}
function checksumBits(entropyBuffer: Buffer) {
var hash = createHash("sha256").update(entropyBuffer).digest();
// Calculated constants from BIP39
var ENT = entropyBuffer.length * 8;
var CS = ENT / 32;
return bytesToBinary([].slice.call(hash)).slice(0, CS);
}
function salt(password: string) {
return "mnemonic" + (unorm.nfkd(password) || ""); // Use unorm until String.prototype.normalize gets better browser support
}
//=========== helper methods from bitcoinjs-lib ========
function bytesToBinary(bytes: any) {
return bytes
.map(function (x: any) {
return lpad(x.toString(2), "0", 8);
})
.join("");
}
function lpad(str: string, padString: string, length: number) {
while (str.length < length) str = padString + str;
return str;
}
module.exports = {
mnemonicToSeed: mnemonicToSeed,
mnemonicToSeedHex: mnemonicToSeedHex,
mnemonicToEntropy: mnemonicToEntropy,
entropyToMnemonic: entropyToMnemonic,
generateMnemonic: generateMnemonic,
validateMnemonic: validateMnemonic,
wordlists: {
EN: DEFAULT_WORDLIST,
ES: SPANISH_WORDLIST,
},
};