feat: control panel binding doc viewer

infrastructure/control-panel/config/admin-enames.json

@@ -3,7 +3,6 @@
 		"@7218b67d-da21-54d6-9a85-7c4db1d09768",
 		"@82f7a77a-f03a-52aa-88fc-1b1e488ad498",
 		"@35a31f0d-dd76-5780-b383-29f219fcae99",
-		"@82f7a77a-f03a-52aa-88fc-1b1e488ad498",
-		"@af7e4f55-ad9d-537c-81ef-4f3a234bdd2c"
+		"@b995a88a-90d1-56fc-ba42-1e1eb664861c"
 	]
 }

infrastructure/control-panel/package.json

@@ -43,6 +43,8 @@
 		"vite": "^7.0.4"
 	},
 	"dependencies": {
+		"graphql-request": "^7.3.1",
+		"@metastate-foundation/types": "workspace:*",
 		"@hugeicons/core-free-icons": "^1.0.13",
 		"@hugeicons/svelte": "^1.0.2",
 		"@inlang/paraglide-js": "^2.0.0",

infrastructure/control-panel/src/lib/server/evault.ts

@@ -0,0 +1,258 @@
+import { GraphQLClient, gql } from 'graphql-request';
+import { PUBLIC_CONTROL_PANEL_URL, PUBLIC_REGISTRY_URL } from '$env/static/public';
+import type { BindingDocument, SocialConnection } from '@metastate-foundation/types';
+
+const BINDING_DOCUMENTS_QUERY = gql`
+	query GetBindingDocuments($first: Int!, $after: String) {
+		bindingDocuments(first: $first, after: $after) {
+			edges {
+				node {
+					id
+					parsed
+				}
+			}
+			pageInfo {
+				hasNextPage
+				endCursor
+			}
+		}
+	}
+`;
+
+const USER_PROFILE_QUERY = gql`
+	query GetUserProfile($ontologyId: ID!, $first: Int!) {
+		metaEnvelopes(filter: { ontologyId: $ontologyId }, first: $first) {
+			edges {
+				node {
+					parsed
+				}
+			}
+		}
+	}
+`;
+
+const USER_PROFILE_ONTOLOGY = '550e8400-e29b-41d4-a716-446655440000';
+
+interface RegistryResolveResponse {
+	evaultUrl?: string;
+	uri?: string;
+}
+
+interface PlatformCertificationResponse {
+	token: string;
+}
+
+interface BindingDocumentsResponse {
+	bindingDocuments: {
+		edges: Array<{
+			node: {
+				id: string;
+				parsed: Record<string, unknown> | null;
+			};
+		}>;
+		pageInfo: {
+			hasNextPage: boolean;
+			endCursor: string | null;
+		};
+	};
+}
+
+class EvaultService {
+	private platformToken: string | null = null;
+	private profileNameCache = new Map<string, string>();
+
+	private getRegistryUrl(): string {
+		const registryUrl = PUBLIC_REGISTRY_URL || 'https://registry.w3ds.metastate.foundation';
+		return registryUrl;
+	}
+
+	private getGraphqlUrl(evaultBaseUrl: string): string {
+		return new URL('/graphql', evaultBaseUrl).toString();
+	}
+
+	normalizeEName(value: string): string {
+		return value.startsWith('@') ? value : `@${value}`;
+	}
+
+	private async getPlatformToken(): Promise<string> {
+		if (this.platformToken) return this.platformToken;
+		const platform = PUBLIC_CONTROL_PANEL_URL || 'control-panel';
+		const endpoint = new URL('/platforms/certification', this.getRegistryUrl()).toString();
+		const response = await fetch(endpoint, {
+			method: 'POST',
+			headers: { 'Content-Type': 'application/json' },
+			body: JSON.stringify({ platform }),
+			signal: AbortSignal.timeout(10_000)
+		});
+
+		if (!response.ok) {
+			throw new Error(`Failed to get platform token: HTTP ${response.status}`);
+		}
+
+		const data = (await response.json()) as PlatformCertificationResponse;
+		if (!data.token) {
+			throw new Error('Failed to get platform token: missing token in response');
+		}
+
+		this.platformToken = data.token;
+		return this.platformToken;
+	}
+
+	async resolveEVaultUrl(eName: string): Promise<string> {
+		const normalized = this.normalizeEName(eName);
+		const endpoint = new URL(
+			`/resolve?w3id=${encodeURIComponent(normalized)}`,
+			this.getRegistryUrl()
+		).toString();
+
+		const response = await fetch(endpoint, {
+			signal: AbortSignal.timeout(10_000)
+		});
+
+		if (!response.ok) {
+			throw new Error(`Registry resolve failed: HTTP ${response.status}`);
+		}
+
+		const data = (await response.json()) as RegistryResolveResponse;
+		const resolved = data.evaultUrl ?? data.uri;
+
+		if (!resolved) {
+			throw new Error('Registry did not return an eVault URL');
+		}
+
+		return resolved;
+	}
+
+	private async resolveDisplayNameForEName(eName: string): Promise<string> {
+		const normalized = this.normalizeEName(eName);
+		const cached = this.profileNameCache.get(normalized);
+		if (cached) return cached;
+
+		const [evaultBaseUrl, token] = await Promise.all([
+			this.resolveEVaultUrl(normalized),
+			this.getPlatformToken()
+		]);
+
+		const client = new GraphQLClient(this.getGraphqlUrl(evaultBaseUrl), {
+			headers: {
+				Authorization: `Bearer ${token}`,
+				'X-ENAME': normalized
+			}
+		});
+
+		const response = await client.request<{
+			metaEnvelopes?: {
+				edges?: Array<{ node?: { parsed?: Record<string, unknown> | null } }>;
+			};
+		}>(USER_PROFILE_QUERY, {
+			ontologyId: USER_PROFILE_ONTOLOGY,
+			first: 1
+		});
+
+		const profile = response.metaEnvelopes?.edges?.[0]?.node?.parsed;
+		const displayName =
+			(typeof profile?.displayName === 'string' && profile.displayName) ||
+			(typeof profile?.name === 'string' && profile.name) ||
+			normalized;
+
+		this.profileNameCache.set(normalized, displayName);
+		return displayName;
+	}
+
+	async fetchBindingDocuments(eName: string): Promise<{
+		eName: string;
+		documents: BindingDocument[];
+		socialConnections: SocialConnection[];
+	}> {
+		const normalized = this.normalizeEName(eName);
+		const [evaultBaseUrl, token] = await Promise.all([
+			this.resolveEVaultUrl(normalized),
+			this.getPlatformToken()
+		]);
+
+		const client = new GraphQLClient(this.getGraphqlUrl(evaultBaseUrl), {
+			headers: {
+				Authorization: `Bearer ${token}`,
+				'X-ENAME': normalized
+			}
+		});
+
+		const allEdges: Array<{ node: { id: string; parsed: Record<string, unknown> | null } }> = [];
+		let afterCursor: string | null = null;
+
+		do {
+			const res: BindingDocumentsResponse = await client.request<BindingDocumentsResponse>(
+				BINDING_DOCUMENTS_QUERY,
+				{ first: 100, after: afterCursor ?? undefined }
+			);
+			allEdges.push(...res.bindingDocuments.edges);
+			afterCursor = res.bindingDocuments.pageInfo.hasNextPage
+				? res.bindingDocuments.pageInfo.endCursor
+				: null;
+		} while (afterCursor !== null);
+
+		const documents: BindingDocument[] = allEdges
+			.map((edge) => {
+				const parsed = edge.node.parsed;
+				if (!parsed || typeof parsed !== 'object') return null;
+				const { subject, type, data, signatures } = parsed;
+				if (
+					typeof subject !== 'string' ||
+					typeof type !== 'string' ||
+					typeof data !== 'object' ||
+					data === null ||
+					!Array.isArray(signatures)
+				) {
+					return null;
+				}
+				return {
+					id: edge.node.id,
+					subject,
+					type: type as BindingDocument['type'],
+					data: data as Record<string, unknown>,
+					signatures: signatures as BindingDocument['signatures']
+				};
+			})
+			.filter((doc): doc is BindingDocument => doc !== null);
+
+		const socialCandidates = documents.filter(
+			(doc) => doc.type === 'social_connection' && doc.signatures.length === 2
+		);
+
+		const socialConnections = (
+			await Promise.all(
+				socialCandidates.map(async (doc) => {
+					const otherPartyEName = doc.signatures.find(
+						(signature) => signature.signer !== normalized
+					)?.signer;
+
+					if (!otherPartyEName) return null;
+
+					let name: string;
+					try {
+						name = await this.resolveDisplayNameForEName(otherPartyEName);
+					} catch {
+						name = otherPartyEName;
+					}
+
+					const relationDescription =
+						typeof doc.data?.relation_description === 'string'
+							? doc.data.relation_description
+							: null;
+
+					return {
+						id: doc.id,
+						name,
+						witnessEName: otherPartyEName,
+						relationDescription: relationDescription || undefined,
+						signatures: doc.signatures
+					};
+				})
+			)
+		).filter((entry): entry is NonNullable<typeof entry> => entry !== null);
+
+		return { eName: normalized, documents, socialConnections };
+	}
+}
+
+export const evaultService = new EvaultService();

infrastructure/control-panel/src/lib/services/evaultService.ts

@@ -1,4 +1,5 @@
 import type { EVault } from '../../routes/api/evaults/+server';
+import type { BindingDocument, SocialConnection } from '@metastate-foundation/types';
 import { cacheService } from './cacheService';
 
 export class EVaultService {
@@ -115,6 +116,32 @@ export class EVaultService {
 		}
 	}
 
+	/**
+	 * Get binding documents for a specific eVault by evaultId
+	 */
+	static async getBindingDocuments(
+		evaultId: string
+	): Promise<{ documents: BindingDocument[]; socialConnections: SocialConnection[]; eName: string }> {
+		try {
+			const response = await fetch(
+				`/api/evaults/${encodeURIComponent(evaultId)}/binding-documents`
+			);
+			if (!response.ok) {
+				const data = await response.json().catch(() => ({}));
+				throw new Error(data.error || `HTTP error! status: ${response.status}`);
+			}
+			const data = await response.json();
+			return {
+				documents: data.documents || [],
+				socialConnections: data.socialConnections || [],
+				eName: data.eName || ''
+			};
+		} catch (error) {
+			console.error('Failed to fetch binding documents:', error);
+			throw error;
+		}
+	}
+
 	/**
 	 * Get logs for a specific eVault by namespace and podName
 	 */

infrastructure/control-panel/src/routes/api/evaults/[evaultId]/binding-documents/+server.ts

@@ -0,0 +1,29 @@
+import { json } from '@sveltejs/kit';
+import type { RequestHandler } from './$types';
+import { registryService } from '$lib/services/registry';
+import { evaultService } from '$lib/server/evault';
+
+export const GET: RequestHandler = async ({ params }) => {
+	const { evaultId } = params;
+
+	try {
+		const evaults = await registryService.getEVaults();
+		if (evaults.length === 0) {
+			return json(
+				{ error: 'Registry unavailable: failed to fetch eVaults' },
+				{ status: 502 }
+			);
+		}
+		const vault = evaults.find((v) => v.evault === evaultId || v.ename === evaultId);
+		if (!vault) {
+			return json({ error: `eVault '${evaultId}' not found in registry.` }, { status: 404 });
+		}
+
+		const result = await evaultService.fetchBindingDocuments(vault.ename);
+		return json(result);
+	} catch (error) {
+		const message =
+			error instanceof Error ? error.message : 'Failed to fetch binding documents';
+		return json({ error: message }, { status: 500 });
+	}
+};