Socket
Socket
Sign inDemoInstall

@iov/crypto

Package Overview
Dependencies
Maintainers
3
Versions
83
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@iov/crypto - npm Package Compare versions

Comparing version 0.13.7 to 0.13.8

build/englishmnemonic.js
build/englishmnemonic.js.map
build/englishmnemonic.spec.js
build/englishmnemonic.spec.js.map
build/testdata/bip39.json
build/testdata/keccak.json
build/testdata/sha.json
src/englishmnemonic.spec.ts
src/englishmnemonic.ts
src/testdata/bip39.json
src/testdata/keccak.json
src/testdata/sha.json
types/englishmnemonic.d.ts

35

build/bip39.js

@@ -17,39 +17,8 @@ "use strict";

};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const bip39 = __importStar(require("bip39"));
// tslint:disable-next-line:no-submodule-imports
const english_json_1 = __importDefault(require("bip39/wordlists/english.json"));
const pbkdf2_1 = require("pbkdf2");
const unorm = __importStar(require("unorm"));
const encoding_1 = require("@iov/encoding");
class EnglishMnemonic {
constructor(mnemonic) {
if (!EnglishMnemonic.mnemonicMatcher.test(mnemonic)) {
throw new Error("Invalid mnemonic format");
}
const words = mnemonic.split(" ");
const allowedWordsLengths = [12, 15, 18, 21, 24];
if (allowedWordsLengths.indexOf(words.length) === -1) {
throw new Error(`Invalid word count in mnemonic (allowed: ${allowedWordsLengths} got: ${words.length})`);
}
for (const word of words) {
if (english_json_1.default.indexOf(word) === -1) {
throw new Error("Mnemonic contains invalid word");
}
}
// Throws with informative error message if mnemonic is not valid
// tslint:disable-next-line:no-unused-expression
bip39.mnemonicToEntropy(mnemonic);
this.data = mnemonic;
}
asString() {
return this.data;
}
}
// list of space separated lower case words (1 or more)
EnglishMnemonic.mnemonicMatcher = /^[a-z]+( [a-z]+)*$/;
exports.EnglishMnemonic = EnglishMnemonic;
const englishmnemonic_1 = require("./englishmnemonic");
class Bip39 {

@@ -61,3 +30,3 @@ static encode(entropy) {

}
return new EnglishMnemonic(bip39.entropyToMnemonic(encoding_1.Encoding.toHex(entropy)));
return new englishmnemonic_1.EnglishMnemonic(bip39.entropyToMnemonic(encoding_1.Encoding.toHex(entropy)));
}

@@ -64,0 +33,0 @@ static decode(mnemonic) {

342

build/bip39.spec.js

@@ -10,276 +10,92 @@ "use strict";

};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const encoding_1 = require("@iov/encoding");
const bip39_1 = require("./bip39");
const englishmnemonic_1 = require("./englishmnemonic");
const bip39_json_1 = __importDefault(require("./testdata/bip39.json"));
const fromHex = encoding_1.Encoding.fromHex;
describe("Bip39", () => {
it("can encode to mnemonic", () => {
// Test vectors from
// https://github.com/trezor/python-mnemonic/blob/b502451a33a440783926e04428115e0bed87d01f/vectors.json
expect(bip39_1.Bip39.encode(fromHex("00000000000000000000000000000000")).asString()).toEqual("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about");
expect(bip39_1.Bip39.encode(fromHex("7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f")).asString()).toEqual("legal winner thank year wave sausage worth useful legal winner thank yellow");
expect(bip39_1.Bip39.encode(fromHex("80808080808080808080808080808080")).asString()).toEqual("letter advice cage absurd amount doctor acoustic avoid letter advice cage above");
expect(bip39_1.Bip39.encode(fromHex("ffffffffffffffffffffffffffffffff")).asString()).toEqual("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong");
expect(bip39_1.Bip39.encode(fromHex("0000000000000000000000000000000000000000")).asString()).toEqual("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon address");
expect(bip39_1.Bip39.encode(fromHex("7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f")).asString()).toEqual("legal winner thank year wave sausage worth useful legal winner thank year wave sausage wise");
expect(bip39_1.Bip39.encode(fromHex("8080808080808080808080808080808080808080")).asString()).toEqual("letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor accident");
expect(bip39_1.Bip39.encode(fromHex("ffffffffffffffffffffffffffffffffffffffff")).asString()).toEqual("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrist");
expect(bip39_1.Bip39.encode(fromHex("000000000000000000000000000000000000000000000000")).asString()).toEqual("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon agent");
expect(bip39_1.Bip39.encode(fromHex("7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f")).asString()).toEqual("legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal will");
expect(bip39_1.Bip39.encode(fromHex("808080808080808080808080808080808080808080808080")).asString()).toEqual("letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter always");
expect(bip39_1.Bip39.encode(fromHex("ffffffffffffffffffffffffffffffffffffffffffffffff")).asString()).toEqual("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo when");
expect(bip39_1.Bip39.encode(fromHex("00000000000000000000000000000000000000000000000000000000")).asString()).toEqual("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon admit");
expect(bip39_1.Bip39.encode(fromHex("7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f")).asString()).toEqual("legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal winner thank year viable");
expect(bip39_1.Bip39.encode(fromHex("80808080808080808080808080808080808080808080808080808080")).asString()).toEqual("letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd apart");
expect(bip39_1.Bip39.encode(fromHex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffff")).asString()).toEqual("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo veteran");
expect(bip39_1.Bip39.encode(fromHex("0000000000000000000000000000000000000000000000000000000000000000")).asString()).toEqual("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art");
expect(bip39_1.Bip39.encode(fromHex("7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f")).asString()).toEqual("legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth title");
expect(bip39_1.Bip39.encode(fromHex("8080808080808080808080808080808080808080808080808080808080808080")).asString()).toEqual("letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic bless");
expect(bip39_1.Bip39.encode(fromHex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")).asString()).toEqual("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo vote");
expect(bip39_1.Bip39.encode(fromHex("9e885d952ad362caeb4efe34a8e91bd2")).asString()).toEqual("ozone drill grab fiber curtain grace pudding thank cruise elder eight picnic");
expect(bip39_1.Bip39.encode(fromHex("610b25967cdcca9d59875f5cb50b0ea754333118")).asString()).toEqual("genre float grain whale smile exchange gravity typical frequent portion senior exchange drip obtain glow");
expect(bip39_1.Bip39.encode(fromHex("6610b25967cdcca9d59875f5cb50b0ea75433311869e930b")).asString()).toEqual("gravity machine north sort system female filter attitude volume fold club stay feature office ecology stable narrow fog");
expect(bip39_1.Bip39.encode(fromHex("8a79eaca2324873eacc50cb9c6eca8cc68ea5d936f98787c60c7ebc7")).asString()).toEqual("media soon raw edge embody palm reason pave right danger clay occur modify conduct ethics vessel journey toast cradle stuff laundry");
expect(bip39_1.Bip39.encode(fromHex("68a79eaca2324873eacc50cb9c6eca8cc68ea5d936f98787c60c7ebc74e6ce7c")).asString()).toEqual("hamster diagram private dutch cause delay private meat slide toddler razor book happy fancy gospel tennis maple dilemma loan word shrug inflict delay length");
expect(bip39_1.Bip39.encode(fromHex("c0ba5a8e914111210f2bd131f3d5e08d")).asString()).toEqual("scheme spot photo card baby mountain device kick cradle pact join borrow");
expect(bip39_1.Bip39.encode(fromHex("232c38b9a99e10d2253fa1aa2739a8e9c3b112d0")).asString()).toEqual("case gift common farm three harbor neutral vintage pretty degree health squeeze deposit maximum donor");
expect(bip39_1.Bip39.encode(fromHex("6d9be1ee6ebd27a258115aad99b7317b9c8d28b6d76431c3")).asString()).toEqual("horn tenant knee talent sponsor spell gate clip pulse soap slush warm silver nephew swap uncle crack brave");
expect(bip39_1.Bip39.encode(fromHex("49208c3112119c4770d44d1a9726b44135748bda464954338f3c1d91")).asString()).toEqual("empty afford arrange category border casual select meadow box rice public list firm echo harbor since feature organ someone depth bitter");
expect(bip39_1.Bip39.encode(fromHex("9f6a2878b2520799a44ef18bc7df394e7061a224d2c33cd015b157d746869863")).asString()).toEqual("panda eyebrow bullet gorilla call smoke muffin taste mesh discover soft ostrich alcohol speed nation flash devote level hobby quick inner drive ghost inside");
expect(bip39_1.Bip39.encode(fromHex("23db8160a31d3e0dca3688ed941adbf3")).asString()).toEqual("cat swing flag economy stadium alone churn speed unique patch report train");
expect(bip39_1.Bip39.encode(fromHex("c9a0ed1374180cd8f8c5cc0bc9c719dfb67add59")).asString()).toEqual("situate alter dynamic trial liar hockey toast ridge armed evolve shoe satoshi guilt huge grass");
expect(bip39_1.Bip39.encode(fromHex("8197a4a47f0425faeaa69deebc05ca29c0a5b5cc76ceacc0")).asString()).toEqual("light rule cinnamon wrap drastic word pride squirrel upgrade then income fatal apart sustain crack supply proud access");
expect(bip39_1.Bip39.encode(fromHex("dc8a247c5379f57c24dbfbd6a0699a8282875dd0a3f0f39b8fc020a4")).asString()).toEqual("symptom eye business plunge palm safe nature legal stove addict grit agree chronic puzzle dream lawn vicious symbol useless donor eagle");
expect(bip39_1.Bip39.encode(fromHex("066dca1a2bb7e8a1db2832148ce9933eea0f3ac9548d793112d9a95c9407efad")).asString()).toEqual("all hour make first leader extend hole alien behind guard gospel lava path output census museum junior mass reopen famous sing advance salt reform");
expect(bip39_1.Bip39.encode(fromHex("f30f8c1da665478f49b001d94c5fc452")).asString()).toEqual("vessel ladder alter error federal sibling chat ability sun glass valve picture");
expect(bip39_1.Bip39.encode(fromHex("ef38bbc81a5fa1756dfd654b0cc1a1759ce1ed94")).asString()).toEqual("upset shift velvet cruise wheel rival retire protect enrich gravity hair twenty sock walnut fat");
expect(bip39_1.Bip39.encode(fromHex("c10ec20dc3cd9f652c7fac2f1230f7a3c828389a14392f05")).asString()).toEqual("scissors invite lock maple supreme raw rapid void congress muscle digital elegant little brisk hair mango congress clump");
expect(bip39_1.Bip39.encode(fromHex("a66afdf103bf42b5858cd1c23a20f7e5114edb111880d634b53454bf")).asString()).toEqual("please fitness labor alter vintage food bike olive season speed digital sketch belt horn dutch avoid stomach pizza escape practice walnut");
expect(bip39_1.Bip39.encode(fromHex("f585c11aec520db57dd353c69554b21a89b20fb0650966fa0a9d6f74fd989d8f")).asString()).toEqual("void come effort suffer camp survey warrior heavy shoot primary clutch crush open amazing screen patrol group space point ten exist slush involve unfold");
// invalid input length
expect(() => {
bip39_1.Bip39.encode(fromHex(""));
}).toThrowError(/invalid input length/);
expect(() => {
bip39_1.Bip39.encode(fromHex("00"));
}).toThrowError(/invalid input length/);
expect(() => {
bip39_1.Bip39.encode(fromHex("000000000000000000000000000000"));
}).toThrowError(/invalid input length/);
expect(() => {
bip39_1.Bip39.encode(fromHex("0000000000000000000000000000000000"));
}).toThrowError(/invalid input length/);
expect(() => {
bip39_1.Bip39.encode(fromHex("0000000000000000000000000000000000000000000000"));
}).toThrowError(/invalid input length/);
expect(() => {
bip39_1.Bip39.encode(fromHex("00000000000000000000000000000000000000000000000000"));
}).toThrowError(/invalid input length/);
expect(() => {
bip39_1.Bip39.encode(fromHex("00000000000000000000000000000000000000000000000000000000000000"));
}).toThrowError(/invalid input length/);
expect(() => {
bip39_1.Bip39.encode(fromHex("000000000000000000000000000000000000000000000000000000000000000000"));
}).toThrowError(/invalid input length/);
});
describe("EnglishMnemonic", () => {
// tslint:disable:no-unused-expression
it("works for valid inputs", () => {
expect(() => {
new bip39_1.EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about");
new bip39_1.EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon address");
new bip39_1.EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon agent");
new bip39_1.EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon admit");
new bip39_1.EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art");
}).not.toThrow();
describe("encode", () => {
it("can encode to mnemonic", () => {
// Test vectors from https://github.com/trezor/python-mnemonic/blob/b502451a33a440783926e04428115e0bed87d01f/vectors.json
// plus similar vectors generated for the missing lengths 15 and 21 words
const { "12": vec12, "15": vec15, "18": vec18, "21": vec21, "24": vec24 } = bip39_json_1.default.encoding;
for (const vectors of [vec12, vec15, vec18, vec21, vec24]) {
for (const { entropy, mnemonic } of vectors) {
expect(bip39_1.Bip39.encode(fromHex(entropy)).asString()).toEqual(mnemonic);
}
}
});
it("rejects invalid whitespacing", () => {
// extra space (leading, middle, trailing)
expect(() => {
new bip39_1.EnglishMnemonic(" abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about");
}).toThrowError(/invalid mnemonic format/i);
expect(() => {
new bip39_1.EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about");
}).toThrowError(/invalid mnemonic format/i);
expect(() => {
new bip39_1.EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about ");
}).toThrowError(/invalid mnemonic format/i);
// newline, tab
expect(() => {
new bip39_1.EnglishMnemonic("abandon\nabandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about");
}).toThrowError(/invalid mnemonic format/i);
expect(() => {
new bip39_1.EnglishMnemonic("abandon\tabandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about");
}).toThrowError(/invalid mnemonic format/i);
it("throws for invalid input", () => {
// invalid input length
expect(() => bip39_1.Bip39.encode(fromHex(""))).toThrowError(/invalid input length/);
expect(() => bip39_1.Bip39.encode(fromHex("00"))).toThrowError(/invalid input length/);
expect(() => bip39_1.Bip39.encode(fromHex("000000000000000000000000000000"))).toThrowError(/invalid input length/);
expect(() => bip39_1.Bip39.encode(fromHex("0000000000000000000000000000000000"))).toThrowError(/invalid input length/);
expect(() => bip39_1.Bip39.encode(fromHex("0000000000000000000000000000000000000000000000"))).toThrowError(/invalid input length/);
expect(() => bip39_1.Bip39.encode(fromHex("00000000000000000000000000000000000000000000000000"))).toThrowError(/invalid input length/);
expect(() => bip39_1.Bip39.encode(fromHex("00000000000000000000000000000000000000000000000000000000000000"))).toThrowError(/invalid input length/);
expect(() => bip39_1.Bip39.encode(fromHex("000000000000000000000000000000000000000000000000000000000000000000"))).toThrowError(/invalid input length/);
});
it("rejects disallowed letters", () => {
// Disallowed letters in words (capital, number, special char)
expect(() => {
new bip39_1.EnglishMnemonic("Abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about");
}).toThrowError(/invalid mnemonic format/i);
expect(() => {
new bip39_1.EnglishMnemonic("abandon abandon Abandon abandon abandon abandon abandon abandon abandon abandon abandon about");
}).toThrowError(/invalid mnemonic format/i);
expect(() => {
new bip39_1.EnglishMnemonic("route66 abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about");
}).toThrowError(/invalid mnemonic format/i);
expect(() => {
new bip39_1.EnglishMnemonic("abandon abandon route66 abandon abandon abandon abandon abandon abandon abandon abandon about");
}).toThrowError(/invalid mnemonic format/i);
expect(() => {
new bip39_1.EnglishMnemonic("lötkolben abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about");
}).toThrowError(/invalid mnemonic format/i);
expect(() => {
new bip39_1.EnglishMnemonic("abandon abandon lötkolben abandon abandon abandon abandon abandon abandon abandon abandon about");
}).toThrowError(/invalid mnemonic format/i);
});
describe("decode", () => {
it("can decode from mnemonic", () => {
const { "12": vec12, "15": vec15, "18": vec18, "21": vec21, "24": vec24 } = bip39_json_1.default.encoding;
for (const vectors of [vec12, vec15, vec18, vec21, vec24]) {
for (const { entropy, mnemonic } of vectors) {
expect(bip39_1.Bip39.decode(new englishmnemonic_1.EnglishMnemonic(mnemonic))).toEqual(fromHex(entropy));
}
}
});
it("word counts other than 12, 15, 18, 21, 24", () => {
// too few and too many words (11, 13, 17, 19, 23, 25)
expect(() => {
new bip39_1.EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about");
}).toThrowError(/invalid word count(.*)got: 11/i);
expect(() => {
new bip39_1.EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about");
}).toThrowError(/invalid word count(.*)got: 13/i);
expect(() => {
new bip39_1.EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon agent");
}).toThrowError(/invalid word count(.*)got: 17/i);
expect(() => {
new bip39_1.EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon agent");
}).toThrowError(/invalid word count(.*)got: 19/i);
expect(() => {
new bip39_1.EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art");
}).toThrowError(/invalid word count(.*)got: 23/i);
expect(() => {
new bip39_1.EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art");
}).toThrowError(/invalid word count(.*)got: 25/i);
});
it("rejects invalid checksums", () => {
// 12x, 15x, 18x, 21x, 24x "zoo"
expect(() => {
new bip39_1.EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo");
}).toThrowError(/invalid mnemonic checksum/i);
expect(() => {
new bip39_1.EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo");
}).toThrowError(/invalid mnemonic checksum/i);
expect(() => {
new bip39_1.EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo");
}).toThrowError(/invalid mnemonic checksum/i);
expect(() => {
new bip39_1.EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo");
}).toThrowError(/invalid mnemonic checksum/i);
expect(() => {
new bip39_1.EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo");
}).toThrowError(/invalid mnemonic checksum/i);
});
it("rejects valid mnemonics of other languages", () => {
// valid Spanish and Italian bip39 mnemonics
expect(() => {
new bip39_1.EnglishMnemonic("humo odio oriente colina taco fingir salto geranio glaciar academia suave vigor");
}).toThrowError(/contains invalid word/i);
expect(() => {
new bip39_1.EnglishMnemonic("yema folleto tos llave obtener natural fruta deseo laico sopa novato lazo imponer afinar vena hoja zarza cama");
}).toThrowError(/contains invalid word/i);
expect(() => {
new bip39_1.EnglishMnemonic("burla plaza arroz ronda pregunta vacuna veloz boina retiro exento prensa tortuga cabeza pilar anual molino molde fiesta masivo jefe leve fatiga clase plomo");
}).toThrowError(/contains invalid word/i);
expect(() => {
new bip39_1.EnglishMnemonic("braccio trincea armonia emiro svedese lepre stridulo metallo baldo rasente potassio rilassato");
}).toThrowError(/contains invalid word/i);
expect(() => {
new bip39_1.EnglishMnemonic("riparato arrosto globulo singolo bozzolo roba pirolisi ultimato padrone munto leggero avanzato monetario guanto lorenzo latino inoltrare modulo");
}).toThrowError(/contains invalid word/i);
expect(() => {
new bip39_1.EnglishMnemonic("promessa mercurio spessore snodo trave risata mecenate vichingo ceto orecchino vissuto risultato canino scarso futile fune epilogo uovo inedito apatico folata egoismo rifugio coma");
}).toThrowError(/contains invalid word/i);
});
// tslint:enable:no-unused-expression
});
it("can decode from mnemonic", () => {
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"))).toEqual(fromHex("00000000000000000000000000000000"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("legal winner thank year wave sausage worth useful legal winner thank yellow"))).toEqual(fromHex("7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("letter advice cage absurd amount doctor acoustic avoid letter advice cage above"))).toEqual(fromHex("80808080808080808080808080808080"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong"))).toEqual(fromHex("ffffffffffffffffffffffffffffffff"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon address"))).toEqual(fromHex("0000000000000000000000000000000000000000"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("legal winner thank year wave sausage worth useful legal winner thank year wave sausage wise"))).toEqual(fromHex("7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor accident"))).toEqual(fromHex("8080808080808080808080808080808080808080"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrist"))).toEqual(fromHex("ffffffffffffffffffffffffffffffffffffffff"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon agent"))).toEqual(fromHex("000000000000000000000000000000000000000000000000"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal will"))).toEqual(fromHex("7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter always"))).toEqual(fromHex("808080808080808080808080808080808080808080808080"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo when"))).toEqual(fromHex("ffffffffffffffffffffffffffffffffffffffffffffffff"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon admit"))).toEqual(fromHex("00000000000000000000000000000000000000000000000000000000"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal winner thank year viable"))).toEqual(fromHex("7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd apart"))).toEqual(fromHex("80808080808080808080808080808080808080808080808080808080"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo veteran"))).toEqual(fromHex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art"))).toEqual(fromHex("0000000000000000000000000000000000000000000000000000000000000000"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth title"))).toEqual(fromHex("7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic bless"))).toEqual(fromHex("8080808080808080808080808080808080808080808080808080808080808080"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo vote"))).toEqual(fromHex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("ozone drill grab fiber curtain grace pudding thank cruise elder eight picnic"))).toEqual(fromHex("9e885d952ad362caeb4efe34a8e91bd2"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("genre float grain whale smile exchange gravity typical frequent portion senior exchange drip obtain glow"))).toEqual(fromHex("610b25967cdcca9d59875f5cb50b0ea754333118"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("gravity machine north sort system female filter attitude volume fold club stay feature office ecology stable narrow fog"))).toEqual(fromHex("6610b25967cdcca9d59875f5cb50b0ea75433311869e930b"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("media soon raw edge embody palm reason pave right danger clay occur modify conduct ethics vessel journey toast cradle stuff laundry"))).toEqual(fromHex("8a79eaca2324873eacc50cb9c6eca8cc68ea5d936f98787c60c7ebc7"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("hamster diagram private dutch cause delay private meat slide toddler razor book happy fancy gospel tennis maple dilemma loan word shrug inflict delay length"))).toEqual(fromHex("68a79eaca2324873eacc50cb9c6eca8cc68ea5d936f98787c60c7ebc74e6ce7c"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("scheme spot photo card baby mountain device kick cradle pact join borrow"))).toEqual(fromHex("c0ba5a8e914111210f2bd131f3d5e08d"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("case gift common farm three harbor neutral vintage pretty degree health squeeze deposit maximum donor"))).toEqual(fromHex("232c38b9a99e10d2253fa1aa2739a8e9c3b112d0"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("horn tenant knee talent sponsor spell gate clip pulse soap slush warm silver nephew swap uncle crack brave"))).toEqual(fromHex("6d9be1ee6ebd27a258115aad99b7317b9c8d28b6d76431c3"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("empty afford arrange category border casual select meadow box rice public list firm echo harbor since feature organ someone depth bitter"))).toEqual(fromHex("49208c3112119c4770d44d1a9726b44135748bda464954338f3c1d91"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("panda eyebrow bullet gorilla call smoke muffin taste mesh discover soft ostrich alcohol speed nation flash devote level hobby quick inner drive ghost inside"))).toEqual(fromHex("9f6a2878b2520799a44ef18bc7df394e7061a224d2c33cd015b157d746869863"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("cat swing flag economy stadium alone churn speed unique patch report train"))).toEqual(fromHex("23db8160a31d3e0dca3688ed941adbf3"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("situate alter dynamic trial liar hockey toast ridge armed evolve shoe satoshi guilt huge grass"))).toEqual(fromHex("c9a0ed1374180cd8f8c5cc0bc9c719dfb67add59"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("light rule cinnamon wrap drastic word pride squirrel upgrade then income fatal apart sustain crack supply proud access"))).toEqual(fromHex("8197a4a47f0425faeaa69deebc05ca29c0a5b5cc76ceacc0"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("symptom eye business plunge palm safe nature legal stove addict grit agree chronic puzzle dream lawn vicious symbol useless donor eagle"))).toEqual(fromHex("dc8a247c5379f57c24dbfbd6a0699a8282875dd0a3f0f39b8fc020a4"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("all hour make first leader extend hole alien behind guard gospel lava path output census museum junior mass reopen famous sing advance salt reform"))).toEqual(fromHex("066dca1a2bb7e8a1db2832148ce9933eea0f3ac9548d793112d9a95c9407efad"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("vessel ladder alter error federal sibling chat ability sun glass valve picture"))).toEqual(fromHex("f30f8c1da665478f49b001d94c5fc452"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("upset shift velvet cruise wheel rival retire protect enrich gravity hair twenty sock walnut fat"))).toEqual(fromHex("ef38bbc81a5fa1756dfd654b0cc1a1759ce1ed94"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("scissors invite lock maple supreme raw rapid void congress muscle digital elegant little brisk hair mango congress clump"))).toEqual(fromHex("c10ec20dc3cd9f652c7fac2f1230f7a3c828389a14392f05"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("please fitness labor alter vintage food bike olive season speed digital sketch belt horn dutch avoid stomach pizza escape practice walnut"))).toEqual(fromHex("a66afdf103bf42b5858cd1c23a20f7e5114edb111880d634b53454bf"));
expect(bip39_1.Bip39.decode(new bip39_1.EnglishMnemonic("void come effort suffer camp survey warrior heavy shoot primary clutch crush open amazing screen patrol group space point ten exist slush involve unfold"))).toEqual(fromHex("f585c11aec520db57dd353c69554b21a89b20fb0650966fa0a9d6f74fd989d8f"));
describe("mnemonicToSeed", () => {
it("can calculate seed from mnemonic (trezor test vectors)", () => __awaiter(this, void 0, void 0, function* () {
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"), "TREZOR")).toEqual(fromHex("c55257c360c07c72029aebc1b53c05ed0362ada38ead3e3e9efa3708e53495531f09a6987599d18264c1e1c92f2cf141630c7a3c4ab7c81b2f001698e7463b04"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("legal winner thank year wave sausage worth useful legal winner thank yellow"), "TREZOR")).toEqual(fromHex("2e8905819b8723fe2c1d161860e5ee1830318dbf49a83bd451cfb8440c28bd6fa457fe1296106559a3c80937a1c1069be3a3a5bd381ee6260e8d9739fce1f607"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("letter advice cage absurd amount doctor acoustic avoid letter advice cage above"), "TREZOR")).toEqual(fromHex("d71de856f81a8acc65e6fc851a38d4d7ec216fd0796d0a6827a3ad6ed5511a30fa280f12eb2e47ed2ac03b5c462a0358d18d69fe4f985ec81778c1b370b652a8"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong"), "TREZOR")).toEqual(fromHex("ac27495480225222079d7be181583751e86f571027b0497b5b5d11218e0a8a13332572917f0f8e5a589620c6f15b11c61dee327651a14c34e18231052e48c069"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon agent"), "TREZOR")).toEqual(fromHex("035895f2f481b1b0f01fcf8c289c794660b289981a78f8106447707fdd9666ca06da5a9a565181599b79f53b844d8a71dd9f439c52a3d7b3e8a79c906ac845fa"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal will"), "TREZOR")).toEqual(fromHex("f2b94508732bcbacbcc020faefecfc89feafa6649a5491b8c952cede496c214a0c7b3c392d168748f2d4a612bada0753b52a1c7ac53c1e93abd5c6320b9e95dd"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter always"), "TREZOR")).toEqual(fromHex("107d7c02a5aa6f38c58083ff74f04c607c2d2c0ecc55501dadd72d025b751bc27fe913ffb796f841c49b1d33b610cf0e91d3aa239027f5e99fe4ce9e5088cd65"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo when"), "TREZOR")).toEqual(fromHex("0cd6e5d827bb62eb8fc1e262254223817fd068a74b5b449cc2f667c3f1f985a76379b43348d952e2265b4cd129090758b3e3c2c49103b5051aac2eaeb890a528"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art"), "TREZOR")).toEqual(fromHex("bda85446c68413707090a52022edd26a1c9462295029f2e60cd7c4f2bbd3097170af7a4d73245cafa9c3cca8d561a7c3de6f5d4a10be8ed2a5e608d68f92fcc8"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth title"), "TREZOR")).toEqual(fromHex("bc09fca1804f7e69da93c2f2028eb238c227f2e9dda30cd63699232578480a4021b146ad717fbb7e451ce9eb835f43620bf5c514db0f8add49f5d121449d3e87"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic bless"), "TREZOR")).toEqual(fromHex("c0c519bd0e91a2ed54357d9d1ebef6f5af218a153624cf4f2da911a0ed8f7a09e2ef61af0aca007096df430022f7a2b6fb91661a9589097069720d015e4e982f"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo vote"), "TREZOR")).toEqual(fromHex("dd48c104698c30cfe2b6142103248622fb7bb0ff692eebb00089b32d22484e1613912f0a5b694407be899ffd31ed3992c456cdf60f5d4564b8ba3f05a69890ad"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("ozone drill grab fiber curtain grace pudding thank cruise elder eight picnic"), "TREZOR")).toEqual(fromHex("274ddc525802f7c828d8ef7ddbcdc5304e87ac3535913611fbbfa986d0c9e5476c91689f9c8a54fd55bd38606aa6a8595ad213d4c9c9f9aca3fb217069a41028"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("gravity machine north sort system female filter attitude volume fold club stay feature office ecology stable narrow fog"), "TREZOR")).toEqual(fromHex("628c3827a8823298ee685db84f55caa34b5cc195a778e52d45f59bcf75aba68e4d7590e101dc414bc1bbd5737666fbbef35d1f1903953b66624f910feef245ac"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("hamster diagram private dutch cause delay private meat slide toddler razor book happy fancy gospel tennis maple dilemma loan word shrug inflict delay length"), "TREZOR")).toEqual(fromHex("64c87cde7e12ecf6704ab95bb1408bef047c22db4cc7491c4271d170a1b213d20b385bc1588d9c7b38f1b39d415665b8a9030c9ec653d75e65f847d8fc1fc440"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("scheme spot photo card baby mountain device kick cradle pact join borrow"), "TREZOR")).toEqual(fromHex("ea725895aaae8d4c1cf682c1bfd2d358d52ed9f0f0591131b559e2724bb234fca05aa9c02c57407e04ee9dc3b454aa63fbff483a8b11de949624b9f1831a9612"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("horn tenant knee talent sponsor spell gate clip pulse soap slush warm silver nephew swap uncle crack brave"), "TREZOR")).toEqual(fromHex("fd579828af3da1d32544ce4db5c73d53fc8acc4ddb1e3b251a31179cdb71e853c56d2fcb11aed39898ce6c34b10b5382772db8796e52837b54468aeb312cfc3d"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("panda eyebrow bullet gorilla call smoke muffin taste mesh discover soft ostrich alcohol speed nation flash devote level hobby quick inner drive ghost inside"), "TREZOR")).toEqual(fromHex("72be8e052fc4919d2adf28d5306b5474b0069df35b02303de8c1729c9538dbb6fc2d731d5f832193cd9fb6aeecbc469594a70e3dd50811b5067f3b88b28c3e8d"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("cat swing flag economy stadium alone churn speed unique patch report train"), "TREZOR")).toEqual(fromHex("deb5f45449e615feff5640f2e49f933ff51895de3b4381832b3139941c57b59205a42480c52175b6efcffaa58a2503887c1e8b363a707256bdd2b587b46541f5"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("light rule cinnamon wrap drastic word pride squirrel upgrade then income fatal apart sustain crack supply proud access"), "TREZOR")).toEqual(fromHex("4cbdff1ca2db800fd61cae72a57475fdc6bab03e441fd63f96dabd1f183ef5b782925f00105f318309a7e9c3ea6967c7801e46c8a58082674c860a37b93eda02"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("all hour make first leader extend hole alien behind guard gospel lava path output census museum junior mass reopen famous sing advance salt reform"), "TREZOR")).toEqual(fromHex("26e975ec644423f4a4c4f4215ef09b4bd7ef924e85d1d17c4cf3f136c2863cf6df0a475045652c57eb5fb41513ca2a2d67722b77e954b4b3fc11f7590449191d"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("vessel ladder alter error federal sibling chat ability sun glass valve picture"), "TREZOR")).toEqual(fromHex("2aaa9242daafcee6aa9d7269f17d4efe271e1b9a529178d7dc139cd18747090bf9d60295d0ce74309a78852a9caadf0af48aae1c6253839624076224374bc63f"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("scissors invite lock maple supreme raw rapid void congress muscle digital elegant little brisk hair mango congress clump"), "TREZOR")).toEqual(fromHex("7b4a10be9d98e6cba265566db7f136718e1398c71cb581e1b2f464cac1ceedf4f3e274dc270003c670ad8d02c4558b2f8e39edea2775c9e232c7cb798b069e88"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("void come effort suffer camp survey warrior heavy shoot primary clutch crush open amazing screen patrol group space point ten exist slush involve unfold"), "TREZOR")).toEqual(fromHex("01f5bced59dec48e362f2c45b5de68b9fd6c92c6634f44d6d40aab69056506f0e35524a518034ddc1192e1dacd32c1ed3eaa3c3b131c88ed8e7e54c49a5d0998"));
}));
it("can calculate seed from mnemonic (no password)", () => __awaiter(this, void 0, void 0, function* () {
// custom test vectors using
// $ git clone https://github.com/trezor/python-mnemonic.git && cd python-mnemonic
// $ python3 -m venv venv
// $ source venv/bin/activate
// $ pip install wheel bip32utils
// $ pip install -r requirements.txt
// patch generate_vectors.py to your needs
// $ python generate_vectors.py
// empty password
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("robust pipe raise illness symptom crowd trip will slow assault recipe oven"), "")).toEqual(fromHex("5539eed11e1096e9d52f69f15ad3d7c6547a40a3865b9517dbcbb03c31f231900622f58616d64d2d1cc0440f31d67fb0b2699a5fc885f796c746e0f844477093"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("pair ethics august street tornado spare present under capital raise cross current main craft stone clutch tray all"), "")).toEqual(fromHex("1272467e954cec4e0ad720002d037a3aaf795a57ffbeea6aaa0c242d410eb52050292447aa2c68470a07ecc80171edfa9e027793265047be3128d94e867a4f99"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("allow finger front connect strategy purchase journey distance trouble guitar honey alpha giraffe canal junk vintage chronic blade gate custom soap flip first mix"), "")).toEqual(fromHex("476a41ac016b5bdf9f114456929975a036ae326e2efdca441ac5a0949ef89ab9246dc9e49a5d2d64d1926eb9dbe17576cb010471c2a821b216202acdf3d7a27b"));
// no password
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("robust pipe raise illness symptom crowd trip will slow assault recipe oven"))).toEqual(fromHex("5539eed11e1096e9d52f69f15ad3d7c6547a40a3865b9517dbcbb03c31f231900622f58616d64d2d1cc0440f31d67fb0b2699a5fc885f796c746e0f844477093"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("pair ethics august street tornado spare present under capital raise cross current main craft stone clutch tray all"))).toEqual(fromHex("1272467e954cec4e0ad720002d037a3aaf795a57ffbeea6aaa0c242d410eb52050292447aa2c68470a07ecc80171edfa9e027793265047be3128d94e867a4f99"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new englishmnemonic_1.EnglishMnemonic("allow finger front connect strategy purchase journey distance trouble guitar honey alpha giraffe canal junk vintage chronic blade gate custom soap flip first mix"))).toEqual(fromHex("476a41ac016b5bdf9f114456929975a036ae326e2efdca441ac5a0949ef89ab9246dc9e49a5d2d64d1926eb9dbe17576cb010471c2a821b216202acdf3d7a27b"));
}));
});
it("can calculate seed from mnemonic (trezor test vectors)", () => __awaiter(this, void 0, void 0, function* () {
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"), "TREZOR")).toEqual(fromHex("c55257c360c07c72029aebc1b53c05ed0362ada38ead3e3e9efa3708e53495531f09a6987599d18264c1e1c92f2cf141630c7a3c4ab7c81b2f001698e7463b04"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("legal winner thank year wave sausage worth useful legal winner thank yellow"), "TREZOR")).toEqual(fromHex("2e8905819b8723fe2c1d161860e5ee1830318dbf49a83bd451cfb8440c28bd6fa457fe1296106559a3c80937a1c1069be3a3a5bd381ee6260e8d9739fce1f607"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("letter advice cage absurd amount doctor acoustic avoid letter advice cage above"), "TREZOR")).toEqual(fromHex("d71de856f81a8acc65e6fc851a38d4d7ec216fd0796d0a6827a3ad6ed5511a30fa280f12eb2e47ed2ac03b5c462a0358d18d69fe4f985ec81778c1b370b652a8"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong"), "TREZOR")).toEqual(fromHex("ac27495480225222079d7be181583751e86f571027b0497b5b5d11218e0a8a13332572917f0f8e5a589620c6f15b11c61dee327651a14c34e18231052e48c069"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon agent"), "TREZOR")).toEqual(fromHex("035895f2f481b1b0f01fcf8c289c794660b289981a78f8106447707fdd9666ca06da5a9a565181599b79f53b844d8a71dd9f439c52a3d7b3e8a79c906ac845fa"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal will"), "TREZOR")).toEqual(fromHex("f2b94508732bcbacbcc020faefecfc89feafa6649a5491b8c952cede496c214a0c7b3c392d168748f2d4a612bada0753b52a1c7ac53c1e93abd5c6320b9e95dd"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter always"), "TREZOR")).toEqual(fromHex("107d7c02a5aa6f38c58083ff74f04c607c2d2c0ecc55501dadd72d025b751bc27fe913ffb796f841c49b1d33b610cf0e91d3aa239027f5e99fe4ce9e5088cd65"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo when"), "TREZOR")).toEqual(fromHex("0cd6e5d827bb62eb8fc1e262254223817fd068a74b5b449cc2f667c3f1f985a76379b43348d952e2265b4cd129090758b3e3c2c49103b5051aac2eaeb890a528"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art"), "TREZOR")).toEqual(fromHex("bda85446c68413707090a52022edd26a1c9462295029f2e60cd7c4f2bbd3097170af7a4d73245cafa9c3cca8d561a7c3de6f5d4a10be8ed2a5e608d68f92fcc8"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth title"), "TREZOR")).toEqual(fromHex("bc09fca1804f7e69da93c2f2028eb238c227f2e9dda30cd63699232578480a4021b146ad717fbb7e451ce9eb835f43620bf5c514db0f8add49f5d121449d3e87"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic bless"), "TREZOR")).toEqual(fromHex("c0c519bd0e91a2ed54357d9d1ebef6f5af218a153624cf4f2da911a0ed8f7a09e2ef61af0aca007096df430022f7a2b6fb91661a9589097069720d015e4e982f"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo vote"), "TREZOR")).toEqual(fromHex("dd48c104698c30cfe2b6142103248622fb7bb0ff692eebb00089b32d22484e1613912f0a5b694407be899ffd31ed3992c456cdf60f5d4564b8ba3f05a69890ad"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("ozone drill grab fiber curtain grace pudding thank cruise elder eight picnic"), "TREZOR")).toEqual(fromHex("274ddc525802f7c828d8ef7ddbcdc5304e87ac3535913611fbbfa986d0c9e5476c91689f9c8a54fd55bd38606aa6a8595ad213d4c9c9f9aca3fb217069a41028"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("gravity machine north sort system female filter attitude volume fold club stay feature office ecology stable narrow fog"), "TREZOR")).toEqual(fromHex("628c3827a8823298ee685db84f55caa34b5cc195a778e52d45f59bcf75aba68e4d7590e101dc414bc1bbd5737666fbbef35d1f1903953b66624f910feef245ac"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("hamster diagram private dutch cause delay private meat slide toddler razor book happy fancy gospel tennis maple dilemma loan word shrug inflict delay length"), "TREZOR")).toEqual(fromHex("64c87cde7e12ecf6704ab95bb1408bef047c22db4cc7491c4271d170a1b213d20b385bc1588d9c7b38f1b39d415665b8a9030c9ec653d75e65f847d8fc1fc440"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("scheme spot photo card baby mountain device kick cradle pact join borrow"), "TREZOR")).toEqual(fromHex("ea725895aaae8d4c1cf682c1bfd2d358d52ed9f0f0591131b559e2724bb234fca05aa9c02c57407e04ee9dc3b454aa63fbff483a8b11de949624b9f1831a9612"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("horn tenant knee talent sponsor spell gate clip pulse soap slush warm silver nephew swap uncle crack brave"), "TREZOR")).toEqual(fromHex("fd579828af3da1d32544ce4db5c73d53fc8acc4ddb1e3b251a31179cdb71e853c56d2fcb11aed39898ce6c34b10b5382772db8796e52837b54468aeb312cfc3d"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("panda eyebrow bullet gorilla call smoke muffin taste mesh discover soft ostrich alcohol speed nation flash devote level hobby quick inner drive ghost inside"), "TREZOR")).toEqual(fromHex("72be8e052fc4919d2adf28d5306b5474b0069df35b02303de8c1729c9538dbb6fc2d731d5f832193cd9fb6aeecbc469594a70e3dd50811b5067f3b88b28c3e8d"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("cat swing flag economy stadium alone churn speed unique patch report train"), "TREZOR")).toEqual(fromHex("deb5f45449e615feff5640f2e49f933ff51895de3b4381832b3139941c57b59205a42480c52175b6efcffaa58a2503887c1e8b363a707256bdd2b587b46541f5"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("light rule cinnamon wrap drastic word pride squirrel upgrade then income fatal apart sustain crack supply proud access"), "TREZOR")).toEqual(fromHex("4cbdff1ca2db800fd61cae72a57475fdc6bab03e441fd63f96dabd1f183ef5b782925f00105f318309a7e9c3ea6967c7801e46c8a58082674c860a37b93eda02"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("all hour make first leader extend hole alien behind guard gospel lava path output census museum junior mass reopen famous sing advance salt reform"), "TREZOR")).toEqual(fromHex("26e975ec644423f4a4c4f4215ef09b4bd7ef924e85d1d17c4cf3f136c2863cf6df0a475045652c57eb5fb41513ca2a2d67722b77e954b4b3fc11f7590449191d"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("vessel ladder alter error federal sibling chat ability sun glass valve picture"), "TREZOR")).toEqual(fromHex("2aaa9242daafcee6aa9d7269f17d4efe271e1b9a529178d7dc139cd18747090bf9d60295d0ce74309a78852a9caadf0af48aae1c6253839624076224374bc63f"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("scissors invite lock maple supreme raw rapid void congress muscle digital elegant little brisk hair mango congress clump"), "TREZOR")).toEqual(fromHex("7b4a10be9d98e6cba265566db7f136718e1398c71cb581e1b2f464cac1ceedf4f3e274dc270003c670ad8d02c4558b2f8e39edea2775c9e232c7cb798b069e88"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("void come effort suffer camp survey warrior heavy shoot primary clutch crush open amazing screen patrol group space point ten exist slush involve unfold"), "TREZOR")).toEqual(fromHex("01f5bced59dec48e362f2c45b5de68b9fd6c92c6634f44d6d40aab69056506f0e35524a518034ddc1192e1dacd32c1ed3eaa3c3b131c88ed8e7e54c49a5d0998"));
}));
it("can calculate seed from mnemonic (no password)", () => __awaiter(this, void 0, void 0, function* () {
// custom test vectors using
// $ git clone https://github.com/trezor/python-mnemonic.git && cd python-mnemonic
// $ python3 -m venv venv
// $ source venv/bin/activate
// $ pip install wheel bip32utils
// $ pip install -r requirements.txt
// patch generate_vectors.py to your needs
// $ python generate_vectors.py
// empty password
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("robust pipe raise illness symptom crowd trip will slow assault recipe oven"), "")).toEqual(fromHex("5539eed11e1096e9d52f69f15ad3d7c6547a40a3865b9517dbcbb03c31f231900622f58616d64d2d1cc0440f31d67fb0b2699a5fc885f796c746e0f844477093"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("pair ethics august street tornado spare present under capital raise cross current main craft stone clutch tray all"), "")).toEqual(fromHex("1272467e954cec4e0ad720002d037a3aaf795a57ffbeea6aaa0c242d410eb52050292447aa2c68470a07ecc80171edfa9e027793265047be3128d94e867a4f99"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("allow finger front connect strategy purchase journey distance trouble guitar honey alpha giraffe canal junk vintage chronic blade gate custom soap flip first mix"), "")).toEqual(fromHex("476a41ac016b5bdf9f114456929975a036ae326e2efdca441ac5a0949ef89ab9246dc9e49a5d2d64d1926eb9dbe17576cb010471c2a821b216202acdf3d7a27b"));
// no password
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("robust pipe raise illness symptom crowd trip will slow assault recipe oven"))).toEqual(fromHex("5539eed11e1096e9d52f69f15ad3d7c6547a40a3865b9517dbcbb03c31f231900622f58616d64d2d1cc0440f31d67fb0b2699a5fc885f796c746e0f844477093"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("pair ethics august street tornado spare present under capital raise cross current main craft stone clutch tray all"))).toEqual(fromHex("1272467e954cec4e0ad720002d037a3aaf795a57ffbeea6aaa0c242d410eb52050292447aa2c68470a07ecc80171edfa9e027793265047be3128d94e867a4f99"));
expect(yield bip39_1.Bip39.mnemonicToSeed(new bip39_1.EnglishMnemonic("allow finger front connect strategy purchase journey distance trouble guitar honey alpha giraffe canal junk vintage chronic blade gate custom soap flip first mix"))).toEqual(fromHex("476a41ac016b5bdf9f114456929975a036ae326e2efdca441ac5a0949ef89ab9246dc9e49a5d2d64d1926eb9dbe17576cb010471c2a821b216202acdf3d7a27b"));
}));
});
//# sourceMappingURL=bip39.spec.js.map

