@eqtylab/explorer 0.0.0

package/src/explorer-component/integrityTypes/StatementTypes.ts

@@ -0,0 +1,333 @@
+import { VerifiableCredential } from "./VCTypes";
+
+export type Statement =
+    | ComputationStatement
+    | DataStatement
+    // | DidStatement
+    // | DsseStatement
+    | GovernanceStatement
+    | MetadataStatement
+    | SigstoreStatement
+    | StorageStatement
+    | VcStatement;
+
+export const RegistrationTypes = {
+    Computation: "ComputationRegistration",
+    Data: "DataRegistration",
+    Did: "DidRegistration",
+    Governance: "GovernanceRegistration",
+    Metadata: "MetadataRegistration",
+    Storage: "StorageRegistration",
+    Credential: "CredentialRegistration",
+    Sigstore: "SigstoreRegistration",
+} as const;
+
+export function StatementToJSON(value: Statement) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+
+    switch (value.type) {
+        case RegistrationTypes.Data: {
+            return DataStatementToJSON(value as DataStatement);
+        }
+        case RegistrationTypes.Computation: {
+            return ComputationStatementToJSON(value as ComputationStatement);
+        }
+        case RegistrationTypes.Metadata: {
+            return MetadataStatementToJSON(value as MetadataStatement);
+        }
+        case RegistrationTypes.Governance: {
+            return GovernanceStatementToJSON(value as GovernanceStatement);
+        }
+        default: {
+            throw new Error(`Unknown statement type: ${value.type}`);
+        }
+    }
+}
+
+export interface ComputationStatement {
+    context: string;
+    id: string;
+    type: string;
+    computation?: string;
+    executedOn?: string;
+    input: string;
+    operatedBy?: string;
+    output: string;
+    registeredBy: string;
+    timestamp: string;
+}
+
+export function ComputationStatementFromJSON(json: any) {
+    if (json === undefined || json === null) {
+        return json;
+    }
+    return {
+        context: json["@context"],
+        id: json["@id"],
+        type: json["@type"],
+        computation: json["computation"] ? json["computation"] : undefined,
+        executedOn: json["executedOn"] ? json["executedOn"] : undefined,
+        input: json["input"],
+        operatedBy: json["operatedBy"],
+        output: json["output"],
+        registeredBy: json["registeredBy"],
+        timestamp: json["timestamp"],
+    };
+}
+
+export function ComputationStatementToJSON(value: ComputationStatement) {
+    if (value === undefined || value === null) {
+        return undefined;
+    }
+    return {
+        "@context": value.context,
+        "@id": value.id,
+        "@type": value.type,
+        computation: value.computation,
+        executedOn: value.executedOn,
+        input: value.input,
+        operatedBy: value.operatedBy,
+        output: value.output,
+        registeredBy: value.registeredBy,
+        timestamp: value.timestamp,
+    };
+}
+
+//End Computation  ***********************
+
+// Data  ***********************
+export interface DataStatement {
+    context: string;
+    id: string;
+    type: string;
+    data: string;
+    registeredBy: string;
+    timestamp: string;
+}
+export function DataStatementFromJSON(json: any) {
+    if (json === undefined || json === null) {
+        return json;
+    }
+    return {
+        context: json["@context"],
+        id: json["@id"],
+        type: json["@type"],
+        data: json["data"],
+        registeredBy: json["registeredBy"],
+        timestamp: json["timestamp"],
+    };
+}
+
+function DataStatementToJSON(value: DataStatement) {
+    if (value === undefined || value === undefined) {
+        return undefined;
+    }
+    return {
+        "@context": value.context,
+        "@id": value.id,
+        "@type": value.type,
+        data: value.data,
+        registeredBy: value.registeredBy,
+        timestamp: value.timestamp,
+    };
+}
+
+//End Data  ***********************
+
+// Metadata  ***********************
+export interface MetadataStatement {
+    context: string;
+    id: string;
+    type: string;
+    metadata: string;
+    registeredBy: string;
+    subject: string;
+    timestamp: string;
+}
+export function MetadataStatementFromJSON(json: any) {
+    if (json === undefined || json === null) {
+        return json;
+    }
+    return {
+        context: json["@context"],
+        id: json["@id"],
+        type: json["@type"],
+        metadata: json["metadata"],
+        registeredBy: json["registeredBy"],
+        subject: json["subject"],
+        timestamp: json["timestamp"],
+    };
+}
+export function MetadataStatementToJSON(value: MetadataStatement) {
+    if (value === undefined || value === null) {
+        return value;
+    }
+    return {
+        "@context": value.context,
+        "@id": value.id,
+        "@type": value.type,
+        metadata: value.metadata,
+        registeredBy: value.registeredBy,
+        subject: value.subject,
+        timestamp: value.timestamp,
+    };
+}
+//End Metadata  ***********************
+
+// Storage  ***********************
+export interface StorageStatement {
+    context: string;
+    id: string;
+    type: string;
+    data: string;
+    operatedBy: string;
+    registeredBy: string;
+    storedOn: string;
+    timestamp: string;
+}
+
+export function StorageStatementFromJSON(json: any) {
+    if (json === undefined || json === null) {
+        return json;
+    }
+    return {
+        context: json["@context"],
+        id: json["@id"],
+        type: json["@type"],
+        data: json["data"],
+        operatedBy: json["operatedBy"],
+        registeredBy: json["registeredBy"],
+        storedOn: json["storedOn"],
+        timestamp: json["timestamp"],
+    };
+}
+//End Storage  ***********************
+
+// VCStatement  ***********************
+export interface VcStatement {
+    context: string;
+    id: string;
+    type: string;
+    credential: VerifiableCredential;
+    registeredBy: string;
+    timestamp: string;
+}
+
+export function VcStatementFromJSON(json: any) {
+    if (json === undefined || json === null) {
+        return json;
+    }
+    return {
+        context: json["@context"],
+        id: json["@id"],
+        type: json["@type"],
+        credential: json["credential"],
+        registeredBy: json["registeredBy"],
+        timestamp: json["timestamp"],
+    };
+}
+//End VCStatement  ***********************
+
+// SigstoreStatement  ***********************
+export interface SigstoreStatement {
+    context: string;
+    id: string;
+    type: string;
+    subject: string;
+    sigstoreBundle: string;
+    registeredBy: string;
+    timestamp: string;
+}
+
+export function SigstoreStatementFromJSON(json: any) {
+    if (json === undefined || json === null) {
+        return json;
+    }
+    return {
+        context: json["@context"],
+        id: json["@id"],
+        type: json["@type"],
+        subject: json["subject"],
+        sigstoreBundle: json["sigstoreBundle"],
+        registeredBy: json["registeredBy"],
+        timestamp: json["timestamp"],
+    };
+}
+
+export function SigstoreStatementToJSON(value: SigstoreStatement) {
+    if (value === undefined || value === null) {
+        return value;
+    }
+    return {
+        "@context": value.context,
+        "@id": value.id,
+        "@type": value.type,
+        subject: value.subject,
+        sigstoreBundle: value.sigstoreBundle,
+        registeredBy: value.registeredBy,
+        timestamp: value.timestamp,
+    };
+}
+
+export interface SigstoreBundle {
+    dsseEnvelope: {
+        payload: string;
+        payloadType: string;
+        signatures: Array<{
+            keyid: string;
+            sig: string;
+        }>;
+    };
+    mediaType: string;
+    verificationMaterial: {
+        publicKey: {
+            hint: string;
+        };
+        tlogEntries: Array<any>;
+    };
+}
+//End SigstoreStatement  ***********************
+
+// Governance  ***********************
+export interface GovernanceStatement {
+    context: string;
+    id: string;
+    type: string;
+    document: string;
+    registeredBy: string;
+    subject: string;
+    timestamp: string;
+}
+
+export function GovernanceStatementFromJSON(json: any) {
+    if (json === undefined || json === null) {
+        return json;
+    }
+    return {
+        context: json["@context"],
+        id: json["@id"],
+        type: json["@type"],
+        document: json["document"],
+        registeredBy: json["registeredBy"],
+        subject: json["subject"],
+        timestamp: json["timestamp"],
+    };
+}
+
+export function GovernanceStatementToJSON(value: GovernanceStatement) {
+    if (value === undefined || value === null) {
+        return value;
+    }
+    return {
+        "@context": value.context,
+        "@id": value.id,
+        "@type": value.type,
+        document: value.document,
+        registeredBy: value.registeredBy,
+        subject: value.subject,
+        timestamp: value.timestamp,
+    };
+}
+//End Governance  ***********************

