@aptos-labs/ts-sdk 1.14.0-zeta.0 → 1.14.0-zeta.1

package/src/core/crypto/keyless.ts

@@ -5,10 +5,11 @@ import { AccountPublicKey, PublicKey } from "./publicKey";
 import { Signature } from "./signature";
 import { Deserializer, Serializable, Serializer } from "../../bcs";
 import { Hex } from "../hex";
-import { HexInput, EphemeralCertificate, AnyPublicKeyVariant, SigningScheme } from "../../types";
+import { HexInput, EphemeralCertificateVariant, AnyPublicKeyVariant, SigningScheme, ZkpVariant } from "../../types";
 import { EphemeralPublicKey, EphemeralSignature } from "./ephemeral";
 import { bigIntToBytesLE, bytesToBigIntLE, hashASCIIStrToField, poseidonHash } from "./poseidon";
 import { AuthenticationKey } from "../authenticationKey";
+import { Proof } from "./proof";
 
 export const EPK_HORIZON_SECS = 10000000;
 export const MAX_AUD_VAL_BYTES = 120;
@@ -25,23 +26,27 @@ export const MAX_COMMITED_EPK_BYTES = 93;
  * KeylessPublicKey authentication key is represented in the SDK as `AnyPublicKey`.
  */
 export class KeylessPublicKey extends AccountPublicKey {
-  static readonly ADDRESS_SEED_LENGTH: number = 32;
+  static readonly ID_COMMITMENT_LENGTH: number = 32;
 
   readonly iss: string;
 
-  readonly addressSeed: Uint8Array;
+  readonly idCommitment: Uint8Array;
 
-  constructor(iss: string, addressSeed: HexInput) {
+  constructor(iss: string, idCommitment: HexInput) {
     super();
-    const addressSeedBytes = Hex.fromHexInput(addressSeed).toUint8Array();
-    if (addressSeedBytes.length !== KeylessPublicKey.ADDRESS_SEED_LENGTH) {
-      throw new Error(`Address seed length in bytes should be ${KeylessPublicKey.ADDRESS_SEED_LENGTH}`);
+    const idcBytes = Hex.fromHexInput(idCommitment).toUint8Array();
+    if (idcBytes.length !== KeylessPublicKey.ID_COMMITMENT_LENGTH) {
+      throw new Error(`Address seed length in bytes should be ${KeylessPublicKey.ID_COMMITMENT_LENGTH}`);
     }
-
     this.iss = iss;
-    this.addressSeed = addressSeedBytes;
+    this.idCommitment = idcBytes;
   }
 
+  /**
+   * Get the authentication key for the keyless public key
+   *
+   * @returns AuthenticationKey
+   */
   authKey(): AuthenticationKey {
     const serializer = new Serializer();
     serializer.serializeU32AsUleb128(AnyPublicKeyVariant.Keyless);
@@ -77,15 +82,14 @@ export class KeylessPublicKey extends AccountPublicKey {
    * @param args.signature The signature
    * @returns true if the signature is valid
    */
-  // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars, class-methods-use-this
   verifySignature(args: { message: HexInput; signature: KeylessSignature }): boolean {
-    // TODO
-    return true;
+    throw new Error("Not yet implemented");
   }
 
   serialize(serializer: Serializer): void {
     serializer.serializeStr(this.iss);
-    serializer.serializeBytes(this.addressSeed);
+    serializer.serializeBytes(this.idCommitment);
   }
 
   static deserialize(deserializer: Deserializer): KeylessPublicKey {
@@ -104,6 +108,16 @@ export class KeylessPublicKey extends AccountPublicKey {
     return publicKey instanceof KeylessPublicKey;
   }
 
+  /**
+   * Creates a KeylessPublicKey from the JWT components plus pepper
+   *
+   * @param args.iss the iss of the identity
+   * @param args.uidKey the key to use to get the uidVal in the JWT token
+   * @param args.uidVal the value of the uidKey in the JWT token
+   * @param args.aud the client ID of the application
+   * @param args.pepper The pepper used to maintain privacy of the account
+   * @returns KeylessPublicKey
+   */
   static create(args: {
     iss: string;
     uidKey: string;
@@ -111,17 +125,12 @@ export class KeylessPublicKey extends AccountPublicKey {
     aud: string;
     pepper: HexInput;
   }): KeylessPublicKey {
-    computeAddressSeed(args);
-    return new KeylessPublicKey(args.iss, computeAddressSeed(args));
+    computeIdCommitment(args);
+    return new KeylessPublicKey(args.iss, computeIdCommitment(args));
   }
 }
 
-export function computeAddressSeed(args: {
-  uidKey: string;
-  uidVal: string;
-  aud: string;
-  pepper: HexInput;
-}): Uint8Array {
+function computeIdCommitment(args: { uidKey: string; uidVal: string; aud: string; pepper: HexInput }): Uint8Array {
   const { uidKey, uidVal, aud, pepper } = args;
 
   const fields = [
@@ -131,65 +140,165 @@ export function computeAddressSeed(args: {
     hashASCIIStrToField(uidKey, MAX_UID_KEY_BYTES),
   ];
 
-  return bigIntToBytesLE(poseidonHash(fields), KeylessPublicKey.ADDRESS_SEED_LENGTH);
+  return bigIntToBytesLE(poseidonHash(fields), KeylessPublicKey.ID_COMMITMENT_LENGTH);
 }
 
-export class OpenIdSignatureOrZkProof extends Signature {
-  public readonly signature: Signature;
+/**
+ * A signature of a message signed via Keyless Accounnt that uses proofs or the jwt token to authenticate.
+ */
+export class KeylessSignature extends Signature {
+  /**
+   * The inner signature ZeroKnowledgeSigniature or OpenIdSignature
+   */
+  readonly ephemeralCertificate: EphemeralCertificate;
+
+  /**
+   * The jwt header in the token used to create the proof/signature.  In json string representation.
+   */
+  readonly jwtHeader: string;
 
-  constructor(signature: Signature) {
+  /**
+   * The expiry timestamp in seconds of the EphemeralKeyPair used to sign
+   */
+  readonly expiryDateSecs: bigint | number;
+
+  /**
+   * The ephemeral public key used to verify the signature
+   */
+  readonly ephemeralPublicKey: EphemeralPublicKey;
+
+  /**
+   * The signature resulting from signing with the private key of the EphemeralKeyPair
+   */
+  readonly ephemeralSignature: EphemeralSignature;
+
+  constructor(args: {
+    jwtHeader: string;
+    ephemeralCertificate: EphemeralCertificate;
+    expiryDateSecs: bigint | number;
+    ephemeralPublicKey: EphemeralPublicKey;
+    ephemeralSignature: EphemeralSignature;
+  }) {
     super();
-    this.signature = signature;
+    const { jwtHeader, ephemeralCertificate, expiryDateSecs, ephemeralPublicKey, ephemeralSignature } = args;
+    this.jwtHeader = jwtHeader;
+    this.ephemeralCertificate = ephemeralCertificate;
+    this.expiryDateSecs = expiryDateSecs;
+    this.ephemeralPublicKey = ephemeralPublicKey;
+    this.ephemeralSignature = ephemeralSignature;
   }
 
   /**
-   * Get the public key in bytes (Uint8Array).
+   * Get the signature in bytes (Uint8Array).
    *
-   * @returns Uint8Array representation of the public key
+   * @returns Uint8Array representation of the signature
    */
   toUint8Array(): Uint8Array {
-    return this.signature.toUint8Array();
+    return this.bcsToBytes();
   }
 
+  serialize(serializer: Serializer): void {
+    this.ephemeralCertificate.serialize(serializer);
+    serializer.serializeStr(this.jwtHeader);
+    serializer.serializeU64(this.expiryDateSecs);
+    this.ephemeralPublicKey.serialize(serializer);
+    this.ephemeralSignature.serialize(serializer);
+  }
+
+  static deserialize(deserializer: Deserializer): KeylessSignature {
+    const ephemeralCertificate = EphemeralCertificate.deserialize(deserializer);
+    const jwtHeader = deserializer.deserializeStr();
+    const expiryDateSecs = deserializer.deserializeU64();
+    const ephemeralPublicKey = EphemeralPublicKey.deserialize(deserializer);
+    const ephemeralSignature = EphemeralSignature.deserialize(deserializer);
+    return new KeylessSignature({
+      jwtHeader,
+      expiryDateSecs,
+      ephemeralCertificate,
+      ephemeralPublicKey,
+      ephemeralSignature,
+    });
+  }
+
+  static load(deserializer: Deserializer): KeylessSignature {
+    const ephemeralCertificate = EphemeralCertificate.deserialize(deserializer);
+    const jwtHeader = deserializer.deserializeStr();
+    const expiryDateSecs = deserializer.deserializeU64();
+    const ephemeralPublicKey = EphemeralPublicKey.deserialize(deserializer);
+    const ephemeralSignature = EphemeralSignature.deserialize(deserializer);
+    return new KeylessSignature({
+      jwtHeader,
+      expiryDateSecs,
+      ephemeralCertificate,
+      ephemeralPublicKey,
+      ephemeralSignature,
+    });
+  }
+
+  static isSignature(signature: Signature): signature is KeylessSignature {
+    return signature instanceof KeylessSignature;
+  }
+}
+
+/**
+ * A container for a signature that is a ZeroKnowledgeSig.  Can be expanded to support OpenIdSignature.
+ */
+export class EphemeralCertificate extends Signature {
+  public readonly signature: Signature;
+
   /**
-   * Get the public key as a hex string with the 0x prefix.
+   * Index of the underlying enum variant
+   */
+  private readonly variant: EphemeralCertificateVariant;
+
+  constructor(signature: Signature, variant: EphemeralCertificateVariant) {
+    super();
+    this.signature = signature;
+    this.variant = variant;
+  }
+
+  /**
+   * Get the public key in bytes (Uint8Array).
    *
-   * @returns string representation of the public key
+   * @returns Uint8Array representation of the public key
    */
-  toString(): string {
-    return this.signature.toString();
+  toUint8Array(): Uint8Array {
+    return this.signature.toUint8Array();
   }
 
   serialize(serializer: Serializer): void {
-    if (this.signature instanceof OpenIdSignature) {
-      serializer.serializeU32AsUleb128(EphemeralCertificate.OpenIdSignature);
-      this.signature.serialize(serializer);
-    } else if (this.signature instanceof SignedGroth16Signature) {
-      serializer.serializeU32AsUleb128(EphemeralCertificate.ZkProof);
-      this.signature.serialize(serializer);
-    } else {
-      throw new Error("Not a valid OIDB signature");
-    }
+    serializer.serializeU32AsUleb128(this.variant);
+    this.signature.serialize(serializer);
   }
 
-  static deserialize(deserializer: Deserializer): OpenIdSignatureOrZkProof {
-    const index = deserializer.deserializeUleb128AsU32();
-    switch (index) {
-      case EphemeralCertificate.ZkProof:
-        return new OpenIdSignatureOrZkProof(SignedGroth16Signature.load(deserializer));
-      case EphemeralCertificate.OpenIdSignature:
-        return new OpenIdSignatureOrZkProof(OpenIdSignature.load(deserializer));
+  static deserialize(deserializer: Deserializer): EphemeralCertificate {
+    const variant = deserializer.deserializeUleb128AsU32();
+    switch (variant) {
+      case EphemeralCertificateVariant.ZkProof:
+        return new EphemeralCertificate(ZeroKnowledgeSig.deserialize(deserializer), variant);
       default:
-        throw new Error(`Unknown variant index for EphemeralCertificate: ${index}`);
+        throw new Error(`Unknown variant index for EphemeralCertificate: ${variant}`);
     }
   }
 }
 
-export class Groth16Zkp extends Serializable {
+/**
+ * A representation of a Groth16 proof.  The points are the compressed serialization of affine reprentation of the proof.
+ */
+export class Groth16Zkp extends Proof {
+  /**
+   * The bytes of G1 proof point a
+   */
   a: Uint8Array;
 
+  /**
+   * The bytes of G2 proof point b
+   */
   b: Uint8Array;
 
+  /**
+   * The bytes of G1 proof point c
+   */
   c: Uint8Array;
 
   constructor(args: { a: HexInput; b: HexInput; c: HexInput }) {
@@ -200,23 +309,13 @@ export class Groth16Zkp extends Serializable {
     this.c = Hex.fromHexInput(c).toUint8Array();
   }
 
-  toUint8Array(): Uint8Array {
-    const serializer = new Serializer();
-    this.serialize(serializer);
-    return serializer.toUint8Array();
-  }
-
   serialize(serializer: Serializer): void {
-    // There's currently only one variant
-    serializer.serializeU32AsUleb128(0);
     serializer.serializeFixedBytes(this.a);
     serializer.serializeFixedBytes(this.b);
     serializer.serializeFixedBytes(this.c);
   }
 
   static deserialize(deserializer: Deserializer): Groth16Zkp {
-    // Ignored, as there's currently only one possible ZKP variant
-    deserializer.deserializeUleb128AsU32();
     const a = deserializer.deserializeFixedBytes(32);
     const b = deserializer.deserializeFixedBytes(64);
     const c = deserializer.deserializeFixedBytes(32);
@@ -224,19 +323,70 @@ export class Groth16Zkp extends Serializable {
   }
 }
 
-export class SignedGroth16Signature extends Signature {
-  readonly proof: Groth16Zkp;
+/**
+ * A container for a different zero knowledge proof types
+ */
+export class ZkProof extends Serializable {
+  public readonly proof: Proof;
+
+  /**
+   * Index of the underlying enum variant
+   */
+  private readonly variant: ZkpVariant;
+
+  constructor(proof: Proof, variant: ZkpVariant) {
+    super();
+    this.proof = proof;
+    this.variant = variant;
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(this.variant);
+    this.proof.serialize(serializer);
+  }
+
+  static deserialize(deserializer: Deserializer): ZkProof {
+    const variant = deserializer.deserializeUleb128AsU32();
+    switch (variant) {
+      case ZkpVariant.Groth16:
+        return new ZkProof(Groth16Zkp.deserialize(deserializer), variant);
+      default:
+        throw new Error(`Unknown variant index for ZkProof: ${variant}`);
+    }
+  }
+}
 
+/**
+ * The signature representation of a proof
+ */
+export class ZeroKnowledgeSig extends Signature {
+  /**
+   * The proof
+   */
+  readonly proof: ZkProof;
+
+  /**
+   * The max lifespan of the proof
+   */
   readonly expHorizonSecs: bigint;
 
+  /**
+   * A key value pair on the JWT token that can be made public
+   */
   readonly extraField?: string;
 
+  /**
+   * Set in the case of signing by recovery services
+   */
   readonly overrideAudVal?: string;
 
+  /**
+   * The training wheels signature
+   */
   readonly trainingWheelsSignature?: EphemeralSignature;
 
   constructor(args: {
-    proof: Groth16Zkp;
+    proof: ZkProof;
     expHorizonSecs?: bigint;
     extraField?: string;
     overrideAudVal?: string;
@@ -263,18 +413,16 @@ export class SignedGroth16Signature extends Signature {
    * @returns Uint8Array representation of the signature
    */
   toUint8Array(): Uint8Array {
-    const serializer = new Serializer();
-    this.serialize(serializer);
-    return serializer.toUint8Array();
+    return this.bcsToBytes();
   }
 
   /**
-   * Get the signature as a hex string with the 0x prefix.
+   * Return a ZeroKnowledgeSig object from its bcs serialization in bytes.
    *
-   * @returns string representation of the signature
+   * @returns ZeroKnowledgeSig
    */
-  toString(): string {
-    return this.toString();
+  static fromBytes(bytes: Uint8Array): ZeroKnowledgeSig {
+    return ZeroKnowledgeSig.deserialize(new Deserializer(bytes));
   }
 
   serialize(serializer: Serializer): void {
@@ -285,224 +433,21 @@ export class SignedGroth16Signature extends Signature {
     serializer.serializeOption(this.trainingWheelsSignature);
   }
 
-  static deserialize(deserializer: Deserializer): SignedGroth16Signature {
-    const proof = Groth16Zkp.deserialize(deserializer);
+  static deserialize(deserializer: Deserializer): ZeroKnowledgeSig {
+    const proof = ZkProof.deserialize(deserializer);
     const expHorizonSecs = deserializer.deserializeU64();
-    const hasExtraField = deserializer.deserializeUleb128AsU32();
-    const extraField = hasExtraField ? deserializer.deserializeStr() : undefined;
-    const hasOverrideAudVal = deserializer.deserializeUleb128AsU32();
-    const overrideAudVal = hasOverrideAudVal ? deserializer.deserializeStr() : undefined;
-    const [trainingWheelsSignature] = deserializer.deserializeVector(EphemeralSignature);
-    return new SignedGroth16Signature({ proof, expHorizonSecs, trainingWheelsSignature, extraField, overrideAudVal });
+    const extraField = deserializer.deserializeOptionStr();
+    const overrideAudVal = deserializer.deserializeOptionStr();
+    const trainingWheelsSignature = deserializer.deserializeOption(EphemeralSignature);
+    return new ZeroKnowledgeSig({ proof, expHorizonSecs, trainingWheelsSignature, extraField, overrideAudVal });
   }
 
-  static load(deserializer: Deserializer): SignedGroth16Signature {
-    const proof = Groth16Zkp.deserialize(deserializer);
+  static load(deserializer: Deserializer): ZeroKnowledgeSig {
+    const proof = ZkProof.deserialize(deserializer);
     const expHorizonSecs = deserializer.deserializeU64();
-    const hasExtraField = deserializer.deserializeUleb128AsU32();
-    const extraField = hasExtraField ? deserializer.deserializeStr() : undefined;
-    const hasOverrideAudVal = deserializer.deserializeUleb128AsU32();
-    const overrideAudVal = hasOverrideAudVal ? deserializer.deserializeStr() : undefined;
-    const [trainingWheelsSignature] = deserializer.deserializeVector(EphemeralSignature);
-    return new SignedGroth16Signature({ proof, expHorizonSecs, trainingWheelsSignature, extraField, overrideAudVal });
-  }
-
-  // static isSignature(signature: Signature): signature is OpenIdSignature {
-  //   return signature instanceof OpenIdSignature;
-  // }
-}
-
-/**
- * A OpenId signature which contains the private inputs to an OIDB proof.
- */
-export class OpenIdSignature extends Signature {
-  readonly jwtSignature: string;
-
-  readonly jwtPayloadJson: string;
-
-  readonly uidKey: string;
-
-  readonly epkBlinder: Uint8Array;
-
-  readonly pepper: Uint8Array;
-
-  readonly overrideAudValue?: string;
-
-  /**
-   * Create a new Signature instance from a Uint8Array or String.
-   *
-   * @param hexInput A HexInput (string or Uint8Array)
-   */
-  constructor(args: {
-    jwtSignature: string;
-    jwtPayloadJson: string;
-    uidKey?: string;
-    epkBlinder: Uint8Array;
-    pepper: Uint8Array;
-    overrideAudValue?: string;
-  }) {
-    super();
-    const { jwtSignature, uidKey, jwtPayloadJson, epkBlinder, pepper, overrideAudValue } = args;
-    this.jwtSignature = jwtSignature;
-    this.jwtPayloadJson = jwtPayloadJson;
-    this.uidKey = uidKey ?? "sub";
-    this.epkBlinder = epkBlinder;
-    this.pepper = pepper;
-    this.overrideAudValue = overrideAudValue;
-  }
-
-  /**
-   * Get the signature in bytes (Uint8Array).
-   *
-   * @returns Uint8Array representation of the signature
-   */
-  toUint8Array(): Uint8Array {
-    // const textEncoder = new TextEncoder();
-    // const jwtSigBytes = textEncoder.encode(this.jwtSignature);
-    // const jwtPayloadJsonBytes = textEncoder.encode(this.jwtPayloadJson);
-    // const uidKeyBytes = textEncoder.encode(this.jwtSignature);
-    // const uidKeyBytes = textEncoder.encode(this.jwtSignature);
-
-    return this.epkBlinder;
-  }
-
-  /**
-   * Get the signature as a hex string with the 0x prefix.
-   *
-   * @returns string representation of the signature
-   */
-  toString(): string {
-    return this.toString();
-  }
-
-  serialize(serializer: Serializer): void {
-    serializer.serializeStr(this.jwtSignature);
-    serializer.serializeStr(this.jwtPayloadJson);
-    serializer.serializeStr(this.uidKey);
-    serializer.serializeFixedBytes(this.epkBlinder);
-    serializer.serializeFixedBytes(this.pepper);
-    serializer.serializeOptionStr(this.overrideAudValue);
-  }
-
-  static deserialize(deserializer: Deserializer): OpenIdSignature {
-    const jwtSignature = deserializer.deserializeStr();
-    const jwtPayloadJson = deserializer.deserializeStr();
-    const uidKey = deserializer.deserializeStr();
-    const epkBlinder = deserializer.deserializeFixedBytes(31);
-    const pepper = deserializer.deserializeFixedBytes(31);
-    const hasOverrideAudValue = deserializer.deserializeUleb128AsU32();
-    const overrideAudValue = hasOverrideAudValue ? deserializer.deserializeStr() : undefined;
-    return new OpenIdSignature({ jwtSignature, jwtPayloadJson, uidKey, epkBlinder, pepper, overrideAudValue });
-  }
-
-  static load(deserializer: Deserializer): OpenIdSignature {
-    const jwtSignature = deserializer.deserializeStr();
-    const jwtPayloadJson = deserializer.deserializeStr();
-    const uidKey = deserializer.deserializeStr();
-    const epkBlinder = deserializer.deserializeFixedBytes(31);
-    const pepper = deserializer.deserializeFixedBytes(31);
-    const hasOverrideAudValue = deserializer.deserializeUleb128AsU32();
-    const overrideAudValue = hasOverrideAudValue ? deserializer.deserializeStr() : undefined;
-    return new OpenIdSignature({ jwtSignature, jwtPayloadJson, uidKey, epkBlinder, pepper, overrideAudValue });
-  }
-
-  static isSignature(signature: Signature): signature is OpenIdSignature {
-    return signature instanceof OpenIdSignature;
-  }
-}
-
-/**
- * A signature of a message signed via OIDC that uses proofs or the jwt token to authenticate.
- */
-export class KeylessSignature extends Signature {
-  readonly openIdSignatureOrZkProof: OpenIdSignatureOrZkProof;
-
-  readonly jwtHeader: string;
-
-  readonly expiryDateSecs: bigint | number;
-
-  readonly ephemeralPublicKey: EphemeralPublicKey;
-
-  readonly ephemeralSignature: EphemeralSignature;
-
-  /**
-   * Create a new Signature instance from a Uint8Array or String.
-   *
-   * @param hexInput A HexInput (string or Uint8Array)
-   */
-  constructor(args: {
-    jwtHeader: string;
-    openIdSignatureOrZkProof: OpenIdSignatureOrZkProof;
-    expiryDateSecs: bigint | number;
-    ephemeralPublicKey: EphemeralPublicKey;
-    ephemeralSignature: EphemeralSignature;
-  }) {
-    super();
-    const { jwtHeader, openIdSignatureOrZkProof, expiryDateSecs, ephemeralPublicKey, ephemeralSignature } = args;
-    this.jwtHeader = jwtHeader;
-    this.openIdSignatureOrZkProof = openIdSignatureOrZkProof;
-    this.expiryDateSecs = expiryDateSecs;
-    this.ephemeralPublicKey = ephemeralPublicKey;
-    this.ephemeralSignature = ephemeralSignature;
-  }
-
-  /**
-   * Get the signature in bytes (Uint8Array).
-   *
-   * @returns Uint8Array representation of the signature
-   */
-  toUint8Array(): Uint8Array {
-    return this.ephemeralSignature.toUint8Array();
-  }
-
-  /**
-   * Get the signature as a hex string with the 0x prefix.
-   *
-   * @returns string representation of the signature
-   */
-  toString(): string {
-    return this.toString();
-  }
-
-  serialize(serializer: Serializer): void {
-    this.openIdSignatureOrZkProof.serialize(serializer);
-    serializer.serializeStr(this.jwtHeader);
-    serializer.serializeU64(this.expiryDateSecs);
-    this.ephemeralPublicKey.serialize(serializer);
-    this.ephemeralSignature.serialize(serializer);
-  }
-
-  static deserialize(deserializer: Deserializer): KeylessSignature {
-    const openIdSignatureOrZkProof = OpenIdSignatureOrZkProof.deserialize(deserializer);
-    const jwtHeader = deserializer.deserializeStr();
-    const expiryDateSecs = deserializer.deserializeU64();
-    const ephemeralPublicKey = EphemeralPublicKey.deserialize(deserializer);
-    const ephemeralSignature = EphemeralSignature.deserialize(deserializer);
-    return new KeylessSignature({
-      jwtHeader,
-      expiryDateSecs,
-      openIdSignatureOrZkProof,
-      ephemeralPublicKey,
-      ephemeralSignature,
-    });
-  }
-
-  static load(deserializer: Deserializer): KeylessSignature {
-    const jwtHeader = deserializer.deserializeStr();
-    const expiryDateSecs = deserializer.deserializeU64();
-    const openIdSignatureOrZkProof = OpenIdSignatureOrZkProof.deserialize(deserializer);
-    const ephemeralPublicKey = EphemeralPublicKey.deserialize(deserializer);
-    const ephemeralSignature = EphemeralSignature.deserialize(deserializer);
-    return new KeylessSignature({
-      jwtHeader,
-      expiryDateSecs,
-      openIdSignatureOrZkProof,
-      ephemeralPublicKey,
-      ephemeralSignature,
-    });
-  }
-
-  static isSignature(signature: Signature): signature is KeylessSignature {
-    return signature instanceof KeylessSignature;
+    const extraField = deserializer.deserializeOptionStr();
+    const overrideAudVal = deserializer.deserializeOptionStr();
+    const trainingWheelsSignature = deserializer.deserializeOption(EphemeralSignature);
+    return new ZeroKnowledgeSig({ proof, expHorizonSecs, trainingWheelsSignature, extraField, overrideAudVal });
   }
 }

package/src/core/crypto/proof.ts

@@ -0,0 +1,16 @@
+import { Serializable } from "../../bcs";
+import { Hex } from "../hex";
+
+/**
+ * An abstract representation of a crypto proof.
+ * associated to a specific zero knowledge proof schemes e.g. Groth16, PLONK
+ */
+export abstract class Proof extends Serializable {
+  /**
+   * Get the proof as a hex string with a 0x prefix e.g. 0x123456...
+   */
+  toString(): string {
+    const bytes = this.bcsToBytes();
+    return Hex.fromHexInput(bytes).toString();
+  }
+}