Go First Admission et confiance historique

Le Go AdmissionService superpose la première admission et la confiance historique au-dessus du vérificateur Signed Document en six étapes (MWP-ADM-005). Le flux indépendant de la langue est la page d’exécution locale de première admission et de confiance historique, et les exigences exactes sont les clauses locales de première admission et de confiance historique.

## Adaptateurs et résultats publics

Public API	Responsabilité
`AdmissionCurrentKeyResolver.ResolveCurrent`	Renvoie la preuve complète Organization Registry selon laquelle le déploiement affirme qu’elle est à jour pour cette décision.
`TrustedAdmissionContext.Issue`	Émettez l’ID d’enregistrement de confiance, l’acceptation instantanée et l’acceptation du service uniquement après une absence faisant autorité.
`AdmissionLog.Lookup`	Renvoie un enregistrement authentifié trouvé ou `AdmissionLookup{AuthoritativeAbsence: true}`. Échec de l’échec du cache, du délai d’attente, de l’absence non authentifiée et de l’état indéterminé sous MWP-ADM-003.
`AdmissionLog.AppendOrReturnExisting`	Ajoutez atomiquement des octets candidats ou renvoyez le gagnant faisant autorité simultané via une identité de service authentifiée.
`AuthenticatedAdmissionRecord`	Liez `RecordBytes` au service authentifié par l’adaptateur afin que MWP-ADM-009 puisse valider l’enregistrement renvoyé.
`AdmissionService.PrepareFirstAdmission`	Créez et validez des preuves de candidat à partir d’un SDK produit par `VerifiedSignedDocument`. Cela n’ajoute ni n’implique une admission.
`AdmissionService.AdmitFirst`	Effectuez la vérification actuelle, la recherche faisant autorité, la création de candidats, l’ajout ou le retour atomique de l’existant et la validation des enregistrements renvoyés sous MWP-ADM-006.
`AdmissionService.VerifyHistoricalAdmission`	Réexécutez la vérification en six étapes avec les preuves historiques Registry et exigez un enregistrement existant sans émettre de contexte ni ajouter d’ajout, comme l’exige MWP-ADM-008.
`AdmittedSignedDocument`	Renvoyez les preuves d’enregistrement vérifiées et analysées ainsi qu’une copie défensive `RecordBytes()`.

Un booléen de confiance fourni par l’appelant n’est pas un résultat de recherche d’admission et ne doit jamais sélectionner le chemin de réussite.

Ordre d’appel de première admission

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

AdmitFirst termine les six étapes du document signé avant de consulter le journal. Un enregistrement trouvé est validé et renvoyé sans émettre de contexte fiable ni ajout. Après une absence faisant autorité, le service émet un contexte approuvé, appelle PrepareFirstAdmission, appelle AppendOrReturnExisting, capture la valeur renvoyée et valide l’enregistrement réellement renvoyé. Un gagnant simultané n’est acceptable que lorsque son schéma, son service authentifié, sa liaison de document et son délai de confiance sont passés MWP-ADM-009 et MWP-ADM-010.

Relecture historique

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

La relecture historique réexécute la vérification avec l’historique Registry conservé, nécessite un enregistrement trouvé et n’appelle jamais TrustedAdmissionContext.Issue ou AdmissionLog.AppendOrReturnExisting. Les ID d’enregistrement correspondant démontrent la récupération du même enregistrement faisant autorité ; ils ne prouvent pas la fraîcheur Command, l’autorisation du signataire, l’acceptation de la machine d’état ou la vérification portable de la preuve de journal. Ceux-ci restent distincts sous MWP-ADM-013 et MWP-ADM-014.

Surface d’erreur

AdmissionError.WireCode() renvoie AUTH_INVALID_SIGNATURE, tandis que ProtectedDiagnostic().Stage() renvoie admission. Les raisons protégées stables distinguent les preuves manquantes, contradictoires, mal formées, non authentifiées, indisponibles, indéterminées et auto-ancrées tout en préservant le résultat de fil non oraculaire requis par MWP-ADM-012.

Les adaptateurs de déploiement doivent renvoyer NewAdmissionAdapterError avec une raison prise en charge lorsqu’ils ont besoin du service pour remapper une panne locale approuvée. Les erreurs arbitraires ne constituent pas une preuve d’absence d’autorité.

Exemple d’exécution exacte épinglée

L’exemple dérive de manière déterministe une clé Ed25519, construit un Registry complet et signé Command, et fournit des adaptateurs en mémoire saisis. Un sync.Mutex protège la carte faisant autorité partagée. Lookup et AppendOrReturnExisting l’acquièrent indépendamment ; le mutex rend AppendOrReturnExisting atomique lorsqu’il recherche un gagnant simultané et l’ajoute sous condition. Le protocole nécessite une recherche faisant autorité et un comportement d’ajout ou de retour atomique existant, et non une transaction couvrant les deux appels. La graine fixée est du matériel de démonstration et ne doit jamais être utilisée en dehors de l’exemple.

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())
}

Exécutez-le à partir d’une extraction exacte SDK :

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

La sortie attendue contient le même ID d’enregistrement pour first admission et historical replay. Le programme affirme également des hachages de signature et des octets d’enregistrement correspondants, ainsi qu’un seul ajout.

Remplacez currentRegistryFixture par des adaptateurs Registry actuels et historiques authentifiés, inMemoryAdmissionLog par un journal durable authentifié qui renvoie des résultats de recherche faisant autorité et rend AppendOrReturnExisting atomique sur la clé logique, et fixedTrustedAdmissionContext par Heure de confiance contrôlée par Organization et émission de service d’acceptation. Un déploiement peut utiliser une transaction plus large, mais le protocole ne nécessite pas qu’une seule transaction s’étende sur Lookup et AppendOrReturnExisting.

Remplacez deterministicSigningKey par un service de clés appartenant au déploiement. Conservez les copies d’octets défensives et ne réduisez pas les limites d’autorité en un seul booléen de confiance fourni par l’appelant.