2

build/index.js

@@ -7,2 +7,4 @@ "use strict";

__export(require("./bip39"));
var englishmnemonic_1 = require("./englishmnemonic");
exports.EnglishMnemonic = englishmnemonic_1.EnglishMnemonic;
__export(require("./hmac"));

@@ -9,0 +11,0 @@ __export(require("./keccak"));

94

build/slip10.spec.js

@@ -35,3 +35,7 @@ "use strict";

it("can derive path m/0'/1/2'", () => {
const path = [slip10_1.Slip10RawIndex.hardened(0), slip10_1.Slip10RawIndex.normal(1), slip10_1.Slip10RawIndex.hardened(2)];
const path = [
slip10_1.Slip10RawIndex.hardened(0),
slip10_1.Slip10RawIndex.normal(1),
slip10_1.Slip10RawIndex.hardened(2),
];
const derived = slip10_1.Slip10.derivePath(slip10_1.Slip10Curve.Secp256k1, seed, path);

@@ -42,3 +46,8 @@ expect(derived.chainCode).toEqual(fromHex("04466b9cc8e161e966409ca52986c584f07e9dc81f735db683c3ff6ec7b1503f"));

it("can derive path m/0'/1/2'/2", () => {
const path = [slip10_1.Slip10RawIndex.hardened(0), slip10_1.Slip10RawIndex.normal(1), slip10_1.Slip10RawIndex.hardened(2), slip10_1.Slip10RawIndex.normal(2)];
const path = [
slip10_1.Slip10RawIndex.hardened(0),
slip10_1.Slip10RawIndex.normal(1),
slip10_1.Slip10RawIndex.hardened(2),
slip10_1.Slip10RawIndex.normal(2),
];
const derived = slip10_1.Slip10.derivePath(slip10_1.Slip10Curve.Secp256k1, seed, path);

@@ -49,3 +58,9 @@ expect(derived.chainCode).toEqual(fromHex("cfb71883f01676f587d023cc53a35bc7f88f724b1f8c2892ac1275ac822a3edd"));

it("can derive path m/0'/1/2'/2/1000000000", () => {
const path = [slip10_1.Slip10RawIndex.hardened(0), slip10_1.Slip10RawIndex.normal(1), slip10_1.Slip10RawIndex.hardened(2), slip10_1.Slip10RawIndex.normal(2), slip10_1.Slip10RawIndex.normal(1000000000)];
const path = [
slip10_1.Slip10RawIndex.hardened(0),
slip10_1.Slip10RawIndex.normal(1),
slip10_1.Slip10RawIndex.hardened(2),
slip10_1.Slip10RawIndex.normal(2),
slip10_1.Slip10RawIndex.normal(1000000000),
];
const derived = slip10_1.Slip10.derivePath(slip10_1.Slip10Curve.Secp256k1, seed, path);

@@ -72,3 +87,6 @@ expect(derived.chainCode).toEqual(fromHex("c783e67b921d2beb8f6b389cc646d7263b4145701dadd2161548a8b078e65e9e"));

it("can derive path m/0/2147483647'", () => {
const path = [slip10_1.Slip10RawIndex.normal(0), slip10_1.Slip10RawIndex.hardened(2147483647)];
const path = [
slip10_1.Slip10RawIndex.normal(0),
slip10_1.Slip10RawIndex.hardened(2147483647),
];
const derived = slip10_1.Slip10.derivePath(slip10_1.Slip10Curve.Secp256k1, seed, path);

@@ -79,3 +97,7 @@ expect(derived.chainCode).toEqual(fromHex("be17a268474a6bb9c61e1d720cf6215e2a88c5406c4aee7b38547f585c9a37d9"));

it("can derive path m/0/2147483647'/1", () => {
const path = [slip10_1.Slip10RawIndex.normal(0), slip10_1.Slip10RawIndex.hardened(2147483647), slip10_1.Slip10RawIndex.normal(1)];
const path = [
slip10_1.Slip10RawIndex.normal(0),
slip10_1.Slip10RawIndex.hardened(2147483647),
slip10_1.Slip10RawIndex.normal(1),
];
const derived = slip10_1.Slip10.derivePath(slip10_1.Slip10Curve.Secp256k1, seed, path);

@@ -86,3 +108,8 @@ expect(derived.chainCode).toEqual(fromHex("f366f48f1ea9f2d1d3fe958c95ca84ea18e4c4ddb9366c336c927eb246fb38cb"));

it("can derive path m/0/2147483647'/1/2147483646'", () => {
const path = [slip10_1.Slip10RawIndex.normal(0), slip10_1.Slip10RawIndex.hardened(2147483647), slip10_1.Slip10RawIndex.normal(1), slip10_1.Slip10RawIndex.hardened(2147483646)];
const path = [
slip10_1.Slip10RawIndex.normal(0),
slip10_1.Slip10RawIndex.hardened(2147483647),
slip10_1.Slip10RawIndex.normal(1),
slip10_1.Slip10RawIndex.hardened(2147483646),
];
const derived = slip10_1.Slip10.derivePath(slip10_1.Slip10Curve.Secp256k1, seed, path);

@@ -93,3 +120,9 @@ expect(derived.chainCode).toEqual(fromHex("637807030d55d01f9a0cb3a7839515d796bd07706386a6eddf06cc29a65a0e29"));

it("can derive path m/0/2147483647'/1/2147483646'/2", () => {
const path = [slip10_1.Slip10RawIndex.normal(0), slip10_1.Slip10RawIndex.hardened(2147483647), slip10_1.Slip10RawIndex.normal(1), slip10_1.Slip10RawIndex.hardened(2147483646), slip10_1.Slip10RawIndex.normal(2)];
const path = [
slip10_1.Slip10RawIndex.normal(0),
slip10_1.Slip10RawIndex.hardened(2147483647),
slip10_1.Slip10RawIndex.normal(1),
slip10_1.Slip10RawIndex.hardened(2147483646),
slip10_1.Slip10RawIndex.normal(2),
];
const derived = slip10_1.Slip10.derivePath(slip10_1.Slip10Curve.Secp256k1, seed, path);

@@ -122,3 +155,7 @@ expect(derived.chainCode).toEqual(fromHex("9452b549be8cea3ecb7a84bec10dcfd94afe4d129ebfd3b3cb58eedf394ed271"));

it("can derive path m/0'/1'/2'", () => {
const path = [slip10_1.Slip10RawIndex.hardened(0), slip10_1.Slip10RawIndex.hardened(1), slip10_1.Slip10RawIndex.hardened(2)];
const path = [
slip10_1.Slip10RawIndex.hardened(0),
slip10_1.Slip10RawIndex.hardened(1),
slip10_1.Slip10RawIndex.hardened(2),
];
const derived = slip10_1.Slip10.derivePath(slip10_1.Slip10Curve.Ed25519, seed, path);

@@ -129,3 +166,8 @@ expect(derived.chainCode).toEqual(fromHex("2e69929e00b5ab250f49c3fb1c12f252de4fed2c1db88387094a0f8c4c9ccd6c"));

it("can derive path m/0'/1'/2'/2'", () => {
const path = [slip10_1.Slip10RawIndex.hardened(0), slip10_1.Slip10RawIndex.hardened(1), slip10_1.Slip10RawIndex.hardened(2), slip10_1.Slip10RawIndex.hardened(2)];
const path = [
slip10_1.Slip10RawIndex.hardened(0),
slip10_1.Slip10RawIndex.hardened(1),
slip10_1.Slip10RawIndex.hardened(2),
slip10_1.Slip10RawIndex.hardened(2),
];
const derived = slip10_1.Slip10.derivePath(slip10_1.Slip10Curve.Ed25519, seed, path);

@@ -136,3 +178,9 @@ expect(derived.chainCode).toEqual(fromHex("8f6d87f93d750e0efccda017d662a1b31a266e4a6f5993b15f5c1f07f74dd5cc"));

it("can derive path m/0'/1'/2'/2'/1000000000'", () => {
const path = [slip10_1.Slip10RawIndex.hardened(0), slip10_1.Slip10RawIndex.hardened(1), slip10_1.Slip10RawIndex.hardened(2), slip10_1.Slip10RawIndex.hardened(2), slip10_1.Slip10RawIndex.hardened(1000000000)];
const path = [
slip10_1.Slip10RawIndex.hardened(0),
slip10_1.Slip10RawIndex.hardened(1),
slip10_1.Slip10RawIndex.hardened(2),
slip10_1.Slip10RawIndex.hardened(2),
slip10_1.Slip10RawIndex.hardened(1000000000),
];
const derived = slip10_1.Slip10.derivePath(slip10_1.Slip10Curve.Ed25519, seed, path);

@@ -159,3 +207,6 @@ expect(derived.chainCode).toEqual(fromHex("68789923a0cac2cd5a29172a475fe9e0fb14cd6adb5ad98a3fa70333e7afa230"));

it("can derive path m/0'/2147483647'", () => {
const path = [slip10_1.Slip10RawIndex.hardened(0), slip10_1.Slip10RawIndex.hardened(2147483647)];
const path = [
slip10_1.Slip10RawIndex.hardened(0),
slip10_1.Slip10RawIndex.hardened(2147483647),
];
const derived = slip10_1.Slip10.derivePath(slip10_1.Slip10Curve.Ed25519, seed, path);

@@ -166,3 +217,7 @@ expect(derived.chainCode).toEqual(fromHex("138f0b2551bcafeca6ff2aa88ba8ed0ed8de070841f0c4ef0165df8181eaad7f"));

it("can derive path m/0'/2147483647'/1'", () => {
const path = [slip10_1.Slip10RawIndex.hardened(0), slip10_1.Slip10RawIndex.hardened(2147483647), slip10_1.Slip10RawIndex.hardened(1)];
const path = [
slip10_1.Slip10RawIndex.hardened(0),
slip10_1.Slip10RawIndex.hardened(2147483647),
slip10_1.Slip10RawIndex.hardened(1),
];
const derived = slip10_1.Slip10.derivePath(slip10_1.Slip10Curve.Ed25519, seed, path);

@@ -173,3 +228,8 @@ expect(derived.chainCode).toEqual(fromHex("73bd9fff1cfbde33a1b846c27085f711c0fe2d66fd32e139d3ebc28e5a4a6b90"));

it("can derive path m/0'/2147483647'/1'/2147483646'", () => {
const path = [slip10_1.Slip10RawIndex.hardened(0), slip10_1.Slip10RawIndex.hardened(2147483647), slip10_1.Slip10RawIndex.hardened(1), slip10_1.Slip10RawIndex.hardened(2147483646)];
const path = [
slip10_1.Slip10RawIndex.hardened(0),
slip10_1.Slip10RawIndex.hardened(2147483647),
slip10_1.Slip10RawIndex.hardened(1),
slip10_1.Slip10RawIndex.hardened(2147483646),
];
const derived = slip10_1.Slip10.derivePath(slip10_1.Slip10Curve.Ed25519, seed, path);

@@ -180,3 +240,9 @@ expect(derived.chainCode).toEqual(fromHex("0902fe8a29f9140480a00ef244bd183e8a13288e4412d8389d140aac1794825a"));

it("can derive path m/0'/2147483647'/1'/2147483646'/2'", () => {
const path = [slip10_1.Slip10RawIndex.hardened(0), slip10_1.Slip10RawIndex.hardened(2147483647), slip10_1.Slip10RawIndex.hardened(1), slip10_1.Slip10RawIndex.hardened(2147483646), slip10_1.Slip10RawIndex.hardened(2)];
const path = [
slip10_1.Slip10RawIndex.hardened(0),
slip10_1.Slip10RawIndex.hardened(2147483647),
slip10_1.Slip10RawIndex.hardened(1),
slip10_1.Slip10RawIndex.hardened(2147483646),
slip10_1.Slip10RawIndex.hardened(2),
];
const derived = slip10_1.Slip10.derivePath(slip10_1.Slip10Curve.Ed25519, seed, path);

@@ -183,0 +249,0 @@ expect(derived.chainCode).toEqual(fromHex("5d70af781f3a37b829f0d060924d5e960bdc02e85423494afc0b1a41bbe196d4"));

7

package.json
{
"name": "@iov/crypto",
"version": "0.13.7",
"version": "0.13.8",
"description": "Cryptography resources for IOV projects",

@@ -20,2 +20,3 @@ "author": "IOV SAS <admin@iov.one>",

"format": "prettier --write --loglevel warn \"./src/**/*.ts\"",
"format-text": "prettier --write --prose-wrap always --print-width 80 \"./*.md\"",
"test-node": "node jasmine-testrunner.js",

@@ -34,3 +35,3 @@ "test-edge": "yarn pack-web && karma start --single-run --browsers Edge",

"dependencies": {
"@iov/encoding": "^0.13.7",
"@iov/encoding": "^0.13.8",
"bip39": "^2.5.0",

@@ -49,3 +50,3 @@ "bn.js": "^4.11.8",

},
"gitHead": "c82dca732db5831ceb3b4cf0a7ffbef98501ad56"
"gitHead": "7fa9f236457f14e320ab0c54654a07828fb4ed46"
}

15

README.md

@@ -5,6 +5,7 @@ # @iov/crypto

@iov/crypto contains low-level cryptographic functionality used in other @iov libraries.
Little of it is implemented here, but mainly it is a curation of external libraries along
with correctness tests. We add type-safety, some more checks, and a simple API to these libraries.
This can also be freely imported outside of @iov/core based applications.
@iov/crypto contains low-level cryptographic functionality used in other @iov
libraries. Little of it is implemented here, but mainly it is a curation of
external libraries along with correctness tests. We add type-safety, some more
checks, and a simple API to these libraries. This can also be freely imported
outside of @iov/core based applications.

@@ -17,3 +18,5 @@ ## API Documentation

This package is part of the IOV-Core repository, licensed under the Apache License 2.0
(see [NOTICE](https://github.com/iov-one/iov-core/blob/master/NOTICE) and [LICENSE](https://github.com/iov-one/iov-core/blob/master/LICENSE)).
This package is part of the IOV-Core repository, licensed under the Apache
License 2.0 (see
[NOTICE](https://github.com/iov-one/iov-core/blob/master/NOTICE) and
[LICENSE](https://github.com/iov-one/iov-core/blob/master/LICENSE)).

676

src/bip39.spec.ts
import { Encoding } from "@iov/encoding";
import { Bip39, EnglishMnemonic } from "./bip39";
import { Bip39 } from "./bip39";
import { EnglishMnemonic } from "./englishmnemonic";
import bip39Vectors from "./testdata/bip39.json";
const fromHex = Encoding.fromHex;
describe("Bip39", () => {
it("can encode to mnemonic", () => {
// Test vectors from
// https://github.com/trezor/python-mnemonic/blob/b502451a33a440783926e04428115e0bed87d01f/vectors.json
expect(Bip39.encode(fromHex("00000000000000000000000000000000")).asString()).toEqual("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about");
expect(Bip39.encode(fromHex("7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f")).asString()).toEqual("legal winner thank year wave sausage worth useful legal winner thank yellow");
expect(Bip39.encode(fromHex("80808080808080808080808080808080")).asString()).toEqual("letter advice cage absurd amount doctor acoustic avoid letter advice cage above");
expect(Bip39.encode(fromHex("ffffffffffffffffffffffffffffffff")).asString()).toEqual("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong");
expect(Bip39.encode(fromHex("0000000000000000000000000000000000000000")).asString()).toEqual("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon address");
expect(Bip39.encode(fromHex("7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f")).asString()).toEqual("legal winner thank year wave sausage worth useful legal winner thank year wave sausage wise");
expect(Bip39.encode(fromHex("8080808080808080808080808080808080808080")).asString()).toEqual("letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor accident");
expect(Bip39.encode(fromHex("ffffffffffffffffffffffffffffffffffffffff")).asString()).toEqual("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrist");
expect(Bip39.encode(fromHex("000000000000000000000000000000000000000000000000")).asString()).toEqual("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon agent");
expect(Bip39.encode(fromHex("7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f")).asString()).toEqual("legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal will");
expect(Bip39.encode(fromHex("808080808080808080808080808080808080808080808080")).asString()).toEqual("letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter always");
expect(Bip39.encode(fromHex("ffffffffffffffffffffffffffffffffffffffffffffffff")).asString()).toEqual("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo when");
expect(Bip39.encode(fromHex("00000000000000000000000000000000000000000000000000000000")).asString()).toEqual("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon admit");
expect(Bip39.encode(fromHex("7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f")).asString()).toEqual("legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal winner thank year viable");
expect(Bip39.encode(fromHex("80808080808080808080808080808080808080808080808080808080")).asString()).toEqual("letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd apart");
expect(Bip39.encode(fromHex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffff")).asString()).toEqual("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo veteran");
expect(Bip39.encode(fromHex("0000000000000000000000000000000000000000000000000000000000000000")).asString()).toEqual("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art");
expect(Bip39.encode(fromHex("7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f")).asString()).toEqual("legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth title");
expect(Bip39.encode(fromHex("8080808080808080808080808080808080808080808080808080808080808080")).asString()).toEqual("letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic bless");
expect(Bip39.encode(fromHex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff")).asString()).toEqual("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo vote");
expect(Bip39.encode(fromHex("9e885d952ad362caeb4efe34a8e91bd2")).asString()).toEqual("ozone drill grab fiber curtain grace pudding thank cruise elder eight picnic");
expect(Bip39.encode(fromHex("610b25967cdcca9d59875f5cb50b0ea754333118")).asString()).toEqual("genre float grain whale smile exchange gravity typical frequent portion senior exchange drip obtain glow");
expect(Bip39.encode(fromHex("6610b25967cdcca9d59875f5cb50b0ea75433311869e930b")).asString()).toEqual("gravity machine north sort system female filter attitude volume fold club stay feature office ecology stable narrow fog");
expect(Bip39.encode(fromHex("8a79eaca2324873eacc50cb9c6eca8cc68ea5d936f98787c60c7ebc7")).asString()).toEqual("media soon raw edge embody palm reason pave right danger clay occur modify conduct ethics vessel journey toast cradle stuff laundry");
expect(Bip39.encode(fromHex("68a79eaca2324873eacc50cb9c6eca8cc68ea5d936f98787c60c7ebc74e6ce7c")).asString()).toEqual("hamster diagram private dutch cause delay private meat slide toddler razor book happy fancy gospel tennis maple dilemma loan word shrug inflict delay length");
expect(Bip39.encode(fromHex("c0ba5a8e914111210f2bd131f3d5e08d")).asString()).toEqual("scheme spot photo card baby mountain device kick cradle pact join borrow");
expect(Bip39.encode(fromHex("232c38b9a99e10d2253fa1aa2739a8e9c3b112d0")).asString()).toEqual("case gift common farm three harbor neutral vintage pretty degree health squeeze deposit maximum donor");
expect(Bip39.encode(fromHex("6d9be1ee6ebd27a258115aad99b7317b9c8d28b6d76431c3")).asString()).toEqual("horn tenant knee talent sponsor spell gate clip pulse soap slush warm silver nephew swap uncle crack brave");
expect(Bip39.encode(fromHex("49208c3112119c4770d44d1a9726b44135748bda464954338f3c1d91")).asString()).toEqual("empty afford arrange category border casual select meadow box rice public list firm echo harbor since feature organ someone depth bitter");
expect(Bip39.encode(fromHex("9f6a2878b2520799a44ef18bc7df394e7061a224d2c33cd015b157d746869863")).asString()).toEqual("panda eyebrow bullet gorilla call smoke muffin taste mesh discover soft ostrich alcohol speed nation flash devote level hobby quick inner drive ghost inside");
expect(Bip39.encode(fromHex("23db8160a31d3e0dca3688ed941adbf3")).asString()).toEqual("cat swing flag economy stadium alone churn speed unique patch report train");
expect(Bip39.encode(fromHex("c9a0ed1374180cd8f8c5cc0bc9c719dfb67add59")).asString()).toEqual("situate alter dynamic trial liar hockey toast ridge armed evolve shoe satoshi guilt huge grass");
expect(Bip39.encode(fromHex("8197a4a47f0425faeaa69deebc05ca29c0a5b5cc76ceacc0")).asString()).toEqual("light rule cinnamon wrap drastic word pride squirrel upgrade then income fatal apart sustain crack supply proud access");
expect(Bip39.encode(fromHex("dc8a247c5379f57c24dbfbd6a0699a8282875dd0a3f0f39b8fc020a4")).asString()).toEqual("symptom eye business plunge palm safe nature legal stove addict grit agree chronic puzzle dream lawn vicious symbol useless donor eagle");
expect(Bip39.encode(fromHex("066dca1a2bb7e8a1db2832148ce9933eea0f3ac9548d793112d9a95c9407efad")).asString()).toEqual("all hour make first leader extend hole alien behind guard gospel lava path output census museum junior mass reopen famous sing advance salt reform");
expect(Bip39.encode(fromHex("f30f8c1da665478f49b001d94c5fc452")).asString()).toEqual("vessel ladder alter error federal sibling chat ability sun glass valve picture");
expect(Bip39.encode(fromHex("ef38bbc81a5fa1756dfd654b0cc1a1759ce1ed94")).asString()).toEqual("upset shift velvet cruise wheel rival retire protect enrich gravity hair twenty sock walnut fat");
expect(Bip39.encode(fromHex("c10ec20dc3cd9f652c7fac2f1230f7a3c828389a14392f05")).asString()).toEqual("scissors invite lock maple supreme raw rapid void congress muscle digital elegant little brisk hair mango congress clump");
expect(Bip39.encode(fromHex("a66afdf103bf42b5858cd1c23a20f7e5114edb111880d634b53454bf")).asString()).toEqual("please fitness labor alter vintage food bike olive season speed digital sketch belt horn dutch avoid stomach pizza escape practice walnut");
expect(Bip39.encode(fromHex("f585c11aec520db57dd353c69554b21a89b20fb0650966fa0a9d6f74fd989d8f")).asString()).toEqual("void come effort suffer camp survey warrior heavy shoot primary clutch crush open amazing screen patrol group space point ten exist slush involve unfold");
describe("encode", () => {
it("can encode to mnemonic", () => {
// Test vectors from https://github.com/trezor/python-mnemonic/blob/b502451a33a440783926e04428115e0bed87d01f/vectors.json
// plus similar vectors generated for the missing lengths 15 and 21 words
const { "12": vec12, "15": vec15, "18": vec18, "21": vec21, "24": vec24 } = bip39Vectors.encoding;
for (const vectors of [vec12, vec15, vec18, vec21, vec24]) {
for (const { entropy, mnemonic } of vectors) {
expect(Bip39.encode(fromHex(entropy)).asString()).toEqual(mnemonic);
}
}
});
// invalid input length
expect(() => {
Bip39.encode(fromHex(""));
}).toThrowError(/invalid input length/);
expect(() => {
Bip39.encode(fromHex("00"));
}).toThrowError(/invalid input length/);
expect(() => {
Bip39.encode(fromHex("000000000000000000000000000000"));
}).toThrowError(/invalid input length/);
expect(() => {
Bip39.encode(fromHex("0000000000000000000000000000000000"));
}).toThrowError(/invalid input length/);
expect(() => {
Bip39.encode(fromHex("0000000000000000000000000000000000000000000000"));
}).toThrowError(/invalid input length/);
expect(() => {
Bip39.encode(fromHex("00000000000000000000000000000000000000000000000000"));
}).toThrowError(/invalid input length/);
expect(() => {
Bip39.encode(fromHex("00000000000000000000000000000000000000000000000000000000000000"));
}).toThrowError(/invalid input length/);
expect(() => {
Bip39.encode(fromHex("000000000000000000000000000000000000000000000000000000000000000000"));
}).toThrowError(/invalid input length/);
it("throws for invalid input", () => {
// invalid input length
expect(() => Bip39.encode(fromHex(""))).toThrowError(/invalid input length/);
expect(() => Bip39.encode(fromHex("00"))).toThrowError(/invalid input length/);
expect(() => Bip39.encode(fromHex("000000000000000000000000000000"))).toThrowError(
/invalid input length/,
);
expect(() => Bip39.encode(fromHex("0000000000000000000000000000000000"))).toThrowError(
/invalid input length/,
);
expect(() => Bip39.encode(fromHex("0000000000000000000000000000000000000000000000"))).toThrowError(
/invalid input length/,
);
expect(() => Bip39.encode(fromHex("00000000000000000000000000000000000000000000000000"))).toThrowError(
/invalid input length/,
);
expect(() =>
Bip39.encode(fromHex("00000000000000000000000000000000000000000000000000000000000000")),
).toThrowError(/invalid input length/);
expect(() =>
Bip39.encode(fromHex("000000000000000000000000000000000000000000000000000000000000000000")),
).toThrowError(/invalid input length/);
});
});
describe("EnglishMnemonic", () => {
// tslint:disable:no-unused-expression
it("works for valid inputs", () => {
expect(() => {
new EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about");
new EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon address");
new EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon agent");
new EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon admit");
new EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art");
}).not.toThrow();
describe("decode", () => {
it("can decode from mnemonic", () => {
const { "12": vec12, "15": vec15, "18": vec18, "21": vec21, "24": vec24 } = bip39Vectors.encoding;
for (const vectors of [vec12, vec15, vec18, vec21, vec24]) {
for (const { entropy, mnemonic } of vectors) {
expect(Bip39.decode(new EnglishMnemonic(mnemonic))).toEqual(fromHex(entropy));
}
}
});
});
it("rejects invalid whitespacing", () => {
// extra space (leading, middle, trailing)
expect(() => {
new EnglishMnemonic(" abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about");
}).toThrowError(/invalid mnemonic format/i);
expect(() => {
new EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about");
}).toThrowError(/invalid mnemonic format/i);
expect(() => {
new EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about ");
}).toThrowError(/invalid mnemonic format/i);
// newline, tab
expect(() => {
new EnglishMnemonic("abandon\nabandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about");
}).toThrowError(/invalid mnemonic format/i);
expect(() => {
new EnglishMnemonic("abandon\tabandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about");
}).toThrowError(/invalid mnemonic format/i);
describe("mnemonicToSeed", () => {
it("can calculate seed from mnemonic (trezor test vectors)", async () => {
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic(
"abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about",
),
"TREZOR",
),
).toEqual(
fromHex(
"c55257c360c07c72029aebc1b53c05ed0362ada38ead3e3e9efa3708e53495531f09a6987599d18264c1e1c92f2cf141630c7a3c4ab7c81b2f001698e7463b04",
),
);
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic("legal winner thank year wave sausage worth useful legal winner thank yellow"),
"TREZOR",
),
).toEqual(
fromHex(
"2e8905819b8723fe2c1d161860e5ee1830318dbf49a83bd451cfb8440c28bd6fa457fe1296106559a3c80937a1c1069be3a3a5bd381ee6260e8d9739fce1f607",
),
);
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic(
"letter advice cage absurd amount doctor acoustic avoid letter advice cage above",
),
"TREZOR",
),
).toEqual(
fromHex(
"d71de856f81a8acc65e6fc851a38d4d7ec216fd0796d0a6827a3ad6ed5511a30fa280f12eb2e47ed2ac03b5c462a0358d18d69fe4f985ec81778c1b370b652a8",
),
);
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong"),
"TREZOR",
),
).toEqual(
fromHex(
"ac27495480225222079d7be181583751e86f571027b0497b5b5d11218e0a8a13332572917f0f8e5a589620c6f15b11c61dee327651a14c34e18231052e48c069",
),
);
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic(
"abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon agent",
),
"TREZOR",
),
).toEqual(
fromHex(
"035895f2f481b1b0f01fcf8c289c794660b289981a78f8106447707fdd9666ca06da5a9a565181599b79f53b844d8a71dd9f439c52a3d7b3e8a79c906ac845fa",
),
);
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic(
"legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal will",
),
"TREZOR",
),
).toEqual(
fromHex(
"f2b94508732bcbacbcc020faefecfc89feafa6649a5491b8c952cede496c214a0c7b3c392d168748f2d4a612bada0753b52a1c7ac53c1e93abd5c6320b9e95dd",
),
);
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic(
"letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter always",
),
"TREZOR",
),
).toEqual(
fromHex(
"107d7c02a5aa6f38c58083ff74f04c607c2d2c0ecc55501dadd72d025b751bc27fe913ffb796f841c49b1d33b610cf0e91d3aa239027f5e99fe4ce9e5088cd65",
),
);
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo when"),
"TREZOR",
),
).toEqual(
fromHex(
"0cd6e5d827bb62eb8fc1e262254223817fd068a74b5b449cc2f667c3f1f985a76379b43348d952e2265b4cd129090758b3e3c2c49103b5051aac2eaeb890a528",
),
);
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic(
"abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art",
),
"TREZOR",
),
).toEqual(
fromHex(
"bda85446c68413707090a52022edd26a1c9462295029f2e60cd7c4f2bbd3097170af7a4d73245cafa9c3cca8d561a7c3de6f5d4a10be8ed2a5e608d68f92fcc8",
),
);
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic(
"legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth title",
),
"TREZOR",
),
).toEqual(
fromHex(
"bc09fca1804f7e69da93c2f2028eb238c227f2e9dda30cd63699232578480a4021b146ad717fbb7e451ce9eb835f43620bf5c514db0f8add49f5d121449d3e87",
),
);
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic(
"letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic bless",
),
"TREZOR",
),
).toEqual(
fromHex(
"c0c519bd0e91a2ed54357d9d1ebef6f5af218a153624cf4f2da911a0ed8f7a09e2ef61af0aca007096df430022f7a2b6fb91661a9589097069720d015e4e982f",
),
);
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic(
"zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo vote",
),
"TREZOR",
),
).toEqual(
fromHex(
"dd48c104698c30cfe2b6142103248622fb7bb0ff692eebb00089b32d22484e1613912f0a5b694407be899ffd31ed3992c456cdf60f5d4564b8ba3f05a69890ad",
),
);
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic("ozone drill grab fiber curtain grace pudding thank cruise elder eight picnic"),
"TREZOR",
),
).toEqual(
fromHex(
"274ddc525802f7c828d8ef7ddbcdc5304e87ac3535913611fbbfa986d0c9e5476c91689f9c8a54fd55bd38606aa6a8595ad213d4c9c9f9aca3fb217069a41028",
),
);
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic(
"gravity machine north sort system female filter attitude volume fold club stay feature office ecology stable narrow fog",
),
"TREZOR",
),
).toEqual(
fromHex(
"628c3827a8823298ee685db84f55caa34b5cc195a778e52d45f59bcf75aba68e4d7590e101dc414bc1bbd5737666fbbef35d1f1903953b66624f910feef245ac",
),
);
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic(
"hamster diagram private dutch cause delay private meat slide toddler razor book happy fancy gospel tennis maple dilemma loan word shrug inflict delay length",
),
"TREZOR",
),
).toEqual(
fromHex(
"64c87cde7e12ecf6704ab95bb1408bef047c22db4cc7491c4271d170a1b213d20b385bc1588d9c7b38f1b39d415665b8a9030c9ec653d75e65f847d8fc1fc440",
),
);
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic("scheme spot photo card baby mountain device kick cradle pact join borrow"),
"TREZOR",
),
).toEqual(
fromHex(
"ea725895aaae8d4c1cf682c1bfd2d358d52ed9f0f0591131b559e2724bb234fca05aa9c02c57407e04ee9dc3b454aa63fbff483a8b11de949624b9f1831a9612",
),
);
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic(
"horn tenant knee talent sponsor spell gate clip pulse soap slush warm silver nephew swap uncle crack brave",
),
"TREZOR",
),
).toEqual(
fromHex(
"fd579828af3da1d32544ce4db5c73d53fc8acc4ddb1e3b251a31179cdb71e853c56d2fcb11aed39898ce6c34b10b5382772db8796e52837b54468aeb312cfc3d",
),
);
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic(
"panda eyebrow bullet gorilla call smoke muffin taste mesh discover soft ostrich alcohol speed nation flash devote level hobby quick inner drive ghost inside",
),
"TREZOR",
),
).toEqual(
fromHex(
"72be8e052fc4919d2adf28d5306b5474b0069df35b02303de8c1729c9538dbb6fc2d731d5f832193cd9fb6aeecbc469594a70e3dd50811b5067f3b88b28c3e8d",
),
);
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic("cat swing flag economy stadium alone churn speed unique patch report train"),
"TREZOR",
),
).toEqual(
fromHex(
"deb5f45449e615feff5640f2e49f933ff51895de3b4381832b3139941c57b59205a42480c52175b6efcffaa58a2503887c1e8b363a707256bdd2b587b46541f5",
),
);
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic(
"light rule cinnamon wrap drastic word pride squirrel upgrade then income fatal apart sustain crack supply proud access",
),
"TREZOR",
),
).toEqual(
fromHex(
"4cbdff1ca2db800fd61cae72a57475fdc6bab03e441fd63f96dabd1f183ef5b782925f00105f318309a7e9c3ea6967c7801e46c8a58082674c860a37b93eda02",
),
);
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic(
"all hour make first leader extend hole alien behind guard gospel lava path output census museum junior mass reopen famous sing advance salt reform",
),
"TREZOR",
),
).toEqual(
fromHex(
"26e975ec644423f4a4c4f4215ef09b4bd7ef924e85d1d17c4cf3f136c2863cf6df0a475045652c57eb5fb41513ca2a2d67722b77e954b4b3fc11f7590449191d",
),
);
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic(
"vessel ladder alter error federal sibling chat ability sun glass valve picture",
),
"TREZOR",
),
).toEqual(
fromHex(
"2aaa9242daafcee6aa9d7269f17d4efe271e1b9a529178d7dc139cd18747090bf9d60295d0ce74309a78852a9caadf0af48aae1c6253839624076224374bc63f",
),
);
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic(
"scissors invite lock maple supreme raw rapid void congress muscle digital elegant little brisk hair mango congress clump",
),
"TREZOR",
),
).toEqual(
fromHex(
"7b4a10be9d98e6cba265566db7f136718e1398c71cb581e1b2f464cac1ceedf4f3e274dc270003c670ad8d02c4558b2f8e39edea2775c9e232c7cb798b069e88",
),
);
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic(
"void come effort suffer camp survey warrior heavy shoot primary clutch crush open amazing screen patrol group space point ten exist slush involve unfold",
),
"TREZOR",
),
).toEqual(
fromHex(
"01f5bced59dec48e362f2c45b5de68b9fd6c92c6634f44d6d40aab69056506f0e35524a518034ddc1192e1dacd32c1ed3eaa3c3b131c88ed8e7e54c49a5d0998",
),
);
});
it("rejects disallowed letters", () => {
// Disallowed letters in words (capital, number, special char)
expect(() => {
new EnglishMnemonic("Abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about");
}).toThrowError(/invalid mnemonic format/i);
expect(() => {
new EnglishMnemonic("abandon abandon Abandon abandon abandon abandon abandon abandon abandon abandon abandon about");
}).toThrowError(/invalid mnemonic format/i);
expect(() => {
new EnglishMnemonic("route66 abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about");
}).toThrowError(/invalid mnemonic format/i);
expect(() => {
new EnglishMnemonic("abandon abandon route66 abandon abandon abandon abandon abandon abandon abandon abandon about");
}).toThrowError(/invalid mnemonic format/i);
expect(() => {
new EnglishMnemonic("lötkolben abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about");
}).toThrowError(/invalid mnemonic format/i);
expect(() => {
new EnglishMnemonic("abandon abandon lötkolben abandon abandon abandon abandon abandon abandon abandon abandon about");
}).toThrowError(/invalid mnemonic format/i);
});
it("can calculate seed from mnemonic (no password)", async () => {
// custom test vectors using
// $ git clone https://github.com/trezor/python-mnemonic.git && cd python-mnemonic
// $ python3 -m venv venv
// $ source venv/bin/activate
// $ pip install wheel bip32utils
// $ pip install -r requirements.txt
// patch generate_vectors.py to your needs
// $ python generate_vectors.py
it("word counts other than 12, 15, 18, 21, 24", () => {
// too few and too many words (11, 13, 17, 19, 23, 25)
expect(() => {
new EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about");
}).toThrowError(/invalid word count(.*)got: 11/i);
expect(() => {
new EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about");
}).toThrowError(/invalid word count(.*)got: 13/i);
expect(() => {
new EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon agent");
}).toThrowError(/invalid word count(.*)got: 17/i);
expect(() => {
new EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon agent");
}).toThrowError(/invalid word count(.*)got: 19/i);
expect(() => {
new EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art");
}).toThrowError(/invalid word count(.*)got: 23/i);
expect(() => {
new EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art");
}).toThrowError(/invalid word count(.*)got: 25/i);
});
// empty password
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic("robust pipe raise illness symptom crowd trip will slow assault recipe oven"),
"",
),
).toEqual(
fromHex(
"5539eed11e1096e9d52f69f15ad3d7c6547a40a3865b9517dbcbb03c31f231900622f58616d64d2d1cc0440f31d67fb0b2699a5fc885f796c746e0f844477093",
),
);
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic(
"pair ethics august street tornado spare present under capital raise cross current main craft stone clutch tray all",
),
"",
),
).toEqual(
fromHex(
"1272467e954cec4e0ad720002d037a3aaf795a57ffbeea6aaa0c242d410eb52050292447aa2c68470a07ecc80171edfa9e027793265047be3128d94e867a4f99",
),
);
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic(
"allow finger front connect strategy purchase journey distance trouble guitar honey alpha giraffe canal junk vintage chronic blade gate custom soap flip first mix",
),
"",
),
).toEqual(
fromHex(
"476a41ac016b5bdf9f114456929975a036ae326e2efdca441ac5a0949ef89ab9246dc9e49a5d2d64d1926eb9dbe17576cb010471c2a821b216202acdf3d7a27b",
),
);
it("rejects invalid checksums", () => {
// 12x, 15x, 18x, 21x, 24x "zoo"
expect(() => {
new EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo");
}).toThrowError(/invalid mnemonic checksum/i);
expect(() => {
new EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo");
}).toThrowError(/invalid mnemonic checksum/i);
expect(() => {
new EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo");
}).toThrowError(/invalid mnemonic checksum/i);
expect(() => {
new EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo");
}).toThrowError(/invalid mnemonic checksum/i);
expect(() => {
new EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo");
}).toThrowError(/invalid mnemonic checksum/i);
// no password
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic("robust pipe raise illness symptom crowd trip will slow assault recipe oven"),
),
).toEqual(
fromHex(
"5539eed11e1096e9d52f69f15ad3d7c6547a40a3865b9517dbcbb03c31f231900622f58616d64d2d1cc0440f31d67fb0b2699a5fc885f796c746e0f844477093",
),
);
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic(
"pair ethics august street tornado spare present under capital raise cross current main craft stone clutch tray all",
),
),
).toEqual(
fromHex(
"1272467e954cec4e0ad720002d037a3aaf795a57ffbeea6aaa0c242d410eb52050292447aa2c68470a07ecc80171edfa9e027793265047be3128d94e867a4f99",
),
);
expect(
await Bip39.mnemonicToSeed(
new EnglishMnemonic(
"allow finger front connect strategy purchase journey distance trouble guitar honey alpha giraffe canal junk vintage chronic blade gate custom soap flip first mix",
),
),
).toEqual(
fromHex(
"476a41ac016b5bdf9f114456929975a036ae326e2efdca441ac5a0949ef89ab9246dc9e49a5d2d64d1926eb9dbe17576cb010471c2a821b216202acdf3d7a27b",
),
);
});
it("rejects valid mnemonics of other languages", () => {
// valid Spanish and Italian bip39 mnemonics
expect(() => {
new EnglishMnemonic("humo odio oriente colina taco fingir salto geranio glaciar academia suave vigor");
}).toThrowError(/contains invalid word/i);
expect(() => {
new EnglishMnemonic("yema folleto tos llave obtener natural fruta deseo laico sopa novato lazo imponer afinar vena hoja zarza cama");
}).toThrowError(/contains invalid word/i);
expect(() => {
new EnglishMnemonic("burla plaza arroz ronda pregunta vacuna veloz boina retiro exento prensa tortuga cabeza pilar anual molino molde fiesta masivo jefe leve fatiga clase plomo");
}).toThrowError(/contains invalid word/i);
expect(() => {
new EnglishMnemonic("braccio trincea armonia emiro svedese lepre stridulo metallo baldo rasente potassio rilassato");
}).toThrowError(/contains invalid word/i);
expect(() => {
new EnglishMnemonic("riparato arrosto globulo singolo bozzolo roba pirolisi ultimato padrone munto leggero avanzato monetario guanto lorenzo latino inoltrare modulo");
}).toThrowError(/contains invalid word/i);
expect(() => {
new EnglishMnemonic("promessa mercurio spessore snodo trave risata mecenate vichingo ceto orecchino vissuto risultato canino scarso futile fune epilogo uovo inedito apatico folata egoismo rifugio coma");
}).toThrowError(/contains invalid word/i);
});
// tslint:enable:no-unused-expression
});
it("can decode from mnemonic", () => {
expect(Bip39.decode(new EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"))).toEqual(fromHex("00000000000000000000000000000000"));
expect(Bip39.decode(new EnglishMnemonic("legal winner thank year wave sausage worth useful legal winner thank yellow"))).toEqual(fromHex("7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f"));
expect(Bip39.decode(new EnglishMnemonic("letter advice cage absurd amount doctor acoustic avoid letter advice cage above"))).toEqual(fromHex("80808080808080808080808080808080"));
expect(Bip39.decode(new EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong"))).toEqual(fromHex("ffffffffffffffffffffffffffffffff"));
expect(Bip39.decode(new EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon address"))).toEqual(fromHex("0000000000000000000000000000000000000000"));
expect(Bip39.decode(new EnglishMnemonic("legal winner thank year wave sausage worth useful legal winner thank year wave sausage wise"))).toEqual(fromHex("7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f"));
expect(Bip39.decode(new EnglishMnemonic("letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor accident"))).toEqual(fromHex("8080808080808080808080808080808080808080"));
expect(Bip39.decode(new EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrist"))).toEqual(fromHex("ffffffffffffffffffffffffffffffffffffffff"));
expect(Bip39.decode(new EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon agent"))).toEqual(fromHex("000000000000000000000000000000000000000000000000"));
expect(Bip39.decode(new EnglishMnemonic("legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal will"))).toEqual(fromHex("7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f"));
expect(Bip39.decode(new EnglishMnemonic("letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter always"))).toEqual(fromHex("808080808080808080808080808080808080808080808080"));
expect(Bip39.decode(new EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo when"))).toEqual(fromHex("ffffffffffffffffffffffffffffffffffffffffffffffff"));
expect(Bip39.decode(new EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon admit"))).toEqual(fromHex("00000000000000000000000000000000000000000000000000000000"));
expect(Bip39.decode(new EnglishMnemonic("legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal winner thank year viable"))).toEqual(fromHex("7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f"));
expect(Bip39.decode(new EnglishMnemonic("letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd apart"))).toEqual(fromHex("80808080808080808080808080808080808080808080808080808080"));
expect(Bip39.decode(new EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo veteran"))).toEqual(fromHex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffff"));
expect(Bip39.decode(new EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art"))).toEqual(fromHex("0000000000000000000000000000000000000000000000000000000000000000"));
expect(Bip39.decode(new EnglishMnemonic("legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth title"))).toEqual(fromHex("7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f7f"));
expect(Bip39.decode(new EnglishMnemonic("letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic bless"))).toEqual(fromHex("8080808080808080808080808080808080808080808080808080808080808080"));
expect(Bip39.decode(new EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo vote"))).toEqual(fromHex("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"));
expect(Bip39.decode(new EnglishMnemonic("ozone drill grab fiber curtain grace pudding thank cruise elder eight picnic"))).toEqual(fromHex("9e885d952ad362caeb4efe34a8e91bd2"));
expect(Bip39.decode(new EnglishMnemonic("genre float grain whale smile exchange gravity typical frequent portion senior exchange drip obtain glow"))).toEqual(fromHex("610b25967cdcca9d59875f5cb50b0ea754333118"));
expect(Bip39.decode(new EnglishMnemonic("gravity machine north sort system female filter attitude volume fold club stay feature office ecology stable narrow fog"))).toEqual(fromHex("6610b25967cdcca9d59875f5cb50b0ea75433311869e930b"));
expect(Bip39.decode(new EnglishMnemonic("media soon raw edge embody palm reason pave right danger clay occur modify conduct ethics vessel journey toast cradle stuff laundry"))).toEqual(fromHex("8a79eaca2324873eacc50cb9c6eca8cc68ea5d936f98787c60c7ebc7"));
expect(Bip39.decode(new EnglishMnemonic("hamster diagram private dutch cause delay private meat slide toddler razor book happy fancy gospel tennis maple dilemma loan word shrug inflict delay length"))).toEqual(fromHex("68a79eaca2324873eacc50cb9c6eca8cc68ea5d936f98787c60c7ebc74e6ce7c"));
expect(Bip39.decode(new EnglishMnemonic("scheme spot photo card baby mountain device kick cradle pact join borrow"))).toEqual(fromHex("c0ba5a8e914111210f2bd131f3d5e08d"));
expect(Bip39.decode(new EnglishMnemonic("case gift common farm three harbor neutral vintage pretty degree health squeeze deposit maximum donor"))).toEqual(fromHex("232c38b9a99e10d2253fa1aa2739a8e9c3b112d0"));
expect(Bip39.decode(new EnglishMnemonic("horn tenant knee talent sponsor spell gate clip pulse soap slush warm silver nephew swap uncle crack brave"))).toEqual(fromHex("6d9be1ee6ebd27a258115aad99b7317b9c8d28b6d76431c3"));
expect(Bip39.decode(new EnglishMnemonic("empty afford arrange category border casual select meadow box rice public list firm echo harbor since feature organ someone depth bitter"))).toEqual(fromHex("49208c3112119c4770d44d1a9726b44135748bda464954338f3c1d91"));
expect(Bip39.decode(new EnglishMnemonic("panda eyebrow bullet gorilla call smoke muffin taste mesh discover soft ostrich alcohol speed nation flash devote level hobby quick inner drive ghost inside"))).toEqual(fromHex("9f6a2878b2520799a44ef18bc7df394e7061a224d2c33cd015b157d746869863"));
expect(Bip39.decode(new EnglishMnemonic("cat swing flag economy stadium alone churn speed unique patch report train"))).toEqual(fromHex("23db8160a31d3e0dca3688ed941adbf3"));
expect(Bip39.decode(new EnglishMnemonic("situate alter dynamic trial liar hockey toast ridge armed evolve shoe satoshi guilt huge grass"))).toEqual(fromHex("c9a0ed1374180cd8f8c5cc0bc9c719dfb67add59"));
expect(Bip39.decode(new EnglishMnemonic("light rule cinnamon wrap drastic word pride squirrel upgrade then income fatal apart sustain crack supply proud access"))).toEqual(fromHex("8197a4a47f0425faeaa69deebc05ca29c0a5b5cc76ceacc0"));
expect(Bip39.decode(new EnglishMnemonic("symptom eye business plunge palm safe nature legal stove addict grit agree chronic puzzle dream lawn vicious symbol useless donor eagle"))).toEqual(fromHex("dc8a247c5379f57c24dbfbd6a0699a8282875dd0a3f0f39b8fc020a4"));
expect(Bip39.decode(new EnglishMnemonic("all hour make first leader extend hole alien behind guard gospel lava path output census museum junior mass reopen famous sing advance salt reform"))).toEqual(fromHex("066dca1a2bb7e8a1db2832148ce9933eea0f3ac9548d793112d9a95c9407efad"));
expect(Bip39.decode(new EnglishMnemonic("vessel ladder alter error federal sibling chat ability sun glass valve picture"))).toEqual(fromHex("f30f8c1da665478f49b001d94c5fc452"));
expect(Bip39.decode(new EnglishMnemonic("upset shift velvet cruise wheel rival retire protect enrich gravity hair twenty sock walnut fat"))).toEqual(fromHex("ef38bbc81a5fa1756dfd654b0cc1a1759ce1ed94"));
expect(Bip39.decode(new EnglishMnemonic("scissors invite lock maple supreme raw rapid void congress muscle digital elegant little brisk hair mango congress clump"))).toEqual(fromHex("c10ec20dc3cd9f652c7fac2f1230f7a3c828389a14392f05"));
expect(Bip39.decode(new EnglishMnemonic("please fitness labor alter vintage food bike olive season speed digital sketch belt horn dutch avoid stomach pizza escape practice walnut"))).toEqual(fromHex("a66afdf103bf42b5858cd1c23a20f7e5114edb111880d634b53454bf"));
expect(Bip39.decode(new EnglishMnemonic("void come effort suffer camp survey warrior heavy shoot primary clutch crush open amazing screen patrol group space point ten exist slush involve unfold"))).toEqual(fromHex("f585c11aec520db57dd353c69554b21a89b20fb0650966fa0a9d6f74fd989d8f"));
});
it("can calculate seed from mnemonic (trezor test vectors)", async () => {
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"), "TREZOR")).toEqual(fromHex("c55257c360c07c72029aebc1b53c05ed0362ada38ead3e3e9efa3708e53495531f09a6987599d18264c1e1c92f2cf141630c7a3c4ab7c81b2f001698e7463b04"));
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("legal winner thank year wave sausage worth useful legal winner thank yellow"), "TREZOR")).toEqual(fromHex("2e8905819b8723fe2c1d161860e5ee1830318dbf49a83bd451cfb8440c28bd6fa457fe1296106559a3c80937a1c1069be3a3a5bd381ee6260e8d9739fce1f607"));
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("letter advice cage absurd amount doctor acoustic avoid letter advice cage above"), "TREZOR")).toEqual(fromHex("d71de856f81a8acc65e6fc851a38d4d7ec216fd0796d0a6827a3ad6ed5511a30fa280f12eb2e47ed2ac03b5c462a0358d18d69fe4f985ec81778c1b370b652a8"));
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo wrong"), "TREZOR")).toEqual(fromHex("ac27495480225222079d7be181583751e86f571027b0497b5b5d11218e0a8a13332572917f0f8e5a589620c6f15b11c61dee327651a14c34e18231052e48c069"));
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon agent"), "TREZOR")).toEqual(fromHex("035895f2f481b1b0f01fcf8c289c794660b289981a78f8106447707fdd9666ca06da5a9a565181599b79f53b844d8a71dd9f439c52a3d7b3e8a79c906ac845fa"));
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal will"), "TREZOR")).toEqual(fromHex("f2b94508732bcbacbcc020faefecfc89feafa6649a5491b8c952cede496c214a0c7b3c392d168748f2d4a612bada0753b52a1c7ac53c1e93abd5c6320b9e95dd"));
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter always"), "TREZOR")).toEqual(fromHex("107d7c02a5aa6f38c58083ff74f04c607c2d2c0ecc55501dadd72d025b751bc27fe913ffb796f841c49b1d33b610cf0e91d3aa239027f5e99fe4ce9e5088cd65"));
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo when"), "TREZOR")).toEqual(fromHex("0cd6e5d827bb62eb8fc1e262254223817fd068a74b5b449cc2f667c3f1f985a76379b43348d952e2265b4cd129090758b3e3c2c49103b5051aac2eaeb890a528"));
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon art"), "TREZOR")).toEqual(fromHex("bda85446c68413707090a52022edd26a1c9462295029f2e60cd7c4f2bbd3097170af7a4d73245cafa9c3cca8d561a7c3de6f5d4a10be8ed2a5e608d68f92fcc8"));
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth useful legal winner thank year wave sausage worth title"), "TREZOR")).toEqual(fromHex("bc09fca1804f7e69da93c2f2028eb238c227f2e9dda30cd63699232578480a4021b146ad717fbb7e451ce9eb835f43620bf5c514db0f8add49f5d121449d3e87"));
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic avoid letter advice cage absurd amount doctor acoustic bless"), "TREZOR")).toEqual(fromHex("c0c519bd0e91a2ed54357d9d1ebef6f5af218a153624cf4f2da911a0ed8f7a09e2ef61af0aca007096df430022f7a2b6fb91661a9589097069720d015e4e982f"));
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo zoo vote"), "TREZOR")).toEqual(fromHex("dd48c104698c30cfe2b6142103248622fb7bb0ff692eebb00089b32d22484e1613912f0a5b694407be899ffd31ed3992c456cdf60f5d4564b8ba3f05a69890ad"));
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("ozone drill grab fiber curtain grace pudding thank cruise elder eight picnic"), "TREZOR")).toEqual(fromHex("274ddc525802f7c828d8ef7ddbcdc5304e87ac3535913611fbbfa986d0c9e5476c91689f9c8a54fd55bd38606aa6a8595ad213d4c9c9f9aca3fb217069a41028"));
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("gravity machine north sort system female filter attitude volume fold club stay feature office ecology stable narrow fog"), "TREZOR")).toEqual(fromHex("628c3827a8823298ee685db84f55caa34b5cc195a778e52d45f59bcf75aba68e4d7590e101dc414bc1bbd5737666fbbef35d1f1903953b66624f910feef245ac"));
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("hamster diagram private dutch cause delay private meat slide toddler razor book happy fancy gospel tennis maple dilemma loan word shrug inflict delay length"), "TREZOR")).toEqual(fromHex("64c87cde7e12ecf6704ab95bb1408bef047c22db4cc7491c4271d170a1b213d20b385bc1588d9c7b38f1b39d415665b8a9030c9ec653d75e65f847d8fc1fc440"));
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("scheme spot photo card baby mountain device kick cradle pact join borrow"), "TREZOR")).toEqual(fromHex("ea725895aaae8d4c1cf682c1bfd2d358d52ed9f0f0591131b559e2724bb234fca05aa9c02c57407e04ee9dc3b454aa63fbff483a8b11de949624b9f1831a9612"));
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("horn tenant knee talent sponsor spell gate clip pulse soap slush warm silver nephew swap uncle crack brave"), "TREZOR")).toEqual(fromHex("fd579828af3da1d32544ce4db5c73d53fc8acc4ddb1e3b251a31179cdb71e853c56d2fcb11aed39898ce6c34b10b5382772db8796e52837b54468aeb312cfc3d"));
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("panda eyebrow bullet gorilla call smoke muffin taste mesh discover soft ostrich alcohol speed nation flash devote level hobby quick inner drive ghost inside"), "TREZOR")).toEqual(fromHex("72be8e052fc4919d2adf28d5306b5474b0069df35b02303de8c1729c9538dbb6fc2d731d5f832193cd9fb6aeecbc469594a70e3dd50811b5067f3b88b28c3e8d"));
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("cat swing flag economy stadium alone churn speed unique patch report train"), "TREZOR")).toEqual(fromHex("deb5f45449e615feff5640f2e49f933ff51895de3b4381832b3139941c57b59205a42480c52175b6efcffaa58a2503887c1e8b363a707256bdd2b587b46541f5"));
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("light rule cinnamon wrap drastic word pride squirrel upgrade then income fatal apart sustain crack supply proud access"), "TREZOR")).toEqual(fromHex("4cbdff1ca2db800fd61cae72a57475fdc6bab03e441fd63f96dabd1f183ef5b782925f00105f318309a7e9c3ea6967c7801e46c8a58082674c860a37b93eda02"));
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("all hour make first leader extend hole alien behind guard gospel lava path output census museum junior mass reopen famous sing advance salt reform"), "TREZOR")).toEqual(fromHex("26e975ec644423f4a4c4f4215ef09b4bd7ef924e85d1d17c4cf3f136c2863cf6df0a475045652c57eb5fb41513ca2a2d67722b77e954b4b3fc11f7590449191d"));
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("vessel ladder alter error federal sibling chat ability sun glass valve picture"), "TREZOR")).toEqual(fromHex("2aaa9242daafcee6aa9d7269f17d4efe271e1b9a529178d7dc139cd18747090bf9d60295d0ce74309a78852a9caadf0af48aae1c6253839624076224374bc63f"));
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("scissors invite lock maple supreme raw rapid void congress muscle digital elegant little brisk hair mango congress clump"), "TREZOR")).toEqual(fromHex("7b4a10be9d98e6cba265566db7f136718e1398c71cb581e1b2f464cac1ceedf4f3e274dc270003c670ad8d02c4558b2f8e39edea2775c9e232c7cb798b069e88"));
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("void come effort suffer camp survey warrior heavy shoot primary clutch crush open amazing screen patrol group space point ten exist slush involve unfold"), "TREZOR")).toEqual(fromHex("01f5bced59dec48e362f2c45b5de68b9fd6c92c6634f44d6d40aab69056506f0e35524a518034ddc1192e1dacd32c1ed3eaa3c3b131c88ed8e7e54c49a5d0998"));
});
it("can calculate seed from mnemonic (no password)", async () => {
// custom test vectors using
// $ git clone https://github.com/trezor/python-mnemonic.git && cd python-mnemonic
// $ python3 -m venv venv
// $ source venv/bin/activate
// $ pip install wheel bip32utils
// $ pip install -r requirements.txt
// patch generate_vectors.py to your needs
// $ python generate_vectors.py
// empty password
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("robust pipe raise illness symptom crowd trip will slow assault recipe oven"), "")).toEqual(fromHex("5539eed11e1096e9d52f69f15ad3d7c6547a40a3865b9517dbcbb03c31f231900622f58616d64d2d1cc0440f31d67fb0b2699a5fc885f796c746e0f844477093"));
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("pair ethics august street tornado spare present under capital raise cross current main craft stone clutch tray all"), "")).toEqual(fromHex("1272467e954cec4e0ad720002d037a3aaf795a57ffbeea6aaa0c242d410eb52050292447aa2c68470a07ecc80171edfa9e027793265047be3128d94e867a4f99"));
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("allow finger front connect strategy purchase journey distance trouble guitar honey alpha giraffe canal junk vintage chronic blade gate custom soap flip first mix"), "")).toEqual(fromHex("476a41ac016b5bdf9f114456929975a036ae326e2efdca441ac5a0949ef89ab9246dc9e49a5d2d64d1926eb9dbe17576cb010471c2a821b216202acdf3d7a27b"));
// no password
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("robust pipe raise illness symptom crowd trip will slow assault recipe oven"))).toEqual(fromHex("5539eed11e1096e9d52f69f15ad3d7c6547a40a3865b9517dbcbb03c31f231900622f58616d64d2d1cc0440f31d67fb0b2699a5fc885f796c746e0f844477093"));
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("pair ethics august street tornado spare present under capital raise cross current main craft stone clutch tray all"))).toEqual(fromHex("1272467e954cec4e0ad720002d037a3aaf795a57ffbeea6aaa0c242d410eb52050292447aa2c68470a07ecc80171edfa9e027793265047be3128d94e867a4f99"));
expect(await Bip39.mnemonicToSeed(new EnglishMnemonic("allow finger front connect strategy purchase journey distance trouble guitar honey alpha giraffe canal junk vintage chronic blade gate custom soap flip first mix"))).toEqual(fromHex("476a41ac016b5bdf9f114456929975a036ae326e2efdca441ac5a0949ef89ab9246dc9e49a5d2d64d1926eb9dbe17576cb010471c2a821b216202acdf3d7a27b"));
});
});

