Java Primera admisión y confianza histórica

El Java AdmissionService coloca la primera admisión y la confianza histórica por encima del verificador Signed Document de seis etapas (MWP-ADM-005). El flujo independiente del idioma es la página de tiempo de ejecución de confianza histórica y de primera admisión local , y los requisitos exactos son las cláusulas de admisión locales.

Adaptadores públicos y resultados.

Público API	Responsabilidad
`AdmissionCurrentKeyResolver.resolveCurrent`	Devuelva evidencia Organization completa de Registry que la implementación afirma que está actualizada para esta decisión.
`TrustedAdmissionContext.issue`	Emita la identificación del registro, el instante de aceptación confiable y el servicio de aceptación solo después de una constatación autoritativa de ausencia.
`AdmissionLog.lookup`	Devuelve `AdmissionLookup.Found` o `AdmissionLookup.AuthoritativeAbsence`. Fallos de pérdida de caché, tiempo de espera o ausencia no autenticada cerrados en MWP-ADM-003.
`AdmissionLog.appendOrReturnExisting`	Agregue atómicamente bytes candidatos o devuelva el registro autoritativo ganador de una carrera concurrente a través de una identidad de servicio autenticada.
`AuthenticatedAdmissionRecord`	Vincule los bytes de registro devueltos al servicio autenticado por el adaptador para MWP-ADM-009.
`AdmissionService.prepareFirstAdmission`	Crear y validar evidencia candidata a partir de un `VerifiedSignedDocument` producido por SDK; no anexa ni implica admisión.
`AdmissionService.admitFirst`	Verifique la evidencia actual, busque, prepárese después de la ausencia, agregue o devuelva lo existente y valide el registro devuelto en MWP-ADM-006.
`AdmissionService.verifyHistoricalAdmission`	Vuelva a ejecutar la verificación con evidencia histórica autoritativa del Registry y exija un registro existente sin emitir contexto ni añadirlo según MWP-ADM-008.
`PreparedFirstAdmission`, `AdmittedSignedDocument`	Conserve la verificación inmutable y registre evidencia y devuelva copias defensivas de bytes de registro.

Un valor booleano de confianza proporcionado por la persona que llama no es un resultado de búsqueda de admisión y nunca debe seleccionar la ruta exitosa.

Orden de llamada de primera admisión

AdmittedSignedDocument first =
    new AdmissionService()
        .admitFirst(
            SignedDocumentKind.COMMAND,
            document,
            currentRegistry,
            admissionLog,
            trustedContext);

admitFirst completa las seis etapas de verificación antes del acceso al registro. Un registro encontrado se valida y se devuelve sin emitir un contexto confiable ni agregarlo. Después de una constatación autoritativa de ausencia, el servicio emite el contexto, prepara bytes candidatos canónicos, llama a appendOrReturnExisting y valida el registro realmente devuelto. Un ganador simultáneo tiene éxito solo cuando el esquema, la autenticación, el enlace de documentos y el tiempo de confianza satisfacen MWP-ADM-009 y MWP-ADM-010.

Repetición histórica y errores

verifyHistoricalAdmission usa KeyResolver, vuelve a ejecutar las seis etapas, requiere AdmissionLookup.Found y nunca llama a TrustedAdmissionContext.issue o AdmissionLog.appendOrReturnExisting. Los ID de registro coincidentes recuperan el mismo registro autoritativo, pero no prueban la actualidad de Command, la autorización del firmante, la aceptación de la máquina de estado ni la verificación portátil a prueba de registros según MWP-ADM-013 y MWP-ADM-014.

Los fallos de seis etapas siguen siendo SignedDocumentVerificationException. Las fallas de la etapa de admisión son AdmissionException con código de cable AUTH_INVALID_SIGNATURE, etapa admission y AdmissionReason escrito, según lo requiere MWP-ADM-012. Los adaptadores de implementación arrojan AdmissionAdapterException; El éxito o la disponibilidad genéricos no son pruebas autenticadas.

Ejemplo ejecutable con fijación exacta

El ejemplo lee los Command y Registry firmados de los recursos empaquetados en el JAR exacto y luego proporciona adaptadores de autoridad en memoria escritos. No lee archivos del repositorio. Afirma ID de registro, hashes de firma y bytes de registro idénticos para la primera admisión y la reproducción histórica, con exactamente un anexo.

package org.missionweaveprotocol.examples;

import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import org.missionweaveprotocol.sdk.AdmissionContextValue;
import org.missionweaveprotocol.sdk.AdmissionCurrentKeyResolver;
import org.missionweaveprotocol.sdk.AdmissionLog;
import org.missionweaveprotocol.sdk.AdmissionLookup;
import org.missionweaveprotocol.sdk.AdmissionService;
import org.missionweaveprotocol.sdk.AuthenticatedAdmissionRecord;
import org.missionweaveprotocol.sdk.KeyRegistrySnapshot;
import org.missionweaveprotocol.sdk.KeyResolutionRequest;
import org.missionweaveprotocol.sdk.KeyResolver;
import org.missionweaveprotocol.sdk.Principal;
import org.missionweaveprotocol.sdk.ProtocolBundle;
import org.missionweaveprotocol.sdk.SignedDocumentKind;
import org.missionweaveprotocol.sdk.TrustedAdmissionContext;

