9285563684

Committed 29 May 2024 11:52AM UTC coverage: 68.659% (+0.5%) from 68.144%

Build # 9285563684

Build Type

Pull #215

github

Committed by

web-flow

Commit Message

Merge 39f7f830b into e80549cb0

Pull Request Pull Request #215: feat: Backup and Restore

Run Details

1064 of 1736 branches covered (61.29%)

Branch coverage included in aggregate %.

169 of 222 new or added lines in 23 files covered. (76.13%)

2 existing lines in 1 file now uncovered.

2244 of 3082 relevant lines covered (72.81%)

16.41 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.46

/src/apollo/Apollo.ts

import { Apollo as ApolloInterface } from "../domain/buildingBlocks/Apollo";
import * as bip39 from "@scure/bip39";
import { wordlist } from "@scure/bip39/wordlists/english";

import {
  getKeyCurveByNameAndIndex,
  ApolloError,
  Curve,
  KeyTypes,
  KeyProperties,
  MnemonicWordList,
  PrivateKey,
  PublicKey,
  Seed,
  SeedWords,
  StorableKey,
  KeyRestoration,
} from "../domain";
import {
  MnemonicLengthException,
  MnemonicWordException,
} from "../domain/models/errors/Mnemonic";

import { Ed25519PrivateKey } from "./utils/Ed25519PrivateKey";
import { X25519PrivateKey } from "./utils/X25519PrivateKey";
import { Secp256k1PrivateKey } from "./utils/Secp256k1PrivateKey";
import { Ed25519KeyPair } from "./utils/Ed25519KeyPair";
import { X25519KeyPair } from "./utils/X25519KeyPair";
import { Secp256k1PublicKey } from "./utils/Secp256k1PublicKey";
import { Ed25519PublicKey } from "./utils/Ed25519PublicKey";
import { X25519PublicKey } from "./utils/X25519PublicKey";

import { DerivationPath } from "./utils/derivation/DerivationPath";
import { notEmptyString } from "../utils";
import ApolloPKG from "@atala/apollo";
const ApolloSDK = ApolloPKG.org.hyperledger.identus.apollo;
const Mnemonic = ApolloSDK.derivation.Mnemonic.Companion;
const HDKey = ApolloSDK.derivation.HDKey;
const BigIntegerWrapper = ApolloSDK.derivation.BigIntegerWrapper;

/**
 * Apollo defines the set of cryptographic operations.
 *
 * @Abstraction
 * We by default are implementing Secp256k1, Ed25519 and X25519 Private and Public key from our generic abstractions.
 * When you are using one of those type of keys, for example with:
 *
 * ```ts
 *  const privateKey = apollo.createPrivateKey({
 *    type: KeyTypes.EC,
 *    curve: Curve.ED25519,
 *  });
 * ```
 * All the properties you pass to the createPrivateKey are just the default keyProperty keys and the values are strings, buffers are represented in hex format also as strings to simplify conversion later
 *
 * You can know check if this key can sign with:
 *
 * ```ts
 * if (privateKey.isSignable()) {
 *  //the sign method will be available inside this if
 *  privateKey.sign(message)
 * }
 * //not outside
 *
 * const signature = privateKey.isSignable() && privateKey.sign(message)
 * //This last one would also would but if your key was not signable would return false
 * ```
 *
 * PublicKeys follow the same concept, imagine you already have an instance of a publicKey, then..
 *
 * ```ts
 * if (publicKey.canVerify()) {
 *  privateKey.verify(challenge, signature)
 * }
 * //not outside
 * ```
 *
 * All keys know also have a generic list of properties which can be accessed at any stage, for example:

 * ```ts
 * privateKey.getProperty(KeyProperties.curve)
 * ```
 *
 * Would give your the Curve value.
 *
 * Find below all the complete list of KeyProperties that are available.
 *
 * ```ts
 * export enum KeyProperties {
 *   /// The 'kid'  represents a key's identifier.
 *   kid = "kid",
 *   /// The 'algorithm'  corresponds to the cryptographic algorithm associated with the key.,
 *   algorithm = "algorithm",
 *   /// The 'curve'  represents the elliptic curve used for an elliptic-curve key.,
 *   curve = "curve",
 *   /// The 'seed'  corresponds to the seed value from which a key is derived.,
 *   seed = "seed",
 *   /// The 'rawKey'  refers to the raw binary form of the key.,
 *   rawKey = "raw",
 *   /// The 'derivationPath'  refers to the path used to derive a key in a hierarchical deterministic (HD) key generation scheme.,
 *   derivationPath = "derivationPath",
 *   index = "index",
 *   /// The 'type'  denotes the type of the key.,
 *   type = "type",
 *   /// The 'curvePointX'  represents the x-coordinate of a curve point for an elliptic-curve key.,
 *   curvePointX = "curvePoint.x",
 *   /// The 'curvePointY'  represents the y-coordinate of a curve point for an elliptic-curve key.,
 *   curvePointY = "curvePoint.y",
 * }
 * ```
 *
 * @class Apollo
 * @typedef {Apollo}
 */