39

src/bip39.ts
import * as bip39 from "bip39";
// tslint:disable-next-line:no-submodule-imports
import bip39_wordlist_english from "bip39/wordlists/english.json";
import { pbkdf2 } from "pbkdf2";

@@ -9,39 +7,4 @@ import * as unorm from "unorm";

export class EnglishMnemonic {
// list of space separated lower case words (1 or more)
private static readonly mnemonicMatcher = /^[a-z]+( [a-z]+)*$/;
import { EnglishMnemonic } from "./englishmnemonic";
private readonly data: string;
constructor(mnemonic: string) {
if (!EnglishMnemonic.mnemonicMatcher.test(mnemonic)) {
throw new Error("Invalid mnemonic format");
}
const words = mnemonic.split(" ");
const allowedWordsLengths: ReadonlyArray<number> = [12, 15, 18, 21, 24];
if (allowedWordsLengths.indexOf(words.length) === -1) {
throw new Error(
`Invalid word count in mnemonic (allowed: ${allowedWordsLengths} got: ${words.length})`,
);
}
for (const word of words) {
if ((bip39_wordlist_english as ReadonlyArray<string>).indexOf(word) === -1) {
throw new Error("Mnemonic contains invalid word");
}
}
// Throws with informative error message if mnemonic is not valid
// tslint:disable-next-line:no-unused-expression
bip39.mnemonicToEntropy(mnemonic);
this.data = mnemonic;
}
public asString(): string {
return this.data;
}
}
export class Bip39 {

@@ -48,0 +11,0 @@ public static encode(entropy: Uint8Array): EnglishMnemonic {

156

src/hmac.spec.ts

@@ -23,3 +23,7 @@ import { Encoding } from "@iov/encoding";

const hmac = new Hmac(Sha1, fromHex("4CA0EF38F1794B28A8F8EE110EE79D48CE13BE25"));
hmac.update(fromHex("54657374205573696E67204C6172676572205468616E20426C6F636B2D53697A65204B6579202D2048617368204B6579204669727374"));
hmac.update(
fromHex(
"54657374205573696E67204C6172676572205468616E20426C6F636B2D53697A65204B6579202D2048617368204B6579204669727374",
),
);
expect(hmac.digest()).toEqual(fromHex("AA4AE5E15272D00E95705637CE8A3B55ED402112"));

@@ -29,3 +33,7 @@ }

const hmac = new Hmac(Sha1, fromHex("4CA0EF38F1794B28A8F8EE110EE79D48CE13BE25"));
hmac.update(fromHex("54657374205573696E67204C6172676572205468616E20426C6F636B2D53697A65204B657920616E64204C6172676572205468616E204F6E6520426C6F636B2D53697A652044617461"));
hmac.update(
fromHex(
"54657374205573696E67204C6172676572205468616E20426C6F636B2D53697A65204B657920616E64204C6172676572205468616E204F6E6520426C6F636B2D53697A652044617461",
),
);
expect(hmac.digest()).toEqual(fromHex("E8E99D0F45237D786D6BBAA7965C7808BBFF1A91"));

@@ -35,3 +43,7 @@ }

