Go Erstzulassung und historisches Vertrauen

Die Go-Schichten AdmissionService legen Erstzulassung und historisches Vertrauen über dem sechsstufigen Verifizierer Signed Document (MWP-ADM-005). Der sprachunabhängige Ablauf ist die lokale Laufzeitseite für Erstzulassung und historisches Vertrauen, und die genauen Anforderungen sind die lokalen First-Admission- und Historical-Trust-Klauseln.

Öffentliche Adapter und Ergebnisse

Öffentlich API	Verantwortung
`AdmissionCurrentKeyResolver.ResolveCurrent`	Geben Sie den vollständigen Organization-weiten Registry-Beweis zurück, dass die Bereitstellung für diese Entscheidung aktuell ist.
`TrustedAdmissionContext.Issue`	Vergeben Sie die vertrauenswürdige Datensatz-ID, den Annahmezeitpunkt und den Annahmedienst erst nach behördlicher Abwesenheit.
`AdmissionLog.Lookup`	Gibt einen gefundenen authentifizierten Datensatz oder `AdmissionLookup{AuthoritativeAbsence: true}` zurück. Cache-Fehler, Zeitüberschreitung, nicht authentifizierte Abwesenheit und unbestimmter Statusfehler geschlossen unter MWP-ADM-003.
`AdmissionLog.AppendOrReturnExisting`	Hängen Sie Kandidatenbytes atomar an oder geben Sie den gleichzeitigen maßgeblichen Gewinner über eine authentifizierte Dienstidentität zurück.
`AuthenticatedAdmissionRecord`	Binden Sie `RecordBytes` an den vom Adapter authentifizierten Dienst, damit MWP-ADM-009 den zurückgegebenen Datensatz validieren kann.
`AdmissionService.PrepareFirstAdmission`	Erstellen und validieren Sie Kandidatennachweise aus einem von SDK erstellten `VerifiedSignedDocument`. Es stellt keine Zulassung dar und impliziert auch keine Zulassung.
`AdmissionService.AdmitFirst`	Führen Sie unter MWP-ADM-006 eine aktuelle Überprüfung, eine maßgebliche Suche, eine Kandidatenerstellung, eine atomare Append-or-Return-Existing- und zurückgegebene Datensatzvalidierung durch.
`AdmissionService.VerifyHistoricalAdmission`	Führen Sie die sechsstufige Überprüfung erneut mit historischen Registry-Beweisen durch und fordern Sie einen vorhandenen Datensatz an, ohne Kontext auszugeben oder anzuhängen, wie von MWP-ADM-008 gefordert.
`AdmittedSignedDocument`	Geben Sie verifizierte und analysierte Datensatzbeweise sowie eine defensive `RecordBytes()`-Kopie zurück.

Ein vom Anrufer bereitgestellter boolescher Vertrauensstellungswert ist kein Ergebnis der Zulassungssuche und darf niemals den Erfolgspfad auswählen.

Reihenfolge der Erstzulassung

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

AdmitFirst schließt alle sechs Phasen des signierten Dokuments ab, bevor das Protokoll konsultiert wird. Ein gefundener Datensatz wird validiert und zurückgegeben, ohne dass ein vertrauenswürdiger Kontext ausgegeben oder ein Anhang hinzugefügt wird. Nach autoritativer Abwesenheit gibt der Dienst einen vertrauenswürdigen Kontext aus, ruft PrepareFirstAdmission auf, ruft AppendOrReturnExisting auf, erstellt einen Snapshot des zurückgegebenen Werts und validiert den tatsächlich zurückgegebenen Datensatz. Ein gleichzeitiger Gewinner ist nur akzeptabel, wenn sein Schema, sein authentifizierter Dienst, seine Dokumentbindung und seine vertrauenswürdige Zeit MWP-ADM-009 und MWP-ADM-010 verstreichen.

Historische Wiederholung

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

Die historische Wiedergabe führt die Überprüfung mit dem beibehaltenen Registry-Verlauf erneut aus, erfordert einen gefundenen Datensatz und ruft niemals TrustedAdmissionContext.Issue oder AdmissionLog.AppendOrReturnExisting auf. Übereinstimmende Datensatz-IDs zeigen die Wiederherstellung desselben maßgeblichen Datensatzes. Sie beweisen nicht die Aktualität von Command, die Autorisierung des Unterzeichners, die Akzeptanz durch die Zustandsmaschine oder die Überprüfung der tragbaren Protokollsicherheit. Diese bleiben unter MWP-ADM-013 und MWP-ADM-014 getrennt.

Fehleroberfläche

AdmissionError.WireCode() gibt AUTH_INVALID_SIGNATURE zurück, während ProtectedDiagnostic().Stage() admission zurückgibt. Stabile geschützte Gründe unterscheiden fehlende, widersprüchliche, fehlerhafte, nicht authentifizierte, nicht verfügbare, unbestimmte und selbstverankernde Beweise und bewahren gleichzeitig das von MWP-ADM-012 geforderte nicht-orakelhafte Drahtergebnis.

Bereitstellungsadapter sollten NewAdmissionAdapterError mit einem unterstützten Grund zurückgeben, wenn sie den Dienst benötigen, um einen vertrauenswürdigen lokalen Fehler neu zuzuordnen. Willkürliche Fehler sind kein Beweis für das Fehlen von Autorität.

Ausführbares, exakt angeheftetes Beispiel

Das Beispiel leitet deterministisch einen Ed25519-Schlüssel ab, erstellt einen vollständigen Registry und einen signierten Command und stellt typisierte In-Memory-Adapter bereit. Ein sync.Mutex schützt die gemeinsam genutzte maßgebliche Map. Lookup und AppendOrReturnExisting erwerben es unabhängig voneinander; Der Mutex macht AppendOrReturnExisting atomar, wenn er nach einem gleichzeitigen Gewinner sucht und bedingt anhängt. Das Protokoll erfordert eine maßgebliche Suche und ein atomares Anfügen-oder-Rückgeben-Verhalten, nicht eine einzige Transaktion, die beide Aufrufe umfasst. Der feste Seed ist Demonstrationsmaterial und darf niemals außerhalb des Beispiels verwendet werden.

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

Führen Sie es von einem exakten SDK-Checkout aus:

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

Die erwartete Ausgabe enthält dieselbe Datensatz-ID für first admission und historical replay. Das Programm stellt außerdem passende Signatur-Hashes und Datensatzbytes sowie genau ein Anhängen sicher.

Ersetzen Sie currentRegistryFixture durch authentifizierte aktuelle und historische Registry-Adapter, inMemoryAdmissionLog durch ein authentifiziertes dauerhaftes Protokoll, das maßgebliche Suchergebnisse zurückgibt und AppendOrReturnExisting über den logischen Schlüssel atomar macht, und fixedTrustedAdmissionContext durch Organization-gesteuerte vertrauenswürdige Zeit und Annahmedienstausgabe. Eine Bereitstellung kann eine umfassendere Transaktion verwenden, aber das Protokoll erfordert nicht, dass eine Transaktion Lookup und AppendOrReturnExisting umfasst.

Ersetzen Sie deterministicSigningKey durch einen Schlüsseldienst im Besitz der Bereitstellung. Behalten Sie defensive Bytekopien bei und reduzieren Sie Autoritätsgrenzen nicht auf einen vom Aufrufer bereitgestellten booleschen Vertrauenswert.