@serve.zone/interfaces 31.9.0 → 32.0.1

package/ts/runtime.networkprojection.ts

@@ -1,10 +1,10 @@
 import * as plugins from './plugins.runtime.js';
-import type { IRuntimeAuthorityReferenceV1, IRuntimeControllerV1 } from './data/runtimeassignment.js';
-import type { IRuntimeNetworkProjectionV1 } from './data/networkprojection.js';
-import { snapshotRuntimeNetworkNodeScopeV1, snapshotRuntimeNetworkProjectionV1, validateRuntimeNetworkProjectionV1 } from './data/networkprojection.js';
-import type { IRuntimeNetworkSigningAuthorityV1, ISignedRuntimeNetworkProjectionV1 } from './data/networksigning.js';
-import { computeRuntimeNetworkSigningAuthorityV1Digest, runtimeNetworkSigningV1Contract,
-  snapshotRuntimeNetworkSigningAuthorityV1, snapshotSignedRuntimeNetworkProjectionV1 } from './data/networksigning.js';
+import type { IRuntimeAuthorityReference, IRuntimeController } from './data/runtimeassignment.js';
+import type { IRuntimeNetworkProjection } from './data/networkprojection.js';
+import { snapshotRuntimeNetworkNodeScope, snapshotRuntimeNetworkProjection, validateRuntimeNetworkProjection } from './data/networkprojection.js';
+import type { IRuntimeNetworkSigningAuthority, ISignedRuntimeNetworkProjection } from './data/networksigning.js';
+import { computeRuntimeNetworkSigningAuthorityDigest, runtimeNetworkSigningContract,
+  snapshotRuntimeNetworkSigningAuthority, snapshotSignedRuntimeNetworkProjection } from './data/networksigning.js';
 import type { IRuntimeNetworkDnsLeaseRenewal, ISignedRuntimeNetworkDnsLeaseRenewal } from './data/networklease.js';
 import { runtimeNetworkDnsLeaseRenewalContract, snapshotRuntimeNetworkDnsLeaseRenewal,
   snapshotSignedRuntimeNetworkDnsLeaseRenewal, validateRuntimeNetworkDnsLeaseRenewal } from './data/networklease.js';
@@ -12,7 +12,7 @@ import { captureNetwork, failNetwork, networkCanonical, networkEqual, networkRef
   networkSameScope, requireNetwork } from './private/networkcontract.js';
 
 /** The private KeyObject is process-local. Persist only through the controller's encrypted secret store. */
-export const createRuntimeNetworkSigningKeyV1 = (): { publicKey: string; privateKey: plugins.crypto.KeyObject } => {
+export const createRuntimeNetworkSigningKey = (): { publicKey: string; privateKey: plugins.crypto.KeyObject } => {
   const pair = plugins.crypto.generateKeyPairSync('ed25519');
   const jwk = pair.publicKey.export({ format: 'jwk' });
   requireNetwork(jwk.kty === 'OKP' && jwk.crv === 'Ed25519' && typeof jwk.x === 'string');
@@ -21,28 +21,28 @@ export const createRuntimeNetworkSigningKeyV1 = (): { publicKey: string; private
 
 /** What every signed network statement carries besides its content. */
 interface IAuthoritySignature {
-  authority: IRuntimeAuthorityReferenceV1;
+  authority: IRuntimeAuthorityReference;
   signature: string;
 }
 
-const projectionEnvelope = (authority: IRuntimeAuthorityReferenceV1, projection: IRuntimeNetworkProjectionV1) =>
-  ({ domain: runtimeNetworkSigningV1Contract.signatureDomain, schemaVersion: 1, authority, projection });
-const renewalEnvelope = (authority: IRuntimeAuthorityReferenceV1, renewal: IRuntimeNetworkDnsLeaseRenewal) =>
+const projectionEnvelope = (authority: IRuntimeAuthorityReference, projection: IRuntimeNetworkProjection) =>
+  ({ domain: runtimeNetworkSigningContract.signatureDomain, authority, projection });
+const renewalEnvelope = (authority: IRuntimeAuthorityReference, renewal: IRuntimeNetworkDnsLeaseRenewal) =>
   ({ domain: runtimeNetworkDnsLeaseRenewalContract.signatureDomain, authority, renewal });
 const envelopeBytes = (envelope: object): Uint8Array => new TextEncoder().encode(networkCanonical(envelope));
 
 /** A revoked revision has no key; any other must be intact and belong to the controller that owns the content. */
-const liveKeyOf = async (authority: IRuntimeNetworkSigningAuthorityV1, contentController: IRuntimeControllerV1): Promise<string> => {
+const liveKeyOf = async (authority: IRuntimeNetworkSigningAuthority, contentController: IRuntimeController): Promise<string> => {
   const { publicKey } = authority;
   requireNetwork(publicKey !== null && networkEqual(authority.controller, contentController)
-    && authority.digest === await computeRuntimeNetworkSigningAuthorityV1Digest(authority));
+    && authority.digest === await computeRuntimeNetworkSigningAuthorityDigest(authority));
   return publicKey;
 };
 
 /** Sign as the authority's revision, and only with the private half of its live key. */
 const signAs = async (
-  authority: IRuntimeNetworkSigningAuthorityV1, privateKey: plugins.crypto.KeyObject, contentController: IRuntimeControllerV1,
-  envelopeOf: (reference: IRuntimeAuthorityReferenceV1) => object,
+  authority: IRuntimeNetworkSigningAuthority, privateKey: plugins.crypto.KeyObject, contentController: IRuntimeController,
+  envelopeOf: (reference: IRuntimeAuthorityReference) => object,
 ): Promise<IAuthoritySignature> => {
   requireNetwork(privateKey instanceof plugins.crypto.KeyObject && privateKey.type === 'private' && privateKey.asymmetricKeyType === 'ed25519');
   const derived = plugins.crypto.createPublicKey(privateKey).export({ format: 'jwk' });
@@ -54,7 +54,7 @@ const signAs = async (
 
 /** The receiver's own trusted revision decides; the envelope only names which revision it claims. */
 const requireSignedBy = async (
-  trusted: IRuntimeNetworkSigningAuthorityV1, signed: IAuthoritySignature, contentController: IRuntimeControllerV1, envelope: object,
+  trusted: IRuntimeNetworkSigningAuthority, signed: IAuthoritySignature, contentController: IRuntimeController, envelope: object,
 ): Promise<void> => {
   requireNetwork(networkEqual(signed.authority, networkReferenceOf(trusted)));
   const key = plugins.crypto.createPublicKey({ format: 'jwk', key: { kty: 'OKP', crv: 'Ed25519',
@@ -63,14 +63,14 @@ const requireSignedBy = async (
 };
 
 /** Sign only validated complete state and a matching dedicated private key. */
-export const signRuntimeNetworkProjectionV1 = async (
+export const signRuntimeNetworkProjection = async (
   projectionValue: unknown, authorityValue: unknown, privateKey: plugins.crypto.KeyObject,
-): Promise<ISignedRuntimeNetworkProjectionV1> => {
+): Promise<ISignedRuntimeNetworkProjection> => {
   try {
-    const input = snapshotRuntimeNetworkProjectionV1(projectionValue), authority = snapshotRuntimeNetworkSigningAuthorityV1(authorityValue);
-    const projection = await validateRuntimeNetworkProjectionV1(input);
+    const input = snapshotRuntimeNetworkProjection(projectionValue), authority = snapshotRuntimeNetworkSigningAuthority(authorityValue);
+    const projection = await validateRuntimeNetworkProjection(input);
     const signed = await signAs(authority, privateKey, projection.controller, reference => projectionEnvelope(reference, projection));
-    return { schemaVersion: 1, authority: signed.authority, projection, signature: signed.signature };
+    return { authority: signed.authority, projection, signature: signed.signature };
   } catch { return failNetwork(); }
 };
 
@@ -79,16 +79,16 @@ export const signRuntimeNetworkProjectionV1 = async (
  * This verifies content/scope/signature only. The owner still performs atomic revision
  * admission, live-session fencing, allocation barriers and conservative DNS time checks.
  */
-export const verifyRuntimeNetworkProjectionV1 = async (
+export const verifyRuntimeNetworkProjection = async (
   value: unknown, trustedAuthorityValue: unknown, trustedScopeValue: unknown,
-): Promise<ISignedRuntimeNetworkProjectionV1> => {
+): Promise<ISignedRuntimeNetworkProjection> => {
   try {
-    const signed = snapshotSignedRuntimeNetworkProjectionV1(value);
-    const authority = snapshotRuntimeNetworkSigningAuthorityV1(trustedAuthorityValue);
-    const trusted = snapshotRuntimeNetworkNodeScopeV1(trustedScopeValue);
+    const signed = snapshotSignedRuntimeNetworkProjection(value);
+    const authority = snapshotRuntimeNetworkSigningAuthority(trustedAuthorityValue);
+    const trusted = snapshotRuntimeNetworkNodeScope(trustedScopeValue);
     requireNetwork(networkSameScope(signed.projection, trusted));
     await requireSignedBy(authority, signed, signed.projection.controller, projectionEnvelope(signed.authority, signed.projection));
-    await validateRuntimeNetworkProjectionV1(signed.projection);
+    await validateRuntimeNetworkProjection(signed.projection);
     return signed;
   } catch { return failNetwork(); }
 };
@@ -98,7 +98,7 @@ export const signRuntimeNetworkDnsLeaseRenewal = async (
   renewalValue: unknown, authorityValue: unknown, privateKey: plugins.crypto.KeyObject,
 ): Promise<ISignedRuntimeNetworkDnsLeaseRenewal> => {
   try {
-    const input = snapshotRuntimeNetworkDnsLeaseRenewal(renewalValue), authority = snapshotRuntimeNetworkSigningAuthorityV1(authorityValue);
+    const input = snapshotRuntimeNetworkDnsLeaseRenewal(renewalValue), authority = snapshotRuntimeNetworkSigningAuthority(authorityValue);
     const renewal = await validateRuntimeNetworkDnsLeaseRenewal(input);
     const signed = await signAs(authority, privateKey, renewal.controller, reference => renewalEnvelope(reference, renewal));
     return { authority: signed.authority, renewal, signature: signed.signature };
@@ -120,8 +120,8 @@ export const verifyRuntimeNetworkDnsLeaseRenewal = async (
 ): Promise<ISignedRuntimeNetworkDnsLeaseRenewal> => {
   try {
     const signed = snapshotSignedRuntimeNetworkDnsLeaseRenewal(value);
-    const authority = snapshotRuntimeNetworkSigningAuthorityV1(trustedAuthorityValue);
-    const trusted = snapshotRuntimeNetworkNodeScopeV1(trustedScopeValue);
+    const authority = snapshotRuntimeNetworkSigningAuthority(trustedAuthorityValue);
+    const trusted = snapshotRuntimeNetworkNodeScope(trustedScopeValue);
     const projectionAuthority = networkReference(captureNetwork(projectionAuthorityValue));
     requireNetwork(networkSameScope(signed.renewal, trusted) && networkEqual(signed.authority, projectionAuthority));
     await requireSignedBy(authority, signed, signed.renewal.controller, renewalEnvelope(signed.authority, signed.renewal));