[wip] showcase

Author: chfanghr

src/library/plugin/pluginType.ts

@@ -1,11 +1,71 @@
+import { json } from "body-parser";
+import { PublicKeyInput } from "crypto";
+import { RequestHandler } from "express";
 import { JsonProof } from "o1js";
+import { initialize } from "passport";
 
 export type PluginType = {
   compile: () => Promise<string>;
   getInputs: () => Promise<string[]>;
   verify: (
-      jsonProof: JsonProof,
-      verificationKey: string,
+    jsonProof: JsonProof,
+    verificationKey: string,
   ) => Promise<[string | boolean | undefined, string]>;
   prove: (inputs: string[]) => Promise<undefined | JsonProof>;
-};
+};
+
+export interface IMinAuthPlugin<PublicInputsArgs, Output> {
+  verifyAndGetOutput(
+    publicInputArgs: PublicInputsArgs,
+    serializedProof: JsonProof): Promise<undefined | Output>;
+
+  readonly customRoutes: Map<string, RequestHandler>;
+
+  readonly verificationKey: string;
+}
+
+export interface IMinAuthPluginFactory<
+  T extends IMinAuthPlugin<PublicInputsArgs, Output>,
+  Configuration, PublicInputsArgs, Output> {
+  initialize(cfg: Configuration): Promise<T>;
+}
+
+export abstract class MinAuthPlugin<Configuration, PublicInputsArgs, Output> {
+  abstract initialize(configuration: Configuration): Promise<string/*The verification key*/>;
+
+  abstract verifyAndGetOutput(
+    publicInputArgs: PublicInputsArgs,
+    serializedProof: JsonProof): Promise<undefined | Output>;
+
+  abstract readonly customRoutes: Map<string, RequestHandler>;
+}
+
+export abstract class MinAuthProver<Configuration, PublicInputsArgs, PublicInput, PrivateInput> {
+  abstract initialize(configuration: Configuration): Promise<void>;
+
+  abstract prove(publicInput: PublicInput, secretInput: PrivateInput):
+    Promise<undefined | JsonProof>;
+
+  abstract fetchPublicInputs(args: PublicInputsArgs): Promise<PublicInput>;
+}
+
+
+export function mkUntypedPlugin<
+  T extends IMinAuthPlugin<PublicInputsArgs, Output>,
+  Configuration, PublicInputsArgs, Output>(
+    type: IMinAuthPluginFactory<T, Configuration, PublicInputsArgs, Output>,
+  ): // Oh please let me use haskell
+  ((_: any) => Promise<IMinAuthPlugin<any, any>>) {
+  return async (cfg: any): Promise<IMinAuthPlugin<any, any>> => {
+    const obj = await type.initialize(cfg as Configuration);
+
+    return {
+      verifyAndGetOutput: async (
+        publicInputArgs: string,
+        serializedProof: JsonProof): Promise<undefined | any> =>
+        await obj.verifyAndGetOutput(publicInputArgs as PublicInputsArgs, serializedProof),
+      customRoutes: obj.customRoutes,
+      verificationKey: obj.verificationKey
+    };
+  };
+}

src/plugins/passwordTree/plugin/index.ts

@@ -89,3 +89,4 @@ export const SimplePasswordTree: PluginType = {
 }
 
 export default SimplePasswordTree;
+

src/plugins/simplePreimage/plugin/index.ts

@@ -1,6 +1,7 @@
 import { verify, Proof, Field, JsonProof, Experimental } from 'o1js';
-import { PluginType } from 'plugin/pluginType';
+import { IMinAuthPlugin, IMinAuthPluginFactory, MinAuthPlugin, PluginType } from 'plugin/pluginType';
 import ProvePreimageProgram, { ProvePreimageProofClass } from './hashPreimageProof';
+import { RequestHandler } from 'express';
 
 
 const roleMapping: Record<string, string> = {
@@ -54,3 +55,60 @@ export const SimplePreimage: PluginType = {
 };
 
 export default SimplePreimage;
+
+class SimplePreimagePlugin extends MinAuthPlugin<{ roles: Record<string, string> }, [], string>{
+    private roles: Record<string, string> = {};
+
+    async initialize(configuration: { roles: Record<string, string> }): Promise<string> {
+
+        const { verificationKey } = await ProvePreimageProgram.compile();
+
+        this.roles = configuration.roles;
+
+        return verificationKey;
+    };
+
+    async verifyAndGetOutput(_: [], serializedProof: JsonProof):
+        Promise<undefined | string> {
+        const proof = ProvePreimageProofClass.fromJSON(serializedProof);
+        const role = roleMapping[proof.publicOutput.toString()];
+        return role;
+    };
+
+    get customRoutes(): Map<string, RequestHandler> {
+        return new Map([["/roles", (_, res) => {
+            res.status(200).json(this.roles);
+        }]]);
+    }
+}
+
+class SimplePreimagePlugin_ implements IMinAuthPlugin<[], string>{
+    readonly verificationKey: string;
+    private readonly roles: Record<string, string>;
+
+    async verifyAndGetOutput(_: [], serializedProof: JsonProof):
+        Promise<undefined | string> {
+        const proof = ProvePreimageProofClass.fromJSON(serializedProof);
+        const role = roleMapping[proof.publicOutput.toString()];
+        return role;
+    };
+
+    get customRoutes(): Map<string, RequestHandler> {
+        return new Map([["/roles", (_, res) => {
+            res.status(200).json(this.roles);
+        }]]);
+    }
+
+    constructor(verificationKey: string, roles: Record<string, string>) {
+        this.verificationKey = verificationKey;
+        this.roles = roles;
+    }
+
+    static async initialize(configuration: { roles: Record<string, string> })
+        : Promise<SimplePreimagePlugin_> {
+        const { verificationKey } = await ProvePreimageProgram.compile();
+        return new SimplePreimagePlugin_(verificationKey, configuration.roles);
+    };
+}
+
+SimplePreimagePlugin_ satisfies IMinAuthPluginFactory<SimplePreimagePlugin_, { roles: Record<string, string> }, [], string>;