feat: feats

e2e/fixtures/externalVC.ts

@@ -1,4 +1,6 @@
-export const validExemplaryExternalVC = {
+// Source: https://github.com/spruceid/ssi/blob/3745b7dfdd18e1b27c6135f8036470efde596f35/did-pkh/tests/vc-eth-eip712sig.jsonld
+
+export const validExampleExternalVC = {
   '@context': ['https://www.w3.org/2018/credentials/v1'],
   type: ['VerifiableCredential'],
   credentialSubject: {
@@ -86,7 +88,7 @@ export const validExemplaryExternalVC = {
   },
 };
 
-export const invalidExemplaryExternalVC = {
+export const invalidExampleExternalVC = {
   '@context': ['https://www.w3.org/2018/credentials/v1'],
   type: ['VerifiableCredential'],
   credentialSubject: {

e2e/verifiableCredentials.service.e2e.ts

@@ -1,14 +1,12 @@
 import { Wallet } from 'ethers';
 import { v4 as uuid } from 'uuid';
-import {
-  invalidExemplaryExternalVC,
-  validExemplaryExternalVC,
-} from './fixtures';
+import { invalidExampleExternalVC, validExampleExternalVC } from './fixtures';
 import { replenish, rpcUrl, setupENS } from './utils/setup_contracts';
-import { fromPrivateKey, VerifiableCredentialsService } from '../src';
+import { fromPrivateKey } from '../src';
+import { VerifiableCredentialsServiceNode } from '../src/modules/verifiableCredentials/verifiableCredentialsNode.service';
 
 describe('Verifiable credentials tests', () => {
-  let verifiableCredentialsService: VerifiableCredentialsService;
+  let verifiableCredentialsService: VerifiableCredentialsServiceNode;
   let rootOwnerDid: string;
   const rootOwnerWallet = Wallet.createRandom();
   const rootOwnerAddress = rootOwnerWallet.address;
@@ -25,9 +23,8 @@ describe('Verifiable credentials tests', () => {
     await signerService.publicKeyAndIdentityToken();
 
     rootOwnerDid = signerService.didHex;
-    verifiableCredentialsService = await VerifiableCredentialsService.create(
-      signerService
-    );
+    verifiableCredentialsService =
+      await VerifiableCredentialsServiceNode.create(signerService);
   });
 
   test('should create a VC proof', async () => {
@@ -123,7 +120,7 @@ describe('Verifiable credentials tests', () => {
   test('should verify valid external VC', async () => {
     const isValid =
       await verifiableCredentialsService.verifyVerifiableCredential(
-        validExemplaryExternalVC
+        validExampleExternalVC
       );
 
     expect(isValid).toBe(true);
@@ -132,7 +129,7 @@ describe('Verifiable credentials tests', () => {
   test('should throw an error for invalid external VC', async () => {
     await expect(
       verifiableCredentialsService.verifyVerifiableCredential(
-        invalidExemplaryExternalVC
+        invalidExampleExternalVC
       )
     ).rejects.toMatchObject({
       message: expect.stringContaining('Verifiable Credential is invalid'),

package.json

@@ -77,7 +77,6 @@
     "@gnosis.pm/safe-apps-provider": "0.8.0",
     "@gnosis.pm/safe-apps-sdk": "4.3.0",
     "@metamask/detect-provider": "^1.2.0",
-    "@spruceid/didkit-wasm-node": "^0.1.7-rc0",
     "@walletconnect/ethereum-provider": "^1.7.1",
     "axios": "^0.26.0",
     "base64url": "^3.0.1",

src/init.ts

@@ -22,6 +22,7 @@ import {
   defaultKmsServerUrl,
 } from './utils';
 import { chainConfigs } from './config';
+import { getVerifiableCredentialsService } from './modules/verifiableCredentials';
 
 export async function initWithPrivateKeySigner(
   privateKey: string,
@@ -61,6 +62,9 @@ export async function initWithEKC(proxyUrl = defaultAzureProxyUrl) {
 
 export async function init(signerService: SignerService) {
   const messagingService = await MessagingService.create(signerService);
+  const verifiableCredentialsService = await getVerifiableCredentialsService(
+    signerService
+  );
 
   async function connectToCacheServer() {
     const chainId = signerService.chainId;
@@ -116,6 +120,7 @@ export async function init(signerService: SignerService) {
   return {
     signerService,
     messagingService,
+    verifiableCredentialsService,
     connectToCacheServer,
   };
 }

src/modules/signer/signer.service.ts

@@ -167,7 +167,9 @@ export class SignerService {
 
   get didHex() {
     const chainBn = BigNumber.from(this.chainId);
-    return `did:${Methods.Erc1056}:${chainBn.toHexString()}:${this._address}`;
+    return `did:${
+      Methods.Erc1056
+    }:${chainBn.toHexString()}:${this._address.toLowerCase()}`;
   }
 
   async send({

src/modules/verifiableCredentials/index.ts

@@ -1,2 +1,26 @@
-export * from './verifiableCredentials.service';
 export * from './verifiableCredentials.types';
+
+import { SignerService } from '../signer';
+import { VerifiableCredentialsServiceBase } from './verifiableCredentialsBase.service';
+
+export const getVerifiableCredentialsService = async (
+  signerService: SignerService
+): Promise<VerifiableCredentialsServiceBase> => {
+  const isNode =
+    typeof process !== 'undefined' &&
+    process.versions != null &&
+    process.versions.node != null;
+
+  let service: VerifiableCredentialsServiceBase;
+  if (isNode) {
+    service = await import('./verifiableCredentialsNode.service').then(
+      (module) => module.VerifiableCredentialsServiceNode.create(signerService)
+    );
+  } else {
+    service = await import('./verifiableCredentialsWeb.service').then(
+      (module) => module.VerifiableCredentialsServiceWeb.create(signerService)
+    );
+  }
+
+  return service;
+};

src/modules/verifiableCredentials/verifiableCredentials.service.ts → src/modules/verifiableCredentials/verifiableCredentialsBase.service.ts

@@ -1,8 +1,3 @@
-import {
-  prepareIssueCredential,
-  completeIssueCredential,
-} from 'didkit-wasm-node';
-import { verifyCredential } from '@spruceid/didkit-wasm-node';
 import { SignerService } from '../signer';
 import {
   SignedVerifiableCredential,
@@ -12,19 +7,36 @@ import {
   VerifyVerifiableCredentialResults,
 } from './verifiableCredentials.types';
 
-export class VerifiableCredentialsService {
-  constructor(private readonly _signerService: SignerService) {}
+export abstract class VerifiableCredentialsServiceBase {
+  abstract prepareIssueCredential: (
+    credential: string,
+    linked_data_proof_options: string,
+    public_key: string
+  ) => Promise<string>;
+  abstract completeIssueCredential: (
+    credential: string,
+    preparation: string,
+    signature: string
+  ) => Promise<string>;
+  abstract verifyCredential: (
+    vc: string,
+    proof_options: string
+  ) => Promise<string>;
+
+  constructor(protected readonly _signerService: SignerService) {}
 
-  static async create(signerService: SignerService) {
-    const service = new VerifiableCredentialsService(signerService);
-    return service;
+  static async create(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    signerService: SignerService
+  ): Promise<VerifiableCredentialsServiceBase> {
+    throw new Error('Not implemented');
   }
 
   public async verifyVerifiableCredential<T>(
     vc: SignedVerifiableCredential<T>,
     options?: VerifyVerifiableCredentialOptions
   ) {
-    const verifyResultsString = await verifyCredential(
+    const verifyResultsString = await this.verifyCredential(
       JSON.stringify(vc),
       JSON.stringify(options || {})
     );
@@ -93,7 +105,7 @@ export class VerifiableCredentialsService {
     };
 
     const stringifyCredential = JSON.stringify(credential);
-    const preparedVC = await prepareIssueCredential(
+    const preparedVC = await this.prepareIssueCredential(
       stringifyCredential,
       JSON.stringify(proofOptions),
       JSON.stringify(keyType)
@@ -113,7 +125,7 @@ export class VerifiableCredentialsService {
       typedData.message
     );
 
-    const signedCredential = await completeIssueCredential(
+    const signedCredential = await this.completeIssueCredential(
       stringifyCredential,
       preparedVC,
       signature

src/modules/verifiableCredentials/verifiableCredentialsNode.service.ts

@@ -0,0 +1,34 @@
+import {
+  prepareIssueCredential,
+  completeIssueCredential,
+  verifyCredential,
+} from 'didkit-wasm-node';
+import { SignerService } from '../signer';
+import { VerifiableCredentialsServiceBase } from './verifiableCredentialsBase.service';
+
+export class VerifiableCredentialsServiceNode extends VerifiableCredentialsServiceBase {
+  prepareIssueCredential: (
+    credential: string,
+    linked_data_proof_options: string,
+    public_key: string
+  ) => Promise<string>;
+  completeIssueCredential: (
+    credential: string,
+    preparation: string,
+    signature: string
+  ) => Promise<string>;
+  verifyCredential: (vc: string, proof_options: string) => Promise<string>;
+
+  constructor(_signerService: SignerService) {
+    super(_signerService);
+
+    this.completeIssueCredential = completeIssueCredential;
+    this.prepareIssueCredential = prepareIssueCredential;
+    this.verifyCredential = verifyCredential;
+  }
+
+  static async create(signerService: SignerService) {
+    const service = new VerifiableCredentialsServiceNode(signerService);
+    return service;
+  }
+}