export default class Apollo implements ApolloInterface, KeyRestoration {
  static Secp256k1PrivateKey = Secp256k1PrivateKey;
  static Ed25519PrivateKey = Ed25519PrivateKey;
  static X25519PrivateKey = X25519PrivateKey;

  /**
   * Creates a random set of mnemonic phrases that can be used as a seed for generating a private key.
   *
   * @example
   * This function creates a random mnemonic phrase whose usage is as a seed for generating a private key.
   *
   * ```ts
   *  const mnemonics = apollo.createRandomMnemonics();
   * ```
   *
   * @returns {MnemonicWordList}
   */
  createRandomMnemonics(): MnemonicWordList {
    return Mnemonic.createRandomMnemonics() as MnemonicWordList;
  }

  /**
   * Takes in a set of mnemonics and a passphrase, and returns a seed object used to generate a private key.
   *
   * @example
   * This function takes mnemonics and passphrases and creates a seed object to generate a private key. It may throw an error if the mnemonics are invalid.
   *
   * ```ts
   *  const seed = apollo.createSeed(mnemonics, "my-secret-passphrase");
   * ```
   *
   * @param {MnemonicWordList} mnemonics
   * @param {?string} [passphrase]
   * @returns {Seed}
   */
  createSeed(mnemonics: MnemonicWordList, passphrase?: string): Seed {
    const mnemonicString = mnemonics.join(" ");

    if (mnemonics.length != 12 && mnemonics.length != 24) {
      throw new MnemonicLengthException(
        "Word list must be 12 or 24 words in length"
      );
    }

    if (!bip39.validateMnemonic(mnemonicString, wordlist)) {
      throw new MnemonicWordException(`Invalid mnemonic word/s`);
    }

    const seed = Mnemonic.createSeed(mnemonics, `mnemonic${passphrase}`);

    return {
      value: Uint8Array.from(seed),
    };
  }

  /**
   * Creates a random seed and a corresponding set of mnemonic phrases.
   *
   * @example
   * This function creates a random mnemonic phrase and seed.
   *
   * ```ts
   *  const {mnemonics, seed} = apollo.createRandomSeed();
   * ```
   *
   * @param {?string} [passphrase]
   * @returns {SeedWords}
   */
  createRandomSeed(passphrase?: string): SeedWords {
    const mnemonics = Mnemonic.createRandomMnemonics() as MnemonicWordList;
    const seed = Mnemonic.createRandomSeed(passphrase);
    return {
      seed: {
        value: Uint8Array.from(seed),
      },
      mnemonics: mnemonics,
    };
  }