package/src/explorer-component/integrityTypes/VCTypes.ts

@@ -0,0 +1,85 @@
+import { Statement, VcStatement } from "./StatementTypes";
+
+export type TeeEnvType = "AMD SEV" | "Intel TDX" | "Azure" | "EQTY Docker" | null;
+
+export interface Actor {
+    did: string;
+    actorName: string | null;
+    teeEnv: TeeEnvType;
+    usesNvidia: boolean;
+    vcompStatements: Map<VCompType, Statement[]>;
+    vcompEvidence: Map<VCompEvidence, VcStatement[]>;
+    metadata: object | null;
+}
+
+export function createEmptyActor(did: string): Actor {
+    return {
+        did: did,
+        actorName: null,
+        teeEnv: null,
+        usesNvidia: false,
+        vcompStatements: new Map(),
+        vcompEvidence: new Map(),
+        metadata: {},
+    };
+}
+
+export type VerifiableCredential = {
+    "@context": string[];
+    id: string;
+    type: string[];
+    credentialSubject: {
+        id: string;
+    };
+    issuer: string;
+    issuanceDate: string;
+    validFrom: string;
+    proof: {
+        type: string;
+        proofPurpose: string;
+        verificationMethod: string;
+        created: string;
+        jws: string;
+    };
+};
+
+export function vcFromString(vc: object): VerifiableCredential | null {
+    const maybeVc = vc as Partial<VerifiableCredential>;
+    if (
+        !maybeVc ||
+        !Array.isArray(maybeVc["@context"]) ||
+        !Array.isArray(maybeVc.type) ||
+        typeof maybeVc.credentialSubject?.id !== "string"
+    ) {
+        return null;
+    }
+
+    return maybeVc as VerifiableCredential;
+}
+
+export const VCompTypeList = [
+    "EqtyVCompAmdSevV1",
+    "EqtyVCompIntelTdxV0",
+    "EqtyVCompAzureV1",
+    "EqtyVCompDockerV1",
+] as const;
+
+export type VCompType = (typeof VCompTypeList)[number];
+
+export function isVCompType(value: string): value is VCompType {
+    return VCompTypeList.includes(value as VCompType);
+}
+
+export const VCompEvidenceList = [
+    "EqtyVCompAmdSevV1Evidence",
+    "EqtyVCompIntelTdxV0Evidence",
+    "EqtyVCompAzureV1Evidence",
+    "EqtyVCompDockerV1Evidence",
+    "EqtyVCompNvidiaCcV0Evidence",
+] as const;
+
+export type VCompEvidence = (typeof VCompEvidenceList)[number];
+
+export function isVCompEvidence(value: string): value is VCompEvidence {
+    return VCompEvidenceList.includes(value as VCompEvidence);
+}