const hmac = new Hmac(Sha1, fromHex("0102030405060708090A0B0C0D0E0F10111213141516171819"));
hmac.update(fromHex("CDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCD"));
hmac.update(
fromHex(
"CDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCDCD",
),
);
expect(hmac.digest()).toEqual(fromHex("4C9007F4026250C6BC8414F9BF50C86C2D7235DA"));

@@ -41,3 +53,7 @@ }

const hmac = new Hmac(Sha1, fromHex("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"));
hmac.update(fromHex("DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD"));
hmac.update(
fromHex(
"DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD",
),
);
expect(hmac.digest()).toEqual(fromHex("125D7342B9AC11CD91A39AF48AA17B4F63F175D3"));

@@ -50,5 +66,10 @@ }

{
const hmac = new Hmac(Sha256, fromHex("0102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F20"));
const hmac = new Hmac(
Sha256,
fromHex("0102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F20"),
);
hmac.update(fromHex("616263"));
expect(hmac.digest()).toEqual(fromHex("A21B1F5D4CF4F73A4DD939750F7A066A7F98CC131CB16A6692759021CFAB8181"));
expect(hmac.digest()).toEqual(
fromHex("A21B1F5D4CF4F73A4DD939750F7A066A7F98CC131CB16A6692759021CFAB8181"),
);
}

