Go Primera admisión y confianza histórica

Go 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 confianza histórica y de primera 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 confiable, el instante de aceptación y el servicio de aceptación solo después de una constatación autoritativa de ausencia.
`AdmissionLog.Lookup`	Devuelve un registro autenticado encontrado o `AdmissionLookup{AuthoritativeAbsence: true}`. Error de caché, tiempo de espera, ausencia no autenticada y error de estado indeterminado cerrado bajo 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 `RecordBytes` al servicio autenticado por el adaptador para que MWP-ADM-009 pueda validar el registro devuelto.
`AdmissionService.PrepareFirstAdmission`	Cree y valide pruebas candidatas a partir de un `VerifiedSignedDocument` producido por SDK. No anexa ni implica admisión.
`AdmissionService.AdmitFirst`	Realice la verificación actual, la búsqueda autoritativa, la creación de candidatos, la validación atómica de anexar o devolver existente y de registros devueltos en MWP-ADM-006.
`AdmissionService.VerifyHistoricalAdmission`	Vuelva a ejecutar la verificación de seis etapas con evidencia histórica autoritativa del Registry y exija un registro existente sin emitir contexto ni añadirlo, como requiere MWP-ADM-008.
`AdmittedSignedDocument`	Devuelva evidencia de Registry verificada y analizada más una copia defensiva `RecordBytes()`.

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

first, err := missionweaveprotocol.NewAdmissionService().AdmitFirst(
    missionweaveprotocol.SignedDocumentCommand,
    documentBytes,
    currentRegistry,
    admissionLog,
    trustedContext,
)

AdmitFirst completa las seis etapas del documento firmado antes de consultar el 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 un contexto confiable, llama a PrepareFirstAdmission, invoca a AppendOrReturnExisting, toma una instantánea del valor devuelto y valida el registro realmente devuelto. Un ganador simultáneo es aceptable solo cuando su esquema, servicio autenticado, enlace de documentos y tiempo confiable pasan MWP-ADM-009 y MWP-ADM-010.

Repetición histórica

historical, err := missionweaveprotocol.NewAdmissionService().VerifyHistoricalAdmission(
    missionweaveprotocol.SignedDocumentCommand,
    documentBytes,
    historicalRegistry,
    admissionLog,
)

La reproducción histórica vuelve a ejecutar la verificación con el historial Registry retenido, requiere un registro encontrado y nunca llama a TrustedAdmissionContext.Issue o AdmissionLog.AppendOrReturnExisting. Los ID de registros coincidentes demuestran la recuperación del mismo registro autorizado; no prueban la frescura 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. Estos permanecen separados en MWP-ADM-013 y MWP-ADM-014.

Superficie de error

AdmissionError.WireCode() devuelve AUTH_INVALID_SIGNATURE, mientras que ProtectedDiagnostic().Stage() devuelve admission. Los motivos protegidos estables distinguen evidencia faltante, conflictiva, mal formada, no autenticada, no disponible, indeterminada y autoanclada, al tiempo que preservan el resultado de cable no oracular requerido por MWP-ADM-012.

Los adaptadores de implementación deben devolver NewAdmissionAdapterError con un motivo admitido cuando necesitan que el servicio reasigne una falla local confiable. Los errores arbitrarios no son prueba de una constatación autoritativa de ausencia.

Ejemplo ejecutable con fijación exacta

El ejemplo deriva de manera determinista una clave Ed25519, construye un Registry completo y un Command firmado, y proporciona adaptadores en memoria escritos. Un sync.Mutex protege el mapa autoritativo compartido. Lookup y AppendOrReturnExisting lo adquieren de forma independiente; el mutex hace que AppendOrReturnExisting sea atómico cuando busca un ganador concurrente y lo agrega condicionalmente. El protocolo requiere una búsqueda autoritativa y un comportamiento atómico de agregar o devolver lo existente, no una transacción que abarque ambas llamadas. La semilla fija es material de demostración y nunca debe usarse fuera del ejemplo.

package main

import (
	"bytes"
	"crypto/ed25519"
	"crypto/sha256"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"sync"

	missionweaveprotocol "github.com/missionweaveprotocol/go-sdk"
)

const (
	agentID        = "urn:missionweaveprotocol:agent:website-example"
	keyID          = "urn:missionweaveprotocol:key:website-example"
	organizationID = "urn:missionweaveprotocol:organization:website-example"
)

