@le-space/shared-types 0.6.1 → 0.6.2

package/index.d.ts

@@ -326,4 +326,23 @@ interface VmBootstrapConfigSignalRecord {
     browserBootstrapMultiaddrs?: string[];
 }
 
-export type { AlephAggregateContent, AlephBroadcastMessage, AlephBroadcastResponse, AlephInstanceContent, AlephMessageType, AlephSenderChain, CrnRecord, CrnSystemUsage, DeploymentInspectionResult, DeploymentIntent, DeploymentIntentEnvelope, DeploymentProgressEvent, DeploymentProgressListener, DeploymentProgressStage, DeploymentResult, GatewayProbeStatus, InstanceAllocation, InstanceAllocationNode, InstanceAllocationPeriod, InstanceExecution, InstanceExecutionNetworking, InstanceExecutionStatus, InstanceRuntimeDetails, InstanceWebAccess, MessageHasher, MessageInspectionResult, MessageReference, MessageSigner, MessageStatus, PortForwardAggregate, PortForwardAggregateEntry, PortForwardFlags, PortMapping, ReferenceStatus, RootfsInstallStrategy, RootfsManifest, RootfsManifestState, RootfsRequiredPortForward, RootfsResolution, RuntimeDiagnostics, RuntimeMetadata, VmBootstrapConfigAggregate, VmBootstrapConfigBootstrap, VmBootstrapConfigRecord, VmBootstrapConfigRuntime, VmBootstrapConfigSignalRecord, VmBootstrapConfigSignalType, VmBootstrapConfigStatus };
+interface UcanStoreBootstrapPackage {
+    operatorAddress: string;
+    adminDid: string;
+    serviceDid?: string | null;
+    spaceDid: string;
+    rootDelegationProof: string;
+    allowedCapabilities: string[];
+    defaultUserDelegationExpiration?: number | null;
+    maxUserDelegationExpiration?: number | null;
+    pwaOrigin: string;
+    serviceOrigin: string;
+}
+interface UcanStoreBootstrapValidationResult {
+    valid: boolean;
+    errors: string[];
+    bootstrapPackage: UcanStoreBootstrapPackage | null;
+}
+declare function validateUcanStoreBootstrapPackage(value: unknown): UcanStoreBootstrapValidationResult;
+
+export { type AlephAggregateContent, type AlephBroadcastMessage, type AlephBroadcastResponse, type AlephInstanceContent, type AlephMessageType, type AlephSenderChain, type CrnRecord, type CrnSystemUsage, type DeploymentInspectionResult, type DeploymentIntent, type DeploymentIntentEnvelope, type DeploymentProgressEvent, type DeploymentProgressListener, type DeploymentProgressStage, type DeploymentResult, type GatewayProbeStatus, type InstanceAllocation, type InstanceAllocationNode, type InstanceAllocationPeriod, type InstanceExecution, type InstanceExecutionNetworking, type InstanceExecutionStatus, type InstanceRuntimeDetails, type InstanceWebAccess, type MessageHasher, type MessageInspectionResult, type MessageReference, type MessageSigner, type MessageStatus, type PortForwardAggregate, type PortForwardAggregateEntry, type PortForwardFlags, type PortMapping, type ReferenceStatus, type RootfsInstallStrategy, type RootfsManifest, type RootfsManifestState, type RootfsRequiredPortForward, type RootfsResolution, type RuntimeDiagnostics, type RuntimeMetadata, type UcanStoreBootstrapPackage, type UcanStoreBootstrapValidationResult, type VmBootstrapConfigAggregate, type VmBootstrapConfigBootstrap, type VmBootstrapConfigRecord, type VmBootstrapConfigRuntime, type VmBootstrapConfigSignalRecord, type VmBootstrapConfigSignalType, type VmBootstrapConfigStatus, validateUcanStoreBootstrapPackage };

package/index.js

