9302965114

Committed 30 May 2024 12:59PM UTC coverage: 69.032% (+0.9%) from 68.144%

Build # 9302965114

Build Type

Pull #215

github

Committed by

web-flow

Commit Message

Merge 65a62aacb into e80549cb0

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

Run Details

1076 of 1743 branches covered (61.73%)

Branch coverage included in aggregate %.

186 of 231 new or added lines in 23 files covered. (80.52%)

2 existing lines in 1 file now uncovered.

2261 of 3091 relevant lines covered (73.15%)

17.85 hits per line

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

73.02

/src/pluto/backup/versions/0_0_1/Restore.ts

import * as Domain from "../../../../domain";
import { Ed25519PrivateKey } from "../../../../apollo/utils/Ed25519PrivateKey";
import { Secp256k1PrivateKey } from "../../../../apollo/utils/Secp256k1PrivateKey";
import { X25519PrivateKey } from "../../../../apollo/utils/X25519PrivateKey";
import { AnonCredsCredential, AnonCredsRecoveryId } from "../../../../pollux/models/AnonCredsVerifiableCredential";
import { JWTCredential, JWTVerifiableCredentialRecoveryId } from "../../../../pollux/models/JWTVerifiableCredential";
import { notEmptyString, notNil } from "../../../../utils";

export class RestoreTask {
  constructor(
    private readonly Pluto: Domain.Pluto,
    private readonly backup: Domain.Pluto.Backup.v0_0_1,
  ) {}

  async run(): Promise<void> {
    await this.restoreCredentials();
    await this.restoreDids();
    await this.restoreDidPairs();
    await this.restoreKeys();
    await this.restoreLinkSecret();
    await this.restoreMessages();
  }

  async restoreCredentials() {
    const credentials = this.backup.credentials.map<Domain.Credential>(item => {
      if (item.recoveryId === JWTVerifiableCredentialRecoveryId) {
        return JWTCredential.fromJWS(item.data);
      }

      if (item.recoveryId === AnonCredsRecoveryId) {
        const jsonStr = Buffer.from(item.data, "base64url").toString();
        const json = JSON.parse(jsonStr);
        return new AnonCredsCredential(json);
      }

      throw new Domain.PlutoError.RestoreCredentialInvalidError();
    });

    await Promise.all(credentials.map(x => this.Pluto.storeCredential(x)));
  }

  async restoreDids() {
    await Promise.all(
      this.backup.dids.map(x => this.Pluto.storeDID(Domain.DID.from(x.did), [], x.alias))
    );
  }

  async restoreDidPairs() {
    await Promise.all(
      this.backup.did_pairs.map(item => {
        const host = Domain.DID.from(item.holder);
        const target = Domain.DID.from(item.recipient);

        return this.Pluto.storeDIDPair(host, target, item.alias);
      })
    );
  }

  async restoreKeys() {
    this.backup.keys.forEach(item => {
      const jwk = JSON.parse(Buffer.from(item.key, "base64url").toString());
      const key = this.jwkToDomain(jwk);

      if (notNil(item.index)) {
        key.keySpecification.set(Domain.KeyProperties.index, item.index.toString());
      }

      if (notEmptyString(item.did)) {
        this.Pluto.storeDID(Domain.DID.from(item.did), key);
      }
      else {
        this.Pluto.storePrivateKey(key);
      }
    });
  }

  private jwkToDomain(jwk: Domain.JWK): Domain.PrivateKey {
    if ((jwk.kty === "OKP" || jwk.kty === "EC") && notEmptyString(jwk.d)) {
      switch (jwk.crv) {
        case Domain.Curve.SECP256K1.toLowerCase():
          return Secp256k1PrivateKey.from.String(jwk.d, "base64url");

        case Domain.Curve.ED25519:
          return Ed25519PrivateKey.from.String(jwk.d, "base64url");

        case Domain.Curve.X25519:
          return X25519PrivateKey.from.String(jwk.d, "base64url");
      }

      throw new Domain.PlutoError.RestoreKeyInvalidError();
    }

    throw new Domain.PlutoError.RestoreJWKInvalidError();
  }

  async restoreLinkSecret() {
    if (notEmptyString(this.backup.link_secret)) {
      const secret = Buffer.from(this.backup.link_secret, "base64url").toString();
      const linkSecret = new Domain.LinkSecret(secret);
      await this.Pluto.storeLinkSecret(linkSecret);
    }
  }

  async restoreMessages() {
    const msgs = this.backup.messages.map<Domain.Message>(item => {
      const data = Buffer.from(item, "base64url").toString();
      const msg = Domain.Message.fromJson(data);
      return msg;
    });

    await this.Pluto.storeMessages(msgs);
  }
}

