9321335840

Committed 31 May 2024 12:54PM UTC coverage: 68.144% (-0.02%) from 68.166%

Build # 9321335840

Build Type

push

github

Committed by

amagyar-iohk

Commit Message

fix: build node wasm not bundled up (#226)

Signed-off-by: Allain Magyar <allain.magyar@iohk.io>
(cherry picked from commit 48e78e3e4)

Run Details

1019 of 1669 branches covered (61.05%)

Branch coverage included in aggregate %.

2102 of 2911 relevant lines covered (72.21%)

15.6 hits per line

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

82.35

/src/castor/resolver/LongFormPrismDIDResolver.ts

import { SHA256 } from "@stablelib/sha256";
import { CastorError } from "../../domain/models/Errors";
import { Apollo } from "../../domain/buildingBlocks/Apollo";
import { LongFormPrismDID } from "../../castor/did/prismDID/LongFormPrismDID";
import {
  DIDResolver,
  DIDDocument,
  VerificationMethod as DIDDocumentVerificationMethod,
  VerificationMethods as DIDDocumentVerificationMethods,
  Service as DIDDocumentService,
  Services as DIDDocumentServices,
  ServiceEndpoint as DIDDocumentServiceEndpoint,
  Authentication as DIDDocumentAuthentication,
  DID,
  DIDUrl,
  DIDDocumentCoreProperty,
} from "../../domain/models";

import * as DIDParser from "../parser/DIDParser";
import * as Protos from "../../castor/protos/node_models";
import {
  getUsage,
  getUsageId,
  PrismDIDPublicKey,
} from "../../castor/did/prismDID/PrismDIDPublicKey";
import * as base64 from "multiformats/bases/base64";
import * as base58 from "multiformats/bases/base58";
import { Secp256k1PublicKey } from "../../apollo/utils/Secp256k1PublicKey";
import { KeyProperties } from "../../domain/models/KeyProperties";

export class LongFormPrismDIDResolver implements DIDResolver {
  method = "prism";

  constructor(private apollo: Apollo) {}

  async resolve(didString: string): Promise<DIDDocument> {
    const did = DIDParser.parse(didString);
    const prismDID = new LongFormPrismDID(did);
    const state = prismDID.encodedState;
    const base64State = base64.base64url.decode(`u${state}`);
    const [verificationMethods, services] = this.decodeState(
      did,
      prismDID.stateHash,
      base64State
    );
    const servicesProperty = new DIDDocumentServices(services);
    const verificationMethodsProperty = new DIDDocumentVerificationMethods([
      ...verificationMethods.values(),
    ]);
    const coreProperties: DIDDocumentCoreProperty[] = [];
    const authenticate: DIDDocumentAuthentication[] = [];

    for (const [key, value] of verificationMethods) {
      authenticate.push(new DIDDocumentAuthentication([key], [value]));
    }

    coreProperties.push(...authenticate);
    coreProperties.push(servicesProperty);
    coreProperties.push(verificationMethodsProperty);

    return new DIDDocument(did, coreProperties);
  }

  private decodeState(
    did: DID,
    stateHash: string,
    encodedData: Uint8Array
  ): [Map<string, DIDDocumentVerificationMethod>, DIDDocumentService[]] {
    try {
      const verifyEncodedState = new SHA256().update(encodedData).digest();
      const verifyEncodedStateHex = verifyEncodedState;

      if (
        Buffer.from(verifyEncodedState).toString("hex") !==
        Buffer.from(verifyEncodedStateHex).toString("hex")
      ) {
        throw new CastorError.InitialStateOfDIDChanged();
      }
      const operation =
        Protos.io.iohk.atala.prism.protos.AtalaOperation.deserializeBinary(
          encodedData
        );

      const publicKeys: PrismDIDPublicKey[] =
        operation.create_did?.did_data?.public_keys?.map(
          (key: Protos.io.iohk.atala.prism.protos.PublicKey) => {
            const publicKey = key.has_compressed_ec_key_data
              ? Secp256k1PublicKey.secp256k1FromBytes(
                  key.compressed_ec_key_data.data
                )
              : Secp256k1PublicKey.secp256k1FromByteCoordinates(
                  key.ec_key_data.x,
                  key.ec_key_data.y
                );

            return new PrismDIDPublicKey(
              getUsageId(getUsage(key.usage)),
              getUsage(key.usage),
              publicKey
            );
          }
        ) || [];

      const services =
        operation.create_did?.did_data?.services?.reduce<DIDDocumentService[]>(
          (acc, service) => {
            const endpoint = service.service_endpoint.at(0);

            if (endpoint === undefined) return acc;

            return acc.concat(
              new DIDDocumentService(
                service.id,
                [service.type],
                new DIDDocumentServiceEndpoint(endpoint)
              )
            );
          },
          []
        ) ?? [];

      const verificationMethods = publicKeys.reduce(
        (partialResult, publicKey) => {
          /**
           * TODO: Support keys in multiple formats, right now its multibase
           */
          const didUrl = new DIDUrl(did, [], new Map(), publicKey.id);
          const curve = publicKey.keyData.getProperty(KeyProperties.curve);
          if (!curve) {
            throw new CastorError.InvalidKeyError();
          }
          const method = new DIDDocumentVerificationMethod(
            didUrl.string(),
            did.toString(),
            curve,
            undefined,
            base58.base58btc.encode(publicKey.keyData.raw)
          );
          partialResult.set(didUrl.string(), method);
          return partialResult;
        },
        new Map<string, DIDDocumentVerificationMethod>()
      );

      return [verificationMethods, services];
    } catch (err) {
      throw new CastorError.InitialStateOfDIDChanged();
    }
  }
}

1	import { SHA256 } from "@stablelib/sha256";
2	import { CastorError } from "../../domain/models/Errors";
3	import { Apollo } from "../../domain/buildingBlocks/Apollo";
4	import { LongFormPrismDID } from "../../castor/did/prismDID/LongFormPrismDID";
5	import {
6	DIDResolver,
7	DIDDocument,
8	VerificationMethod as DIDDocumentVerificationMethod,
9	VerificationMethods as DIDDocumentVerificationMethods,
10	Service as DIDDocumentService,
11	Services as DIDDocumentServices,
12	ServiceEndpoint as DIDDocumentServiceEndpoint,
13	Authentication as DIDDocumentAuthentication,
14	DID,
15	DIDUrl,
16	DIDDocumentCoreProperty,
17	} from "../../domain/models";
18
19	import * as DIDParser from "../parser/DIDParser";
20	import * as Protos from "../../castor/protos/node_models";
21	import {
22	getUsage,
23	getUsageId,
24	PrismDIDPublicKey,
25	} from "../../castor/did/prismDID/PrismDIDPublicKey";
26	import * as base64 from "multiformats/bases/base64";
27	import * as base58 from "multiformats/bases/base58";
28	import { Secp256k1PublicKey } from "../../apollo/utils/Secp256k1PublicKey";
29	import { KeyProperties } from "../../domain/models/KeyProperties";
30
31	export class LongFormPrismDIDResolver implements DIDResolver {
32	method = "prism";	139✔
33
34	constructor(private apollo: Apollo) {}
35
36	async resolve(didString: string): Promise<DIDDocument> {
37	const did = DIDParser.parse(didString);	16✔
38	const prismDID = new LongFormPrismDID(did);	16✔
39	const state = prismDID.encodedState;	16✔
40	const base64State = base64.base64url.decode(`u${state}`);	16✔
41	const [verificationMethods, services] = this.decodeState(	16✔
42	did,
43	prismDID.stateHash,
44	base64State
45	);
46	const servicesProperty = new DIDDocumentServices(services);	16✔
47	const verificationMethodsProperty = new DIDDocumentVerificationMethods([	16✔
48	...verificationMethods.values(),
49	]);
50	const coreProperties: DIDDocumentCoreProperty[] = [];	16✔
51	const authenticate: DIDDocumentAuthentication[] = [];	16✔
52
53	for (const [key, value] of verificationMethods) {	16✔
54	authenticate.push(new DIDDocumentAuthentication([key], [value]));	33✔
55	}
56
57	coreProperties.push(...authenticate);	16✔
58	coreProperties.push(servicesProperty);	16✔
59	coreProperties.push(verificationMethodsProperty);	16✔
60
61	return new DIDDocument(did, coreProperties);	16✔
62	}
63
64	private decodeState(
65	did: DID,
66	stateHash: string,
67	encodedData: Uint8Array
68	): [Map<string, DIDDocumentVerificationMethod>, DIDDocumentService[]] {
69	try {	16✔
70	const verifyEncodedState = new SHA256().update(encodedData).digest();	16✔
71	const verifyEncodedStateHex = verifyEncodedState;	16✔
72
73	if (	16!
74	Buffer.from(verifyEncodedState).toString("hex") !==
75	Buffer.from(verifyEncodedStateHex).toString("hex")
76	) {
77	throw new CastorError.InitialStateOfDIDChanged();	×
78	}
79	const operation =
80	Protos.io.iohk.atala.prism.protos.AtalaOperation.deserializeBinary(	16✔
81	encodedData
82	);
83
84	const publicKeys: PrismDIDPublicKey[] =
85	operation.create_did?.did_data?.public_keys?.map(	16!
86	(key: Protos.io.iohk.atala.prism.protos.PublicKey) => {
87	const publicKey = key.has_compressed_ec_key_data	33!
88	? Secp256k1PublicKey.secp256k1FromBytes(
89	key.compressed_ec_key_data.data
90	)
91	: Secp256k1PublicKey.secp256k1FromByteCoordinates(
92	key.ec_key_data.x,
93	key.ec_key_data.y
94	);
95
96	return new PrismDIDPublicKey(	33✔
97	getUsageId(getUsage(key.usage)),
98	getUsage(key.usage),
99	publicKey
100	);
101	}
102	) \|\| [];
103
104	const services =
105	operation.create_did?.did_data?.services?.reduce<DIDDocumentService[]>(	16!
106	(acc, service) => {
107	const endpoint = service.service_endpoint.at(0);	4✔
108
109	if (endpoint === undefined) return acc;	4!
110
111	return acc.concat(	4✔
112	new DIDDocumentService(
113	service.id,
114	[service.type],
115	new DIDDocumentServiceEndpoint(endpoint)
116	)
117	);
118	},
119	[]
120	) ?? [];
121
122	const verificationMethods = publicKeys.reduce(	16✔
123	(partialResult, publicKey) => {
124	/**
125	* TODO: Support keys in multiple formats, right now its multibase
126	*/
127	const didUrl = new DIDUrl(did, [], new Map(), publicKey.id);	33✔
128	const curve = publicKey.keyData.getProperty(KeyProperties.curve);	33✔
129	if (!curve) {	33!
130	throw new CastorError.InvalidKeyError();	×
131	}
132	const method = new DIDDocumentVerificationMethod(	33✔
133	didUrl.string(),
134	did.toString(),
135	curve,
136	undefined,
137	base58.base58btc.encode(publicKey.keyData.raw)
138	);
139	partialResult.set(didUrl.string(), method);	33✔
140	return partialResult;	33✔
141	},
142	new Map<string, DIDDocumentVerificationMethod>()
143	);
144
145	return [verificationMethods, services];	16✔
146	} catch (err) {
147	throw new CastorError.InitialStateOfDIDChanged();	×
148	}
149	}
150	}

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

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