@@ -58,18 +79,39 @@ {

hmac.update(fromHex("7768617420646F2079612077616E7420666F72206E6F7468696E673F"));
expect(hmac.digest()).toEqual(fromHex("5BDCC146BF60754E6A042426089575C75A003F089D2739839DEC58B964EC3843"));
expect(hmac.digest()).toEqual(
fromHex("5BDCC146BF60754E6A042426089575C75A003F089D2739839DEC58B964EC3843"),
);
}
{
const hmac = new Hmac(Sha256, fromHex("0102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F20"));
hmac.update(fromHex("6162636462636465636465666465666765666768666768696768696A68696A6B696A6B6C6A6B6C6D6B6C6D6E6C6D6E6F6D6E6F706E6F70716162636462636465636465666465666765666768666768696768696A68696A6B696A6B6C6A6B6C6D6B6C6D6E6C6D6E6F6D6E6F706E6F7071"));
expect(hmac.digest()).toEqual(fromHex("470305FC7E40FE34D3EEB3E773D95AAB73ACF0FD060447A5EB4595BF33A9D1A3"));
const hmac = new Hmac(
Sha256,
fromHex("0102030405060708090A0B0C0D0E0F101112131415161718191A1B1C1D1E1F20"),
);
hmac.update(
fromHex(
"6162636462636465636465666465666765666768666768696768696A68696A6B696A6B6C6A6B6C6D6B6C6D6E6C6D6E6F6D6E6F706E6F70716162636462636465636465666465666765666768666768696768696A68696A6B696A6B6C6A6B6C6D6B6C6D6E6C6D6E6F6D6E6F706E6F7071",
),
);
expect(hmac.digest()).toEqual(
fromHex("470305FC7E40FE34D3EEB3E773D95AAB73ACF0FD060447A5EB4595BF33A9D1A3"),
);
}
{
const hmac = new Hmac(Sha256, fromHex("0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B"));
const hmac = new Hmac(
Sha256,
fromHex("0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B0B"),
);
hmac.update(fromHex("4869205468657265"));
expect(hmac.digest()).toEqual(fromHex("198A607EB44BFBC69903A0F1CF2BBDC5BA0AA3F3D9AE3C1C7A3B1696A0B68CF7"));
expect(hmac.digest()).toEqual(
fromHex("198A607EB44BFBC69903A0F1CF2BBDC5BA0AA3F3D9AE3C1C7A3B1696A0B68CF7"),
);
}
{
const hmac = new Hmac(Sha256, fromHex("0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C"));
const hmac = new Hmac(
Sha256,
fromHex("0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C"),
);
hmac.update(fromHex("546573742057697468205472756E636174696F6E"));
expect(hmac.digest()).toEqual(fromHex("7546AF01841FC09B1AB9C3749A5F1C17D4F589668A587B2700A9C97C1193CF42"));
expect(hmac.digest()).toEqual(
fromHex("7546AF01841FC09B1AB9C3749A5F1C17D4F589668A587B2700A9C97C1193CF42"),
);
}

@@ -83,3 +125,7 @@ });

hmac.update(fromHex("4869205468657265"));
expect(hmac.digest()).toEqual(fromHex("87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b30545e17cdedaa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f1702e696c203a126854"));
expect(hmac.digest()).toEqual(
fromHex(
"87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b30545e17cdedaa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f1702e696c203a126854",
),
);
}

@@ -89,13 +135,33 @@ {

hmac.update(fromHex("7768617420646f2079612077616e7420666f72206e6f7468696e673f"));
expect(hmac.digest()).toEqual(fromHex("164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737"));
expect(hmac.digest()).toEqual(
fromHex(
"164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea2505549758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737",
),
);
}
{
const hmac = new Hmac(Sha512, fromHex("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
hmac.update(fromHex("dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"));
expect(hmac.digest()).toEqual(fromHex("fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33b2279d39bf3e848279a722c806b485a47e67c807b946a337bee8942674278859e13292fb"));
hmac.update(
fromHex(
"dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd",
),
);
expect(hmac.digest()).toEqual(
fromHex(
"fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33b2279d39bf3e848279a722c806b485a47e67c807b946a337bee8942674278859e13292fb",
),
);
}
{
const hmac = new Hmac(Sha512, fromHex("0102030405060708090a0b0c0d0e0f10111213141516171819"));
hmac.update(fromHex("cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd"));
expect(hmac.digest()).toEqual(fromHex("b0ba465637458c6990e5a8c5f61d4af7e576d97ff94b872de76f8050361ee3dba91ca5c11aa25eb4d679275cc5788063a5f19741120c4f2de2adebeb10a298dd"));
hmac.update(
fromHex(
"cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
),
);
expect(hmac.digest()).toEqual(
fromHex(
"b0ba465637458c6990e5a8c5f61d4af7e576d97ff94b872de76f8050361ee3dba91ca5c11aa25eb4d679275cc5788063a5f19741120c4f2de2adebeb10a298dd",
),
);
}

@@ -108,10 +174,36 @@ {

{
const hmac = new Hmac(Sha512, fromHex("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
hmac.update(fromHex("54657374205573696e67204c6172676572205468616e20426c6f636b2d53697a65204b6579202d2048617368204b6579204669727374"));
expect(hmac.digest()).toEqual(fromHex("80b24263c7c1a3ebb71493c1dd7be8b49b46d1f41b4aeec1121b013783f8f3526b56d037e05f2598bd0fd2215d6a1e5295e64f73f63f0aec8b915a985d786598"));
const hmac = new Hmac(
Sha512,
fromHex(
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
),
);
hmac.update(
fromHex(
"54657374205573696e67204c6172676572205468616e20426c6f636b2d53697a65204b6579202d2048617368204b6579204669727374",
),
);
expect(hmac.digest()).toEqual(
fromHex(
"80b24263c7c1a3ebb71493c1dd7be8b49b46d1f41b4aeec1121b013783f8f3526b56d037e05f2598bd0fd2215d6a1e5295e64f73f63f0aec8b915a985d786598",
),
);
}
{
const hmac = new Hmac(Sha512, fromHex("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"));
hmac.update(fromHex("5468697320697320612074657374207573696e672061206c6172676572207468616e20626c6f636b2d73697a65206b657920616e642061206c6172676572207468616e20626c6f636b2d73697a6520646174612e20546865206b6579206e6565647320746f20626520686173686564206265666f7265206265696e6720757365642062792074686520484d414320616c676f726974686d2e"));
expect(hmac.digest()).toEqual(fromHex("e37b6a775dc87dbaa4dfa9f96e5e3ffddebd71f8867289865df5a32d20cdc944b6022cac3c4982b10d5eeb55c3e4de15134676fb6de0446065c97440fa8c6a58"));
const hmac = new Hmac(
Sha512,
fromHex(
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
),
);
hmac.update(
fromHex(
"5468697320697320612074657374207573696e672061206c6172676572207468616e20626c6f636b2d73697a65206b657920616e642061206c6172676572207468616e20626c6f636b2d73697a6520646174612e20546865206b6579206e6565647320746f20626520686173686564206265666f7265206265696e6720757365642062792074686520484d414320616c676f726974686d2e",
),
);
expect(hmac.digest()).toEqual(
fromHex(
"e37b6a775dc87dbaa4dfa9f96e5e3ffddebd71f8867289865df5a32d20cdc944b6022cac3c4982b10d5eeb55c3e4de15134676fb6de0446065c97440fa8c6a58",
),
);
}

@@ -141,3 +233,5 @@ });

hmac.update(fromHex("7061756c"));
expect(hmac.digest()).toEqual(fromHex("50972b73add1dbbbe6884104d0f91efcef184e0aef6e485a075b3cab1f70e572"));
expect(hmac.digest()).toEqual(
fromHex("50972b73add1dbbbe6884104d0f91efcef184e0aef6e485a075b3cab1f70e572"),
);
}

@@ -147,3 +241,5 @@ {

hmac.update(fromHex("70"));
expect(hmac.digest()).toEqual(fromHex("a1d75fa8dc0d1a84cf6df6f0e55cb52d89d44acb26e786c9329cf8dc8804a94e"));
expect(hmac.digest()).toEqual(
fromHex("a1d75fa8dc0d1a84cf6df6f0e55cb52d89d44acb26e786c9329cf8dc8804a94e"),
);
}

@@ -153,5 +249,7 @@ {

hmac.update(fromHex(""));
expect(hmac.digest()).toEqual(fromHex("b613679a0814d9ec772f95d778c35fc5ff1697c493715653c6c712144292c5ad"));
expect(hmac.digest()).toEqual(
fromHex("b613679a0814d9ec772f95d778c35fc5ff1697c493715653c6c712144292c5ad"),
);
}
});
});

1

src/index.ts
export * from "./bip39";
export { EnglishMnemonic } from "./englishmnemonic";
export * from "./hmac";

@@ -3,0 +4,0 @@ export * from "./keccak";

338

src/secp256k1.spec.ts

@@ -28,3 +28,7 @@ /* tslint:disable:no-bitwise */

const keypair = await Secp256k1.makeKeypair(privkey);
expect(keypair.pubkey).toEqual(fromHex("043e1113575cf01f9281381f626deccf76cdc85a320052297f7cae3548ea024d0b9fbec8a56d345a2984050be859c96471ef6aa4669ff31a659ce1d32db372f9b9"));
expect(keypair.pubkey).toEqual(
fromHex(
"043e1113575cf01f9281381f626deccf76cdc85a320052297f7cae3548ea024d0b9fbec8a56d345a2984050be859c96471ef6aa4669ff31a659ce1d32db372f9b9",
),
);
});

@@ -35,13 +39,35 @@

