@learncard/create-http-bridge 1.1.34

package/esbuildWasmPlugin.cjs

@@ -0,0 +1,31 @@
+const wasmPlugin = {
+    name: 'wasm',
+    setup(build) {
+        let path = require('path');
+        let fs = require('fs');
+
+        // Resolve ".wasm" files to a path with a namespace
+        build.onResolve({ filter: /\.wasm$/ }, args => {
+            if (args.resolveDir === '') {
+                return; // Ignore unresolvable paths
+            }
+            return {
+                path: path.isAbsolute(args.path)
+                    ? args.path
+                    : path.join(args.resolveDir, args.path),
+                namespace: 'wasm-binary',
+            };
+        });
+
+        // Virtual modules in the "wasm-binary" namespace contain the
+        // actual bytes of the WebAssembly file. This uses esbuild's
+        // built-in "binary" loader instead of manually embedding the
+        // binary data inside JavaScript code ourselves.
+        build.onLoad({ filter: /.*/, namespace: 'wasm-binary' }, async args => ({
+            contents: await fs.promises.readFile(args.path),
+            loader: 'binary',
+        }));
+    },
+};
+
+module.exports = [wasmPlugin];

package/lambda.ts

@@ -0,0 +1,18 @@
+import { APIGatewayProxyHandlerV2 } from 'aws-lambda';
+import serverlessHttp from 'serverless-http';
+
+import app from './src/app';
+import { getLearnCard } from './src/learn-card';
+
+const _handler = serverlessHttp(app);
+
+export const handler: APIGatewayProxyHandlerV2 = async (event, context) => {
+    if ((event as any).source === 'serverless-plugin-warmup') {
+        console.log('[Warmup] Initializing wallet...');
+        await getLearnCard(); // Intentionally don't wait for the wallet to init!
+        console.log('[Warmup] Done!');
+        return 'All done! 😄';
+    }
+
+    return _handler(event, context);
+};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@learncard/create-http-bridge",
+  "version": "1.1.34",
+  "description": "Instantly create and deploy a Learn Card Bridge HTTP API via AWS Lambda!",
+  "main": "dist/index.js",
+  "bin": "dist/index.js",
+  "author": "Learning Economy Foundation (www.learningeconomy.io)",
+  "license": "MIT",
+  "dependencies": {
+    "@rollup/plugin-json": "^4.1.0",
+    "commander": "^9.3.0",
+    "cors": "^2.8.5",
+    "express": "~4.16.1",
+    "figlet": "^1.5.2",
+    "immer": "^9.0.15",
+    "ink": "^3.2.0",
+    "ink-gradient": "^2.0.0",
+    "ink-spinner": "^4.0.3",
+    "ink-syntax-highlight": "^1.0.1",
+    "ink-text-input": "^4.0.3",
+    "ink-use-stdout-dimensions": "^1.0.5",
+    "inquirer": "^8.2.4",
+    "lookpath": "^1.2.2",
+    "react": "^18.2.0",
+    "rollup": "^2.71.1",
+    "rollup-plugin-esbuild": "^4.9.1",
+    "serverless-esbuild": "^1.25.0",
+    "serverless-http": "^3.0.1",
+    "serverless-plugin-warmup": "^8.1.0",
+    "simple-git": "^3.9.0",
+    "use-immer": "^0.7.0",
+    "zod": "^3.20.2",
+    "@learncard/core": "8.5.4",
+    "@learncard/types": "5.2.6"
+  },
+  "devDependencies": {
+    "@types/aws-lambda": "^8.10.106",
+    "@types/cors": "^2.8.12",
+    "@types/express": "^4.17.13",
+    "@types/figlet": "^1.5.4",
+    "@types/ink-gradient": "^2.0.1",
+    "@types/inquirer": "^8.2.1",
+    "@types/node": "^18.0.0",
+    "@types/react": "^17.0.2",
+    "nodemon": "^2.0.16",
+    "serverless-plugin-typescript": "^2.1.0",
+    "shx": "^0.3.4",
+    "ts-node": "^10.8.1",
+    "typescript": "^4.7.4"
+  },
+  "scripts": {
+    "serverless-deploy": "shx cp ../learn-card-core/src/didkit/pkg/didkit_wasm_bg.wasm src/didkit_wasm_bg.wasm && serverless deploy",
+    "start": "rollup -c && node dist/index.js",
+    "build": "rollup -c"
+  }
+}