1	import * as Domain from "../../../../domain";
2	import { Ed25519PrivateKey } from "../../../../apollo/utils/Ed25519PrivateKey";
3	import { Secp256k1PrivateKey } from "../../../../apollo/utils/Secp256k1PrivateKey";
4	import { X25519PrivateKey } from "../../../../apollo/utils/X25519PrivateKey";
5	import { AnonCredsCredential, AnonCredsRecoveryId } from "../../../../pollux/models/AnonCredsVerifiableCredential";
6	import { JWTCredential, JWTVerifiableCredentialRecoveryId } from "../../../../pollux/models/JWTVerifiableCredential";
7	import { notEmptyString, notNil } from "../../../../utils";
8
9	export class RestoreTask {
10	constructor(
11	private readonly Pluto: Domain.Pluto,
12	private readonly backup: Domain.Pluto.Backup.v0_0_1,
13	) {}
14
15	async run(): Promise<void> {
16	await this.restoreCredentials();	7✔
17	await this.restoreDids();	7✔
18	await this.restoreDidPairs();	7✔
19	await this.restoreKeys();	7✔
20	await this.restoreLinkSecret();	7✔
21	await this.restoreMessages();	7✔
22	}
23
24	async restoreCredentials() {
25	const credentials = this.backup.credentials.map<Domain.Credential>(item => {	7✔
26	if (item.recoveryId === JWTVerifiableCredentialRecoveryId) {	2!
27	return JWTCredential.fromJWS(item.data);	2✔
28	}
29
NEW 30	if (item.recoveryId === AnonCredsRecoveryId) {	×
NEW 31	const jsonStr = Buffer.from(item.data, "base64url").toString();	×
NEW 32	const json = JSON.parse(jsonStr);	×
NEW 33	return new AnonCredsCredential(json);	×
34	}
35
NEW 36	throw new Domain.PlutoError.RestoreCredentialInvalidError();	×
37	});
38
39	await Promise.all(credentials.map(x => this.Pluto.storeCredential(x)));	7✔
40	}
41
42	async restoreDids() {
43	await Promise.all(	7✔
44	this.backup.dids.map(x => this.Pluto.storeDID(Domain.DID.from(x.did), [], x.alias))	3✔
45	);
46	}
47
48	async restoreDidPairs() {
49	await Promise.all(	7✔
50	this.backup.did_pairs.map(item => {
51	const host = Domain.DID.from(item.holder);	2✔
52	const target = Domain.DID.from(item.recipient);	2✔
53
54	return this.Pluto.storeDIDPair(host, target, item.alias);	2✔
55	})
56	);
57	}
58
59	async restoreKeys() {
60	this.backup.keys.forEach(item => {	7✔
61	const jwk = JSON.parse(Buffer.from(item.key, "base64url").toString());	2✔
62	const key = this.jwkToDomain(jwk);	2✔
63
64	if (notNil(item.index)) {	2!
NEW 65	key.keySpecification.set(Domain.KeyProperties.index, item.index.toString());	×
66	}
67
68	if (notEmptyString(item.did)) {	2✔
69	this.Pluto.storeDID(Domain.DID.from(item.did), key);	1✔
70	}
71	else {
72	this.Pluto.storePrivateKey(key);	1✔
73	}
74	});
75	}
76
77	private jwkToDomain(jwk: Domain.JWK): Domain.PrivateKey {
78	if ((jwk.kty === "OKP" \|\| jwk.kty === "EC") && notEmptyString(jwk.d)) {	2!
79	switch (jwk.crv) {	2!
80	case Domain.Curve.SECP256K1.toLowerCase():
81	return Secp256k1PrivateKey.from.String(jwk.d, "base64url");	2✔
82
83	case Domain.Curve.ED25519:
NEW 84	return Ed25519PrivateKey.from.String(jwk.d, "base64url");	×
85
86	case Domain.Curve.X25519:
NEW 87	return X25519PrivateKey.from.String(jwk.d, "base64url");	×
88	}
89
NEW 90	throw new Domain.PlutoError.RestoreKeyInvalidError();	×
91	}
92
NEW 93	throw new Domain.PlutoError.RestoreJWKInvalidError();	×
94	}
95
96	async restoreLinkSecret() {
97	if (notEmptyString(this.backup.link_secret)) {	7✔
98	const secret = Buffer.from(this.backup.link_secret, "base64url").toString();	2✔
99	const linkSecret = new Domain.LinkSecret(secret);	2✔
100	await this.Pluto.storeLinkSecret(linkSecret);	2✔
101	}
102	}
103
104	async restoreMessages() {
105	const msgs = this.backup.messages.map<Domain.Message>(item => {	7✔
106	const data = Buffer.from(item, "base64url").toString();	2✔
107	const msg = Domain.Message.fromJson(data);	2✔
108	return msg;	2✔
109	});
110
111	await this.Pluto.storeMessages(msgs);	7✔
112	}
113	}

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

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