const keypair = await Secp256k1.makeKeypair(privkey);
expect(keypair.privkey).toEqual(fromHex("8c8bc2bc7954db5ef751e3e84b4e99bbe387a90d8019d8066c0e1e8bf33e713f"));
expect(keypair.privkey).toEqual(
fromHex("8c8bc2bc7954db5ef751e3e84b4e99bbe387a90d8019d8066c0e1e8bf33e713f"),
);
});
it("can load private keys", async () => {
expect(await Secp256k1.makeKeypair(fromHex("5eaf4344dab73d0caee1fd03607bb969074fb217f076896c2125f8607feab7b1"))).toBeTruthy();
expect(await Secp256k1.makeKeypair(fromHex("f7ac570ea2844e29e7f3b3c6a724ee1f47d3de8c2175a69abae94ae871573d0e"))).toBeTruthy();
expect(await Secp256k1.makeKeypair(fromHex("e4ade2a5232a7c6f37e7b854a774e25e6047ee7c6d63e8304ae04fa190bc1732"))).toBeTruthy();
expect(
await Secp256k1.makeKeypair(
fromHex("5eaf4344dab73d0caee1fd03607bb969074fb217f076896c2125f8607feab7b1"),
),
).toBeTruthy();
expect(
await Secp256k1.makeKeypair(
fromHex("f7ac570ea2844e29e7f3b3c6a724ee1f47d3de8c2175a69abae94ae871573d0e"),
),
).toBeTruthy();
expect(
await Secp256k1.makeKeypair(
fromHex("e4ade2a5232a7c6f37e7b854a774e25e6047ee7c6d63e8304ae04fa190bc1732"),
),
).toBeTruthy();
// smallest and largest allowed values: 1 and N-1 (from https://crypto.stackexchange.com/a/30273)
expect(await Secp256k1.makeKeypair(fromHex("0000000000000000000000000000000000000000000000000000000000000001"))).toBeTruthy();
expect(await Secp256k1.makeKeypair(fromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364140"))).toBeTruthy();
expect(
await Secp256k1.makeKeypair(
fromHex("0000000000000000000000000000000000000000000000000000000000000001"),
),
).toBeTruthy();
expect(
await Secp256k1.makeKeypair(
fromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364140"),
),
).toBeTruthy();

@@ -127,3 +153,5 @@ // too short and too long

// signature corrupted
const corruptedSignature = Secp256k1Signature.fromDer(signature.toDer().map((x, i) => (i === 5 ? x ^ 0x01 : x)));
const corruptedSignature = Secp256k1Signature.fromDer(
signature.toDer().map((x, i) => (i === 5 ? x ^ 0x01 : x)),
);
const ok = await Secp256k1.verifySignature(corruptedSignature, messageHash, keypair.pubkey);

@@ -143,4 +171,10 @@ expect(ok).toEqual(false);

it("throws for empty message hash in verification", async () => {
const dummySignature = Secp256k1Signature.fromDer(fromHex("304602210083de9be443bcf480892b8c8ca1d5ee65c79a315642c3f7b5305aff3065fda2780221009747932122b93cec42cad8ee4630a8f6cbe127578b8c495b4ab927275f657658"));
const keypair = await Secp256k1.makeKeypair(fromHex("43a9c17ccbb0e767ea29ce1f10813afde5f1e0a7a504e89b4d2cc2b952b8e0b9"));
const dummySignature = Secp256k1Signature.fromDer(
fromHex(
"304602210083de9be443bcf480892b8c8ca1d5ee65c79a315642c3f7b5305aff3065fda2780221009747932122b93cec42cad8ee4630a8f6cbe127578b8c495b4ab927275f657658",
),
);
const keypair = await Secp256k1.makeKeypair(
fromHex("43a9c17ccbb0e767ea29ce1f10813afde5f1e0a7a504e89b4d2cc2b952b8e0b9"),
);
const messageHash = new Uint8Array([]);

@@ -153,4 +187,10 @@ await Secp256k1.verifySignature(dummySignature, messageHash, keypair.pubkey)

it("throws for message hash longer than 32 bytes in verification", async () => {
const dummySignature = Secp256k1Signature.fromDer(fromHex("304602210083de9be443bcf480892b8c8ca1d5ee65c79a315642c3f7b5305aff3065fda2780221009747932122b93cec42cad8ee4630a8f6cbe127578b8c495b4ab927275f657658"));
const keypair = await Secp256k1.makeKeypair(fromHex("43a9c17ccbb0e767ea29ce1f10813afde5f1e0a7a504e89b4d2cc2b952b8e0b9"));
const dummySignature = Secp256k1Signature.fromDer(
fromHex(
"304602210083de9be443bcf480892b8c8ca1d5ee65c79a315642c3f7b5305aff3065fda2780221009747932122b93cec42cad8ee4630a8f6cbe127578b8c495b4ab927275f657658",
),
);
const keypair = await Secp256k1.makeKeypair(
fromHex("43a9c17ccbb0e767ea29ce1f10813afde5f1e0a7a504e89b4d2cc2b952b8e0b9"),
);
const messageHash = fromHex("11223344556677889900aabbccddeeff11223344556677889900aabbccddeeff11");

@@ -164,102 +204,186 @@ await Secp256k1.verifySignature(dummySignature, messageHash, keypair.privkey)

// signatures are mixed lowS and non-lowS, prehash type is sha256
const data: ReadonlyArray<{ readonly message: Uint8Array; readonly privkey: Uint8Array; readonly signature: Uint8Array }> = [
const data: ReadonlyArray<{
readonly message: Uint8Array;
readonly privkey: Uint8Array;
readonly signature: Uint8Array;
}> = [
{
message: fromHex("5c868fedb8026979ebd26f1ba07c27eedf4ff6d10443505a96ecaf21ba8c4f0937b3cd23ffdc3dd429d4cd1905fb8dbcceeff1350020e18b58d2ba70887baa3a9b783ad30d3fbf210331cdd7df8d77defa398cdacdfc2e359c7ba4cae46bb74401deb417f8b912a1aa966aeeba9c39c7dd22479ae2b30719dca2f2206c5eb4b7"),
message: fromHex(
"5c868fedb8026979ebd26f1ba07c27eedf4ff6d10443505a96ecaf21ba8c4f0937b3cd23ffdc3dd429d4cd1905fb8dbcceeff1350020e18b58d2ba70887baa3a9b783ad30d3fbf210331cdd7df8d77defa398cdacdfc2e359c7ba4cae46bb74401deb417f8b912a1aa966aeeba9c39c7dd22479ae2b30719dca2f2206c5eb4b7",
),
privkey: fromHex("21142a7e90031ea750c9fa1ba1beae16782386be438133bd43195826ae2e25f0"),
signature: fromHex("30440220207082eb2c3dfa0b454e0906051270ba4074ac93760ba9e7110cd94714751111022051eb0dbbc9920e72146fb564f99d039802bf6ef2561446eb126ef364d21ee9c4"),
signature: fromHex(
"30440220207082eb2c3dfa0b454e0906051270ba4074ac93760ba9e7110cd94714751111022051eb0dbbc9920e72146fb564f99d039802bf6ef2561446eb126ef364d21ee9c4",
),
},
{
message: fromHex("17cd4a74d724d55355b6fb2b0759ca095298e3fd1856b87ca1cb2df5409058022736d21be071d820b16dfc441be97fbcea5df787edc886e759475469e2128b22f26b82ca993be6695ab190e673285d561d3b6d42fcc1edd6d12db12dcda0823e9d6079e7bc5ff54cd452dad308d52a15ce9c7edd6ef3dad6a27becd8e001e80f"),
message: fromHex(
"17cd4a74d724d55355b6fb2b0759ca095298e3fd1856b87ca1cb2df5409058022736d21be071d820b16dfc441be97fbcea5df787edc886e759475469e2128b22f26b82ca993be6695ab190e673285d561d3b6d42fcc1edd6d12db12dcda0823e9d6079e7bc5ff54cd452dad308d52a15ce9c7edd6ef3dad6a27becd8e001e80f",
),
privkey: fromHex("824282b6069fe3df857ce37204df4312c35750ee7a0f5e5fd8181666d5e46fb2"),
signature: fromHex("30440220626d61b7be1488b563e8a85bfb623b2331903964b5c0476c9f9ad29144f076fe02202002a2c0ab5e48626bf761cf677dfeede9c7309d2436d4b8c2b89f21ee2ebc6a"),
signature: fromHex(
"30440220626d61b7be1488b563e8a85bfb623b2331903964b5c0476c9f9ad29144f076fe02202002a2c0ab5e48626bf761cf677dfeede9c7309d2436d4b8c2b89f21ee2ebc6a",
),
},
{
message: fromHex("db0d31717b04802adbbae1997487da8773440923c09b869e12a57c36dda34af11b8897f266cd81c02a762c6b74ea6aaf45aaa3c52867eb8f270f5092a36b498f88b65b2ebda24afe675da6f25379d1e194d093e7a2f66e450568dbdffebff97c4597a00c96a5be9ba26deefcca8761c1354429622c8db269d6a0ec0cc7a8585c"),
message: fromHex(
"db0d31717b04802adbbae1997487da8773440923c09b869e12a57c36dda34af11b8897f266cd81c02a762c6b74ea6aaf45aaa3c52867eb8f270f5092a36b498f88b65b2ebda24afe675da6f25379d1e194d093e7a2f66e450568dbdffebff97c4597a00c96a5be9ba26deefcca8761c1354429622c8db269d6a0ec0cc7a8585c",
),
privkey: fromHex("5c0da42cec87a6b7a173514965343c30013386c0fe9b39203ed7af43ea425944"),
signature: fromHex("304602210083de9be443bcf480892b8c8ca1d5ee65c79a315642c3f7b5305aff3065fda2780221009747932122b93cec42cad8ee4630a8f6cbe127578b8c495b4ab927275f657658"),
signature: fromHex(
"304602210083de9be443bcf480892b8c8ca1d5ee65c79a315642c3f7b5305aff3065fda2780221009747932122b93cec42cad8ee4630a8f6cbe127578b8c495b4ab927275f657658",
),
},
{
message: fromHex("47c9deddfd8c841a63a99be96e972e40fa035ae10d929babfc86c437b9d5d495577a45b7f8a35ce3f880e7d8ae8cd8eb685cf41f0506e68046ccf5559232c674abb9c3683829dcc8002683c4f4ca3a29a7bfde20d96dd0f1a0ead847dea18f297f220f94932536ca4deacedc2c6701c3ee50e28e358dcc54cdbf69daf0eb87f6"),
message: fromHex(
"47c9deddfd8c841a63a99be96e972e40fa035ae10d929babfc86c437b9d5d495577a45b7f8a35ce3f880e7d8ae8cd8eb685cf41f0506e68046ccf5559232c674abb9c3683829dcc8002683c4f4ca3a29a7bfde20d96dd0f1a0ead847dea18f297f220f94932536ca4deacedc2c6701c3ee50e28e358dcc54cdbf69daf0eb87f6",
),
privkey: fromHex("ab30a326599165b48c65ab8d3c77d312d7b2ea4853f721e18cc278628a866980"),
signature: fromHex("30440220723da69da81c8f6b081a9a728b9bba785d2067e0ed769675f8a7563d22ed8a1602203a993793cf39b96b3cd625df0e06f206e17579cd8ebcb7e704174c3d94dba684"),
signature: fromHex(
"30440220723da69da81c8f6b081a9a728b9bba785d2067e0ed769675f8a7563d22ed8a1602203a993793cf39b96b3cd625df0e06f206e17579cd8ebcb7e704174c3d94dba684",
),
},
{
message: fromHex("f15433188c2bbc93b2150bb2f34d36ba8ae49f8f7e4e81aed651c8fb2022b2a7e851c4dbbbc21c14e27380316bfdebb0a049246349537dba687581c1344e40f75afd2735bb21ea074861de6801d28b22e8beb76fdd25598812b2061ca3fba229daf59a4ab416704543b02e16b8136c22acc7e197748ae19b5cbbc160fdc3a8cd"),
message: fromHex(
"f15433188c2bbc93b2150bb2f34d36ba8ae49f8f7e4e81aed651c8fb2022b2a7e851c4dbbbc21c14e27380316bfdebb0a049246349537dba687581c1344e40f75afd2735bb21ea074861de6801d28b22e8beb76fdd25598812b2061ca3fba229daf59a4ab416704543b02e16b8136c22acc7e197748ae19b5cbbc160fdc3a8cd",
),
privkey: fromHex("1560b9fa5229f623a9c556132da4fc0e58633f39ce6421d25b5a6cde4ad7e019"),
signature: fromHex("304502200e0c5228e6783bee4d0406f4f7b7d79f705f0dbb55126966f79e631bd8b23079022100faae33aec5b0fafd3413c14bfdef9c7c9ac6abd06c923c48ab136a2c56826118"),
signature: fromHex(
"304502200e0c5228e6783bee4d0406f4f7b7d79f705f0dbb55126966f79e631bd8b23079022100faae33aec5b0fafd3413c14bfdef9c7c9ac6abd06c923c48ab136a2c56826118",
),
},
{
message: fromHex("1bc796124b87793b7f7fdd53b896f8f0d0f2d2be36d1944e3c2a0ac5c6b2839f59a4b4fad200f8035ec98630c51ef0d40863a5ddd69b703d73f06b4afae8ad1a88e19b1b26e8c10b7bff953c05eccc82fd771b220910165f3a906b7c931683e431998d1fd06c32dd11b4f872bf980d547942f22124c7e50c9523321aee23a36d"),
message: fromHex(
"1bc796124b87793b7f7fdd53b896f8f0d0f2d2be36d1944e3c2a0ac5c6b2839f59a4b4fad200f8035ec98630c51ef0d40863a5ddd69b703d73f06b4afae8ad1a88e19b1b26e8c10b7bff953c05eccc82fd771b220910165f3a906b7c931683e431998d1fd06c32dd11b4f872bf980d547942f22124c7e50c9523321aee23a36d",
),
privkey: fromHex("42f7d48e1c90f3d20252713f7c7c6ce8492c2b99bcef198927de334cda6bad00"),
signature: fromHex("3046022100b9d3962edadc893f8eeff379f136c7b8fc6ea824a5afc6cbda7e3cb4c7a1e860022100bb1c1f901cf450edfdce20686352bb0cf0a643301123140ec87c92480d7f9d6a"),
signature: fromHex(
"3046022100b9d3962edadc893f8eeff379f136c7b8fc6ea824a5afc6cbda7e3cb4c7a1e860022100bb1c1f901cf450edfdce20686352bb0cf0a643301123140ec87c92480d7f9d6a",
),
},
{
message: fromHex("18e55ac264031da435b613fc9dc6c4aafc49aae8ddf6f220d523415896ff915fae5c5b2e6aed61d88e5721823f089c46173afc5d9b47fd917834c85284f62dda6ed2d7a6ff10eb553b9312b05dad7decf7f73b69479c02f14ea0a2aa9e05ec07396cd37c28795c90e590631137102315635d702278e352aa41d0826adadff5e1"),
message: fromHex(
"18e55ac264031da435b613fc9dc6c4aafc49aae8ddf6f220d523415896ff915fae5c5b2e6aed61d88e5721823f089c46173afc5d9b47fd917834c85284f62dda6ed2d7a6ff10eb553b9312b05dad7decf7f73b69479c02f14ea0a2aa9e05ec07396cd37c28795c90e590631137102315635d702278e352aa41d0826adadff5e1",
),
privkey: fromHex("6fe5b986c18da5d4fbcea6f602f469ac039085247ccb97b6292992363ea1d21c"),
signature: fromHex("30460221009369ab86afae5e22ed5f4012964804d2a19c36b8b58cf2855205b1cfcc937422022100a27dfc38d899b78edcf38a1b2b53578e72270b083d7d69424c4b4a7d25d39f4d"),
signature: fromHex(
"30460221009369ab86afae5e22ed5f4012964804d2a19c36b8b58cf2855205b1cfcc937422022100a27dfc38d899b78edcf38a1b2b53578e72270b083d7d69424c4b4a7d25d39f4d",
),
},
{
message: fromHex("a5290666c97294d090f8da898e555cbd33990579e5e95498444bfb318b4aa1643e0d4348425e21c7c6f99f9955f3048f56c22b68c4a516af5c90ed5268acc9c5a20fec0200c2a282a90e20d3c46d4ecdda18ba18b803b19263de2b79238da921707a0864799cdee9f02913b40681c02c6923070688844b58fe415b7d71ea6845"),
message: fromHex(
"a5290666c97294d090f8da898e555cbd33990579e5e95498444bfb318b4aa1643e0d4348425e21c7c6f99f9955f3048f56c22b68c4a516af5c90ed5268acc9c5a20fec0200c2a282a90e20d3c46d4ecdda18ba18b803b19263de2b79238da921707a0864799cdee9f02913b40681c02c6923070688844b58fe415b7d71ea6845",
),
privkey: fromHex("fbf02ff086b215d057130a509346b64eb63bec0e38db692e07ad24c6ca8fe210"),
signature: fromHex("3045022100c5e439cef76b28dc0fe9d260763bec05b5e795ac8d90b25d9fccbc1918bc32f302201b06144e6b191224d5eda822a5b3b2026af6aa7f25a9061c9e81c312728aa94a"),
signature: fromHex(
"3045022100c5e439cef76b28dc0fe9d260763bec05b5e795ac8d90b25d9fccbc1918bc32f302201b06144e6b191224d5eda822a5b3b2026af6aa7f25a9061c9e81c312728aa94a",
),
},
{
message: fromHex("13ad0600229c2a66b2f11617f69c7210ad044c49265dc98ec3c64f56e56a083234d277d404e2c40523c414ad23af5cc2f91a47fe59e7ca572f7fe1d3d3cfceaedadac4396749a292a38e92727273272335f12b2acea21cf069682e67d7e7d7a31ab5bb8e472298a9451aeae6f160f36e6623c9b632b9c93371a002818addc243"),
message: fromHex(
"13ad0600229c2a66b2f11617f69c7210ad044c49265dc98ec3c64f56e56a083234d277d404e2c40523c414ad23af5cc2f91a47fe59e7ca572f7fe1d3d3cfceaedadac4396749a292a38e92727273272335f12b2acea21cf069682e67d7e7d7a31ab5bb8e472298a9451aeae6f160f36e6623c9b632b9c93371a002818addc243",
),
privkey: fromHex("474a7dc7f5033b6bf5e3027254cd0dbd956f16f61874b2992839a867f607d0dd"),
signature: fromHex("3045022100ee8615a5fab6fc674e6d3d9cde8da2b18dece076ae94d96662e16109db12d72002203171705cdab2b3d34c58e556c80358c105807e98243f5754b70b771071308b94"),
signature: fromHex(
"3045022100ee8615a5fab6fc674e6d3d9cde8da2b18dece076ae94d96662e16109db12d72002203171705cdab2b3d34c58e556c80358c105807e98243f5754b70b771071308b94",
),
},
{
message: fromHex("51ad843da5eafc177d49a50a82609555e52773c5dfa14d7c02db5879c11a6b6e2e0860df38452dc579d763f91a83ade23b73f4fcbd703f35dd6ecfbb4c9578d5b604ed809c8633e6ac5679a5f742ce94fea3b97b5ba8a29ea28101a7b35f9eaa894dda54e3431f2464d18faf8342b7c59dfe0598c0ab29a14622a08eea70126b"),
message: fromHex(
"51ad843da5eafc177d49a50a82609555e52773c5dfa14d7c02db5879c11a6b6e2e0860df38452dc579d763f91a83ade23b73f4fcbd703f35dd6ecfbb4c9578d5b604ed809c8633e6ac5679a5f742ce94fea3b97b5ba8a29ea28101a7b35f9eaa894dda54e3431f2464d18faf8342b7c59dfe0598c0ab29a14622a08eea70126b",
),
privkey: fromHex("e8a2939a46e6bb7e706e419c0101d39f0494935b17fe3ca907b2ea3558d6ab3a"),
signature: fromHex("3046022100f753c447161aa3a58e5deeca31797f21484fb0ec3a7fe6e464ab1914896f253b02210099640fbcce1f25fd66744b046e0dfd57fa23070555f438af6c5e5828d47e9fa7"),
signature: fromHex(
"3046022100f753c447161aa3a58e5deeca31797f21484fb0ec3a7fe6e464ab1914896f253b02210099640fbcce1f25fd66744b046e0dfd57fa23070555f438af6c5e5828d47e9fa7",
),
},
{
message: fromHex("678b505467d55ce01aec23fd4851957137c3a1de3ff2c673ec95a577aa9fb011b4b4a8eb7a0e6f391d4236a35b7e769692ace5851d7c53700e180fa522d3d37dbaa496163f3de6d96391e38ff83271e621f2458729ff74de462cdce6b3029f308d4eb8aef036357b9de06d68558e0388a6e88af91340c875050b8c91c4e26fc8"),
message: fromHex(
"678b505467d55ce01aec23fd4851957137c3a1de3ff2c673ec95a577aa9fb011b4b4a8eb7a0e6f391d4236a35b7e769692ace5851d7c53700e180fa522d3d37dbaa496163f3de6d96391e38ff83271e621f2458729ff74de462cdce6b3029f308d4eb8aef036357b9de06d68558e0388a6e88af91340c875050b8c91c4e26fc8",
),
privkey: fromHex("08ce8f7118eda55b008f6eb3281a445a3ddbc5209d5ac16c09dbf40fe4bbc22c"),
signature: fromHex("30440220439fd0423bde36a1616a6fa4343bb7e07a6b3f6dc629aa8c93c91831055e476c022020998a26ae4b96ef36d48d83e8af0288f0bbc2db5ca5c8271a42f3fdc478fcb2"),
signature: fromHex(
"30440220439fd0423bde36a1616a6fa4343bb7e07a6b3f6dc629aa8c93c91831055e476c022020998a26ae4b96ef36d48d83e8af0288f0bbc2db5ca5c8271a42f3fdc478fcb2",
),
},
{
message: fromHex("9bf457159f0d44b78d0e151ee53c41cecd98fb4e4129fcda8cc84a758636f84dcad9032f3ec422219d8a7ec61ea89f45d19cab3c3d451de1a634e3d2532231bc03031973d7150cf8e83d8b6a34f25fc136446878e3851b780abdca069c8e981b3ea3f1bf1ff6e47a03f97aed64c1cc90dd00389fa21bb973f142af5e8ceccef4"),
message: fromHex(
"9bf457159f0d44b78d0e151ee53c41cecd98fb4e4129fcda8cc84a758636f84dcad9032f3ec422219d8a7ec61ea89f45d19cab3c3d451de1a634e3d2532231bc03031973d7150cf8e83d8b6a34f25fc136446878e3851b780abdca069c8e981b3ea3f1bf1ff6e47a03f97aed64c1cc90dd00389fa21bb973f142af5e8ceccef4",
),
privkey: fromHex("820be5c5e14e802300ca024fce318910f00470f6c3eabb12e7f3fac9383cf247"),
signature: fromHex("304502204ce72a83cf1d148db4d1e46e2f773c677f72933c40d7100b9192750a1c8222a80221009d5fbd67ce89ba8c79df9dc3b42922026a8498921c2bdb4ea8f36496d88c2cfb"),
signature: fromHex(
"304502204ce72a83cf1d148db4d1e46e2f773c677f72933c40d7100b9192750a1c8222a80221009d5fbd67ce89ba8c79df9dc3b42922026a8498921c2bdb4ea8f36496d88c2cfb",
),
},
{
message: fromHex("2469172b7a046e6112dfe365590dfddb7c045cccd4ab353edc3076091aad1c780a9a73ff93f3dbf9e2189c5d1fdd6f6167d0ae8cc0f53dc8950e60dd0410e23589999d4ce4fa49e268774defd4edce01c05b205014b63591a041745bfffc6ae4d72d3add353e49478106653cc735b07b0fe665c42d0e6766e525bb9718264c87"),
message: fromHex(
"2469172b7a046e6112dfe365590dfddb7c045cccd4ab353edc3076091aad1c780a9a73ff93f3dbf9e2189c5d1fdd6f6167d0ae8cc0f53dc8950e60dd0410e23589999d4ce4fa49e268774defd4edce01c05b205014b63591a041745bfffc6ae4d72d3add353e49478106653cc735b07b0fe665c42d0e6766e525bb9718264c87",
),
privkey: fromHex("d92d6170e63bc33647e6dcdf1981771ecd57e11d47d73138696fbf49a430c3ab"),
signature: fromHex("304502201f1e1fb673e9a7dee09961c6824b473189904deb4f0d8e28da51f77f4de2efe6022100ae8df1fcdb226fac8b46e494720e45f6d9a5350174faaf22e47b6329ee6c5e1b"),
signature: fromHex(
"304502201f1e1fb673e9a7dee09961c6824b473189904deb4f0d8e28da51f77f4de2efe6022100ae8df1fcdb226fac8b46e494720e45f6d9a5350174faaf22e47b6329ee6c5e1b",
),
},
{
message: fromHex("6f8983e74f304c3657cffde0682b42699cb2c3475b925058ff37292c40a0aa296690ad129730339ac60cf784225b2fd3db58297c8ce5889df7a48d3e74a363ae4135e8a234cab53ca4c11c031d561a6cf7dd47b925ed5bc4c2794ba7b74a868b0c3da31ff1e4540d0768612192a236d86f74fb8c73f375b71c62f1648c0e6126"),
message: fromHex(
"6f8983e74f304c3657cffde0682b42699cb2c3475b925058ff37292c40a0aa296690ad129730339ac60cf784225b2fd3db58297c8ce5889df7a48d3e74a363ae4135e8a234cab53ca4c11c031d561a6cf7dd47b925ed5bc4c2794ba7b74a868b0c3da31ff1e4540d0768612192a236d86f74fb8c73f375b71c62f1648c0e6126",
),
privkey: fromHex("a70eb435feaeb6ccda7d3ebd3c4ae40b60643bc933f37ad1aca41dd086e8ae50"),
signature: fromHex("30460221009cf7d941dcbbbe61c2a6f5112cb518094e79e5d203891de2247e75fd532c3f21022100fc5a04579b2526f2543efd2a57e82b647da08b6924bff39cf021398a56ad70de"),
signature: fromHex(
"30460221009cf7d941dcbbbe61c2a6f5112cb518094e79e5d203891de2247e75fd532c3f21022100fc5a04579b2526f2543efd2a57e82b647da08b6924bff39cf021398a56ad70de",
),
},
{
message: fromHex("6fbe6f0f178fdc8a3ad1a8eecb02d37108c5831281fe85e3ff8eeb66ca1082a217b6d602439948f828e140140412544f994da75b6efc203b295235deca060ecfc7b71f05e5af2acc564596772ddbfb4078b4665f6b85f4e70641af26e31f6a14e5c88604459df4eeeed9b77b33c4b82a3c1458bd2fd1dc7214c04f9c79c8f09b"),
message: fromHex(
"6fbe6f0f178fdc8a3ad1a8eecb02d37108c5831281fe85e3ff8eeb66ca1082a217b6d602439948f828e140140412544f994da75b6efc203b295235deca060ecfc7b71f05e5af2acc564596772ddbfb4078b4665f6b85f4e70641af26e31f6a14e5c88604459df4eeeed9b77b33c4b82a3c1458bd2fd1dc7214c04f9c79c8f09b",
),
privkey: fromHex("34a677d6f0c132eeffc3451b61e5d55969399699019ac929e6fdb5215d37be5e"),
signature: fromHex("3045022059cd6c2a30227afbd693d87b201d0989435d6e116c144276a5223466a822c0f2022100b01495efda969b3fd3a2c05aa098a4e04b0d0e748726fc6174627da15b143799"),
signature: fromHex(
"3045022059cd6c2a30227afbd693d87b201d0989435d6e116c144276a5223466a822c0f2022100b01495efda969b3fd3a2c05aa098a4e04b0d0e748726fc6174627da15b143799",
),
},
{
message: fromHex("2b49de971bb0f705a3fb5914eb7638d72884a6c3550667dbfdf301adf26bde02f387fd426a31be6c9ff8bfe8690c8113c88576427f1466508458349fc86036afcfb66448b947707e791e71f558b2bf4e7e7507773aaf4e9af51eda95cbce0a0f752b216f8a54a045d47801ff410ee411a1b66a516f278327df2462fb5619470e"),
message: fromHex(
"2b49de971bb0f705a3fb5914eb7638d72884a6c3550667dbfdf301adf26bde02f387fd426a31be6c9ff8bfe8690c8113c88576427f1466508458349fc86036afcfb66448b947707e791e71f558b2bf4e7e7507773aaf4e9af51eda95cbce0a0f752b216f8a54a045d47801ff410ee411a1b66a516f278327df2462fb5619470e",
),
privkey: fromHex("2258cdecaf3510bc398d08c000245cadceadcf149022730d93b176b4844713e1"),
signature: fromHex("30460221009eaf69170aeba44966afe957295526ee9852b5034c18dc5aeef3255c8567838a022100ebd4c8de2c22b5cb8803d6e070186786f6d5dae2202b9f899276fa31a66cb3bb"),
signature: fromHex(
"30460221009eaf69170aeba44966afe957295526ee9852b5034c18dc5aeef3255c8567838a022100ebd4c8de2c22b5cb8803d6e070186786f6d5dae2202b9f899276fa31a66cb3bb",
),
},
{
message: fromHex("1fa7201d96ad4d190415f2656d1387fa886afc38e5cd18b8c60da367acf32c627d2c9ea19ef3f030e559fc2a21695cdbb65ddf6ba36a70af0d3fa292a32de31da6acc6108ab2be8bd37843338f0c37c2d62648d3d49013edeb9e179dadf78bf885f95e712fcdfcc8a172e47c09ab159f3a00ed7b930f628c3c48257e92fc7407"),
message: fromHex(
"1fa7201d96ad4d190415f2656d1387fa886afc38e5cd18b8c60da367acf32c627d2c9ea19ef3f030e559fc2a21695cdbb65ddf6ba36a70af0d3fa292a32de31da6acc6108ab2be8bd37843338f0c37c2d62648d3d49013edeb9e179dadf78bf885f95e712fcdfcc8a172e47c09ab159f3a00ed7b930f628c3c48257e92fc7407",
),
privkey: fromHex("a67cf8cead99827c7956327aa04ab30cfd2d67f21b78f28a35694ece51052a61"),
signature: fromHex("304402210091058d1b912514940e1002855cc930c01a21234bad88f607f213af495c32b69f021f5d387ce3de25f1b9bad1fb180de110686d91b461ae2972fa4e4a7018519870"),
signature: fromHex(
"304402210091058d1b912514940e1002855cc930c01a21234bad88f607f213af495c32b69f021f5d387ce3de25f1b9bad1fb180de110686d91b461ae2972fa4e4a7018519870",
),
},
{
message: fromHex("74715fe10748a5b98b138f390f7ca9629c584c5d6ad268fc455c8de2e800b73fa1ea9aaee85de58baa2ce9ce68d822fc31842c6b153baef3a12bf6b4541f74af65430ae931a64c8b4950ad1c76b31aea8c229b3623390e233c112586aa5907bbe419841f54f0a7d6d19c003b91dc84bbb59b14ec477a1e9d194c137e21c75bbb"),
message: fromHex(
"74715fe10748a5b98b138f390f7ca9629c584c5d6ad268fc455c8de2e800b73fa1ea9aaee85de58baa2ce9ce68d822fc31842c6b153baef3a12bf6b4541f74af65430ae931a64c8b4950ad1c76b31aea8c229b3623390e233c112586aa5907bbe419841f54f0a7d6d19c003b91dc84bbb59b14ec477a1e9d194c137e21c75bbb",
),
privkey: fromHex("4f1050422c4fce146bab0d735a70a91d6447210964b064309f90315c986be400"),
signature: fromHex("3046022100fe43eb9c38b506d118e20f8605ac8954fc0406efd306ba7ea5b07577a2735d15022100d589e91bf5014c7c360342ad135259dd7ae684e2c21234d7a912b43d148fcf19"),
signature: fromHex(
"3046022100fe43eb9c38b506d118e20f8605ac8954fc0406efd306ba7ea5b07577a2735d15022100d589e91bf5014c7c360342ad135259dd7ae684e2c21234d7a912b43d148fcf19",
),
},
{
message: fromHex("d10131982dd1a1d839aba383cd72855bf41061c0cb04dfa1acad3181f240341d744ca6002b52f25fb3c63f16d050c4a4ef2c0ebf5f16ce987558f4b9d4a5ad3c6b81b617de00e04ba32282d8bf223bfedbb325b741dfdc8f56fa85c65d42f05f6a1330d8cc6664ad32050dd7b9e3993f4d6c91e5e12cbd9e82196e009ad22560"),
message: fromHex(
"d10131982dd1a1d839aba383cd72855bf41061c0cb04dfa1acad3181f240341d744ca6002b52f25fb3c63f16d050c4a4ef2c0ebf5f16ce987558f4b9d4a5ad3c6b81b617de00e04ba32282d8bf223bfedbb325b741dfdc8f56fa85c65d42f05f6a1330d8cc6664ad32050dd7b9e3993f4d6c91e5e12cbd9e82196e009ad22560",
),
privkey: fromHex("79506f5f68941c60a0d7c62595652a5f42f2b9f5aa2b6456af1c56a79a346c2f"),
signature: fromHex("3046022100ccdbbd2500043bf7f705536d5984ab5f05fdc0fa3cf464d8c88f861e3fc8e54c022100d5c6342c08dcd8242e1daf3595cae968e320a025aa45ec4bc725795da3d1becb"),
signature: fromHex(
"3046022100ccdbbd2500043bf7f705536d5984ab5f05fdc0fa3cf464d8c88f861e3fc8e54c022100d5c6342c08dcd8242e1daf3595cae968e320a025aa45ec4bc725795da3d1becb",
),
},
{
message: fromHex("ef9dbd90ded96ad627a0a987ab90537a3e7acc1fdfa991088e9d999fd726e3ce1e1bd89a7df08d8c2bf51085254c89dc67bc21e8a1a93f33a38c18c0ce3880e958ac3e3dbe8aec49f981821c4ac6812dd29fab3a9ebe7fbd799fb50f12021b48d1d9abca8842547b3b99befa612cc8b4ca5f9412e0352e72ab1344a0ac2913db"),
message: fromHex(
"ef9dbd90ded96ad627a0a987ab90537a3e7acc1fdfa991088e9d999fd726e3ce1e1bd89a7df08d8c2bf51085254c89dc67bc21e8a1a93f33a38c18c0ce3880e958ac3e3dbe8aec49f981821c4ac6812dd29fab3a9ebe7fbd799fb50f12021b48d1d9abca8842547b3b99befa612cc8b4ca5f9412e0352e72ab1344a0ac2913db",
),
privkey: fromHex("4c53b8e372f70593afb08fb0f3ba228e1bd2430f562414e9bd1b89e53becbac8"),
signature: fromHex("304402205c707b6df7667324f950216b933d28e307a0223b24d161bc5887208d7f880b3a02204b7bc56586dc51d806ac3ad72807bc62d1d06d0812f121bd91e9770d84885c39"),
signature: fromHex(
"304402205c707b6df7667324f950216b933d28e307a0223b24d161bc5887208d7f880b3a02204b7bc56586dc51d806ac3ad72807bc62d1d06d0812f121bd91e9770d84885c39",
),
},

@@ -271,3 +395,7 @@ ];

const messageHash = new Sha256(row.message).digest();
const isValid = await Secp256k1.verifySignature(Secp256k1Signature.fromDer(row.signature), messageHash, pubkey);
const isValid = await Secp256k1.verifySignature(
Secp256k1Signature.fromDer(row.signature),
messageHash,
pubkey,
);
expect(isValid)

@@ -281,52 +409,96 @@ .withContext(`(index ${index})`)

// signatures are normalized to lowS, prehash type is sha256
const data: ReadonlyArray<{ readonly message: Uint8Array; readonly privkey: Uint8Array; readonly signature: Uint8Array }> = [
const data: ReadonlyArray<{
readonly message: Uint8Array;
readonly privkey: Uint8Array;
readonly signature: Uint8Array;
}> = [
{
message: fromHex("5c868fedb8026979ebd26f1ba07c27eedf4ff6d10443505a96ecaf21ba8c4f0937b3cd23ffdc3dd429d4cd1905fb8dbcceeff1350020e18b58d2ba70887baa3a9b783ad30d3fbf210331cdd7df8d77defa398cdacdfc2e359c7ba4cae46bb74401deb417f8b912a1aa966aeeba9c39c7dd22479ae2b30719dca2f2206c5eb4b7"),
message: fromHex(
"5c868fedb8026979ebd26f1ba07c27eedf4ff6d10443505a96ecaf21ba8c4f0937b3cd23ffdc3dd429d4cd1905fb8dbcceeff1350020e18b58d2ba70887baa3a9b783ad30d3fbf210331cdd7df8d77defa398cdacdfc2e359c7ba4cae46bb74401deb417f8b912a1aa966aeeba9c39c7dd22479ae2b30719dca2f2206c5eb4b7",
),
privkey: fromHex("1812bcfaa7566ba0724846d47dd4cc39306a506382cba33710ce6abd4d86553c"),
signature: fromHex("3044022045c0b7f8c09a9e1f1cea0c25785594427b6bf8f9f878a8af0b1abbb48e16d09202200d8becd0c220f67c51217eecfd7184ef0732481c843857e6bc7fc095c4f6b788"),
signature: fromHex(
"3044022045c0b7f8c09a9e1f1cea0c25785594427b6bf8f9f878a8af0b1abbb48e16d09202200d8becd0c220f67c51217eecfd7184ef0732481c843857e6bc7fc095c4f6b788",
),
},
{
message: fromHex("17cd4a74d724d55355b6fb2b0759ca095298e3fd1856b87ca1cb2df5409058022736d21be071d820b16dfc441be97fbcea5df787edc886e759475469e2128b22f26b82ca993be6695ab190e673285d561d3b6d42fcc1edd6d12db12dcda0823e9d6079e7bc5ff54cd452dad308d52a15ce9c7edd6ef3dad6a27becd8e001e80f"),
message: fromHex(
"17cd4a74d724d55355b6fb2b0759ca095298e3fd1856b87ca1cb2df5409058022736d21be071d820b16dfc441be97fbcea5df787edc886e759475469e2128b22f26b82ca993be6695ab190e673285d561d3b6d42fcc1edd6d12db12dcda0823e9d6079e7bc5ff54cd452dad308d52a15ce9c7edd6ef3dad6a27becd8e001e80f",
),
privkey: fromHex("1aea57ea357cecc13b876b76a1825f433ff603d76e6794fdb55aeda481b9482b"),
signature: fromHex("304402204e0ea79d4a476276e4b067facdec7460d2c98c8a65326a6e5c998fd7c650611402200e45aea5034af973410e65cf97651b3f2b976e3fc79c6a93065ed7cb69a2ab5a"),
signature: fromHex(
"304402204e0ea79d4a476276e4b067facdec7460d2c98c8a65326a6e5c998fd7c650611402200e45aea5034af973410e65cf97651b3f2b976e3fc79c6a93065ed7cb69a2ab5a",
),
},
{
message: fromHex("db0d31717b04802adbbae1997487da8773440923c09b869e12a57c36dda34af11b8897f266cd81c02a762c6b74ea6aaf45aaa3c52867eb8f270f5092a36b498f88b65b2ebda24afe675da6f25379d1e194d093e7a2f66e450568dbdffebff97c4597a00c96a5be9ba26deefcca8761c1354429622c8db269d6a0ec0cc7a8585c"),
message: fromHex(
"db0d31717b04802adbbae1997487da8773440923c09b869e12a57c36dda34af11b8897f266cd81c02a762c6b74ea6aaf45aaa3c52867eb8f270f5092a36b498f88b65b2ebda24afe675da6f25379d1e194d093e7a2f66e450568dbdffebff97c4597a00c96a5be9ba26deefcca8761c1354429622c8db269d6a0ec0cc7a8585c",
),
privkey: fromHex("03708999fddd22091e93a8fd6b2205b662089a97507623cb5ce04240bcae55b8"),
signature: fromHex("3045022100f25b86e1d8a11d72475b3ed273b0781c7d7f6f9e1dae0dd5d3ee9b84f3fab891022063d9c4e1391de077244583e9a6e3d8e8e1f236a3bf5963735353b93b1a3ba935"),
signature: fromHex(
"3045022100f25b86e1d8a11d72475b3ed273b0781c7d7f6f9e1dae0dd5d3ee9b84f3fab891022063d9c4e1391de077244583e9a6e3d8e8e1f236a3bf5963735353b93b1a3ba935",
),
},
{
message: fromHex("47c9deddfd8c841a63a99be96e972e40fa035ae10d929babfc86c437b9d5d495577a45b7f8a35ce3f880e7d8ae8cd8eb685cf41f0506e68046ccf5559232c674abb9c3683829dcc8002683c4f4ca3a29a7bfde20d96dd0f1a0ead847dea18f297f220f94932536ca4deacedc2c6701c3ee50e28e358dcc54cdbf69daf0eb87f6"),
message: fromHex(
"47c9deddfd8c841a63a99be96e972e40fa035ae10d929babfc86c437b9d5d495577a45b7f8a35ce3f880e7d8ae8cd8eb685cf41f0506e68046ccf5559232c674abb9c3683829dcc8002683c4f4ca3a29a7bfde20d96dd0f1a0ead847dea18f297f220f94932536ca4deacedc2c6701c3ee50e28e358dcc54cdbf69daf0eb87f6",
),
privkey: fromHex("44da7ab9eab17b93175bf4d5388c6b334f35a3283215b9e602a264d2e831fea3"),
signature: fromHex("3045022100f2cab57d108aaf7c9c9dd061404447d59f968d1468b25dd827d624b64601c32a022077558dbf7bf90885b9128c371959085e9dd1b7d8a5c45b7265e8e7d9f125c008"),
signature: fromHex(
"3045022100f2cab57d108aaf7c9c9dd061404447d59f968d1468b25dd827d624b64601c32a022077558dbf7bf90885b9128c371959085e9dd1b7d8a5c45b7265e8e7d9f125c008",
),
},
{
message: fromHex("f15433188c2bbc93b2150bb2f34d36ba8ae49f8f7e4e81aed651c8fb2022b2a7e851c4dbbbc21c14e27380316bfdebb0a049246349537dba687581c1344e40f75afd2735bb21ea074861de6801d28b22e8beb76fdd25598812b2061ca3fba229daf59a4ab416704543b02e16b8136c22acc7e197748ae19b5cbbc160fdc3a8cd"),
message: fromHex(
"f15433188c2bbc93b2150bb2f34d36ba8ae49f8f7e4e81aed651c8fb2022b2a7e851c4dbbbc21c14e27380316bfdebb0a049246349537dba687581c1344e40f75afd2735bb21ea074861de6801d28b22e8beb76fdd25598812b2061ca3fba229daf59a4ab416704543b02e16b8136c22acc7e197748ae19b5cbbc160fdc3a8cd",
),
privkey: fromHex("5452b1bf1b1d96929f7ee3637a1bca637490f97634e6d164aeddda3dbb243a26"),
signature: fromHex("3045022100d702bec0f058f5e18f5fcdb204f79250562f11121f5513ae1006c9b93ddafb11022063de551c508405a280a21fb007b660542b58fcd3256b7cea45e3f2ebe9a29ecd"),
signature: fromHex(
"3045022100d702bec0f058f5e18f5fcdb204f79250562f11121f5513ae1006c9b93ddafb11022063de551c508405a280a21fb007b660542b58fcd3256b7cea45e3f2ebe9a29ecd",
),
},
{
message: fromHex("1bc796124b87793b7f7fdd53b896f8f0d0f2d2be36d1944e3c2a0ac5c6b2839f59a4b4fad200f8035ec98630c51ef0d40863a5ddd69b703d73f06b4afae8ad1a88e19b1b26e8c10b7bff953c05eccc82fd771b220910165f3a906b7c931683e431998d1fd06c32dd11b4f872bf980d547942f22124c7e50c9523321aee23a36d"),
message: fromHex(
"1bc796124b87793b7f7fdd53b896f8f0d0f2d2be36d1944e3c2a0ac5c6b2839f59a4b4fad200f8035ec98630c51ef0d40863a5ddd69b703d73f06b4afae8ad1a88e19b1b26e8c10b7bff953c05eccc82fd771b220910165f3a906b7c931683e431998d1fd06c32dd11b4f872bf980d547942f22124c7e50c9523321aee23a36d",
),
privkey: fromHex("a4095a3d464d20ea154f4312c087bd22c8a92207717cca40b1f3267e13cbf05c"),
signature: fromHex("3045022100ae17ab6a3bd2ccd0901cc3904103e825895540bf416a5f717b74b529512e4c1802204bc049a8a2287cfccea77fb3769755ba92c35154c635448cf633244edf4f6fe1"),
signature: fromHex(
"3045022100ae17ab6a3bd2ccd0901cc3904103e825895540bf416a5f717b74b529512e4c1802204bc049a8a2287cfccea77fb3769755ba92c35154c635448cf633244edf4f6fe1",
),
},
{
message: fromHex("18e55ac264031da435b613fc9dc6c4aafc49aae8ddf6f220d523415896ff915fae5c5b2e6aed61d88e5721823f089c46173afc5d9b47fd917834c85284f62dda6ed2d7a6ff10eb553b9312b05dad7decf7f73b69479c02f14ea0a2aa9e05ec07396cd37c28795c90e590631137102315635d702278e352aa41d0826adadff5e1"),
message: fromHex(
"18e55ac264031da435b613fc9dc6c4aafc49aae8ddf6f220d523415896ff915fae5c5b2e6aed61d88e5721823f089c46173afc5d9b47fd917834c85284f62dda6ed2d7a6ff10eb553b9312b05dad7decf7f73b69479c02f14ea0a2aa9e05ec07396cd37c28795c90e590631137102315635d702278e352aa41d0826adadff5e1",
),
privkey: fromHex("4babce8321dcd2b5e3ac936e278519fb4b9be96688bbefb2e87d53b863a349b8"),
signature: fromHex("3044022003b51d02eac41f2969fc36c816c9772da21a139376b09d1c8809bb8f543be62f02200629c1396ae304d2c2e7b63890d91e56dfc3459f4d664cb914c7ff2a12a21925"),
signature: fromHex(
"3044022003b51d02eac41f2969fc36c816c9772da21a139376b09d1c8809bb8f543be62f02200629c1396ae304d2c2e7b63890d91e56dfc3459f4d664cb914c7ff2a12a21925",
),
},
{
message: fromHex("a5290666c97294d090f8da898e555cbd33990579e5e95498444bfb318b4aa1643e0d4348425e21c7c6f99f9955f3048f56c22b68c4a516af5c90ed5268acc9c5a20fec0200c2a282a90e20d3c46d4ecdda18ba18b803b19263de2b79238da921707a0864799cdee9f02913b40681c02c6923070688844b58fe415b7d71ea6845"),
message: fromHex(
"a5290666c97294d090f8da898e555cbd33990579e5e95498444bfb318b4aa1643e0d4348425e21c7c6f99f9955f3048f56c22b68c4a516af5c90ed5268acc9c5a20fec0200c2a282a90e20d3c46d4ecdda18ba18b803b19263de2b79238da921707a0864799cdee9f02913b40681c02c6923070688844b58fe415b7d71ea6845",
),
privkey: fromHex("02f98a6eb5320fc0c65f3eb2911b8500bedf47230bdfa2ba5e1c0c1c0bf9fc0a"),
signature: fromHex("30440220400f52f4c4925b4b8886706331535230fafb6455c3a3eef6fbf19a82593812300220727cc4b3341d7d95d0dc404d910dc009b3b5f21baadc0c4ee199a46e558d7f56"),
signature: fromHex(
"30440220400f52f4c4925b4b8886706331535230fafb6455c3a3eef6fbf19a82593812300220727cc4b3341d7d95d0dc404d910dc009b3b5f21baadc0c4ee199a46e558d7f56",
),
},
{
message: fromHex("13ad0600229c2a66b2f11617f69c7210ad044c49265dc98ec3c64f56e56a083234d277d404e2c40523c414ad23af5cc2f91a47fe59e7ca572f7fe1d3d3cfceaedadac4396749a292a38e92727273272335f12b2acea21cf069682e67d7e7d7a31ab5bb8e472298a9451aeae6f160f36e6623c9b632b9c93371a002818addc243"),
message: fromHex(
"13ad0600229c2a66b2f11617f69c7210ad044c49265dc98ec3c64f56e56a083234d277d404e2c40523c414ad23af5cc2f91a47fe59e7ca572f7fe1d3d3cfceaedadac4396749a292a38e92727273272335f12b2acea21cf069682e67d7e7d7a31ab5bb8e472298a9451aeae6f160f36e6623c9b632b9c93371a002818addc243",
),
privkey: fromHex("f2a08a52b0edbaa64dacb3244666d4fdb684e6cc995bed81ec9d86c58f9999de"),
signature: fromHex("3045022100b2927afc8856b7e14d02e01e7aa3c76951a4621bfde5d794adda165b51dbe198022006eee6e0b087143ed06933cba699fbe4097ba7d7b038b173cbbd183718a86d43"),
signature: fromHex(
"3045022100b2927afc8856b7e14d02e01e7aa3c76951a4621bfde5d794adda165b51dbe198022006eee6e0b087143ed06933cba699fbe4097ba7d7b038b173cbbd183718a86d43",
),
},
{
message: fromHex("51ad843da5eafc177d49a50a82609555e52773c5dfa14d7c02db5879c11a6b6e2e0860df38452dc579d763f91a83ade23b73f4fcbd703f35dd6ecfbb4c9578d5b604ed809c8633e6ac5679a5f742ce94fea3b97b5ba8a29ea28101a7b35f9eaa894dda54e3431f2464d18faf8342b7c59dfe0598c0ab29a14622a08eea70126b"),
message: fromHex(
"51ad843da5eafc177d49a50a82609555e52773c5dfa14d7c02db5879c11a6b6e2e0860df38452dc579d763f91a83ade23b73f4fcbd703f35dd6ecfbb4c9578d5b604ed809c8633e6ac5679a5f742ce94fea3b97b5ba8a29ea28101a7b35f9eaa894dda54e3431f2464d18faf8342b7c59dfe0598c0ab29a14622a08eea70126b",
),
privkey: fromHex("e27f10d444fa50b53283863941619b11d585b27018b0e29301371371b45e3c65"),
signature: fromHex("3044022100fe9717965673fbe585780e18d892a3cfa77b59ac2f44f5337a3e58ce6ecd4409021f155459b19d2e9a2e676d7d8d48a9303391ffb9befdd3a57324306d69e0e0ab"),
signature: fromHex(
"3044022100fe9717965673fbe585780e18d892a3cfa77b59ac2f44f5337a3e58ce6ecd4409021f155459b19d2e9a2e676d7d8d48a9303391ffb9befdd3a57324306d69e0e0ab",
),
},

@@ -349,3 +521,7 @@ ];

// verify original signature
const ok2 = await Secp256k1.verifySignature(Secp256k1Signature.fromDer(row.signature), messageHash, keypair.pubkey);
const ok2 = await Secp256k1.verifySignature(
Secp256k1Signature.fromDer(row.signature),
messageHash,
keypair.pubkey,
);
expect(ok2)

@@ -366,4 +542,10 @@ .withContext(`(index ${index})`)

// Test data from https://github.com/ethereumjs/ethereumjs-util/blob/v6.1.0/test/index.js#L496
const expectedPubkey = (await Secp256k1.makeKeypair(fromHex("3c9229289a6125f7fdf1885a77bb12c37a8d3b4962d936f7e3084dece32a3ca1"))).pubkey;
const signature = new ExtendedSecp256k1Signature(fromHex("99e71a99cb2270b8cac5254f9e99b6210c6c10224a1579cf389ef88b20a1abe9"), fromHex("129ff05af364204442bdb53ab6f18a99ab48acc9326fa689f228040429e3ca66"), 0);
const expectedPubkey = (await Secp256k1.makeKeypair(
fromHex("3c9229289a6125f7fdf1885a77bb12c37a8d3b4962d936f7e3084dece32a3ca1"),
)).pubkey;
const signature = new ExtendedSecp256k1Signature(
fromHex("99e71a99cb2270b8cac5254f9e99b6210c6c10224a1579cf389ef88b20a1abe9"),
fromHex("129ff05af364204442bdb53ab6f18a99ab48acc9326fa689f228040429e3ca66"),
0,
);
const messageHash = fromHex("82ff40c0a986c6a5cfad4ddf4c3aa6996f1a7837f9c398e17e5de5cbd5a12b28");

@@ -370,0 +552,0 @@ const pubkey = Secp256k1.recoverPubkey(signature, messageHash);

92

src/secp256k1signature.spec.ts

@@ -23,3 +23,5 @@ import { Encoding } from "@iov/encoding";

expect(signature.r(5)).toEqual(fromHex("0000002233"));
expect(signature.r(32)).toEqual(fromHex("0000000000000000000000000000000000000000000000000000000000002233"));
expect(signature.r(32)).toEqual(
fromHex("0000000000000000000000000000000000000000000000000000000000002233"),
);
expect(signature.s(1)).toEqual(fromHex("AA"));

@@ -31,3 +33,6 @@ expect(signature.s(2)).toEqual(fromHex("00AA"));

it("throws when output size of r or s is too small", () => {
const signature = new Secp256k1Signature(new Uint8Array([0x22, 0x33, 0x44]), new Uint8Array([0xaa, 0xbb]));
const signature = new Secp256k1Signature(
new Uint8Array([0x22, 0x33, 0x44]),
new Uint8Array([0xaa, 0xbb]),
);
expect(() => signature.r(0)).toThrowError(/length too small to hold parameter r/i);

@@ -41,7 +46,19 @@ expect(() => signature.r(1)).toThrowError(/length too small to hold parameter r/i);

it("throws for r with leading 0", () => {
expect(() => new Secp256k1Signature(fromHex("00F25B86E1D8A11D72475B3ED273B0781C7D7F6F9E1DAE0DD5D3EE9B84F3FAB891"), new Uint8Array([0xaa]))).toThrowError(/unsigned integer r must be encoded as unpadded big endian./i);
expect(
() =>
new Secp256k1Signature(
fromHex("00F25B86E1D8A11D72475B3ED273B0781C7D7F6F9E1DAE0DD5D3EE9B84F3FAB891"),
new Uint8Array([0xaa]),
),
).toThrowError(/unsigned integer r must be encoded as unpadded big endian./i);
});
it("throws for s with leading 0", () => {
expect(() => new Secp256k1Signature(new Uint8Array([0xaa]), fromHex("00F25B86E1D8A11D72475B3ED273B0781C7D7F6F9E1DAE0DD5D3EE9B84F3FAB891"))).toThrowError(/unsigned integer s must be encoded as unpadded big endian./i);
expect(
() =>
new Secp256k1Signature(
new Uint8Array([0xaa]),
fromHex("00F25B86E1D8A11D72475B3ED273B0781C7D7F6F9E1DAE0DD5D3EE9B84F3FAB891"),
),
).toThrowError(/unsigned integer s must be encoded as unpadded big endian./i);
});

@@ -52,4 +69,11 @@

// decoded by http://asn1-playground.oss.com/
const signature = new Secp256k1Signature(fromHex("F25B86E1D8A11D72475B3ED273B0781C7D7F6F9E1DAE0DD5D3EE9B84F3FAB891"), fromHex("63D9C4E1391DE077244583E9A6E3D8E8E1F236A3BF5963735353B93B1A3BA935"));
expect(signature.toDer()).toEqual(fromHex("3045022100f25b86e1d8a11d72475b3ed273b0781c7d7f6f9e1dae0dd5d3ee9b84f3fab891022063d9c4e1391de077244583e9a6e3d8e8e1f236a3bf5963735353b93b1a3ba935"));
const signature = new Secp256k1Signature(
fromHex("F25B86E1D8A11D72475B3ED273B0781C7D7F6F9E1DAE0DD5D3EE9B84F3FAB891"),
fromHex("63D9C4E1391DE077244583E9A6E3D8E8E1F236A3BF5963735353B93B1A3BA935"),
);
expect(signature.toDer()).toEqual(
fromHex(
"3045022100f25b86e1d8a11d72475b3ed273b0781c7d7f6f9e1dae0dd5d3ee9b84f3fab891022063d9c4e1391de077244583e9a6e3d8e8e1f236a3bf5963735353b93b1a3ba935",
),
);
});

@@ -60,6 +84,18 @@

// decoded by http://asn1-playground.oss.com/
const signature = Secp256k1Signature.fromDer(fromHex("3045022100f25b86e1d8a11d72475b3ed273b0781c7d7f6f9e1dae0dd5d3ee9b84f3fab891022063d9c4e1391de077244583e9a6e3d8e8e1f236a3bf5963735353b93b1a3ba935"));
expect(signature.toDer()).toEqual(fromHex("3045022100f25b86e1d8a11d72475b3ed273b0781c7d7f6f9e1dae0dd5d3ee9b84f3fab891022063d9c4e1391de077244583e9a6e3d8e8e1f236a3bf5963735353b93b1a3ba935"));
expect(signature.r()).toEqual(fromHex("F25B86E1D8A11D72475B3ED273B0781C7D7F6F9E1DAE0DD5D3EE9B84F3FAB891"));
expect(signature.s()).toEqual(fromHex("63D9C4E1391DE077244583E9A6E3D8E8E1F236A3BF5963735353B93B1A3BA935"));
const signature = Secp256k1Signature.fromDer(
fromHex(
"3045022100f25b86e1d8a11d72475b3ed273b0781c7d7f6f9e1dae0dd5d3ee9b84f3fab891022063d9c4e1391de077244583e9a6e3d8e8e1f236a3bf5963735353b93b1a3ba935",
),
);
expect(signature.toDer()).toEqual(
fromHex(
"3045022100f25b86e1d8a11d72475b3ed273b0781c7d7f6f9e1dae0dd5d3ee9b84f3fab891022063d9c4e1391de077244583e9a6e3d8e8e1f236a3bf5963735353b93b1a3ba935",
),
);
expect(signature.r()).toEqual(
fromHex("F25B86E1D8A11D72475B3ED273B0781C7D7F6F9E1DAE0DD5D3EE9B84F3FAB891"),
);
expect(signature.s()).toEqual(
fromHex("63D9C4E1391DE077244583E9A6E3D8E8E1F236A3BF5963735353B93B1A3BA935"),
);
});

@@ -75,9 +111,21 @@ });

it("throws for recovery param out of range", () => {
expect(() => new ExtendedSecp256k1Signature(fromHex("aa"), fromHex("bb"), Number.NaN)).toThrowError(/the recovery parameter must be an integer/i);
expect(() => new ExtendedSecp256k1Signature(fromHex("aa"), fromHex("bb"), Number.NEGATIVE_INFINITY)).toThrowError(/the recovery parameter must be an integer/i);
expect(() => new ExtendedSecp256k1Signature(fromHex("aa"), fromHex("bb"), Number.POSITIVE_INFINITY)).toThrowError(/the recovery parameter must be an integer/i);
expect(() => new ExtendedSecp256k1Signature(fromHex("aa"), fromHex("bb"), 1.1)).toThrowError(/the recovery parameter must be an integer/i);
expect(() => new ExtendedSecp256k1Signature(fromHex("aa"), fromHex("bb"), Number.NaN)).toThrowError(
/the recovery parameter must be an integer/i,
);
expect(
() => new ExtendedSecp256k1Signature(fromHex("aa"), fromHex("bb"), Number.NEGATIVE_INFINITY),
).toThrowError(/the recovery parameter must be an integer/i);
expect(
() => new ExtendedSecp256k1Signature(fromHex("aa"), fromHex("bb"), Number.POSITIVE_INFINITY),
).toThrowError(/the recovery parameter must be an integer/i);
expect(() => new ExtendedSecp256k1Signature(fromHex("aa"), fromHex("bb"), 1.1)).toThrowError(
/the recovery parameter must be an integer/i,
);
expect(() => new ExtendedSecp256k1Signature(fromHex("aa"), fromHex("bb"), -1)).toThrowError(/the recovery parameter must be one of 0, 1, 2, 3/i);
expect(() => new ExtendedSecp256k1Signature(fromHex("aa"), fromHex("bb"), 5)).toThrowError(/the recovery parameter must be one of 0, 1, 2, 3/i);
expect(() => new ExtendedSecp256k1Signature(fromHex("aa"), fromHex("bb"), -1)).toThrowError(
/the recovery parameter must be one of 0, 1, 2, 3/i,
);
expect(() => new ExtendedSecp256k1Signature(fromHex("aa"), fromHex("bb"), 5)).toThrowError(
/the recovery parameter must be one of 0, 1, 2, 3/i,
);
});

@@ -87,7 +135,15 @@

const signature = new ExtendedSecp256k1Signature(new Uint8Array([0x22, 0x33]), new Uint8Array([0xaa]), 1);
expect(signature.toFixedLength()).toEqual(fromHex("000000000000000000000000000000000000000000000000000000000000223300000000000000000000000000000000000000000000000000000000000000aa01"));
expect(signature.toFixedLength()).toEqual(
fromHex(
"000000000000000000000000000000000000000000000000000000000000223300000000000000000000000000000000000000000000000000000000000000aa01",
),
);
});
it("can be decoded from fixed length", () => {
const signature = ExtendedSecp256k1Signature.fromFixedLength(fromHex("000000000000000000000000000000000000000000000000000000000000223300000000000000000000000000000000000000000000000000000000000000aa01"));
const signature = ExtendedSecp256k1Signature.fromFixedLength(
fromHex(
"000000000000000000000000000000000000000000000000000000000000223300000000000000000000000000000000000000000000000000000000000000aa01",
),
);
expect(signature.r()).toEqual(new Uint8Array([0x22, 0x33]));

@@ -94,0 +150,0 @@ expect(signature.s()).toEqual(new Uint8Array([0xaa]));

294

src/slip10.spec.ts

@@ -22,4 +22,8 @@ import { Encoding } from "@iov/encoding";

const derived = Slip10.derivePath(Slip10Curve.Secp256k1, seed, path);
expect(derived.chainCode).toEqual(fromHex("873dff81c02f525623fd1fe5167eac3a55a049de3d314bb42ee227ffed37d508"));
expect(derived.privkey).toEqual(fromHex("e8f32e723decf4051aefac8e2c93c9c5b214313817cdb01a1494b917c8436b35"));
expect(derived.chainCode).toEqual(
fromHex("873dff81c02f525623fd1fe5167eac3a55a049de3d314bb42ee227ffed37d508"),
);
expect(derived.privkey).toEqual(
fromHex("e8f32e723decf4051aefac8e2c93c9c5b214313817cdb01a1494b917c8436b35"),
);
});

@@ -30,4 +34,8 @@

const derived = Slip10.derivePath(Slip10Curve.Secp256k1, seed, path);
expect(derived.chainCode).toEqual(fromHex("47fdacbd0f1097043b78c63c20c34ef4ed9a111d980047ad16282c7ae6236141"));
expect(derived.privkey).toEqual(fromHex("edb2e14f9ee77d26dd93b4ecede8d16ed408ce149b6cd80b0715a2d911a0afea"));
expect(derived.chainCode).toEqual(
fromHex("47fdacbd0f1097043b78c63c20c34ef4ed9a111d980047ad16282c7ae6236141"),
);
expect(derived.privkey).toEqual(
fromHex("edb2e14f9ee77d26dd93b4ecede8d16ed408ce149b6cd80b0715a2d911a0afea"),
);
});

@@ -38,25 +46,56 @@

const derived = Slip10.derivePath(Slip10Curve.Secp256k1, seed, path);
expect(derived.chainCode).toEqual(fromHex("2a7857631386ba23dacac34180dd1983734e444fdbf774041578e9b6adb37c19"));
expect(derived.privkey).toEqual(fromHex("3c6cb8d0f6a264c91ea8b5030fadaa8e538b020f0a387421a12de9319dc93368"));
expect(derived.chainCode).toEqual(
fromHex("2a7857631386ba23dacac34180dd1983734e444fdbf774041578e9b6adb37c19"),
);
expect(derived.privkey).toEqual(
fromHex("3c6cb8d0f6a264c91ea8b5030fadaa8e538b020f0a387421a12de9319dc93368"),
);
});
it("can derive path m/0'/1/2'", () => {
const path: ReadonlyArray<Slip10RawIndex> = [Slip10RawIndex.hardened(0), Slip10RawIndex.normal(1), Slip10RawIndex.hardened(2)];
const path: ReadonlyArray<Slip10RawIndex> = [
Slip10RawIndex.hardened(0),
Slip10RawIndex.normal(1),
Slip10RawIndex.hardened(2),
];
const derived = Slip10.derivePath(Slip10Curve.Secp256k1, seed, path);
expect(derived.chainCode).toEqual(fromHex("04466b9cc8e161e966409ca52986c584f07e9dc81f735db683c3ff6ec7b1503f"));
expect(derived.privkey).toEqual(fromHex("cbce0d719ecf7431d88e6a89fa1483e02e35092af60c042b1df2ff59fa424dca"));
expect(derived.chainCode).toEqual(
fromHex("04466b9cc8e161e966409ca52986c584f07e9dc81f735db683c3ff6ec7b1503f"),
);
expect(derived.privkey).toEqual(
fromHex("cbce0d719ecf7431d88e6a89fa1483e02e35092af60c042b1df2ff59fa424dca"),
);
});
it("can derive path m/0'/1/2'/2", () => {
const path: ReadonlyArray<Slip10RawIndex> = [Slip10RawIndex.hardened(0), Slip10RawIndex.normal(1), Slip10RawIndex.hardened(2), Slip10RawIndex.normal(2)];
const path: ReadonlyArray<Slip10RawIndex> = [
Slip10RawIndex.hardened(0),
Slip10RawIndex.normal(1),
Slip10RawIndex.hardened(2),
Slip10RawIndex.normal(2),
];
const derived = Slip10.derivePath(Slip10Curve.Secp256k1, seed, path);
expect(derived.chainCode).toEqual(fromHex("cfb71883f01676f587d023cc53a35bc7f88f724b1f8c2892ac1275ac822a3edd"));
expect(derived.privkey).toEqual(fromHex("0f479245fb19a38a1954c5c7c0ebab2f9bdfd96a17563ef28a6a4b1a2a764ef4"));
expect(derived.chainCode).toEqual(
fromHex("cfb71883f01676f587d023cc53a35bc7f88f724b1f8c2892ac1275ac822a3edd"),
);
expect(derived.privkey).toEqual(
fromHex("0f479245fb19a38a1954c5c7c0ebab2f9bdfd96a17563ef28a6a4b1a2a764ef4"),
);
});
it("can derive path m/0'/1/2'/2/1000000000", () => {
const path: ReadonlyArray<Slip10RawIndex> = [Slip10RawIndex.hardened(0), Slip10RawIndex.normal(1), Slip10RawIndex.hardened(2), Slip10RawIndex.normal(2), Slip10RawIndex.normal(1000000000)];
const path: ReadonlyArray<Slip10RawIndex> = [
Slip10RawIndex.hardened(0),
Slip10RawIndex.normal(1),
Slip10RawIndex.hardened(2),
Slip10RawIndex.normal(2),
Slip10RawIndex.normal(1000000000),
];
const derived = Slip10.derivePath(Slip10Curve.Secp256k1, seed, path);
expect(derived.chainCode).toEqual(fromHex("c783e67b921d2beb8f6b389cc646d7263b4145701dadd2161548a8b078e65e9e"));
expect(derived.privkey).toEqual(fromHex("471b76e389e528d6de6d816857e012c5455051cad6660850e58372a6c3e6e7c8"));
expect(derived.chainCode).toEqual(
fromHex("c783e67b921d2beb8f6b389cc646d7263b4145701dadd2161548a8b078e65e9e"),
);
expect(derived.privkey).toEqual(
fromHex("471b76e389e528d6de6d816857e012c5455051cad6660850e58372a6c3e6e7c8"),
);
});