package/project.json

@@ -0,0 +1,22 @@
+{
+    "$schema": "../../node_modules/nx/schemas/project-schema.json",
+    "name": "create-http-bridge",
+    "sourceRoot": "packages/learn-card-bridge-http/src",
+    "projectType": "library",
+    "root": "packages/learn-card-bridge-http",
+    "tags": [],
+    "implicitDependencies": ["types", "core"],
+    "namedInputs": {
+        "source": ["{projectRoot}/src/**/*"],
+        "dist": ["{projectRoot}/dist/**/*"]
+    },
+    "targets": {
+        "build": {
+            "executor": "nx:run-script",
+            "inputs": ["source"],
+            "options": {
+                "script": "build"
+            }
+        }
+    }
+}

package/rollup.config.js

@@ -0,0 +1,12 @@
+import json from '@rollup/plugin-json';
+import esbuild from 'rollup-plugin-esbuild';
+
+const packageJson = require('./package.json');
+
+export default [
+    {
+        input: ['cli/index.tsx'],
+        output: [{ file: packageJson.bin, format: 'cjs', banner: '#!/usr/bin/env node' }],
+        plugins: [json(), esbuild()],
+    },
+];

package/serverless.yml

@@ -0,0 +1,56 @@
+# serverless.yml
+
+useDotenv: true
+
+service: learn-card-http-bridge
+
+plugins:
+    - serverless-esbuild
+    - serverless-plugin-warmup
+
+custom:
+    esbuild:
+        packager: pnpm
+        plugins: esbuildWasmPlugin.cjs
+    warmup:
+        default:
+            enabled: true
+
+provider:
+    name: aws
+    runtime: nodejs14.x
+    stage: dev
+    region: us-east-1
+    timeout: 29
+    httpApi:
+        cors: true
+    environment:
+        WALLET_SEED: ${env:WALLET_SEED}
+
+functions:
+    api:
+        handler: lambda.handler
+        memorySize: 2048
+        events:
+            - httpApi: 'GET /'
+            - httpApi: 'GET /did'
+            - httpApi: 'GET /credentials'
+            - httpApi: 'GET /credentials/{id}'
+            - httpApi: 'DELETE /credentials/{id}'
+            - httpApi: 'POST /credentials/issue'
+            - httpApi: 'POST /credentials/status'
+            - httpApi: 'POST /credentials/verify'
+            - httpApi: 'POST /credentials/derive'
+            - httpApi: 'POST /presentations/issue'
+            - httpApi: 'POST /presentations/verify'
+            - httpApi: 'POST /presentations/prove'
+            - httpApi: 'GET /presentations'
+            - httpApi: 'GET /presentations/{id}'
+            - httpApi: 'DELETE /presentations/{id}'
+            - httpApi: 'POST /exchanges/{exchangeId}'
+            - httpApi: 'POST /exchanges/{exchangeId}/{transactionId}'
+        warmup:
+            default:
+                enabled:
+                    - dev
+                    - prod

package/src/app.ts

