Reorganize data types #1

Author: adamczykm

minauth-plugins/minauth-verified-zkdocument-plugin/src/claim.ts

@@ -2,28 +2,8 @@ import { CircuitString, Field, Poseidon } from 'o1js';
 import { z } from 'zod';
 import { ClaimStruct, IClaimStruct } from './data/claims.js';
 import { FieldsSchema } from './data/simple.js';
+import { ClaimSchema_, ClaimStandard } from './data/transit-cred.js';
 
-export const ClaimStandardSchema = z.object({
-  standardId: z.string().min(2),
-  description: z.string(),
-  referenceToExternalStandard: z.string().optional(),
-  fieldsConversion: z.object({
-    length: z.number().int().min(1),
-    description: z.string(),
-    codeExample: z.string()
-  })
-});
-
-export type ClaimStandard = z.infer<typeof ClaimStandardSchema>;
-
-export function ClaimSchema<V>(valueSchema: z.ZodType<V>) {
-  return z.object({
-    name: z.string().min(1),
-    value: valueSchema,
-    fieldsValue: FieldsSchema,
-    standard: ClaimStandardSchema
-  });
-}
 
 export interface IClaim<V> {
   get name(): string;
@@ -50,7 +30,7 @@ export const claimStandardHash = (standard: ClaimStandard): Field => {
 // ==========================================
 // inline tests
 
-const TypeCheckerTestSchema = ClaimSchema(z.number());
+const TypeCheckerTestSchema = ClaimSchema_(z.number());
 type TypeCheckerTestType = z.infer<typeof TypeCheckerTestSchema>;
 const typeCheckerTestValue = undefined as unknown as TypeCheckerTestType;
 typeCheckerTestValue satisfies IClaim<number>;

minauth-plugins/minauth-verified-zkdocument-plugin/src/data/o1js/claim.ts

@@ -0,0 +1,164 @@
+import { Struct, Provable, Field } from 'o1js';
+import { ZodTypeAny, z } from 'zod';
+import { arraysAreEqual, ftn } from '../../helpers/utils.js';
+import { FieldsSchema } from './common.js';
+import { Claim } from '../transit/cred.js';
+
+const CLAIMS_MAX_SIZE = 128;
+
+export interface IClaimStruct {
+  get length(): Field;
+  get claimValue(): Field[];
+  toFields(): Field[];
+}
+
+export function mkClaimStruct(claim: Claim): IClaimStruct;
+export function mkClaimStruct(flds: Field[]): IClaimStruct;
+
+export function mkClaimStruct(claim: Claim | Field[]): IClaimStruct {
+  if (Array.isArray(claim)) {
+    return ClaimStruct(claim.length).fromFields(claim);
+  } else {
+    return ClaimStruct(claim.fieldsValue.length).fromFields(claim.fieldsValue.map(s => new Field(s)));
+  }
+}
+
+export interface IClaimStructClass {
+  new (claimValue: Field[]): IClaimStruct;
+  fromFields(fields: Field[]): IClaimStruct;
+  schema: z.ZodType<any>;
+}
+
+export interface IFieldClaims {
+  count: Field;
+  packed: Field[];
+  toFields(): Field[];
+  getClaim(ix: Field, assert: Field[]): Field[];
+}
+
+export const ClaimStruct = (length: number): IClaimStructClass => {
+  class Claim_
+    extends Struct({
+      length: Field,
+      claimValue: Provable.Array(Field, length)
+    })
+    implements IClaimStruct
+  {
+    constructor(claimValue: Field[]) {
+      if (claimValue.length !== length) {
+        throw new Error(`Invalid claim array size: ${claimValue.length}`);
+      }
+      super({ length: new Field(length), claimValue });
+    }
+
+    public toFields() {
+      return [this.length, ...this.claimValue];
+    }
+
+    static fromFields(fields: Field[]) {
+      const length = Number(fields[0].toBigInt());
+      if (fields.length !== length + 1) {
+        throw new Error(`Invalid claim array size: ${fields.length}`);
+      }
+      return new Claim_(fields.slice(1, length + 1));
+    }
+
+    static schema = z
+      .object({
+        claimValue: FieldsSchema.length(length)
+      })
+      .transform((o) => new Claim_(o.claimValue));
+  }
+
+  return Claim_ as IClaimStructClass;
+};
+
+
+export const computeClaimSizes = (claims: IClaimStruct[]) => {
+  return claims.map(c => ftn(c.length));
+};
+
+export const mkClaims = (claims: IClaimStruct[]): IFieldClaims => {
+  const size = computeClaimSizes(claims);
+  return Claims(size).fromClaims(claims);
+};
+
+export function Claims(claimSizes: number[]) {
+  if (claimSizes.length == 0) {
+    throw new Error('claimSizes must not be empty.');
+  }
+  const claimCount = claimSizes.length;
+  // 0 (start index) + indices + claims
+  const totalSize = 1 + claimCount + claimSizes.reduce((a, v) => a + v, 0);
+
+  if (totalSize > CLAIMS_MAX_SIZE) {
+    throw new Error(
+      `Total Claims size ${totalSize} exceeds the maximum size ${CLAIMS_MAX_SIZE}`
+    );
+  }
+
+  class Claims_
+    extends Struct({
+      count: Field,
+      packed: Provable.Array(Field, totalSize)
+    })
+    implements IFieldClaims
+  {
+    static MAX_SIZE = CLAIMS_MAX_SIZE;
+
+    public toFields() {
+      return [this.count, ...this.packed];
+    }
+
+    static fromClaims(claims: IClaimStruct[]) {
+      const receivedSizes = claims.map((c) => ftn(c.length));
+
+      if (!arraysAreEqual(receivedSizes, claimSizes)) {
+        throw new Error("'claims' array sizes are invalid");
+      }
+
+      let packed: Field[] = [];
+      // first push all locations
+      packed.push(new Field(0));
+      for (let i = 0; i < claims.length; i++) {
+        const claimEndIx = packed[i].add(claims[i].length);
+        packed.push(claimEndIx);
+      }
+      // then push all values
+      for (const claim of claims) {
+        packed.push(...claim.claimValue);
+      }
+
+      return new Claims_({ count: new Field(claims.length), packed });
+    }
+
+    static get schema() {
+      const claimSchemas = claimSizes.map(
+        (size) => ClaimStruct(size).schema
+      ) as [ZodTypeAny, ...ZodTypeAny[]];
+      return z
+        .tuple(claimSchemas)
+        .transform((claims) => Claims_.fromClaims(claims));
+    }
+
+    public getClaim(ix: Field, assert: Field[]): Field[] {
+      const i = Number(ix.toBigInt());
+      const length = Number(this.packed[i + 1].sub(this.packed[i]).toBigInt());
+      const c = Number(this.count.toBigInt());
+
+      const op = Provable.witness(Provable.Array(Field, length), () => {
+        const start = Number(this.packed[i].toBigInt());
+        const next = Number(this.packed[i + 1].toBigInt());
+        return this.packed.slice(c + 1 + start, c + 1 + next);
+      });
+
+      for (let j = 0; j < length; j++) {
+        op[j].assertEquals(assert[j]);
+      }
+
+      return op;
+    }
+  }
+
+  return Claims_;
+}

minauth-plugins/minauth-verified-zkdocument-plugin/src/data/o1js/common.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { Signature, Field, PublicKey, Struct } from "o1js"
+import * as T from "../transit/common.js";
+import { DateTime } from "luxon";
+
+export const FieldSchema = T.FieldSchema.transform(Field);
+
+export const FieldsSchema = z.array(FieldSchema);
+
+export const PublicKeySchema = T.PublicKeyB58Schema.transform(PublicKey.fromBase58);
+
+export const SignatureSchema = T.SignatureSchema.transform(Signature.fromBase58);
+
+export const UnixTimestampFieldSchema = T.DateTimeSchema.transform((dt) => {
+  const dt2 = dt || "";
+  const ts = DateTime.fromISO(dt2)
+  if (!ts.isValid) {
+    throw new Error(`Invalid timestamp: ${dt}`)
+  }
+  const seconds = ts.toUTC().toUnixInteger();
+
+  return new Field(seconds);
+})
+
+export class UnixTimestamp extends Struct({
+  unixTimestamp: Field
+}) {
+  static fromTransit(t: unknown) {
+    const unixTimestamp = UnixTimestampFieldSchema.parse(t);
+    return new UnixTimestamp({ unixTimestamp });
+  }
+  public toFields() {
+    return [this.unixTimestamp]
+  }
+}

minauth-plugins/minauth-verified-zkdocument-plugin/src/data/o1js/ids.ts

@@ -0,0 +1,57 @@
+import * as z from 'zod';
+import * as S from './common.js';
+import { Field, PublicKey, Struct } from 'o1js';
+import * as T from '../transit/cred.js';
+
+// =============== IDs ===============
+
+export const PubKeyIdSchema = z.object({
+  pubkey: S.PublicKeySchema
+});
+
+export type PubKeyId = z.infer<typeof PubKeyIdSchema>;
+
+export const IssuerIdSchema = PubKeyIdSchema;
+
+export class IssuerId extends Struct({
+  pubkey: PublicKey
+}) {
+  static fromTransit(t: T.IssuerId) {
+    const pubkey = S.PublicKeySchema.parse(t);
+    return new IssuerId({pubkey});
+  }
+
+  public toFields() {
+    return this.pubkey.toFields();
+  }
+}
+
+export const CredSubjectIdSchema = PubKeyIdSchema;
+
+export class CredSubjectId extends Struct({
+  pubkey: PublicKey
+}) {
+  static fromTransit(t: T.CredSubjectId) {
+    const pubkey = S.PublicKeySchema.parse(t);
+    return new CredSubjectId({pubkey});
+  }
+
+  public toFields() {
+    return this.pubkey.toFields();
+  }
+}
+
+export class VCredId extends Struct({
+  id: Field
+}) {
+  static fromTransit(t: T.VCredId) {
+    const id = S.FieldSchema.parse(t);
+    return new VCredId({id});
+  }
+
+  public toFields() {
+    return this.id.toFields();
+  }
+}
+
+

minauth-plugins/minauth-verified-zkdocument-plugin/src/data/o1js/vcred.ts

@@ -0,0 +1,89 @@
+import { Struct, Field, Signature } from 'o1js';
+import {
+  SignatureSchema,
+  FieldSchema,
+  UnixTimestamp
+} from './common.js';
+import { Claims, mkClaimStruct, mkClaims } from './claim.js';
+import { CredSubjectId, IssuerId, VCredId } from './ids.js';
+import { Credential, CredentialData } from '../transit/cred.js';
+
+export function VCredStructUnsigned(claimSizes: number[]) {
+  const ClaimsType = Claims(claimSizes);
+
+  const Data = {
+    id: VCredId,
+    issuer: IssuerId,
+    issuanceDate: UnixTimestamp,
+    expirationDate: UnixTimestamp,
+    subject: CredSubjectId,
+    claims: ClaimsType,
+    credentialStandardHash: Field
+  };
+
+  class BaseVCredStruct_ extends Struct(Data) {
+    static Fields = Data;
+
+    public toFields(): Field[] {
+      return [
+        ...this.id.toFields(),
+        ...this.issuer.toFields(),
+        ...this.issuanceDate.toFields(),
+        ...this.expirationDate.toFields(),
+        ...this.subject.toFields(),
+        ...this.claims.toFields(),
+        ...this.credentialStandardHash.toFields()
+      ];
+    }
+
+    static fromTransit(t: CredentialData): BaseVCredStruct_ {
+      const id = VCredId.fromTransit(t.id);
+      const issuer = IssuerId.fromTransit(t.issuer);
+      const issuanceDate = UnixTimestamp.fromTransit(t.issuanceDate);
+      const expirationDate = UnixTimestamp.fromTransit(t.expirationDate);
+      const subject = CredSubjectId.fromTransit(t.subject);
+      const claims = mkClaims(Object.values(t.claims).map(mkClaimStruct));
+      const credentialStandardHash = FieldSchema.parse(t.credentialStandardHash);
+
+      return new BaseVCredStruct_({
+        id,
+        issuer,
+        issuanceDate,
+        expirationDate,
+        subject,
+        claims,
+        credentialStandardHash
+      });
+    }
+  }
+
+  return BaseVCredStruct_;
+}
+
+export function VCredStruct(claimSizes: number[]) {
+  const BaseVCredStructType = VCredStructUnsigned(claimSizes);
+
+  const Fields = { ...BaseVCredStructType.Fields, signature: Signature };
+
+  class VCredStruct_ extends Struct(Fields) {
+    static Fields = Fields;
+
+    public contentToFields() {
+      return new BaseVCredStructType(this).toFields();
+    }
+
+    public toFields() {
+      return [...this.contentToFields(), ...this.signature.toFields()];
+    }
+
+    static fromTransit(t: Credential): VCredStruct_ {
+      const base = BaseVCredStructType.fromTransit(t);
+      const signature = SignatureSchema.parse(t.signature);
+
+      return new VCredStruct_({ ...base, signature });
+    }
+
+  }
+
+  return VCredStruct_;
+}