@@ -67,3 +106,5 @@ });

// https://github.com/satoshilabs/slips/blob/master/slip-0010.md#test-vector-2-for-secp256k1
const seed = fromHex("fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542");
const seed = fromHex(
"fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542",
);

@@ -73,4 +114,8 @@ it("can derive path m", () => {

const derived = Slip10.derivePath(Slip10Curve.Secp256k1, seed, path);
expect(derived.chainCode).toEqual(fromHex("60499f801b896d83179a4374aeb7822aaeaceaa0db1f85ee3e904c4defbd9689"));
expect(derived.privkey).toEqual(fromHex("4b03d6fc340455b363f51020ad3ecca4f0850280cf436c70c727923f6db46c3e"));
expect(derived.chainCode).toEqual(
fromHex("60499f801b896d83179a4374aeb7822aaeaceaa0db1f85ee3e904c4defbd9689"),
);
expect(derived.privkey).toEqual(
fromHex("4b03d6fc340455b363f51020ad3ecca4f0850280cf436c70c727923f6db46c3e"),
);
});

@@ -81,32 +126,70 @@

const derived = Slip10.derivePath(Slip10Curve.Secp256k1, seed, path);
expect(derived.chainCode).toEqual(fromHex("f0909affaa7ee7abe5dd4e100598d4dc53cd709d5a5c2cac40e7412f232f7c9c"));
expect(derived.privkey).toEqual(fromHex("abe74a98f6c7eabee0428f53798f0ab8aa1bd37873999041703c742f15ac7e1e"));
expect(derived.chainCode).toEqual(
fromHex("f0909affaa7ee7abe5dd4e100598d4dc53cd709d5a5c2cac40e7412f232f7c9c"),
);
expect(derived.privkey).toEqual(
fromHex("abe74a98f6c7eabee0428f53798f0ab8aa1bd37873999041703c742f15ac7e1e"),
);
});
it("can derive path m/0/2147483647'", () => {
const path: ReadonlyArray<Slip10RawIndex> = [Slip10RawIndex.normal(0), Slip10RawIndex.hardened(2147483647)];
const path: ReadonlyArray<Slip10RawIndex> = [
Slip10RawIndex.normal(0),
Slip10RawIndex.hardened(2147483647),
];
const derived = Slip10.derivePath(Slip10Curve.Secp256k1, seed, path);
expect(derived.chainCode).toEqual(fromHex("be17a268474a6bb9c61e1d720cf6215e2a88c5406c4aee7b38547f585c9a37d9"));
expect(derived.privkey).toEqual(fromHex("877c779ad9687164e9c2f4f0f4ff0340814392330693ce95a58fe18fd52e6e93"));
expect(derived.chainCode).toEqual(
fromHex("be17a268474a6bb9c61e1d720cf6215e2a88c5406c4aee7b38547f585c9a37d9"),
);
expect(derived.privkey).toEqual(
fromHex("877c779ad9687164e9c2f4f0f4ff0340814392330693ce95a58fe18fd52e6e93"),
);
});
it("can derive path m/0/2147483647'/1", () => {
const path: ReadonlyArray<Slip10RawIndex> = [Slip10RawIndex.normal(0), Slip10RawIndex.hardened(2147483647), Slip10RawIndex.normal(1)];
const path: ReadonlyArray<Slip10RawIndex> = [
Slip10RawIndex.normal(0),
Slip10RawIndex.hardened(2147483647),
Slip10RawIndex.normal(1),
];
const derived = Slip10.derivePath(Slip10Curve.Secp256k1, seed, path);
expect(derived.chainCode).toEqual(fromHex("f366f48f1ea9f2d1d3fe958c95ca84ea18e4c4ddb9366c336c927eb246fb38cb"));
expect(derived.privkey).toEqual(fromHex("704addf544a06e5ee4bea37098463c23613da32020d604506da8c0518e1da4b7"));
expect(derived.chainCode).toEqual(
fromHex("f366f48f1ea9f2d1d3fe958c95ca84ea18e4c4ddb9366c336c927eb246fb38cb"),
);
expect(derived.privkey).toEqual(
fromHex("704addf544a06e5ee4bea37098463c23613da32020d604506da8c0518e1da4b7"),
);
});
it("can derive path m/0/2147483647'/1/2147483646'", () => {
const path: ReadonlyArray<Slip10RawIndex> = [Slip10RawIndex.normal(0), Slip10RawIndex.hardened(2147483647), Slip10RawIndex.normal(1), Slip10RawIndex.hardened(2147483646)];
const path: ReadonlyArray<Slip10RawIndex> = [
Slip10RawIndex.normal(0),
Slip10RawIndex.hardened(2147483647),
Slip10RawIndex.normal(1),
Slip10RawIndex.hardened(2147483646),
];
const derived = Slip10.derivePath(Slip10Curve.Secp256k1, seed, path);
expect(derived.chainCode).toEqual(fromHex("637807030d55d01f9a0cb3a7839515d796bd07706386a6eddf06cc29a65a0e29"));
expect(derived.privkey).toEqual(fromHex("f1c7c871a54a804afe328b4c83a1c33b8e5ff48f5087273f04efa83b247d6a2d"));
expect(derived.chainCode).toEqual(
fromHex("637807030d55d01f9a0cb3a7839515d796bd07706386a6eddf06cc29a65a0e29"),
);
expect(derived.privkey).toEqual(
fromHex("f1c7c871a54a804afe328b4c83a1c33b8e5ff48f5087273f04efa83b247d6a2d"),
);
});
it("can derive path m/0/2147483647'/1/2147483646'/2", () => {
const path: ReadonlyArray<Slip10RawIndex> = [Slip10RawIndex.normal(0), Slip10RawIndex.hardened(2147483647), Slip10RawIndex.normal(1), Slip10RawIndex.hardened(2147483646), Slip10RawIndex.normal(2)];
const path: ReadonlyArray<Slip10RawIndex> = [
Slip10RawIndex.normal(0),
Slip10RawIndex.hardened(2147483647),
Slip10RawIndex.normal(1),
Slip10RawIndex.hardened(2147483646),
Slip10RawIndex.normal(2),
];
const derived = Slip10.derivePath(Slip10Curve.Secp256k1, seed, path);
expect(derived.chainCode).toEqual(fromHex("9452b549be8cea3ecb7a84bec10dcfd94afe4d129ebfd3b3cb58eedf394ed271"));
expect(derived.privkey).toEqual(fromHex("bb7d39bdb83ecf58f2fd82b6d918341cbef428661ef01ab97c28a4842125ac23"));
expect(derived.chainCode).toEqual(
fromHex("9452b549be8cea3ecb7a84bec10dcfd94afe4d129ebfd3b3cb58eedf394ed271"),
);
expect(derived.privkey).toEqual(
fromHex("bb7d39bdb83ecf58f2fd82b6d918341cbef428661ef01ab97c28a4842125ac23"),
);
});