package/src/explorer-component/integrityTypes/types.ts

@@ -0,0 +1,3 @@
+export * from "./AnchorTypes";
+export * from "./StatementTypes";
+export * from "./VCTypes";

package/src/explorer-component/utils/config.ts

@@ -0,0 +1,163 @@
+import { NodeConfig, defaultNodeSize } from "../components/nodes/types";
+
+export type ExplorerConfig = {
+    nodes: Map<string, NodeConfig>;
+    fallbackConfig: NodeConfig;
+};
+
+// Example:
+// {
+//     displayType: "Model",        // Label displayed in the Node
+//     shape: "square",             // Shape of the Node (options: see ../components/nodes/types ["square" | "round"])
+//     icon: "ModelIcon",           // Icon to display in the node. Must exist in ./public/icons folder!
+//     component: "CustomNode",     // React component to use to render the Node. (options: see ../components/nodes/types ["CustomNode" | "ComputationNode"])
+// },
+//
+
+const fallbackNodeConfig: NodeConfig = {
+    displayType: "Unknown",
+    shape: "square",
+    icon: "UnknownIcon",
+    component: "CustomNode",
+    size: defaultNodeSize,
+};
+
+export const nodeConfigMap: Map<string, NodeConfig> = new Map([
+    [
+        "Model",
+        {
+            ...fallbackNodeConfig,
+            displayType: "Model",
+            icon: "ModelIcon",
+        },
+    ],
+    [
+        "Agent",
+        {
+            ...fallbackNodeConfig,
+            displayType: "Agent",
+            icon: "ModelIcon",
+        },
+    ],
+    [
+        "Attribution",
+        {
+            ...fallbackNodeConfig,
+            displayType: "Attribution",
+            icon: "AttributionIcon",
+        },
+    ],
+    [
+        "Benchmark",
+        {
+            ...fallbackNodeConfig,
+            displayType: "Benchmark",
+            icon: "BenchmarkIcon",
+        },
+    ],
+    [
+        "Benchmark_result",
+        {
+            ...fallbackNodeConfig,
+            displayType: "Benchmark Result",
+            icon: "BenchmarkResultIcon",
+        },
+    ],
+    [
+        "Certificate",
+        {
+            ...fallbackNodeConfig,
+            displayType: "Certificate",
+            icon: "CertificateIcon",
+        },
+    ],
+    [
+        "Code",
+        {
+            ...fallbackNodeConfig,
+            displayType: "Code",
+            icon: "CodeIcon",
+        },
+    ],
+    [
+        "Data",
+        {
+            ...fallbackNodeConfig,
+            displayType: "Data",
+            icon: "DataIcon",
+        },
+    ],
+    [
+        "Database",
+        {
+            ...fallbackNodeConfig,
+            displayType: "Database",
+            icon: "DatabaseIcon",
+        },
+    ],
+    [
+        "Dataset",
+        {
+            ...fallbackNodeConfig,
+            displayType: "Dataset",
+            icon: "DatasetIcon",
+        },
+    ],
+    [
+        "Document",
+        {
+            ...fallbackNodeConfig,
+            displayType: "Document",
+            icon: "DocumentIcon",
+        },
+    ],
+    [
+        "Internet",
+        {
+            ...fallbackNodeConfig,
+            displayType: "Internet",
+            icon: "DocumentIcon",
+        },
+    ],
+    [
+        "Media",
+        {
+            ...fallbackNodeConfig,
+            displayType: "Media File",
+            icon: "MediaIcon",
+        },
+    ],
+    [
+        "Token",
+        {
+            ...fallbackNodeConfig,
+            displayType: "Token",
+            icon: "TokenIcon",
+        },
+    ],
+    [
+        "Computation",
+        {
+            ...fallbackNodeConfig,
+            displayType: "Computation",
+            icon: "ComputationIcon",
+            component: "ComputationNode",
+            size: { width: 56, height: 56 },
+        },
+    ],
+]);
+
+/// Merges the nodeOverrides with the defaults. nodeOverrides take precedence over the defaults
+export function buildNodeConfig(nodeOverrides?: { [key: string]: Partial<NodeConfig> }): ExplorerConfig {
+    const mergedNodes = new Map<string, NodeConfig>();
+
+    for (const [key, defaultNode] of nodeConfigMap.entries()) {
+        const override = nodeOverrides?.[key];
+        mergedNodes.set(key, {
+            ...defaultNode,
+            ...override,
+        });
+    }
+
+    return { nodes: mergedNodes, fallbackConfig: fallbackNodeConfig };
+}

package/src/explorer-component/utils/formatTimestamp.ts

@@ -0,0 +1,5 @@
+import { formatInTimeZone } from "date-fns-tz";
+
+export const formatTimestamp = (timestamp: string) => {
+    return formatInTimeZone(timestamp, "UTC", "d MMMM yyyy 'at' HH:mm a");
+};