var admissionService = missionweaveprotocol.Principal{
	Type: "service",
	ID:   "urn:missionweaveprotocol:service:admission",
}

type deterministicSigningKey struct {
	privateKey ed25519.PrivateKey
}

func (deterministicSigningKey) Algorithm() string { return "Ed25519" }
func (deterministicSigningKey) KeyID() string     { return keyID }
func (key deterministicSigningKey) Sign(message []byte) ([]byte, error) {
	return ed25519.Sign(key.privateKey, message), nil
}

type currentRegistryFixture struct {
	registryBytes []byte
}

var _ missionweaveprotocol.AdmissionCurrentKeyResolver = currentRegistryFixture{}
var _ missionweaveprotocol.KeyResolver = currentRegistryFixture{}

func (fixture currentRegistryFixture) ResolveCurrent(
	_ missionweaveprotocol.KeyResolutionRequest,
) (missionweaveprotocol.KeyRegistrySnapshot, error) {
	return fixture.snapshot(), nil
}

func (fixture currentRegistryFixture) Resolve(
	_ missionweaveprotocol.KeyResolutionRequest,
) (missionweaveprotocol.KeyRegistrySnapshot, error) {
	return fixture.snapshot(), nil
}

func (fixture currentRegistryFixture) snapshot() missionweaveprotocol.KeyRegistrySnapshot {
	return missionweaveprotocol.KeyRegistrySnapshot{
		Completeness:  missionweaveprotocol.KeyRegistryOrganizationWide,
		RegistryBytes: append([]byte(nil), fixture.registryBytes...),
	}
}

type fixedTrustedAdmissionContext struct{}

var _ missionweaveprotocol.TrustedAdmissionContext = fixedTrustedAdmissionContext{}

func (fixedTrustedAdmissionContext) Issue(
	organizationID string,
	signingHash string,
) (missionweaveprotocol.AdmissionContextValue, error) {
	digest := sha256.Sum256([]byte(organizationID + "\x00" + signingHash))
	return missionweaveprotocol.AdmissionContextValue{
		AdmissionRecordID: fmt.Sprintf(
			"urn:missionweaveprotocol:admission-record:%x",
			digest,
		),
		TrustedAcceptedAt: "2026-07-15T00:05:00Z",
		AcceptedBy:        admissionService,
	}, nil
}

type inMemoryAdmissionLog struct {
	mu          sync.Mutex
	records     map[string]missionweaveprotocol.AuthenticatedAdmissionRecord
	appendCount int
}

var _ missionweaveprotocol.AdmissionLog = (*inMemoryAdmissionLog)(nil)

func (log *inMemoryAdmissionLog) Lookup(
	organizationID string,
	signingHash string,
) (missionweaveprotocol.AdmissionLookup, error) {
	log.mu.Lock()
	defer log.mu.Unlock()
	record, found := log.records[logKey(organizationID, signingHash)]
	if !found {
		return missionweaveprotocol.AdmissionLookup{AuthoritativeAbsence: true}, nil
	}
	copied := copyAuthenticatedRecord(record)
	return missionweaveprotocol.AdmissionLookup{Record: &copied}, nil
}

func (log *inMemoryAdmissionLog) AppendOrReturnExisting(
	organizationID string,
	signingHash string,
	candidateBytes []byte,
) (missionweaveprotocol.AuthenticatedAdmissionRecord, error) {
	log.mu.Lock()
	defer log.mu.Unlock()
	key := logKey(organizationID, signingHash)
	if existing, found := log.records[key]; found {
		return copyAuthenticatedRecord(existing), nil
	}
	candidate := missionweaveprotocol.AuthenticatedAdmissionRecord{
		RecordBytes:          append([]byte(nil), candidateBytes...),
		AuthenticatedService: admissionService,
	}
	log.records[key] = copyAuthenticatedRecord(candidate)
	log.appendCount++
	return copyAuthenticatedRecord(candidate), nil
}

func copyAuthenticatedRecord(
	record missionweaveprotocol.AuthenticatedAdmissionRecord,
) missionweaveprotocol.AuthenticatedAdmissionRecord {
	return missionweaveprotocol.AuthenticatedAdmissionRecord{
		RecordBytes:          append([]byte(nil), record.RecordBytes...),
		AuthenticatedService: record.AuthenticatedService,
	}
}

func logKey(organizationID string, signingHash string) string {
	return organizationID + "\x00" + signingHash
}