  /**
   * Creates a private key based on the current cryptographic abstraction
   *
   *
   * @example
   * Create an EC Key with secp256k1 curve
   *
   * ```ts
   *  const privateKey = apollo.createPrivateKey({
   *    type: KeyTypes.EC,
   *    curve: Curve.SECP256K1,
   *    seed: Buffer.from(seed.value).toString("hex"),
   *  });
   * ```
   *
   *
   * @example
   * Create an EC Key with secp256k1 curve, but also specify a derivationPath
   *
   * ```ts
   *  const privateKey = apollo.createPrivateKey({
   *    type: KeyTypes.EC,
   *    curve: Curve.SECP256K1,
   *    seed: Buffer.from(seed.value).toString("hex"),
   *    derivationPath: "m/0'/0'/0'"
   *  });
   * ```
   *
   *
   * @example
   * Create an EC Key with ed25519 curve, ED25519 keys do not use derivation,
   * passing the seed or derivation path will make no effect.
   * Calling this function just generates a new random privateKey for that curve
   *
   * ```ts
   *  const privateKey = apollo.createPrivateKey({
   *    type: KeyTypes.EC,
   *    curve: Curve.ED25519,
   *  });
   * ```
   *
   *
   * @example
   * Create an EC Key with X25519 curve, X25519 keys do not use derivation,
   * passing the seed or derivation path will make no effect.
   * Calling this function just generates a new random privateKey for that curve
   *
   * ```ts
   *  const privateKey = apollo.createPrivateKey({
   *    type: KeyTypes.Curve25519,
   *    curve: Curve.X25519,
   *  });
   * ```
   *
   * @param {PrivateKey} privateKey
   * @returns {KeyPair}
   */
  createPrivateKey(parameters: {
    [name: KeyProperties | string]: any;
  }): PrivateKey {
    if (!parameters[KeyProperties.type]) {
      throw new ApolloError.InvalidKeyType(
        parameters[KeyProperties.type],
        Object.values(KeyTypes)
      );
    }
    if (!parameters[KeyProperties.curve]) {
      throw new ApolloError.InvalidKeyCurve(
        parameters[KeyProperties.curve],
        Object.values(Curve)
      );
    }

    const keyType = parameters[KeyProperties.type];
    const { curve } = getKeyCurveByNameAndIndex(
      parameters[KeyProperties.curve]
    );
    const keyData = parameters[KeyProperties.rawKey];

    if (keyType === KeyTypes.EC) {
      if (curve === Curve.ED25519) {
        if (keyData) {
          return new Ed25519PrivateKey(keyData);
        }

        const seedHex = parameters[KeyProperties.seed];
        if (notEmptyString(seedHex)) {
          const seed = Int8Array.from(Buffer.from(seedHex, "hex"));
          const hdKey = ApolloSDK.derivation.EdHDKey.Companion.initFromSeed(seed);
          const edKey = Ed25519PrivateKey.from.Buffer(Buffer.from(hdKey.privateKey));

          return edKey;
        }

        const keyPair = Ed25519KeyPair.generateKeyPair();
        return keyPair.privateKey;
      }

      if (curve === Curve.SECP256K1) {
        //TODO: Instanciating from a raw value does not include chainCode
        //This keys will not be derivable until we export them as extendedKeys
        if (keyData) {
          return new Secp256k1PrivateKey(keyData);
        }

        const seedHex = parameters[KeyProperties.seed];
        if (!seedHex) {
          throw new ApolloError.MissingKeyParameters([KeyProperties.seed]);
        }

        const seed = Buffer.from(seedHex, "hex");
        const hdKey = HDKey.InitFromSeed(Int8Array.from(seed), 0, BigIntegerWrapper.initFromInt(0));

        if (hdKey.privateKey == null) {
          throw new ApolloError.MissingPrivateKey();
        }

        if (hdKey.chainCode == null) {
          throw new ApolloError.MissingChainCode();
        }

        const baseKey = new Secp256k1PrivateKey(Buffer.from(hdKey.privateKey));
        baseKey.keySpecification.set(KeyProperties.chainCode, Buffer.from(hdKey.chainCode).toString("hex"));
        baseKey.keySpecification.set(KeyProperties.derivationPath, Buffer.from(`m/0'/0'/0'`).toString("hex"));
        baseKey.keySpecification.set(KeyProperties.index, "0");

        const derivationParam = parameters[KeyProperties.derivationPath];
        if (derivationParam) {
          const derivationPath = DerivationPath.from(derivationParam);
          const privateKey = baseKey.derive(derivationPath);
          return privateKey;
        }

        return baseKey;
      }
    }

    if (keyType === KeyTypes.Curve25519) {
      if (curve === Curve.X25519) {
        if (keyData) {
          return new X25519PrivateKey(keyData);
        }

        const seedHex = parameters[KeyProperties.seed];
        if (notEmptyString(seedHex)) {
          const seed = Int8Array.from(Buffer.from(seedHex, "hex"));
          const hdKey = ApolloSDK.derivation.EdHDKey.Companion.initFromSeed(seed);
          const edKey = Ed25519PrivateKey.from.Buffer(Buffer.from(hdKey.privateKey));
          const xKey = edKey.x25519();

          return xKey;
        }

        const keyPair = X25519KeyPair.generateKeyPair();
        return keyPair.privateKey;
      }
    }

    throw new ApolloError.InvalidKeyType(keyType, Object.values(KeyTypes));
  }