@@ -0,0 +1,297 @@
+import express from 'express';
+import cors from 'cors';
+import { VP, VPValidator } from '@learncard/types';
+
+import { TypedRequest } from './types.helpers';
+import {
+    IssueEndpoint,
+    IssueEndpointValidator,
+    IssuePresentationEndpointValidator,
+    UpdateStatusEndpoint,
+    VerifyCredentialEndpoint,
+    VerifyCredentialEndpointValidator,
+    VerifyPresentationEndpoint,
+    VerifyPresentationEndpointValidator,
+} from './validators';
+import { getLearnCard } from './learn-card';
+
+const router = express.Router();
+
+const app = express();
+
+app.use(cors());
+app.use(express.json());
+
+app.get('/', async (_req: TypedRequest<{}>, res) => {
+    res.sendStatus(501);
+});
+
+// This is non-standard! But very helpful for the VC-API plugin
+app.get('/did', async (_req: TypedRequest<{}>, res) => {
+    const learnCard = await getLearnCard();
+
+    res.status(200).send(learnCard.id.did());
+});
+
+app.get('/credentials', async (_req: TypedRequest<{}>, res) => {
+    res.sendStatus(501);
+});
+
+app.get('/credentials/:id', async (req: TypedRequest<{}>, res) => {
+    console.log('credentials' + req.params.id);
+    res.sendStatus(501);
+});
+
+app.delete('/credentials/:id', async (_req: TypedRequest<{}>, res) => {
+    res.sendStatus(501);
+});
+
+app.post('/credentials/issue', async (req: TypedRequest<IssueEndpoint>, res) => {
+    try {
+        // If incoming credential doesn't have an issuanceDate, default it to right now
+        if (req.body?.credential && !('issuanceDate' in (req.body?.credential ?? {}))) {
+            req.body.credential.issuanceDate = new Date().toISOString();
+        }
+
+        const validationResult = await IssueEndpointValidator.spa(req.body);
+
+        if (!validationResult.success) {
+            console.error(
+                '[/credentials/issue] Validation error: ',
+                validationResult.error.message,
+                '(received: ',
+                req.body,
+                ')'
+            );
+            return res.status(400).json(`Invalid input: ${validationResult.error.message}`);
+        }
+
+        const validatedBody = validationResult.data;
+        const learnCard = await getLearnCard();
+        const { credentialStatus, ...options } = validatedBody.options ?? {};
+
+        const issuedCredential = await learnCard.invoke.issueCredential(
+            validatedBody.credential,
+            options
+        );
+
+        return res.status(201).json(issuedCredential);
+    } catch (error) {
+        console.error('[/credentials/issue] Caught error: ', error, '(received: ', req.body);
+        return res.status(400).json(`Invalid input: ${error}`);
+    }
+});
+
+app.post('/credentials/status', async (_req: TypedRequest<UpdateStatusEndpoint>, res) => {
+    res.sendStatus(501);
+});
+
+app.post('/credentials/verify', async (req: TypedRequest<VerifyCredentialEndpoint>, res) => {
+    try {
+        const validationResult = await VerifyCredentialEndpointValidator.spa(req.body);
+
+        if (!validationResult.success) {
+            console.error(
+                '[/credentials/verify] Validation error: ',
+                validationResult.error.message,
+                '(received: ',
+                req.body,
+                ')'
+            );
+            return res.status(400).json(`Invalid input: ${validationResult.error.message}`);
+        }
+
+        const validatedBody = validationResult.data;
+        const learnCard = await getLearnCard();
+
+        const verificationResult = await learnCard.invoke.verifyCredential(
+            validatedBody.verifiableCredential,
+            validatedBody.options
+        );
+
+        if (verificationResult.errors.length > 0) {
+            console.error(
+                '[/credentials/verify] Verification error(s): ',
+                verificationResult.errors,
+                '(received: ',
+                req.body
+            );
+            return res.status(400).json(verificationResult);
+        }
+
+        // Pass a test for interop 🙃
+        verificationResult.checks = verificationResult.checks.filter(
+            check => check !== 'expiration'
+        );
+
+        return res.status(200).json(verificationResult);
+    } catch (error) {
+        console.error('[/credentials/verify] Caught error: ', error, '(received: ', req.body);
+        return res.status(400).json(`Invalid input: ${error}`);
+    }
+});
+
+app.post('/credentials/derive', async (_req: TypedRequest<{}>, res) => {
+    res.sendStatus(501);
+});
+
+// This is non-standard! But very helpful for the VC-API plugin
+app.post('/presentations/issue', async (req: TypedRequest<IssueEndpoint>, res) => {
+    try {
+        const validationResult = await IssuePresentationEndpointValidator.spa(req.body);
+
+        if (!validationResult.success) {
+            console.error(
+                '[/presentations/issue] Validation error: ',
+                validationResult.error.message,
+                '(received: ',
+                req.body,
+                ')'
+            );
+            return res.status(400).json(`Invalid input: ${validationResult.error.message}`);
+        }
+
+        const validatedBody = validationResult.data;
+        const learnCard = await getLearnCard();
+
+        const issuedPresentation = await learnCard.invoke.issuePresentation(
+            validatedBody.presentation,
+            validatedBody.options
+        );
+
+        return res.status(201).json(issuedPresentation);
+    } catch (error) {
+        console.error('[/presentations/issue] Caught error: ', error, '(received: ', req.body);
+        return res.status(400).json(`Invalid input: ${error}`);
+    }
+});
+
+app.post('/presentations/verify', async (req: TypedRequest<VerifyPresentationEndpoint>, res) => {
+    try {
+        const validationResult = await VerifyPresentationEndpointValidator.spa(req.body);
+
+        if (!validationResult.success) {
+            console.error(
+                '[/presentations/verify] Validation error: ',
+                validationResult.error.message,
+                '(received: ',
+                req.body,
+                ')'
+            );
+            return res.status(400).json(`Invalid input: ${validationResult.error.message}`);
+        }
+
+        const validatedBody = validationResult.data;
+        const learnCard = await getLearnCard();
+
+        if ('presentation' in validatedBody) return res.sendStatus(501);
+
+        const verificationResult = await learnCard.invoke.verifyPresentation(
+            validatedBody.verifiablePresentation,
+            validatedBody.options
+        );
+
+        if (verificationResult.errors.length > 0) {
+            console.error(
+                '[/presentations/verify] Verification error(s): ',
+                verificationResult.errors,
+                '(received: ',
+                req.body
+            );
+            return res.status(400).json(verificationResult);
+        }
+
+        return res.status(200).json(verificationResult);
+    } catch (error) {
+        console.error('[/presentations/verify] Caught error: ', error, '(received: ', req.body);
+        return res.status(400).json(`Invalid input: ${error}`);
+    }
+});
+
+app.post('/presentations/prove', async (_req: TypedRequest<{}>, res) => {
+    res.sendStatus(501);
+});
+
+app.get('/presentations', async (_req: TypedRequest<{}>, res) => {
+    res.sendStatus(501);
+});
+
+app.get('/presentations/:id', async (_req: TypedRequest<{}>, res) => {
+    res.sendStatus(501);
+});
+
+app.delete('/presentations/:id', async (_req: TypedRequest<{}>, res) => {
+    res.sendStatus(501);
+});
+
+app.post('/exchanges/:uri', async (req: TypedRequest<VP, { challenge?: string }>, res) => {
+    try {
+        const validationResult = await VPValidator.spa(req.body);
+
+        if (!validationResult.success) {
+            console.error(
+                '[/exchanges/:uri] Validation error: ',
+                validationResult.error.message,
+                '(received: ',
+                req.body,
+                ')'
+            );
+            return res.status(400).json(`Invalid input: ${validationResult.error.message}`);
+        }
+
+        const validatedBody = validationResult.data;
+        const learnCard = await getLearnCard();
+        const challenge = Array.isArray(validatedBody.proof)
+            ? validatedBody.proof[0]?.challenge
+            : validatedBody.proof.challenge;
+
+        const verification = await learnCard.invoke.verifyPresentation(validatedBody, {
+            challenge,
+            proofPurpose: 'authentication',
+        });
+
+        if (verification.warnings.length > 0 || verification.errors.length > 0) {
+            console.error(
+                '[/exchanges/:uri] Validation error: ',
+                verification,
+                '(received: ',
+                req.body,
+                ')'
+            );
+            return res
+                .status(400)
+                .json({ reason: 'Invalid DID Auth VP', verificationResult: verification });
+        }
+
+        const subject = validatedBody.holder;
+
+        const credential = await learnCard.read.get(req.params.uri);
+
+        credential.issuer = {
+            ...(typeof credential.issuer === 'string' ? {} : credential.issuer),
+            id: learnCard.id.did(),
+        };
+        credential.issuanceDate = new Date().toISOString();
+
+        if (!Array.isArray(credential.credentialSubject) && subject) {
+            credential.credentialSubject.id = subject;
+        }
+
+        delete credential.proof;
+
+        const newVc = await learnCard.invoke.issueCredential(credential);
+
+        return res.status(201).json(newVc);
+    } catch (error) {
+        console.error('[/exchanges/:uri] Caught error: ', error, '(received: ', req.body);
+        return res.status(400).json(`Invalid input: ${error}`);
+    }
+});
+
+app.post('/exchanges/:exchangeId/:transactionId', async (_req: TypedRequest<{}>, res) => {
+    res.sendStatus(501);
+});
+
+app.use('', router);
+
+export default app;