public final class AdmissionExample {
  private static final Principal ADMISSION_SERVICE =
      new Principal("service", "urn:missionweaveprotocol:service:admission");

  private AdmissionExample() {}

  private static final class CurrentRegistry implements AdmissionCurrentKeyResolver, KeyResolver {
    private final byte[] registry;

    private CurrentRegistry(byte[] registry) {
      this.registry = registry.clone();
    }

    @Override
    public KeyRegistrySnapshot resolveCurrent(KeyResolutionRequest request) {
      return snapshot();
    }

    @Override
    public KeyRegistrySnapshot resolve(KeyResolutionRequest request) {
      return snapshot();
    }

    private KeyRegistrySnapshot snapshot() {
      return KeyRegistrySnapshot.organizationWide(registry);
    }
  }

  private static final class FixedTrustedContext implements TrustedAdmissionContext {
    @Override
    public AdmissionContextValue issue(String organizationId, String signingHash) {
      return new AdmissionContextValue(
          "urn:missionweaveprotocol:admission-record:website-example",
          "2026-07-15T00:05:00Z",
          ADMISSION_SERVICE);
    }
  }

  private static final class InMemoryAdmissionLog implements AdmissionLog {
    private final Map<String, AuthenticatedAdmissionRecord> records = new HashMap<>();
    private int appendCount;

    @Override
    public AdmissionLookup lookup(String organizationId, String signingHash) {
      AuthenticatedAdmissionRecord record = records.get(key(organizationId, signingHash));
      return record == null
          ? new AdmissionLookup.AuthoritativeAbsence()
          : new AdmissionLookup.Found(copy(record));
    }

    @Override
    public AuthenticatedAdmissionRecord appendOrReturnExisting(
        String organizationId, String signingHash, byte[] candidateBytes) {
      String key = key(organizationId, signingHash);
      AuthenticatedAdmissionRecord existing = records.get(key);
      if (existing != null) {
        return copy(existing);
      }

      AuthenticatedAdmissionRecord committed =
          new AuthenticatedAdmissionRecord(candidateBytes, ADMISSION_SERVICE);
      records.put(key, committed);
      appendCount += 1;
      return copy(committed);
    }

    private int appendCount() {
      return appendCount;
    }

    private static String key(String organizationId, String signingHash) {
      return organizationId + "\0" + signingHash;
    }

    private static AuthenticatedAdmissionRecord copy(AuthenticatedAdmissionRecord record) {
      return new AuthenticatedAdmissionRecord(record.recordBytes(), record.authenticatedService());
    }
  }

  public static void main(String[] arguments) throws Exception {
    ProtocolBundle.verifyPackaged();
    ProtocolBundle.verifyPackagedCryptographyBundle();
    ProtocolBundle.verifyPackagedAdmissionBundle();

    byte[] document = resource("cryptography/vectors/signed-documents/valid/command.json");
    CurrentRegistry currentRegistry =
        new CurrentRegistry(resource("cryptography/keys/registry-valid.json"));
    InMemoryAdmissionLog admissionLog = new InMemoryAdmissionLog();
    AdmissionService service = new AdmissionService();

    var first =
        service.admitFirst(
            SignedDocumentKind.COMMAND,
            document,
            currentRegistry,
            admissionLog,
            new FixedTrustedContext());
    var historical =
        service.verifyHistoricalAdmission(
            SignedDocumentKind.COMMAND, document, currentRegistry, admissionLog);

    if (!first.record().admissionRecordId().equals(historical.record().admissionRecordId())) {
      throw new IllegalStateException("historical replay returned a different record ID");
    }
    if (!first.verified().signingHash().equals(historical.verified().signingHash())) {
      throw new IllegalStateException("historical replay returned a different signing hash");
    }
    if (!Arrays.equals(first.recordBytes(), historical.recordBytes())) {
      throw new IllegalStateException("historical replay returned different record bytes");
    }
    if (!(admissionLog.appendCount() == 1)) {
      throw new IllegalStateException("Admission Log did not append exactly once");
    }

    System.out.println("first admission: " + first.record().admissionRecordId());
    System.out.println("historical replay: " + historical.record().admissionRecordId());
  }

  private static byte[] resource(String path) throws IOException {
    try (InputStream input = AdmissionExample.class.getClassLoader().getResourceAsStream(path)) {
      if (input == null) {
        throw new IOException("Missing packaged protocol resource: " + path);
      }
      return input.readAllBytes();
    }
  }
}

Cópielo en un checkout exacto y ejecute:

cp /absolute/path/to/examples/sdk/java/AdmissionExample.java \
  examples/src/main/java/org/missionweaveprotocol/examples/AdmissionExample.java
./mvnw -B -ntp verify
./mvnw -q -Dexec.mainClass=org.missionweaveprotocol.examples.AdmissionExample \
  -Dexec.classpathScope=test exec:java

La salida esperada contiene el mismo ID de registro para first admission y historical replay.