  restorePrivateKey(key: StorableKey): PrivateKey {
    switch (key.recoveryId) {
      case "secp256k1+priv":
        return new Secp256k1PrivateKey(key.raw);

      case "ed25519+priv":
        return new Ed25519PrivateKey(key.raw);

      case "x25519+priv":
        return new X25519PrivateKey(key.raw);
    }

    throw new ApolloError.KeyRestoratonFailed(key);
  }

  restorePublicKey(key: StorableKey): PublicKey {
    switch (key.recoveryId) {
      case "secp256k1+pub":
        return new Secp256k1PublicKey(key.raw);

      case "ed25519+pub":
        return new Ed25519PublicKey(key.raw);

      case "x25519+pub":
        return new X25519PublicKey(key.raw);
    }

    throw new ApolloError.KeyRestoratonFailed(key);
  }
}

1	import { Apollo as ApolloInterface } from "../domain/buildingBlocks/Apollo";
2	import * as bip39 from "@scure/bip39";
3	import { wordlist } from "@scure/bip39/wordlists/english";
4
5	import {
6	getKeyCurveByNameAndIndex,
7	ApolloError,
8	Curve,
9	KeyTypes,
10	KeyProperties,
11	MnemonicWordList,
12	PrivateKey,
13	PublicKey,
14	Seed,
15	SeedWords,
16	StorableKey,
17	KeyRestoration,
18	} from "../domain";
19	import {
20	MnemonicLengthException,
21	MnemonicWordException,
22	} from "../domain/models/errors/Mnemonic";
23
24	import { Ed25519PrivateKey } from "./utils/Ed25519PrivateKey";
25	import { X25519PrivateKey } from "./utils/X25519PrivateKey";
26	import { Secp256k1PrivateKey } from "./utils/Secp256k1PrivateKey";
27	import { Ed25519KeyPair } from "./utils/Ed25519KeyPair";
28	import { X25519KeyPair } from "./utils/X25519KeyPair";
29	import { Secp256k1PublicKey } from "./utils/Secp256k1PublicKey";
30	import { Ed25519PublicKey } from "./utils/Ed25519PublicKey";
31	import { X25519PublicKey } from "./utils/X25519PublicKey";
32
33	import { DerivationPath } from "./utils/derivation/DerivationPath";
34	import { notEmptyString } from "../utils";
35	import ApolloPKG from "@atala/apollo";
36	const ApolloSDK = ApolloPKG.org.hyperledger.identus.apollo;	17✔
37	const Mnemonic = ApolloSDK.derivation.Mnemonic.Companion;	17✔
38	const HDKey = ApolloSDK.derivation.HDKey;	17✔
39	const BigIntegerWrapper = ApolloSDK.derivation.BigIntegerWrapper;	17✔
40
41	/**
42	* Apollo defines the set of cryptographic operations.
43	*
44	* @Abstraction
45	* We by default are implementing Secp256k1, Ed25519 and X25519 Private and Public key from our generic abstractions.
46	* When you are using one of those type of keys, for example with:
47	*
48	* ```ts
49	* const privateKey = apollo.createPrivateKey({
50	* type: KeyTypes.EC,
51	* curve: Curve.ED25519,
52	* });
53	* ```
54	* All the properties you pass to the createPrivateKey are just the default keyProperty keys and the values are strings, buffers are represented in hex format also as strings to simplify conversion later
55	*
56	* You can know check if this key can sign with:
57	*
58	* ```ts
59	* if (privateKey.isSignable()) {
60	* //the sign method will be available inside this if
61	* privateKey.sign(message)
62	* }
63	* //not outside
64	*
65	* const signature = privateKey.isSignable() && privateKey.sign(message)
66	* //This last one would also would but if your key was not signable would return false
67	* ```
68	*
69	* PublicKeys follow the same concept, imagine you already have an instance of a publicKey, then..
70	*
71	* ```ts
72	* if (publicKey.canVerify()) {
73	* privateKey.verify(challenge, signature)
74	* }
75	* //not outside
76	* ```
77	*
78	* All keys know also have a generic list of properties which can be accessed at any stage, for example:
79
80	* ```ts
81	* privateKey.getProperty(KeyProperties.curve)
82	* ```
83	*
84	* Would give your the Curve value.
85	*
86	* Find below all the complete list of KeyProperties that are available.
87	*
88	* ```ts
89	* export enum KeyProperties {
90	* /// The 'kid' represents a key's identifier.
91	* kid = "kid",
92	* /// The 'algorithm' corresponds to the cryptographic algorithm associated with the key.,
93	* algorithm = "algorithm",
94	* /// The 'curve' represents the elliptic curve used for an elliptic-curve key.,
95	* curve = "curve",
96	* /// The 'seed' corresponds to the seed value from which a key is derived.,
97	* seed = "seed",
98	* /// The 'rawKey' refers to the raw binary form of the key.,
99	* rawKey = "raw",
100	* /// The 'derivationPath' refers to the path used to derive a key in a hierarchical deterministic (HD) key generation scheme.,
101	* derivationPath = "derivationPath",
102	* index = "index",
103	* /// The 'type' denotes the type of the key.,
104	* type = "type",
105	* /// The 'curvePointX' represents the x-coordinate of a curve point for an elliptic-curve key.,
106	* curvePointX = "curvePoint.x",
107	* /// The 'curvePointY' represents the y-coordinate of a curve point for an elliptic-curve key.,
108	* curvePointY = "curvePoint.y",
109	* }
110	* ```
111	*
112	* @class Apollo
113	* @typedef {Apollo}
114	*/
115	export default class Apollo implements ApolloInterface, KeyRestoration {
116	static Secp256k1PrivateKey = Secp256k1PrivateKey;	17✔
117	static Ed25519PrivateKey = Ed25519PrivateKey;	17✔
118	static X25519PrivateKey = X25519PrivateKey;	17✔
119
120	/**
121	* Creates a random set of mnemonic phrases that can be used as a seed for generating a private key.
122	*
123	* @example
124	* This function creates a random mnemonic phrase whose usage is as a seed for generating a private key.
125	*
126	* ```ts
127	* const mnemonics = apollo.createRandomMnemonics();
128	* ```
129	*
130	* @returns {MnemonicWordList}
131	*/
132	createRandomMnemonics(): MnemonicWordList {
133	return Mnemonic.createRandomMnemonics() as MnemonicWordList;	310✔
134	}
135
136	/**
137	* Takes in a set of mnemonics and a passphrase, and returns a seed object used to generate a private key.
138	*
139	* @example
140	* This function takes mnemonics and passphrases and creates a seed object to generate a private key. It may throw an error if the mnemonics are invalid.
141	*
142	* ```ts
143	* const seed = apollo.createSeed(mnemonics, "my-secret-passphrase");
144	* ```
145	*
146	* @param {MnemonicWordList} mnemonics
147	* @param {?string} [passphrase]
148	* @returns {Seed}
149	*/
150	createSeed(mnemonics: MnemonicWordList, passphrase?: string): Seed {
151	const mnemonicString = mnemonics.join(" ");	35✔
152
153	if (mnemonics.length != 12 && mnemonics.length != 24) {	35✔
154	throw new MnemonicLengthException(	23✔
155	"Word list must be 12 or 24 words in length"
156	);
157	}
158
159	if (!bip39.validateMnemonic(mnemonicString, wordlist)) {	12✔
160	throw new MnemonicWordException(`Invalid mnemonic word/s`);	2✔
161	}
162
163	const seed = Mnemonic.createSeed(mnemonics, `mnemonic${passphrase}`);	10✔
164
165	return {	10✔
166	value: Uint8Array.from(seed),
167	};
168	}
169
170	/**
171	* Creates a random seed and a corresponding set of mnemonic phrases.
172	*
173	* @example
174	* This function creates a random mnemonic phrase and seed.
175	*
176	* ```ts
177	* const {mnemonics, seed} = apollo.createRandomSeed();
178	* ```
179	*
180	* @param {?string} [passphrase]
181	* @returns {SeedWords}
182	*/
183	createRandomSeed(passphrase?: string): SeedWords {
184	const mnemonics = Mnemonic.createRandomMnemonics() as MnemonicWordList;	110✔
185	const seed = Mnemonic.createRandomSeed(passphrase);	110✔
186	return {	110✔
187	seed: {
188	value: Uint8Array.from(seed),
189	},
190	mnemonics: mnemonics,
191	};
192	}
193
194	/**
195	* Creates a private key based on the current cryptographic abstraction
196	*
197	*
198	* @example
199	* Create an EC Key with secp256k1 curve
200	*
201	* ```ts
202	* const privateKey = apollo.createPrivateKey({
203	* type: KeyTypes.EC,
204	* curve: Curve.SECP256K1,
205	* seed: Buffer.from(seed.value).toString("hex"),
206	* });
207	* ```
208	*
209	*
210	* @example
211	* Create an EC Key with secp256k1 curve, but also specify a derivationPath
212	*
213	* ```ts
214	* const privateKey = apollo.createPrivateKey({
215	* type: KeyTypes.EC,
216	* curve: Curve.SECP256K1,
217	* seed: Buffer.from(seed.value).toString("hex"),
218	* derivationPath: "m/0'/0'/0'"
219	* });
220	* ```
221	*
222	*
223	* @example
224	* Create an EC Key with ed25519 curve, ED25519 keys do not use derivation,
225	* passing the seed or derivation path will make no effect.
226	* Calling this function just generates a new random privateKey for that curve
227	*
228	* ```ts
229	* const privateKey = apollo.createPrivateKey({
230	* type: KeyTypes.EC,
231	* curve: Curve.ED25519,
232	* });
233	* ```
234	*
235	*
236	* @example
237	* Create an EC Key with X25519 curve, X25519 keys do not use derivation,
238	* passing the seed or derivation path will make no effect.
239	* Calling this function just generates a new random privateKey for that curve
240	*
241	* ```ts
242	* const privateKey = apollo.createPrivateKey({
243	* type: KeyTypes.Curve25519,
244	* curve: Curve.X25519,
245	* });
246	* ```
247	*
248	* @param {PrivateKey} privateKey
249	* @returns {KeyPair}
250	*/
251	createPrivateKey(parameters: {
252	[name: KeyProperties \| string]: any;
253	}): PrivateKey {
254	if (!parameters[KeyProperties.type]) {	59✔
255	throw new ApolloError.InvalidKeyType(	1✔
256	parameters[KeyProperties.type],
257	Object.values(KeyTypes)
258	);
259	}
260	if (!parameters[KeyProperties.curve]) {	58✔
261	throw new ApolloError.InvalidKeyCurve(	1✔
262	parameters[KeyProperties.curve],
263	Object.values(Curve)
264	);
265	}
266
267	const keyType = parameters[KeyProperties.type];	57✔
268	const { curve } = getKeyCurveByNameAndIndex(	57✔
269	parameters[KeyProperties.curve]
270	);
271	const keyData = parameters[KeyProperties.rawKey];	57✔
272
273	if (keyType === KeyTypes.EC) {	57✔
274	if (curve === Curve.ED25519) {	52✔
275	if (keyData) {	8✔
276	return new Ed25519PrivateKey(keyData);	2✔
277	}
278
279	const seedHex = parameters[KeyProperties.seed];	6✔
280	if (notEmptyString(seedHex)) {	6!
NEW 281	const seed = Int8Array.from(Buffer.from(seedHex, "hex"));	×
NEW 282	const hdKey = ApolloSDK.derivation.EdHDKey.Companion.initFromSeed(seed);	×
NEW 283	const edKey = Ed25519PrivateKey.from.Buffer(Buffer.from(hdKey.privateKey));	×
284
NEW 285	return edKey;	×
286	}
287
288	const keyPair = Ed25519KeyPair.generateKeyPair();	6✔
289	return keyPair.privateKey;	6✔
290	}
291
292	if (curve === Curve.SECP256K1) {	44!
293	//TODO: Instanciating from a raw value does not include chainCode
294	//This keys will not be derivable until we export them as extendedKeys
295	if (keyData) {	44!
296	return new Secp256k1PrivateKey(keyData);	×
297	}
298
299	const seedHex = parameters[KeyProperties.seed];	44✔
300	if (!seedHex) {	44✔
301	throw new ApolloError.MissingKeyParameters([KeyProperties.seed]);	1✔
302	}
303
304	const seed = Buffer.from(seedHex, "hex");	43✔
305	const hdKey = HDKey.InitFromSeed(Int8Array.from(seed), 0, BigIntegerWrapper.initFromInt(0));	43✔
306
307	if (hdKey.privateKey == null) {	42!
308	throw new ApolloError.MissingPrivateKey();	×
309	}
310
311	if (hdKey.chainCode == null) {	42!
312	throw new ApolloError.MissingChainCode();	×
313	}
314
315	const baseKey = new Secp256k1PrivateKey(Buffer.from(hdKey.privateKey));	42✔
316	baseKey.keySpecification.set(KeyProperties.chainCode, Buffer.from(hdKey.chainCode).toString("hex"));	42✔
317	baseKey.keySpecification.set(KeyProperties.derivationPath, Buffer.from(`m/0'/0'/0'`).toString("hex"));	42✔
318	baseKey.keySpecification.set(KeyProperties.index, "0");	42✔
319
320	const derivationParam = parameters[KeyProperties.derivationPath];	42✔
321	if (derivationParam) {	42✔
322	const derivationPath = DerivationPath.from(derivationParam);	15✔
323	const privateKey = baseKey.derive(derivationPath);	14✔
324	return privateKey;	14✔
325	}
326
327	return baseKey;	27✔
328	}
329	}
330
331	if (keyType === KeyTypes.Curve25519) {	5!
332	if (curve === Curve.X25519) {	5!
333	if (keyData) {	5✔
334	return new X25519PrivateKey(keyData);	2✔
335	}
336
337	const seedHex = parameters[KeyProperties.seed];	3✔
338	if (notEmptyString(seedHex)) {	3!
NEW 339	const seed = Int8Array.from(Buffer.from(seedHex, "hex"));	×
NEW 340	const hdKey = ApolloSDK.derivation.EdHDKey.Companion.initFromSeed(seed);	×
NEW 341	const edKey = Ed25519PrivateKey.from.Buffer(Buffer.from(hdKey.privateKey));	×
NEW 342	const xKey = edKey.x25519();	×
343
NEW 344	return xKey;	×
345	}
346
347	const keyPair = X25519KeyPair.generateKeyPair();	3✔
348	return keyPair.privateKey;	3✔
349	}
350	}
351
352	throw new ApolloError.InvalidKeyType(keyType, Object.values(KeyTypes));	×
353	}
354
355
356	restorePrivateKey(key: StorableKey): PrivateKey {
357	switch (key.recoveryId) {	17✔
358	case "secp256k1+priv":
359	return new Secp256k1PrivateKey(key.raw);	4✔
360
361	case "ed25519+priv":
362	return new Ed25519PrivateKey(key.raw);	6✔
363
364	case "x25519+priv":
365	return new X25519PrivateKey(key.raw);	6✔
366	}
367
368	throw new ApolloError.KeyRestoratonFailed(key);	1✔
369	}
370
371	restorePublicKey(key: StorableKey): PublicKey {
372	switch (key.recoveryId) {	4✔
373	case "secp256k1+pub":
374	return new Secp256k1PublicKey(key.raw);	1✔
375
376	case "ed25519+pub":
377	return new Ed25519PublicKey(key.raw);	1✔
378
379	case "x25519+pub":
380	return new X25519PublicKey(key.raw);	1✔
381	}
382
383	throw new ApolloError.KeyRestoratonFailed(key);	1✔
384	}
385	}

input-output-hk / atala-prism-wallet-sdk-ts / 9285563684

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous