add token cache

docker-compose.dev.yml

@@ -76,11 +76,6 @@ services:
     extends:
       file: docker-compose.yml
       service: oid4vc-tanglelabs
-    environment:
-      RP_DID: did:iota:snd:0x2cfb60f00089a91a96fa8fcee5e2bda15f51b0b062762ad9ca846bba536f8818
-      SIGNER_KEYID: pK0JAYw5RFFKqorBn0x4w98zl2UBfRys
-      KEY_FRAGMENT: key-1
-      PUBLIC_URL: "bank.selv.local"
     labels:
       traefik.enable: true
       traefik.http.routers.oid4vc-tanglelabs.rule: Host(`bank.selv.local`)

oid4vc/TangleLabs/package.json

@@ -18,7 +18,8 @@
     "@types/express": "^4.17.21",
     "express": "^4.18.2",
     "express-async-handler": "^1.2.0",
-    "key-did-resolver": "^4.0.0"
+    "key-did-resolver": "^4.0.0",
+    "memory-cache-node": "^1.4.0"
   },
   "devDependencies": {
     "ts-node": "^10.9.2"

oid4vc/TangleLabs/src/cache.ts

@@ -0,0 +1,35 @@
+import pkg from 'memory-cache-node';
+const { MemoryCache } = pkg;
+import type { MemoryCache as IMemoryCache } from 'memory-cache-node';
+
+const itemsExpirationCheckIntervalInSecs = 10 * 60;
+const maxItemCount = 1000000;
+
+export class Cache<K,V> {
+
+    memoryCache: IMemoryCache<K,V>;
+
+    private constructor(memoryCache) {
+        this.memoryCache = memoryCache; 
+    }
+
+    static async init<K,V>() {
+        return new Cache<K,V>(new MemoryCache<K,V>(itemsExpirationCheckIntervalInSecs, maxItemCount));
+    }
+
+    async storeItem(key: K, item: V) {
+        return this.memoryCache.storePermanentItem(key, item);
+    }
+
+    async hasItem(key: K) {
+        return this.memoryCache.hasItem(key);
+    }
+
+    async consumeItem(key: K) {
+        const item = this.memoryCache.retrieveItemValue(key);
+        this.memoryCache.removeItem(key);
+        return item;
+    }
+
+    private generate
+}

oid4vc/TangleLabs/src/grpcService.ts

@@ -1,48 +1,47 @@
 import path from "path";
 import * as grpc from "@grpc/grpc-js";
 import { loadSync } from "@grpc/proto-loader";
-import {
-  AuthResponse,
-  RelyingParty,
-  SiopRequestResult,
-  VcIssuer,
-} from "@tanglelabs/oid4vc";
+import { RelyingParty, SiopRequestResult, VcIssuer } from "@tanglelabs/oid4vc";
 import { PresentationDefinitionV2 } from "@sphereon/pex-models";
+import { Cache } from "./cache";
 
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
+const crypto = await import('node:crypto');
+
+import { fileURLToPath } from "url";
+import { dirname } from "path";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
 const getPackageDefinition = (protoFile: string): grpc.GrpcObject => {
-  const protoPath = path.join(
-    __dirname,
-    "..",
-    "..",
-    "..",
-    protoFile
-  );
+  const protoPath = path.join(__dirname, "..", "..", "..", protoFile);
   const packageDefinition = loadSync(protoPath);
   return grpc.loadPackageDefinition(packageDefinition);
-}
-
-export const createService = async (rp: RelyingParty, issuer: VcIssuer) => {
+};
 
+export const createService = async (
+  rp: RelyingParty,
+  issuer: VcIssuer,
+  tokenCache: Cache<string, any>,
+  credentialCache: Cache<string, any>
+) => {
   async function createSIOPRequest(
-    call: grpc.ServerUnaryCall<
-      { state: any; nonce: string },
-      any
-    >,
+    call: grpc.ServerUnaryCall<{ state: any; nonce: string }, any>,
     callback: grpc.sendUnaryData<SiopRequestResult>
   ): Promise<void> {
+    const requestId = crypto.randomUUID();
     const request = await rp.createRequest({
-      requestBy: "value",
+      requestBy: "reference",
+      requestUri: `${process.env.PUBLIC_URL}/offer/${requestId}`,
       responseType: "id_token",
       state: call.request.state,
       nonce: call.request.nonce,
     });
+
+    tokenCache.storeItem(requestId, request.request);
+
     if (request) {
+      /// should just be uri
       callback(null, request);
     } else {
       callback({
@@ -51,21 +50,26 @@ export const createService = async (rp: RelyingParty, issuer: VcIssuer) => {
       });
     }
   }
-  
+
   async function createOID4VPRequest(
     call: grpc.ServerUnaryCall<
       { presentationDefinition: any; state: any; nonce: string },
       any
     >,
     callback: grpc.sendUnaryData<SiopRequestResult>
   ): Promise<void> {
+    const requestId = crypto.randomUUID();
     const request = await rp.createRequest({
       presentationDefinition: call.request.presentationDefinition,
-      requestBy: "value",
+      requestBy: "reference",
+      requestUri: `${process.env.PUBLIC_URL}/offer/${requestId}`,
       responseType: "vp_token",
       state: call.request.state,
       nonce: call.request.nonce,
     });
+
+    tokenCache.storeItem(requestId, request.request);
+
     if (request) {
       callback(null, request);
     } else {
@@ -78,18 +82,24 @@ export const createService = async (rp: RelyingParty, issuer: VcIssuer) => {
 
   async function createOID4VCIOffer(
     call: grpc.ServerUnaryCall<
-      { credentials: string[] },
+      { credentials: string[]; state: any; nonce: string },
       any
     >,
-    callback: grpc.sendUnaryData<{uri: string, offer: any}>
+    callback: grpc.sendUnaryData<{ uri: string; offer: any }>
   ): Promise<void> {
-    const offer = await issuer.createCredentialOffer({
-      credentials: call.request.credentials,
-      requestBy: "value",
-    });
+    const requestId = crypto.randomUUID();
+    const offer = await issuer.createCredentialOffer(
+      {
+        credentials: call.request.credentials,
+        requestBy: "reference",
+        credentialOfferUri: `${process.env.PUBLIC_URL}/credential-offer/${requestId}`,
+      },
+      { state: call.request.state }
+    );
+    tokenCache.storeItem(requestId, offer.offer);
     if (offer) {
       console.log(JSON.stringify(offer.offer));
-      callback(null, {uri: offer.uri, offer: JSON.stringify(offer.offer)});
+      callback(null, { uri: offer.uri, offer: JSON.stringify(offer.offer) });
     } else {
       callback({
         message: "Could not create offer",
@@ -98,30 +108,36 @@ export const createService = async (rp: RelyingParty, issuer: VcIssuer) => {
     }
   }
 
-
   const gRPCServer = new grpc.Server();
-  //@ts-ignore
-  gRPCServer.addService(getPackageDefinition("proto/oid4vc/siopv2.proto").oid4vc.SIOPV2.service, {
-    createRequest: createSIOPRequest,
-  });
-  //@ts-ignore
-  gRPCServer.addService(getPackageDefinition("proto/oid4vc/oid4vp.proto").oid4vc.OID4VP.service, {
-    createRequest: createOID4VPRequest,
-  });
-  //@ts-ignore
-  gRPCServer.addService(getPackageDefinition("proto/oid4vc/oid4vci.proto").oid4vc.OID4VCI.service, {
-    createOffer: createOID4VCIOffer,
-  });
+  gRPCServer.addService(
+    //@ts-ignore
+    getPackageDefinition("proto/oid4vc/siopv2.proto").oid4vc.SIOPV2.service,
+    {
+      createRequest: createSIOPRequest,
+    }
+  );
+  gRPCServer.addService(
+    //@ts-ignore
+    getPackageDefinition("proto/oid4vc/oid4vp.proto").oid4vc.OID4VP.service,
+    {
+      createRequest: createOID4VPRequest,
+    }
+  );
+  gRPCServer.addService(
+    //@ts-ignore
+    getPackageDefinition("proto/oid4vc/oid4vci.proto").oid4vc.OID4VCI.service,
+    {
+      createOffer: createOID4VCIOffer,
+    }
+  );
   gRPCServer.bindAsync(
     "0.0.0.0:50051",
     grpc.ServerCredentials.createInsecure(),
     (err, port) => {
-      if(err){
+      if (err) {
         throw err;
       }
       console.log(`gRPC server listening on port ${port}`);
     }
   );
-
-
 };