package/src/learn-card.ts

@@ -0,0 +1,13 @@
+import fs from 'fs/promises';
+import { initLearnCard } from '@learncard/core';
+import didkit from './didkit_wasm_bg.wasm';
+
+export const getLearnCard = async () => {
+    const seed = process.env.WALLET_SEED;
+
+    if (!seed) {
+        throw new Error('No seed set! Please make a .env file and set WALLET_SEED to your seed!');
+    }
+
+    return initLearnCard({ seed, didkit });
+};

package/src/types.helpers.ts

@@ -0,0 +1,7 @@
+import Express from 'express';
+import { Query } from 'express-serve-static-core';
+
+export interface TypedRequest<T, U extends Query = {}> extends Express.Request {
+    body: T;
+    query: U;
+}

package/src/validators.ts

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+import {
+    UnsignedVCValidator,
+    UnsignedVPValidator,
+    VCValidator,
+    VPValidator,
+} from '@learncard/types';
+
+export const IssueEndpointValidator = z.object({
+    credential: UnsignedVCValidator,
+    options: z
+        .object({
+            created: z.string().optional(),
+            challenge: z.string().optional(),
+            domain: z.string().optional(),
+            credentialStatus: z.object({ type: z.string() }).optional(),
+        })
+        .optional(),
+});
+export type IssueEndpoint = z.infer<typeof IssueEndpointValidator>;
+
+export const IssuePresentationEndpointValidator = z.object({
+    presentation: UnsignedVPValidator,
+    options: z
+        .object({
+            created: z.string().optional(),
+            challenge: z.string().optional(),
+            domain: z.string().optional(),
+        })
+        .optional(),
+});
+export type IssuePresentationEndpoint = z.infer<typeof IssuePresentationEndpointValidator>;
+
+export const UpdateStatusEndpointValidator = z.object({
+    credentialId: z.string(),
+    credentialStatus: z
+        .object({ type: z.string().optional(), status: z.string().optional() })
+        .array()
+        .optional(),
+});
+export type UpdateStatusEndpoint = z.infer<typeof UpdateStatusEndpointValidator>;
+
+export const VerifyCredentialEndpointValidator = z.object({
+    verifiableCredential: VCValidator,
+    options: z
+        .object({ challenge: z.string().optional(), domain: z.string().optional() })
+        .optional(),
+});
+export type VerifyCredentialEndpoint = z.infer<typeof VerifyCredentialEndpointValidator>;
+
+export const VerifyPresentationEndpointValidator = z
+    .object({
+        verifiablePresentation: VPValidator,
+        options: z
+            .object({ challenge: z.string().optional(), domain: z.string().optional() })
+            .optional(),
+    })
+    .or(z.object({ presentation: UnsignedVPValidator }));
+export type VerifyPresentationEndpoint = z.infer<typeof VerifyPresentationEndpointValidator>;

package/tsconfig.json

@@ -0,0 +1,36 @@
+{
+    "compilerOptions": {
+        "lib": ["es2017"],
+        "module": "esnext",
+        "moduleResolution": "node",
+        "resolveJsonModule": true,
+        "removeComments": true,
+        "preserveConstEnums": true,
+        "strict": true,
+        "alwaysStrict": true,
+        "strictNullChecks": true,
+        "noUncheckedIndexedAccess": true,
+        "jsx": "react",
+
+        "noImplicitAny": true,
+        "noImplicitReturns": true,
+        "noImplicitThis": true,
+        "noUnusedLocals": true,
+        "noUnusedParameters": true,
+        "allowUnreachableCode": false,
+        "noFallthroughCasesInSwitch": true,
+
+        "target": "es2017",
+        "outDir": "dist",
+        "declaration": true,
+        "sourceMap": true,
+        "baseUrl": ".",
+
+        "esModuleInterop": true,
+        "allowSyntheticDefaultImports": true,
+        "allowJs": false,
+        "skipLibCheck": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "exclude": ["./dist/**/*", "./node_modules/**/*"]
+}