func main() {
	seed := make([]byte, ed25519.SeedSize)
	for index := range seed {
		seed[index] = byte(index + 1)
	}
	privateKey := ed25519.NewKeyFromSeed(seed)
	publicKey := privateKey.Public().(ed25519.PublicKey)
	signingKey := deterministicSigningKey{privateKey: privateKey}

	registryBytes, err := json.Marshal(map[string]any{
		"organizationId": organizationID,
		"bindings": []any{map[string]any{
			"keyId":           keyID,
			"principal":       map[string]any{"type": "agent", "id": agentID},
			"algorithm":       "Ed25519",
			"publicKey":       base64.RawURLEncoding.EncodeToString(publicKey),
			"validFrom":       "2026-07-01T00:00:00Z",
			"validityHistory": []any{},
		}},
	})
	if err != nil {
		panic(err)
	}
	registry := currentRegistryFixture{registryBytes: registryBytes}

	codec, err := missionweaveprotocol.NewSignedDocumentCodec()
	if err != nil {
		panic(err)
	}
	signedDocument, err := codec.Sign(
		missionweaveprotocol.SignedDocumentCommand,
		map[string]any{
			"protocolVersion": "0.1",
			"actionId":        "urn:uuid:11111111-2222-4333-8444-555555555555",
			"actor":           map[string]any{"type": "agent", "id": agentID},
			"sessionEpoch":    float64(1),
			"membershipEpoch": float64(1),
			"groupId":         "urn:missionweaveprotocol:group:website-example",
			"kind":            "message.post",
			"correlationId":   "urn:uuid:aaaaaaaa-bbbb-4ccc-8ddd-eeeeeeeeeeee",
			"issuedAt":        "2026-07-15T00:00:00Z",
			"payload":         map[string]any{"text": "Admission example"},
		},
		signingKey,
	)
	if err != nil {
		panic(err)
	}
	documentBytes, err := missionweaveprotocol.MarshalCanonicalJSON(signedDocument)
	if err != nil {
		panic(err)
	}

	admissionLog := &inMemoryAdmissionLog{
		records: make(map[string]missionweaveprotocol.AuthenticatedAdmissionRecord),
	}
	service := missionweaveprotocol.NewAdmissionService()
	first, err := service.AdmitFirst(
		missionweaveprotocol.SignedDocumentCommand,
		documentBytes,
		registry,
		admissionLog,
		fixedTrustedAdmissionContext{},
	)
	if err != nil {
		panic(err)
	}
	historical, err := service.VerifyHistoricalAdmission(
		missionweaveprotocol.SignedDocumentCommand,
		documentBytes,
		registry,
		admissionLog,
	)
	if err != nil {
		panic(err)
	}

	if !(first.Record().AdmissionRecordID() == historical.Record().AdmissionRecordID()) {
		panic("historical replay returned a different Admission record")
	}
	if !(first.Verified().SigningHash() == historical.Verified().SigningHash()) {
		panic("historical replay returned a different signing hash")
	}
	if !bytes.Equal(first.RecordBytes(), historical.RecordBytes()) {
		panic("historical replay returned different record bytes")
	}
	if !(admissionLog.appendCount == 1) {
		panic("Admission Log did not append exactly once")
	}

	fmt.Printf("first admission: %s\n", first.Record().AdmissionRecordID())
	fmt.Printf("historical replay: %s\n", historical.Record().AdmissionRecordID())
}

Ejecútelo desde un pago SDK exacto:

go test ./...
go run /absolute/path/to/examples/sdk/go/admission/main.go

El resultado esperado contiene el mismo ID de registro para first admission y historical replay. El programa también afirma que los hashes de firma y los bytes de registro coinciden y exactamente un anexo.

Reemplace currentRegistryFixture con adaptadores Registry actuales e históricos autenticados, inMemoryAdmissionLog con un registro duradero autenticado que devuelve resultados de búsqueda autoritativos y hace que AppendOrReturnExisting sea atómico sobre la clave lógica, y fixedTrustedAdmissionContext con tiempo de confianza controlado por Organization y emisión de servicio de aceptación. Una implementación puede utilizar una transacción más amplia, pero el protocolo no requiere que una transacción abarque Lookup y AppendOrReturnExisting.

Reemplace deterministicSigningKey con un servicio de claves propiedad de la implementación. Conserve copias de bytes defensivas y no colapse los límites de autoridad en un valor booleano de confianza proporcionado por la persona que llama.