8535065835

Committed 03 Apr 2024 07:46AM UTC coverage: 66.036% (+0.5%) from 65.502%

Build # 8535065835

Build Type

Pull #188

github

Committed by

web-flow

Commit Message

Merge acb57f291 into 11cc07cfd

Pull Request Pull Request #188: feat(Pluto)!: Backup and Restore

Run Details

749 of 1317 branches covered (56.87%)

Branch coverage included in aggregate %.

118 of 133 new or added lines in 11 files covered. (88.72%)

2 existing lines in 1 file now uncovered.

1868 of 2646 relevant lines covered (70.6%)

13.76 hits per line

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

64.62

/src/pluto/backup/Restore.task.ts

import { AnonCredsCredential, AnonCredsRecoveryId, Domain, Ed25519PrivateKey, JWTCredential, JWTVerifiableCredentialRecoveryId, Secp256k1PrivateKey, X25519PrivateKey } from "../..";
import { JWK } from "../../domain";

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

  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.fromJWT(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 Error();
      // ?? handle not matched
    });

    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: JWK = JSON.parse(Buffer.from(item.key, "base64url").toString());
      const key = this.jwkToDomain(jwk, item.index);

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

  private jwkToDomain(jwk: JWK, index?: number): Domain.PrivateKey {
    if (jwk.kty === "OKP") {
      // TODO jwk.crv should be lowercase
      if (jwk.crv === Domain.Curve.SECP256K1) {
        const key = Secp256k1PrivateKey.from.String(jwk.d!, "base64url");

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

        return key;
      }

      if (jwk.crv === Domain.Curve.ED25519) {
        return Ed25519PrivateKey.from.String(jwk.d!, "base64url");
      }

      if (jwk.crv === Domain.Curve.X25519) {
        return X25519PrivateKey.from.String(jwk.d!, "base64url");
      }
    }

    // TODO improve
    throw new Error("key not handled");
  }

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

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

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