@@ -0,0 +1,122 @@
+// src/ucan-store-bootstrap.ts
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeNonEmptyString(value) {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim();
+  return normalized ? normalized : null;
+}
+function normalizeDid(value) {
+  const did = normalizeNonEmptyString(value);
+  return did && did.startsWith("did:") ? did : null;
+}
+function normalizeOrigin(value) {
+  const raw = normalizeNonEmptyString(value);
+  if (!raw) return null;
+  try {
+    const parsed = new URL(raw);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:" || !parsed.hostname || parsed.pathname && parsed.pathname !== "/" || parsed.search || parsed.hash) {
+      return null;
+    }
+    return parsed.origin;
+  } catch {
+    return null;
+  }
+}
+function normalizeExpiration(value) {
+  if (value == null) return void 0;
+  if (value === null) return null;
+  if (!Number.isInteger(value) || Number(value) < 0) return void 0;
+  return Number(value);
+}
+function validateUcanStoreBootstrapPackage(value) {
+  if (!isRecord(value)) {
+    return {
+      valid: false,
+      errors: ["Bootstrap package must be a JSON object."],
+      bootstrapPackage: null
+    };
+  }
+  const errors = [];
+  const operatorAddress = normalizeNonEmptyString(value.operatorAddress);
+  if (!operatorAddress || !/^0x[a-fA-F0-9]{40}$/.test(operatorAddress)) {
+    errors.push("operatorAddress must be a 0x-prefixed 20-byte Ethereum address.");
+  }
+  const adminDid = normalizeDid(value.adminDid);
+  if (!adminDid) {
+    errors.push("adminDid must be a non-empty DID string.");
+  }
+  const serviceDidRaw = value.serviceDid;
+  const serviceDid = serviceDidRaw == null || serviceDidRaw === "" ? null : normalizeDid(serviceDidRaw);
+  if (serviceDidRaw != null && serviceDidRaw !== "" && !serviceDid) {
+    errors.push("serviceDid must be empty or a non-empty DID string.");
+  }
+  const spaceDid = normalizeDid(value.spaceDid);
+  if (!spaceDid) {
+    errors.push("spaceDid must be a non-empty DID string.");
+  }
+  const rootDelegationProof = normalizeNonEmptyString(value.rootDelegationProof);
+  if (!rootDelegationProof) {
+    errors.push("rootDelegationProof must be a non-empty proof string.");
+  }
+  const allowedCapabilities = Array.isArray(value.allowedCapabilities) ? value.allowedCapabilities.map((entry) => normalizeNonEmptyString(entry)).filter((entry) => Boolean(entry)) : [];
+  if (allowedCapabilities.length === 0) {
+    errors.push("allowedCapabilities must contain at least one capability string.");
+  }
+  const defaultUserDelegationExpiration = normalizeExpiration(
+    value.defaultUserDelegationExpiration
+  );
+  if (value.defaultUserDelegationExpiration != null && defaultUserDelegationExpiration === void 0) {
+    errors.push(
+      "defaultUserDelegationExpiration must be null or a non-negative integer number of seconds."
+    );
+  }
+  const maxUserDelegationExpiration = normalizeExpiration(
+    value.maxUserDelegationExpiration
+  );
+  if (value.maxUserDelegationExpiration != null && maxUserDelegationExpiration === void 0) {
+    errors.push(
+      "maxUserDelegationExpiration must be null or a non-negative integer number of seconds."
+    );
+  }
+  if (typeof defaultUserDelegationExpiration === "number" && typeof maxUserDelegationExpiration === "number" && defaultUserDelegationExpiration > maxUserDelegationExpiration) {
+    errors.push(
+      "defaultUserDelegationExpiration cannot exceed maxUserDelegationExpiration."
+    );
+  }
+  const pwaOrigin = normalizeOrigin(value.pwaOrigin);
+  if (!pwaOrigin) {
+    errors.push("pwaOrigin must be an http(s) origin without path, query, or hash.");
+  }
+  const serviceOrigin = normalizeOrigin(value.serviceOrigin);
+  if (!serviceOrigin) {
+    errors.push("serviceOrigin must be an http(s) origin without path, query, or hash.");
+  }
+  if (errors.length > 0) {
+    return {
+      valid: false,
+      errors,
+      bootstrapPackage: null
+    };
+  }
+  return {
+    valid: true,
+    errors: [],
+    bootstrapPackage: {
+      operatorAddress,
+      adminDid,
+      serviceDid,
+      spaceDid,
+      rootDelegationProof,
+      allowedCapabilities,
+      defaultUserDelegationExpiration,
+      maxUserDelegationExpiration,
+      pwaOrigin,
+      serviceOrigin
+    }
+  };
+}
+export {
+  validateUcanStoreBootstrapPackage
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@le-space/shared-types",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "Shared type contracts for the shared Aleph tooling monorepo.",
   "license": "MIT",
   "type": "module",