@@ -122,4 +205,8 @@ });

const derived = Slip10.derivePath(Slip10Curve.Ed25519, seed, path);
expect(derived.chainCode).toEqual(fromHex("90046a93de5380a72b5e45010748567d5ea02bbf6522f979e05c0d8d8ca9fffb"));
expect(derived.privkey).toEqual(fromHex("2b4be7f19ee27bbf30c667b642d5f4aa69fd169872f8fc3059c08ebae2eb19e7"));
expect(derived.chainCode).toEqual(
fromHex("90046a93de5380a72b5e45010748567d5ea02bbf6522f979e05c0d8d8ca9fffb"),
);
expect(derived.privkey).toEqual(
fromHex("2b4be7f19ee27bbf30c667b642d5f4aa69fd169872f8fc3059c08ebae2eb19e7"),
);
});

@@ -130,4 +217,8 @@

const derived = Slip10.derivePath(Slip10Curve.Ed25519, seed, path);
expect(derived.chainCode).toEqual(fromHex("8b59aa11380b624e81507a27fedda59fea6d0b779a778918a2fd3590e16e9c69"));
expect(derived.privkey).toEqual(fromHex("68e0fe46dfb67e368c75379acec591dad19df3cde26e63b93a8e704f1dade7a3"));
expect(derived.chainCode).toEqual(
fromHex("8b59aa11380b624e81507a27fedda59fea6d0b779a778918a2fd3590e16e9c69"),
);
expect(derived.privkey).toEqual(
fromHex("68e0fe46dfb67e368c75379acec591dad19df3cde26e63b93a8e704f1dade7a3"),
);
});

@@ -138,25 +229,56 @@

const derived = Slip10.derivePath(Slip10Curve.Ed25519, seed, path);
expect(derived.chainCode).toEqual(fromHex("a320425f77d1b5c2505a6b1b27382b37368ee640e3557c315416801243552f14"));
expect(derived.privkey).toEqual(fromHex("b1d0bad404bf35da785a64ca1ac54b2617211d2777696fbffaf208f746ae84f2"));
expect(derived.chainCode).toEqual(
fromHex("a320425f77d1b5c2505a6b1b27382b37368ee640e3557c315416801243552f14"),
);
expect(derived.privkey).toEqual(
fromHex("b1d0bad404bf35da785a64ca1ac54b2617211d2777696fbffaf208f746ae84f2"),
);
});
it("can derive path m/0'/1'/2'", () => {
const path: ReadonlyArray<Slip10RawIndex> = [Slip10RawIndex.hardened(0), Slip10RawIndex.hardened(1), Slip10RawIndex.hardened(2)];
const path: ReadonlyArray<Slip10RawIndex> = [
Slip10RawIndex.hardened(0),
Slip10RawIndex.hardened(1),
Slip10RawIndex.hardened(2),
];
const derived = Slip10.derivePath(Slip10Curve.Ed25519, seed, path);
expect(derived.chainCode).toEqual(fromHex("2e69929e00b5ab250f49c3fb1c12f252de4fed2c1db88387094a0f8c4c9ccd6c"));
expect(derived.privkey).toEqual(fromHex("92a5b23c0b8a99e37d07df3fb9966917f5d06e02ddbd909c7e184371463e9fc9"));
expect(derived.chainCode).toEqual(
fromHex("2e69929e00b5ab250f49c3fb1c12f252de4fed2c1db88387094a0f8c4c9ccd6c"),
);
expect(derived.privkey).toEqual(
fromHex("92a5b23c0b8a99e37d07df3fb9966917f5d06e02ddbd909c7e184371463e9fc9"),
);
});
it("can derive path m/0'/1'/2'/2'", () => {
const path: ReadonlyArray<Slip10RawIndex> = [Slip10RawIndex.hardened(0), Slip10RawIndex.hardened(1), Slip10RawIndex.hardened(2), Slip10RawIndex.hardened(2)];
const path: ReadonlyArray<Slip10RawIndex> = [
Slip10RawIndex.hardened(0),
Slip10RawIndex.hardened(1),
Slip10RawIndex.hardened(2),
Slip10RawIndex.hardened(2),
];
const derived = Slip10.derivePath(Slip10Curve.Ed25519, seed, path);
expect(derived.chainCode).toEqual(fromHex("8f6d87f93d750e0efccda017d662a1b31a266e4a6f5993b15f5c1f07f74dd5cc"));
expect(derived.privkey).toEqual(fromHex("30d1dc7e5fc04c31219ab25a27ae00b50f6fd66622f6e9c913253d6511d1e662"));
expect(derived.chainCode).toEqual(
fromHex("8f6d87f93d750e0efccda017d662a1b31a266e4a6f5993b15f5c1f07f74dd5cc"),
);
expect(derived.privkey).toEqual(
fromHex("30d1dc7e5fc04c31219ab25a27ae00b50f6fd66622f6e9c913253d6511d1e662"),
);
});
it("can derive path m/0'/1'/2'/2'/1000000000'", () => {
const path: ReadonlyArray<Slip10RawIndex> = [Slip10RawIndex.hardened(0), Slip10RawIndex.hardened(1), Slip10RawIndex.hardened(2), Slip10RawIndex.hardened(2), Slip10RawIndex.hardened(1000000000)];
const path: ReadonlyArray<Slip10RawIndex> = [
Slip10RawIndex.hardened(0),
Slip10RawIndex.hardened(1),
Slip10RawIndex.hardened(2),
Slip10RawIndex.hardened(2),
Slip10RawIndex.hardened(1000000000),
];
const derived = Slip10.derivePath(Slip10Curve.Ed25519, seed, path);
expect(derived.chainCode).toEqual(fromHex("68789923a0cac2cd5a29172a475fe9e0fb14cd6adb5ad98a3fa70333e7afa230"));
expect(derived.privkey).toEqual(fromHex("8f94d394a8e8fd6b1bc2f3f49f5c47e385281d5c17e65324b0f62483e37e8793"));
expect(derived.chainCode).toEqual(
fromHex("68789923a0cac2cd5a29172a475fe9e0fb14cd6adb5ad98a3fa70333e7afa230"),
);
expect(derived.privkey).toEqual(
fromHex("8f94d394a8e8fd6b1bc2f3f49f5c47e385281d5c17e65324b0f62483e37e8793"),
);
});

@@ -167,3 +289,5 @@ });

// https://github.com/satoshilabs/slips/blob/master/slip-0010.md#test-vector-2-for-ed25519
const seed = fromHex("fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542");
const seed = fromHex(
"fffcf9f6f3f0edeae7e4e1dedbd8d5d2cfccc9c6c3c0bdbab7b4b1aeaba8a5a29f9c999693908d8a8784817e7b7875726f6c696663605d5a5754514e4b484542",
);

@@ -173,4 +297,8 @@ it("can derive path m", () => {

const derived = Slip10.derivePath(Slip10Curve.Ed25519, seed, path);
expect(derived.chainCode).toEqual(fromHex("ef70a74db9c3a5af931b5fe73ed8e1a53464133654fd55e7a66f8570b8e33c3b"));
expect(derived.privkey).toEqual(fromHex("171cb88b1b3c1db25add599712e36245d75bc65a1a5c9e18d76f9f2b1eab4012"));
expect(derived.chainCode).toEqual(
fromHex("ef70a74db9c3a5af931b5fe73ed8e1a53464133654fd55e7a66f8570b8e33c3b"),
);
expect(derived.privkey).toEqual(
fromHex("171cb88b1b3c1db25add599712e36245d75bc65a1a5c9e18d76f9f2b1eab4012"),
);
});

@@ -181,34 +309,72 @@

const derived = Slip10.derivePath(Slip10Curve.Ed25519, seed, path);
expect(derived.chainCode).toEqual(fromHex("0b78a3226f915c082bf118f83618a618ab6dec793752624cbeb622acb562862d"));
expect(derived.privkey).toEqual(fromHex("1559eb2bbec5790b0c65d8693e4d0875b1747f4970ae8b650486ed7470845635"));
expect(derived.chainCode).toEqual(
fromHex("0b78a3226f915c082bf118f83618a618ab6dec793752624cbeb622acb562862d"),
);
expect(derived.privkey).toEqual(
fromHex("1559eb2bbec5790b0c65d8693e4d0875b1747f4970ae8b650486ed7470845635"),
);
});
it("can derive path m/0'/2147483647'", () => {
const path: ReadonlyArray<Slip10RawIndex> = [Slip10RawIndex.hardened(0), Slip10RawIndex.hardened(2147483647)];
const path: ReadonlyArray<Slip10RawIndex> = [
Slip10RawIndex.hardened(0),
Slip10RawIndex.hardened(2147483647),
];
const derived = Slip10.derivePath(Slip10Curve.Ed25519, seed, path);
expect(derived.chainCode).toEqual(fromHex("138f0b2551bcafeca6ff2aa88ba8ed0ed8de070841f0c4ef0165df8181eaad7f"));
expect(derived.privkey).toEqual(fromHex("ea4f5bfe8694d8bb74b7b59404632fd5968b774ed545e810de9c32a4fb4192f4"));
expect(derived.chainCode).toEqual(
fromHex("138f0b2551bcafeca6ff2aa88ba8ed0ed8de070841f0c4ef0165df8181eaad7f"),
);
expect(derived.privkey).toEqual(
fromHex("ea4f5bfe8694d8bb74b7b59404632fd5968b774ed545e810de9c32a4fb4192f4"),
);
});
it("can derive path m/0'/2147483647'/1'", () => {
const path: ReadonlyArray<Slip10RawIndex> = [Slip10RawIndex.hardened(0), Slip10RawIndex.hardened(2147483647), Slip10RawIndex.hardened(1)];
const path: ReadonlyArray<Slip10RawIndex> = [
Slip10RawIndex.hardened(0),
Slip10RawIndex.hardened(2147483647),
Slip10RawIndex.hardened(1),
];
const derived = Slip10.derivePath(Slip10Curve.Ed25519, seed, path);
expect(derived.chainCode).toEqual(fromHex("73bd9fff1cfbde33a1b846c27085f711c0fe2d66fd32e139d3ebc28e5a4a6b90"));
expect(derived.privkey).toEqual(fromHex("3757c7577170179c7868353ada796c839135b3d30554bbb74a4b1e4a5a58505c"));
expect(derived.chainCode).toEqual(
fromHex("73bd9fff1cfbde33a1b846c27085f711c0fe2d66fd32e139d3ebc28e5a4a6b90"),
);
expect(derived.privkey).toEqual(
fromHex("3757c7577170179c7868353ada796c839135b3d30554bbb74a4b1e4a5a58505c"),
);
});
it("can derive path m/0'/2147483647'/1'/2147483646'", () => {
const path: ReadonlyArray<Slip10RawIndex> = [Slip10RawIndex.hardened(0), Slip10RawIndex.hardened(2147483647), Slip10RawIndex.hardened(1), Slip10RawIndex.hardened(2147483646)];
const path: ReadonlyArray<Slip10RawIndex> = [
Slip10RawIndex.hardened(0),
Slip10RawIndex.hardened(2147483647),
Slip10RawIndex.hardened(1),
Slip10RawIndex.hardened(2147483646),
];
const derived = Slip10.derivePath(Slip10Curve.Ed25519, seed, path);
expect(derived.chainCode).toEqual(fromHex("0902fe8a29f9140480a00ef244bd183e8a13288e4412d8389d140aac1794825a"));
expect(derived.privkey).toEqual(fromHex("5837736c89570de861ebc173b1086da4f505d4adb387c6a1b1342d5e4ac9ec72"));
expect(derived.chainCode).toEqual(
fromHex("0902fe8a29f9140480a00ef244bd183e8a13288e4412d8389d140aac1794825a"),
);
expect(derived.privkey).toEqual(
fromHex("5837736c89570de861ebc173b1086da4f505d4adb387c6a1b1342d5e4ac9ec72"),
);
});
it("can derive path m/0'/2147483647'/1'/2147483646'/2'", () => {
const path: ReadonlyArray<Slip10RawIndex> = [Slip10RawIndex.hardened(0), Slip10RawIndex.hardened(2147483647), Slip10RawIndex.hardened(1), Slip10RawIndex.hardened(2147483646), Slip10RawIndex.hardened(2)];
const path: ReadonlyArray<Slip10RawIndex> = [
Slip10RawIndex.hardened(0),
Slip10RawIndex.hardened(2147483647),
Slip10RawIndex.hardened(1),
Slip10RawIndex.hardened(2147483646),
Slip10RawIndex.hardened(2),
];
const derived = Slip10.derivePath(Slip10Curve.Ed25519, seed, path);
expect(derived.chainCode).toEqual(fromHex("5d70af781f3a37b829f0d060924d5e960bdc02e85423494afc0b1a41bbe196d4"));
expect(derived.privkey).toEqual(fromHex("551d333177df541ad876a60ea71f00447931c0a9da16f227c11ea080d7391b8d"));
expect(derived.chainCode).toEqual(
fromHex("5d70af781f3a37b829f0d060924d5e960bdc02e85423494afc0b1a41bbe196d4"),
);
expect(derived.privkey).toEqual(
fromHex("551d333177df541ad876a60ea71f00447931c0a9da16f227c11ea080d7391b8d"),
);
});
});
});

1

tsconfig.json
{
"extends": "../../tsconfig.json",
"compilerOptions": {
"resolveJsonModule": true,
"baseUrl": ".",

@@ -5,0 +6,0 @@ "outDir": "build",

7

types/bip39.d.ts

@@ -1,7 +0,2 @@

export declare class EnglishMnemonic {
private static readonly mnemonicMatcher;
private readonly data;
constructor(mnemonic: string);
asString(): string;
}
import { EnglishMnemonic } from "./englishmnemonic";
export declare class Bip39 {

@@ -8,0 +3,0 @@ static encode(entropy: Uint8Array): EnglishMnemonic;

1

types/index.d.ts
export * from "./bip39";
export { EnglishMnemonic } from "./englishmnemonic";
export * from "./hmac";

@@ -3,0 +4,0 @@ export * from "./keccak";

.prettierrc.json
build/bip39.js.map

Sorry, the diff of this file is not supported yet

build/bip39.spec.js.map

Sorry, the diff of this file is not supported yet

build/hmac.spec.js.map

Sorry, the diff of this file is not supported yet

build/index.js.map

Sorry, the diff of this file is not supported yet

build/keccak.spec.js

Sorry, the diff of this file is too big to display

build/keccak.spec.js.map

Sorry, the diff of this file is not supported yet

build/libsodium.spec.js

Sorry, the diff of this file is too big to display

build/libsodium.spec.js.map

Sorry, the diff of this file is not supported yet

build/secp256k1.spec.js.map

Sorry, the diff of this file is not supported yet

build/secp256k1signature.spec.js.map

Sorry, the diff of this file is not supported yet

build/sha.spec.js

Sorry, the diff of this file is too big to display

build/sha.spec.js.map

Sorry, the diff of this file is not supported yet

build/slip10.spec.js.map

Sorry, the diff of this file is not supported yet

src/keccak.spec.ts

Sorry, the diff of this file is too big to display

src/libsodium.spec.ts

Sorry, the diff of this file is too big to display

src/sha.spec.ts

Sorry, the diff of this file is too big to display

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc