Prove Types

type Settings = {
  production: boolean;                                   // false for dev, true for production
  privateKey?: string;                                   // SP1 prover network private key (optional)
  certChain?: SelfSignedCertChain | ExistingCertChain;  // Certificate chain (optional)
  proverNetworkMode?: ProverNetworkMode;                 // Prover network mode (optional, defaults to Mainnet)
}

class ProvingClient {
  // Request proof generation
  requestProof(originalPath: string): Promise<string>;
  
  // Check proof status
  getProofStatus(requestId: string): Promise<ProofRequestStatus>;
  
  // Embed proof into photo
  embedProof(originalPath: string, proof: ArrayBuffer): Promise<string>;
  
  // Convenience: request, wait, and embed in one step
  waitAndEmbedProof(originalPath: string): Promise<string>;
}

type ProverContextValue = {
  provingClient: ProvingClient | null;     // The proving client instance
  provingTasks: ProvingTasksState;         // Active proof requests
  provingTasksCount: number;               // Number of active requests
  isInitializing: boolean;                 // Whether proving client is initializing
  error: unknown;                          // Any initialization error
}

type ProofRequestContextValue = {
  isInitializing: boolean;            // Whether proving client is initializing
  error: unknown;                     // Any initialization error
  fulfillementStatus: FulfillmentStatus; // Current proof status
  proof: ArrayBuffer | undefined;     // Generated proof bytes (when fulfilled)
}

type ProvingTask = {
  photoPath: string;      // Path to the photo being proven
  createdAtMs: number;    // Timestamp when proof was requested
}

type ProvingTasksState = Record<string, ProvingTask>

type ProofRequestStatus = {
  fulfillmentStatus: FulfillmentStatus;  // Current status
  proof?: ArrayBuffer;                   // Proof bytes (when fulfilled)
}

enum FulfillmentStatus {
  UnspecifiedFulfillmentStatus = 0,  // Initial/unknown state
  Requested = 1,                     // Request received by backend
  Assigned = 2,                      // Request assigned to a prover
  Fulfilled = 3,                     // Proof generated successfully
  Unfulfillable = 4,                 // Proof generation failed
}

enum ProverNetworkMode {
  Mainnet,   // Auction-based proving on the mainnet network
  Reserved,  // Reserved capacity network for hosted/reserved proving
}

type SelfSignedCertChain = {
  signingAlgorithm?: string;  // Algorithm for signing (default: ES256)
  tsaUrl?: string;            // Timestamp authority URL (optional)
}

type ExistingCertChain = {
  pem: string;  // Certificate chain in PEM format
}

enum AuthenticityStatus {
  Unknown = 0,          // Unable to determine status
  NoManifest = 1,       // No C2PA manifest found
  InvalidManifest = 2,  // C2PA manifest is invalid
  Bindings = 3,         // Has succinct.bindings assertion
  Proof = 4             // Has succinct.proof assertion
}