Support and consume only sequence-based export

httpapi/server.go

···
 	"net"
 	"net/http"
 	"slices"
+	"strconv"
 	"strings"
 	"sync"
 	"sync/atomic"
 	"time"
 
 	"github.com/bluesky-social/indigo/atproto/atcrypto"
-	"github.com/bluesky-social/indigo/atproto/syntax"
 	"github.com/cometbft/cometbft/node"
 	"github.com/did-method-plc/go-didplc"
 	"github.com/google/uuid"
 	cbornode "github.com/ipfs/go-ipld-cbor"
 	"github.com/palantir/stacktrace"
 	"github.com/rs/cors"
+	"github.com/samber/lo"
 
 	"tangled.org/gbl08ma/didplcbft/abciapp"
 	"tangled.org/gbl08ma/didplcbft/plc"
···
 	}
 
 	afterStr := query.Get("after")
-	after, err := syntax.ParseDatetime(afterStr)
-	if err != nil && afterStr != "" {
-		sendErrorResponse(w, http.StatusBadRequest, "Invalid after parameter")
-		return
+	after := uint64(0)
+	var err error
+	if afterStr != "" {
+		after, err = strconv.ParseUint(afterStr, 10, 64)
+		if err != nil {
+			sendErrorResponse(w, http.StatusBadRequest, "Only sequence-based pagination is supported")
+			return
+		}
 	}
 
-	entries, err := s.plc.Export(r.Context(), plc.CommittedTreeVersion, after.Time(), count)
+	entries, err := s.plc.Export(r.Context(), plc.CommittedTreeVersion, after, count)
 	if handlePLCError(w, err, "") {
 		return
 	}
 
 	w.Header().Set("Content-Type", "application/jsonlines")
+
+	type jsonEntry struct {
+		Seq  uint64 `json:"seq"`
+		Type string `json:"type"`
+		*didplc.LogEntry
+	}
 	for _, entry := range entries {
-		json.NewEncoder(w).Encode(&entry)
+		json.NewEncoder(w).Encode(jsonEntry{
+			Seq:      entry.Seq,
+			Type:     "sequenced_op",
+			LogEntry: lo.ToPtr(entry.ToDIDPLCLogEntry()),
+		})
 	}
 }
 
···
 
 // sendErrorResponse sends an error response with the specified status code and message.
 func sendErrorResponse(w http.ResponseWriter, statusCode int, message string) {
+	w.Header().Set("Content-Type", "application/json")
 	w.WriteHeader(statusCode)
 	json.NewEncoder(w).Encode(map[string]string{"message": message})
 }

httpapi/server_test.go

···
 	"github.com/did-method-plc/go-didplc"
 	"github.com/stretchr/testify/require"
 	"tangled.org/gbl08ma/didplcbft/plc"
+	"tangled.org/gbl08ma/didplcbft/types"
 )
 
 // MockReadPLC is a mock implementation of the ReadPLC interface for testing.
···
 	return didplc.RegularOp{}, nil
 }
 
-func (m *MockReadPLC) Export(ctx context.Context, atHeight plc.TreeVersion, after time.Time, count int) ([]didplc.LogEntry, error) {
+func (m *MockReadPLC) Export(ctx context.Context, atHeight plc.TreeVersion, after uint64, count int) ([]types.SequencedLogEntry, error) {
 	if m.shouldReturnError {
-		return []didplc.LogEntry{}, fmt.Errorf("internal error")
+		return []types.SequencedLogEntry{}, fmt.Errorf("internal error")
 	}
-	return []didplc.LogEntry{}, nil
+	return []types.SequencedLogEntry{}, nil
 }
 
 func TestServer(t *testing.T) {

importer/importer_test.go

···
 )
 
 func TestImportV2(t *testing.T) {
-	c, err := rpchttp.New("http://localhost:26100", "/websocket")
+	c, err := rpchttp.New("http://localhost:26657", "/websocket")
 	require.NoError(t, err)
 
 	ctx := t.Context()
···
 	var wg sync.WaitGroup
 	noMoreNewEntries := atomic.Bool{}
 	wg.Go(func() {
-		for entry := range iterateOverExport(ctx, "2023-10-10T00:00:00.000Z") {
+		for entry := range iterateOverExport(ctx, 0) {
 			if totalAwaiting.Size() > 5000 {
 				for totalAwaiting.Size() > 1000 {
 					time.Sleep(1 * time.Second)
···
 	wg.Wait()
 }
 
-func iterateOverExport(ctx context.Context, startAt string) iter.Seq[didplc.LogEntry] {
+func iterateOverExport(ctx context.Context, startAt uint64) iter.Seq[didplc.LogEntry] {
 	return func(yield func(didplc.LogEntry) bool) {
 		const batchSize = 1000
 		baseURL := didplc.DefaultDirectoryURL + "/export"
 		client := &http.Client{Timeout: 30 * time.Second}
-
-		// The /export seems to sometimes return outright duplicated entries :weary:
-		seenCIDs := map[string]struct{}{}
 
 		after := startAt
 		for {
···
 
 			q := req.URL.Query()
 			q.Add("count", fmt.Sprint(batchSize))
-			if after != "" {
-				q.Add("after", after)
-			}
+			q.Add("after", fmt.Sprint(after))
 			req.URL.RawQuery = q.Encode()
 
 			resp, err := client.Do(req)
···
 				return // Non-200 status code
 			}
 
-			entries := make([]didplc.LogEntry, 0, batchSize)
+			type logEntryWithSeq struct {
+				didplc.LogEntry
+				Seq uint64 `json:"seq"`
+			}
+
+			entries := make([]logEntryWithSeq, 0, batchSize)
 
 			// Read response body
 			s := bufio.NewScanner(resp.Body)
 			receivedEntries := 0
 			for s.Scan() {
-				var entry didplc.LogEntry
+				var entry logEntryWithSeq
 				if err := json.Unmarshal(s.Bytes(), &entry); err != nil {
 					return // Failed to decode JSON
 				}
-				if _, present := seenCIDs[entry.CID]; !present {
-					entries = append(entries, entry)
-					seenCIDs[entry.CID] = struct{}{}
-				}
+				entries = append(entries, entry)
 				receivedEntries++
 			}
 			if s.Err() != nil {
···
 			}
 
 			// Process each entry
-			var lastCreatedAt string
 			for _, entry := range entries {
-				lastCreatedAt = entry.CreatedAt
-				if !yield(entry) {
+				after = entry.Seq
+				if !yield(entry.LogEntry) {
 					return
 				}
 			}
···
 			if receivedEntries < batchSize {
 				return
 			}
-
-			after = lastCreatedAt
-
-			// Small delay to be respectful to the API
-			time.Sleep(100 * time.Millisecond)
 		}
 	}
 }

plc/impl.go

···
 	"github.com/samber/lo"
 	"github.com/samber/mo"
 	"tangled.org/gbl08ma/didplcbft/store"
+	"tangled.org/gbl08ma/didplcbft/types"
 )
 
 type TreeProvider interface {
···
 	plc.mu.Lock()
 	defer plc.mu.Unlock()
 
-	timestamp := syntax.Datetime(at.Format(store.ActualAtprotoDatetimeLayout))
+	timestamp := syntax.Datetime(at.Format(types.ActualAtprotoDatetimeLayout))
 
 	// TODO set true to false only while importing old ops
 	_, err := plc.validator.Validate(atHeight, timestamp, did, opBytes, true)
···
 	plc.mu.Lock()
 	defer plc.mu.Unlock()
 
-	timestamp := syntax.Datetime(t.Format(store.ActualAtprotoDatetimeLayout))
+	timestamp := syntax.Datetime(t.Format(types.ActualAtprotoDatetimeLayout))
 
 	// TODO set true to false only while importing old ops
 	effects, err := plc.validator.Validate(WorkingTreeVersion, timestamp, did, opBytes, true)
···
 	newCID := newEntry.CID
 	newPrev := newEntry.Operation.AsOperation().PrevCIDStr()
 
-	// TODO avoid redundant CreatedAt formating and parsing by using a specialized LogEntry type internally (i.e. between us and the store)
 	newCreatedAtDT, err := syntax.ParseDatetime(newEntry.CreatedAt)
 	if err != nil {
 		return stacktrace.Propagate(err, "")
···
 
 	mustFullyReplaceHistory := false
 	for _, entry := range l {
-		existingCreatedAt, err := syntax.ParseDatetime(entry.CreatedAt)
-		if err != nil {
-			return stacktrace.Propagate(err, "")
-		}
-		if existingCreatedAt.Time().After(newCreatedAt) {
+		if entry.CreatedAt.After(newCreatedAt) {
 			// We're trying to import an operation whose timestamp precedes one of the timestamps for operations we already know about
 			// We'll need to discard all known history and import it anew using the authoritative source data (same as when dealing with sequence forks)
 			mustFullyReplaceHistory = true
 			break
 		}
 
-		if entry.CID == newCID {
+		if entry.CID.String() == newCID && entry.Nullified == newEntry.Nullified {
 			// If an operation with the same CID already exists -> easy-ish
 
 			// this operation is already present, there is nothing to do
···
 		}
 	}
 
-	if len(l) == 0 || (!mustFullyReplaceHistory && l[len(l)-1].CID == newPrev) {
+	if len(l) == 0 || (!mustFullyReplaceHistory && l[len(l)-1].CID.String() == newPrev) {
 		// If DID doesn't exist at all -> easy
 		// If prev matches CID of latest operation, and resulting timestamp sequence monotonically increases -> easy
 		err = store.Tree.StoreOperation(tree, newEntry, mo.None[int]())
···
 		return didplc.Doc{}, stacktrace.Propagate(ErrDIDNotFound, "")
 	}
 
-	opEnum := l[len(l)-1].Operation
-	if opEnum.Tombstone != nil {
-		return didplc.Doc{}, stacktrace.Propagate(ErrDIDGone, "")
+	// find most recent operation that isn't nullified (during authoritative import, the latest operation might be nullified)
+	for i := len(l) - 1; i >= 0; i-- {
+		opEnum := l[i].Operation
+		if !l[i].Nullified {
+			if opEnum.Tombstone != nil {
+				return didplc.Doc{}, stacktrace.Propagate(ErrDIDGone, "")
+			}
+			return opEnum.AsOperation().Doc(did)
+		}
 	}
-	return opEnum.AsOperation().Doc(did)
+	// in the worst case all operations are somehow nullified and the loop ends with opEnum holding a nullified operation
+	// that _shouldn't_ be possible (right?) but if it does happen, let's just behave as if the DID was tombstoned
+	return didplc.Doc{}, stacktrace.Propagate(ErrDIDGone, "")
 }
 
 func (plc *plcImpl) OperationLog(ctx context.Context, atHeight TreeVersion, did string) ([]didplc.OpEnum, error) {
···
 		return nil, stacktrace.Propagate(ErrDIDNotFound, "")
 	}
 
-	return lo.Map(l, func(logEntry didplc.LogEntry, _ int) didplc.OpEnum {
+	l = lo.Filter(l, func(logEntry types.SequencedLogEntry, _ int) bool {
+		return !logEntry.Nullified
+	})
+
+	return lo.Map(l, func(logEntry types.SequencedLogEntry, _ int) didplc.OpEnum {
 		return logEntry.Operation
 	}), nil
 }
···
 		return nil, stacktrace.Propagate(ErrDIDNotFound, "")
 	}
 
-	return l, nil
+	// if the latest operations are nullified (happens while authoritative import is in progress), just pretend we don't have them yet,
+	// since a properly functioning PLC implementation could never have the latest operation for a DID be nullified
+	dropAfterIdx := len(l) - 1
+	for ; dropAfterIdx >= 0; dropAfterIdx-- {
+		if !l[dropAfterIdx].Nullified {
+			break
+		}
+	}
+	l = l[0 : dropAfterIdx+1]
+
+	return lo.Map(l, func(logEntry types.SequencedLogEntry, _ int) didplc.LogEntry {
+		return logEntry.ToDIDPLCLogEntry()
+	}), nil
 }
 
 func (plc *plcImpl) LastOperation(ctx context.Context, atHeight TreeVersion, did string) (didplc.OpEnum, error) {
-	// GetLastOp - /:did/log/last - latest op from audit log which isn't nullified (isn't the latest op guaranteed to not be nullified?)
+	// GetLastOp - /:did/log/last - latest op from audit log which isn't nullified
 	// if missing -> returns ErrDIDNotFound
 	// if tombstone -> returns tombstone op
 	plc.mu.Lock()
···
 		return didplc.OpEnum{}, stacktrace.Propagate(ErrDIDNotFound, "")
 	}
 
-	return l[len(l)-1].Operation, nil
+	// find most recent operation that isn't nullified (during authoritative import, the latest operation might be nullified)
+	for i := len(l) - 1; i >= 0; i-- {
+		opEnum := l[i].Operation
+		if !l[i].Nullified {
+			return opEnum, nil
+		}
+	}
+	// in the worst case all operations are somehow nullified and the loop ends with opEnum holding a nullified operation
+	// that _shouldn't_ be possible (right?) but if it does happen, let's just behave as if the DID did not exist
+	return didplc.OpEnum{}, stacktrace.Propagate(ErrDIDNotFound, "")
 }
 
 func (plc *plcImpl) Data(ctx context.Context, atHeight TreeVersion, did string) (didplc.RegularOp, error) {
···
 		return didplc.RegularOp{}, stacktrace.Propagate(ErrDIDNotFound, "")
 	}
 
-	opEnum := l[len(l)-1].Operation
-	if opEnum.Tombstone != nil {
-		return didplc.RegularOp{}, stacktrace.Propagate(ErrDIDGone, "")
+	// find most recent operation that isn't nullified (during authoritative import, the latest operation might be nullified)
+	for i := len(l) - 1; i >= 0; i-- {
+		opEnum := l[i].Operation
+		if !l[i].Nullified {
+			if opEnum.Tombstone != nil {
+				return didplc.RegularOp{}, stacktrace.Propagate(ErrDIDGone, "")
+			}
+			if opEnum.Regular != nil {
+				return *opEnum.Regular, nil
+			}
+			return *modernizeOp(opEnum.Legacy), nil
+		}
 	}
-	if opEnum.Regular != nil {
-		return *opEnum.Regular, nil
-	}
-	return *modernizeOp(opEnum.Legacy), nil
+	// in the worst case all operations are somehow nullified and the loop ends with opEnum holding a nullified operation
+	// that _shouldn't_ be possible (right?) but if it does happen, let's just behave as if the DID was tombstoned
+	return didplc.RegularOp{}, stacktrace.Propagate(ErrDIDGone, "")
+
 }
 
-func (plc *plcImpl) Export(ctx context.Context, atHeight TreeVersion, after time.Time, count int) ([]didplc.LogEntry, error) {
+func (plc *plcImpl) Export(ctx context.Context, atHeight TreeVersion, after uint64, count int) ([]types.SequencedLogEntry, error) {
 	plc.mu.Lock()
 	defer plc.mu.Unlock()
 
···
 	plc *plcImpl
 }
 
-func (a *inMemoryAuditLogFetcher) AuditLogReverseIterator(atHeight TreeVersion, did string, retErr *error) iter.Seq2[int, didplc.LogEntry] {
+func (a *inMemoryAuditLogFetcher) AuditLogReverseIterator(atHeight TreeVersion, did string, retErr *error) iter.Seq2[int, types.SequencedLogEntry] {
 	tree, err := a.plc.treeProvider.ImmutableTree(atHeight)
 	if err != nil {
 		*retErr = stacktrace.Propagate(err, "")
-		return func(yield func(int, didplc.LogEntry) bool) {}
+		return func(yield func(int, types.SequencedLogEntry) bool) {}
 	}
 
 	return store.Tree.AuditLogReverseIterator(tree, did, retErr)

plc/operation_validator.go

···
 	"github.com/did-method-plc/go-didplc"
 	"github.com/palantir/stacktrace"
 	"github.com/samber/mo"
+	"tangled.org/gbl08ma/didplcbft/types"
 )
 
 type AuditLogFetcher interface {
 	// AuditLogReverseIterator should return an iterator over the list of log entries for the specified DID, in reverse
-	AuditLogReverseIterator(atHeight TreeVersion, did string, err *error) iter.Seq2[int, didplc.LogEntry]
+	AuditLogReverseIterator(atHeight TreeVersion, did string, err *error) iter.Seq2[int, types.SequencedLogEntry]
 }
 
 type V0OperationValidator struct {
···
 
 	proposedPrev := op.PrevCIDStr()
 
-	partialLog := make(map[int]didplc.LogEntry)
+	partialLog := make(map[int]types.SequencedLogEntry)
 	mostRecentOpIndex := -1
 	indexOfPrev := -1
 	var iteratorErr error
···
 			}
 		}
 
-		if entry.CID == proposedPrev {
+		if entry.CID.String() == proposedPrev {
 			indexOfPrev = entryIdx
 			break
 		}
···
 		return OperationEffects{}, stacktrace.Propagate(iteratorErr, "")
 	}
 
-	nullifiedEntries := []didplc.LogEntry{}
+	nullifiedEntries := []types.SequencedLogEntry{}
 	nullifiedEntriesStartingIndex := mo.None[int]()
 
 	if mostRecentOpIndex < 0 {
···
 
 		// timestamps must increase monotonically
 		mostRecentOp := partialLog[mostRecentOpIndex]
-		mostRecentCreatedAt, err := syntax.ParseDatetime(mostRecentOp.CreatedAt)
-		if err != nil {
-			return OperationEffects{}, stacktrace.Propagate(err, "reached invalid internal state")
-		}
-		if !timestamp.Time().After(mostRecentCreatedAt.Time()) {
+		if !timestamp.Time().After(mostRecentOp.CreatedAt) {
 			return OperationEffects{}, stacktrace.Propagate(ErrInvalidOperationSequence, "")
 		}
 
···
 			}
 
 			// recovery key gets a 72hr window to do historical re-writes
-			firstNullifiedCreatedAt, err := syntax.ParseDatetime(nullifiedEntries[0].CreatedAt)
-			if err != nil {
-				return OperationEffects{}, stacktrace.Propagate(err, "reached invalid internal state")
-			}
-			if timestamp.Time().Sub(firstNullifiedCreatedAt.Time()) > 72*time.Hour {
+			if timestamp.Time().Sub(nullifiedEntries[0].CreatedAt) > 72*time.Hour {
 				return OperationEffects{}, stacktrace.Propagate(ErrRecoveryWindowExpired, "")
 			}
 		} else {
···
 	for _, entry := range v.auditLogFetcher.AuditLogReverseIterator(atHeight, did, &err) {
 		if entry.Nullified {
 			// The typescript implementation operates over a `ops` array which doesn't include nullified ops
-			// (With recovery ops also skipping rate limits, doesn't this leave the PLC vulnerable to the spam of constant recovery operations?)
+			// (With recovery ops also skipping rate limits, doesn't this leave the PLC vulnerable to the spam of constant recovery operations? TODO investigate)
 			continue
 		}
-		// Parse the CreatedAt timestamp string
-		// The CreatedAt field is stored as a string in ISO 8601 format
-		opDatetime, err := syntax.ParseDatetime(entry.CreatedAt)
-		if err != nil {
-			return stacktrace.Propagate(err, "")
-		}
-		opTime := opDatetime.Time()
+		opTime := entry.CreatedAt
 
 		if opTime.Before(weekAgo) {
 			// operations are always ordered by timestamp, and we're iterating from newest to oldest

plc/plc.go

···
 
 	"github.com/bluesky-social/indigo/atproto/syntax"
 	"github.com/did-method-plc/go-didplc"
+	"tangled.org/gbl08ma/didplcbft/types"
 )
 
 var ErrDIDNotFound = errors.New("DID not found")
···
 	AuditLog(ctx context.Context, atHeight TreeVersion, did string) ([]didplc.LogEntry, error)
 	LastOperation(ctx context.Context, atHeight TreeVersion, did string) (didplc.OpEnum, error)
 	Data(ctx context.Context, atHeight TreeVersion, did string) (didplc.RegularOp, error)
-	Export(ctx context.Context, atHeight TreeVersion, after time.Time, count int) ([]didplc.LogEntry, error)
+	Export(ctx context.Context, atHeight TreeVersion, after uint64, count int) ([]types.SequencedLogEntry, error)
 }
 
 type WritePLC interface {

plc/plc_test.go

···
 	"github.com/samber/lo"
 	"github.com/stretchr/testify/require"
 	"tangled.org/gbl08ma/didplcbft/plc"
+	"tangled.org/gbl08ma/didplcbft/types"
 )
 
 func TestPLC(t *testing.T) {
···
 	doc, err = testPLC.Resolve(ctx, plc.SpecificTreeVersion(origVersion+4), testDID)
 	require.NoError(t, err)
 
-	export, err := testPLC.Export(ctx, plc.CommittedTreeVersion, time.Time{}, 1000)
+	export, err := testPLC.Export(ctx, plc.CommittedTreeVersion, 0, 1000)
 	require.NoError(t, err)
 	require.Len(t, export, 3)
 
 	require.Equal(t, "bafyreifgafcel2okxszhgbugieyvtmfig2gtf3dgqoh5fvdh3nlh6ncv6q", export[0].Operation.AsOperation().CID().String())
-	require.Equal(t, "bafyreifgafcel2okxszhgbugieyvtmfig2gtf3dgqoh5fvdh3nlh6ncv6q", export[0].CID)
+	require.Equal(t, "bafyreifgafcel2okxszhgbugieyvtmfig2gtf3dgqoh5fvdh3nlh6ncv6q", export[0].CID.String())
 	require.Equal(t, "bafyreia6ewwkwjgly6dijfepaq2ey6zximodbtqqi5f6fyugli3cxohn5m", export[1].Operation.AsOperation().CID().String())
-	require.Equal(t, "bafyreia6ewwkwjgly6dijfepaq2ey6zximodbtqqi5f6fyugli3cxohn5m", export[1].CID)
+	require.Equal(t, "bafyreia6ewwkwjgly6dijfepaq2ey6zximodbtqqi5f6fyugli3cxohn5m", export[1].CID.String())
 	require.Equal(t, "bafyreigyzl2esgnk7nvav5myvgywbshdmatzthc73iiar7tyeq3xjt47m4", export[2].Operation.AsOperation().CID().String())
-	require.Equal(t, "bafyreigyzl2esgnk7nvav5myvgywbshdmatzthc73iiar7tyeq3xjt47m4", export[2].CID)
+	require.Equal(t, "bafyreigyzl2esgnk7nvav5myvgywbshdmatzthc73iiar7tyeq3xjt47m4", export[2].CID.String())
 
-	// the after parameter is exclusive, we should just get the second successful operation
-	export, err = testPLC.Export(ctx, plc.CommittedTreeVersion, operations[1].ApplyAt.Time(), 1)
+	// the after parameter is exclusive, with a limit of 1, we should just get the second successful operation
+	export, err = testPLC.Export(ctx, plc.CommittedTreeVersion, export[0].Seq, 1)
 	require.NoError(t, err)
 	require.Len(t, export, 1)
-	require.Equal(t, "bafyreia6ewwkwjgly6dijfepaq2ey6zximodbtqqi5f6fyugli3cxohn5m", export[0].CID)
+	require.Equal(t, "bafyreia6ewwkwjgly6dijfepaq2ey6zximodbtqqi5f6fyugli3cxohn5m", export[0].CID.String())
 }
 
 func TestPLCFromRemoteOperations(t *testing.T) {
···
 		}
 	}
 
-	export, err := testPLC.Export(ctx, plc.CommittedTreeVersion, time.Time{}, 0)
+	export, err := testPLC.Export(ctx, plc.CommittedTreeVersion, 0, 0)
 	require.NoError(t, err)
-	require.Len(t, export, 96)
+	require.Len(t, export, 100)
 
 	// ensure entries are sorted correctly
-	last := time.Time{}
+	last := uint64(0)
 	for _, entry := range export {
-		et, err := syntax.ParseDatetime(entry.CreatedAt)
-		require.NoError(t, err)
-		require.True(t, et.Time().After(last))
-		last = et.Time()
+		require.True(t, entry.Seq > last)
+		last = entry.Seq
 	}
 }
 
···
 	require.NoError(t, err)
 
 	seenCIDs := map[string]struct{}{}
-	for entry := range iterateOverExport(ctx, "") {
+	for entry := range iterateOverExport(ctx, 0) {
 		err := testPLC.ImportOperationFromAuthoritativeSource(ctx, entry, func() ([]didplc.LogEntry, error) {
 			e, err := client.AuditLog(ctx, entry.DID)
 			return e, stacktrace.Propagate(err, "")
···
 		require.NoError(t, err)
 
 		seenCIDs[entry.CID] = struct{}{}
-		if len(seenCIDs) == 4000 {
+		if len(seenCIDs) == 10000 {
 			break
 		}
 	}
···
 	_, _, err = tree.SaveVersion()
 	require.NoError(t, err)
 
-	exportedEntries, err := testPLC.Export(ctx, plc.CommittedTreeVersion, time.Time{}, len(seenCIDs)+1)
+	exportedEntries, err := testPLC.Export(ctx, plc.CommittedTreeVersion, 0, len(seenCIDs)+1)
 	require.NoError(t, err)
 
 	require.Len(t, exportedEntries, len(seenCIDs))
 
 	for _, exportedEntry := range exportedEntries {
-		delete(seenCIDs, exportedEntry.CID)
+		delete(seenCIDs, exportedEntry.CID.String())
 	}
 	require.Empty(t, seenCIDs)
 }
 
-func iterateOverExport(ctx context.Context, startAt string) iter.Seq[didplc.LogEntry] {
+func TestImportOperationWithNullification(t *testing.T) {
+	var client didplc.Client
+
+	ctx := t.Context()
+
+	testFn := func(toImport []didplc.LogEntry, mutate func(didplc.LogEntry) didplc.LogEntry) ([]types.SequencedLogEntry, []didplc.LogEntry) {
+		treeProvider := NewTestTreeProvider()
+		testPLC := plc.NewPLC(treeProvider)
+
+		tree, err := treeProvider.MutableTree()
+		require.NoError(t, err)
+		_, _, err = tree.SaveVersion()
+		require.NoError(t, err)
+
+		for _, entry := range toImport {
+			entry = mutate(entry)
+			err := testPLC.ImportOperationFromAuthoritativeSource(ctx, entry, func() ([]didplc.LogEntry, error) {
+				e, err := client.AuditLog(ctx, entry.DID)
+				return e, stacktrace.Propagate(err, "")
+			})
+			require.NoError(t, err)
+		}
+
+		_, _, err = tree.SaveVersion()
+		require.NoError(t, err)
+
+		exportedEntries, err := testPLC.Export(ctx, plc.CommittedTreeVersion, 0, len(toImport)+1)
+		require.NoError(t, err)
+
+		require.Len(t, exportedEntries, len(toImport))
+
+		auditLog, err := testPLC.AuditLog(ctx, plc.CommittedTreeVersion, "did:plc:pkmfz5soq2swsvbhvjekb36g")
+		require.NoError(t, err)
+
+		return exportedEntries, auditLog
+	}
+
+	toImport, err := client.AuditLog(ctx, "did:plc:pkmfz5soq2swsvbhvjekb36g")
+	require.NoError(t, err)
+
+	exportedEntries, auditLog := testFn(toImport, func(le didplc.LogEntry) didplc.LogEntry { return le })
+	require.Len(t, auditLog, len(toImport))
+
+	for i, entry := range exportedEntries {
+		require.Equal(t, uint64(i+1), entry.Seq)
+		require.Equal(t, toImport[i].CID, entry.CID.String())
+		require.Equal(t, toImport[i].CID, auditLog[i].CID)
+		require.Equal(t, toImport[i].CreatedAt, entry.CreatedAt.Format(types.ActualAtprotoDatetimeLayout))
+		require.Equal(t, toImport[i].CreatedAt, auditLog[i].CreatedAt)
+		require.Equal(t, toImport[i].Nullified, entry.Nullified)
+		require.Equal(t, toImport[i].Nullified, auditLog[i].Nullified)
+	}
+
+	// ensure auditLog never returns nullified entries as the last entries
+	exportedEntries, auditLog = testFn(toImport[0:5], func(le didplc.LogEntry) didplc.LogEntry { return le })
+
+	require.Len(t, exportedEntries, 5)
+	require.Len(t, auditLog, 1)
+	require.False(t, auditLog[0].Nullified)
+	require.Equal(t, auditLog[0].CID, "bafyreid2tbopmtuguvuvij5kjcqo7rv7yvqza37uvfcvk5zdxyo57xlfdi")
+
+	// now pretend that at the time of import, no operations were nullified
+	exportedEntries, auditLog = testFn(toImport, func(le didplc.LogEntry) didplc.LogEntry {
+		le.Nullified = false
+		return le
+	})
+	require.Len(t, auditLog, len(toImport))
+
+	for i, entry := range exportedEntries {
+		if i < 1 {
+			require.Equal(t, uint64(i+1), entry.Seq)
+		} else {
+			require.Equal(t, uint64(i+5), entry.Seq)
+		}
+		require.Equal(t, toImport[i].CID, entry.CID.String())
+		require.Equal(t, toImport[i].CID, auditLog[i].CID)
+		require.Equal(t, toImport[i].CreatedAt, entry.CreatedAt.Format(types.ActualAtprotoDatetimeLayout))
+		require.Equal(t, toImport[i].CreatedAt, auditLog[i].CreatedAt)
+		require.Equal(t, toImport[i].Nullified, entry.Nullified)
+		require.Equal(t, toImport[i].Nullified, auditLog[i].Nullified)
+	}
+
+	// now manipulate the timestamp on the first operation just to see the first operation get rewritten
+	exportedEntries, auditLog = testFn(toImport, func(le didplc.LogEntry) didplc.LogEntry {
+		if le.CID == "bafyreid2tbopmtuguvuvij5kjcqo7rv7yvqza37uvfcvk5zdxyo57xlfdi" {
+			// this should cause mustFullyReplaceHistory to become true
+			le.CreatedAt = syntax.DatetimeNow().String()
+		}
+		return le
+	})
+	require.Len(t, auditLog, len(toImport))
+
+	for i, entry := range exportedEntries {
+		require.Equal(t, uint64(i+2), entry.Seq)
+		require.Equal(t, toImport[i].CID, entry.CID.String())
+		require.Equal(t, toImport[i].CID, auditLog[i].CID)
+		require.Equal(t, toImport[i].CreatedAt, entry.CreatedAt.Format(types.ActualAtprotoDatetimeLayout))
+		require.Equal(t, toImport[i].CreatedAt, auditLog[i].CreatedAt)
+		require.Equal(t, toImport[i].Nullified, entry.Nullified)
+		require.Equal(t, toImport[i].Nullified, auditLog[i].Nullified)
+	}
+}
+
+func iterateOverExport(ctx context.Context, startAt uint64) iter.Seq[didplc.LogEntry] {
 	return func(yield func(didplc.LogEntry) bool) {
 		const batchSize = 1000
 		baseURL := didplc.DefaultDirectoryURL + "/export"
 		client := &http.Client{Timeout: 30 * time.Second}
-
-		// The /export seems to sometimes return outright duplicated entries :weary:
-		seenCIDs := map[string]struct{}{}
 
 		after := startAt
 		for {
···
 
 			q := req.URL.Query()
 			q.Add("count", fmt.Sprint(batchSize))
-			if after != "" {
-				q.Add("after", after)
-			}
+			q.Add("after", fmt.Sprint(after))
 			req.URL.RawQuery = q.Encode()
 
 			resp, err := client.Do(req)
···
 				return // Non-200 status code
 			}
 
-			entries := make([]didplc.LogEntry, 0, batchSize)
+			type logEntryWithSeq struct {
+				didplc.LogEntry
+				Seq uint64 `json:"seq"`
+			}
+
+			entries := make([]logEntryWithSeq, 0, batchSize)
 
 			// Read response body
 			s := bufio.NewScanner(resp.Body)
 			receivedEntries := 0
 			for s.Scan() {
-				var entry didplc.LogEntry
+				var entry logEntryWithSeq
 				if err := json.Unmarshal(s.Bytes(), &entry); err != nil {
 					return // Failed to decode JSON
 				}
-				if _, present := seenCIDs[entry.CID]; !present {
-					entries = append(entries, entry)
-					seenCIDs[entry.CID] = struct{}{}
-				}
+				entries = append(entries, entry)
 				receivedEntries++
 			}
 			if s.Err() != nil {
···
 			}
 
 			// Process each entry
-			var lastCreatedAt string
 			for _, entry := range entries {
-				lastCreatedAt = entry.CreatedAt
-				if !yield(entry) {
+				after = entry.Seq
+				if !yield(entry.LogEntry) {
 					return
 				}
 			}
···
 			if receivedEntries < batchSize {
 				return
 			}
-
-			after = lastCreatedAt
 		}
 	}
 }

store/tree.go

···
 	"encoding/base32"
 	"encoding/binary"
 	"iter"
+	"math"
 	"slices"
 	"strings"
 	"time"
···
 	"github.com/polydawn/refmt/obj/atlas"
 	"github.com/samber/lo"
 	"github.com/samber/mo"
+	"tangled.org/gbl08ma/didplcbft/types"
 )
 
-// ActualAtprotoDatetimeLayout is the format for CreatedAt timestamps
-// AtprotoDatetimeLayout as defined by github.com/bluesky-social/indigo/atproto/syntax omits trailing zeros in the milliseconds
-// This doesn't match how the official plc.directory implementation formats them, so we define that format here with trailing zeros included
-const ActualAtprotoDatetimeLayout = "2006-01-02T15:04:05.000Z"
-
 var Tree PLCTreeStore = &TreeStore{}
 
 type PLCTreeStore interface {
-	AuditLog(tree ReadOnlyTree, did string, withProof bool) ([]didplc.LogEntry, *ics23.CommitmentProof, error)
-	AuditLogReverseIterator(tree ReadOnlyTree, did string, err *error) iter.Seq2[int, didplc.LogEntry]
-	ExportOperations(tree ReadOnlyTree, after time.Time, count int) ([]didplc.LogEntry, error) // passing a count of zero means unlimited
+	AuditLog(tree ReadOnlyTree, did string, withProof bool) ([]types.SequencedLogEntry, *ics23.CommitmentProof, error)
+	AuditLogReverseIterator(tree ReadOnlyTree, did string, err *error) iter.Seq2[int, types.SequencedLogEntry]
+	ExportOperations(tree ReadOnlyTree, after uint64, count int) ([]types.SequencedLogEntry, error) // passing a count of zero means unlimited
 	StoreOperation(tree *iavl.MutableTree, entry didplc.LogEntry, nullifyWithIndexEqualOrGreaterThan mo.Option[int]) error
 	ReplaceHistory(tree *iavl.MutableTree, history []didplc.LogEntry) error
 }
···
 // TreeStore exists just to groups methods nicely
 type TreeStore struct{}
 
-func (t *TreeStore) AuditLog(tree ReadOnlyTree, did string, withProof bool) ([]didplc.LogEntry, *ics23.CommitmentProof, error) {
+func (t *TreeStore) AuditLog(tree ReadOnlyTree, did string, withProof bool) ([]types.SequencedLogEntry, *ics23.CommitmentProof, error) {
 	proofs := []*ics23.CommitmentProof{}
 
 	didBytes, err := didToBytes(did)
···
 			return nil, nil, stacktrace.Propagate(err, "")
 		}
 		operationKeys = make([][]byte, 0, len(logOperations)/8)
-		for ts := range slices.Chunk(logOperations, 8) {
-			operationKeys = append(operationKeys, timestampBytesToDIDOperationKey(ts, didBytes))
+		for seqBytes := range slices.Chunk(logOperations, 8) {
+			operationKeys = append(operationKeys, sequenceBytesToOperationKey(seqBytes))
 		}
 	}
 
···
 		proofs = append(proofs, proof)
 	}
 
-	logEntries := make([]didplc.LogEntry, 0, len(operationKeys))
+	logEntries := make([]types.SequencedLogEntry, 0, len(operationKeys))
 	for _, opKey := range operationKeys {
 		operationValue, err := tree.Get(opKey)
 		if err != nil {
···
 			proofs = append(proofs, proof)
 		}
 
-		nullified, operation, err := unmarshalOperationValue(operationValue)
+		logEntry, err := unmarshalLogEntry(opKey, operationValue)
 		if err != nil {
 			return nil, nil, stacktrace.Propagate(err, "")
 		}
 
-		timestamp, actualDID, err := unmarshalOperationKey(opKey)
-		if err != nil {
-			return nil, nil, stacktrace.Propagate(err, "")
-		}
-
-		logEntries = append(logEntries, didplc.LogEntry{
-			DID:       actualDID,
-			Operation: operation,
-			CID:       operation.AsOperation().CID().String(),
-			Nullified: nullified,
-			CreatedAt: timestamp.Format(ActualAtprotoDatetimeLayout),
-		})
+		logEntries = append(logEntries, logEntry)
 	}
 
 	var combinedProof *ics23.CommitmentProof
···
 	return logEntries, combinedProof, nil
 }
 
-func (t *TreeStore) AuditLogReverseIterator(tree ReadOnlyTree, did string, retErr *error) iter.Seq2[int, didplc.LogEntry] {
-	return func(yield func(int, didplc.LogEntry) bool) {
+func (t *TreeStore) AuditLogReverseIterator(tree ReadOnlyTree, did string, retErr *error) iter.Seq2[int, types.SequencedLogEntry] {
+	return func(yield func(int, types.SequencedLogEntry) bool) {
 		didBytes, err := didToBytes(did)
 		if err != nil {
 			*retErr = stacktrace.Propagate(err, "")
···
 				return
 			}
 			operationKeys = make([][]byte, 0, len(logOperations)/8)
-			for ts := range slices.Chunk(logOperations, 8) {
-				operationKeys = append(operationKeys, timestampBytesToDIDOperationKey(ts, didBytes))
+			for seqBytes := range slices.Chunk(logOperations, 8) {
+				operationKeys = append(operationKeys, sequenceBytesToOperationKey(seqBytes))
 			}
 		}
 
···
 				return
 			}
 
-			nullified, operation, err := unmarshalOperationValue(operationValue)
+			logEntry, err := unmarshalLogEntry(opKey, operationValue)
 			if err != nil {
 				*retErr = stacktrace.Propagate(err, "")
 				return
 			}
 
-			timestamp, actualDID, err := unmarshalOperationKey(opKey)
-			if err != nil {
-				*retErr = stacktrace.Propagate(err, "")
-				return
-			}
-
-			if !yield(i, didplc.LogEntry{
-				DID:       actualDID,
-				Operation: operation,
-				CID:       operation.AsOperation().CID().String(),
-				Nullified: nullified,
-				CreatedAt: timestamp.Format(ActualAtprotoDatetimeLayout),
-			}) {
+			if !yield(i, logEntry) {
 				return
 			}
 		}
 	}
 }
 
-func (t *TreeStore) ExportOperations(tree ReadOnlyTree, after time.Time, count int) ([]didplc.LogEntry, error) {
+func (t *TreeStore) ExportOperations(tree ReadOnlyTree, after uint64, count int) ([]types.SequencedLogEntry, error) {
 	// as the name suggests, after is an exclusive lower bound, but our iterators use inclusive lower bounds
-	start := after.Add(1 * time.Nanosecond)
-	startKey := marshalOperationKey(start, make([]byte, 15))
-	if after.UnixNano() < 0 {
-		// our storage format doesn't deal well with negative unix timestamps,
-		// but that's fine because we don't have operations created that far back. assume we just want to iterate from the start
-		copy(startKey[1:8], make([]byte, 8))
-	}
+	start := after + 1
+	startKey := marshalOperationKey(start)
+	endKey := maxOperationKey
 
-	entries := make([]didplc.LogEntry, 0, count)
+	entries := make([]types.SequencedLogEntry, 0, count)
 	var iterErr error
-	tree.IterateRange(startKey, nil, true, func(operationKey, operationValue []byte) bool {
-		nullified, operation, err := unmarshalOperationValue(operationValue)
+	tree.IterateRange(startKey, endKey, true, func(operationKey, operationValue []byte) bool {
+		logEntry, err := unmarshalLogEntry(operationKey, operationValue)
 		if err != nil {
 			iterErr = stacktrace.Propagate(err, "")
 			return true
 		}
 
-		timestamp, actualDID, err := unmarshalOperationKey(operationKey)
-		if err != nil {
-			iterErr = stacktrace.Propagate(err, "")
-			return true
-		}
-
-		entries = append(entries, didplc.LogEntry{
-			DID:       actualDID,
-			Operation: operation,
-			CID:       operation.AsOperation().CID().String(),
-			Nullified: nullified,
-			CreatedAt: timestamp.Format(ActualAtprotoDatetimeLayout),
-		})
+		entries = append(entries, logEntry)
 		return len(entries) == count // this condition being checked here also makes it so that a count of zero means unlimited
 	})
 	if iterErr != nil {
···
 			operationKeys = [][]byte{}
 		} else {
 			operationKeys = make([][]byte, 0, len(logOperations)/8)
-			for ts := range slices.Chunk(logOperations, 8) {
-				operationKeys = append(operationKeys, timestampBytesToDIDOperationKey(ts, didBytes))
+			for seqBytes := range slices.Chunk(logOperations, 8) {
+				operationKeys = append(operationKeys, sequenceBytesToOperationKey(seqBytes))
 			}
 		}
 
···
 		return stacktrace.Propagate(err, "invalid CreatedAt")
 	}
 
+	seq, err := getNextSeqID(tree)
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+
 	operation := entry.Operation.AsOperation()
-	opKey := marshalOperationKey(opDatetime.Time(), didBytes)
-	opValue := marshalOperationValue(entry.Nullified, operation)
+	opKey := marshalOperationKey(seq)
+	opValue := marshalOperationValue(entry.Nullified, didBytes, opDatetime.Time(), operation)
 
 	_, err = tree.Set(opKey, opValue)
 	if err != nil {
···
 	return nil
 }
 
-func (t *TreeStore) ReplaceHistory(tree *iavl.MutableTree, history []didplc.LogEntry) error {
-	if len(history) == 0 {
+func (t *TreeStore) ReplaceHistory(tree *iavl.MutableTree, remoteHistory []didplc.LogEntry) error {
+	if len(remoteHistory) == 0 {
 		// for now this isn't needed, if it's needed in the future we'll have to accept a DID as argument on this function
 		return stacktrace.NewError("can't replace with empty history")
 	}
 
-	did := history[0].DID
+	did := remoteHistory[0].DID
 
 	didBytes, err := didToBytes(did)
 	if err != nil {
···
 
 	logKey := marshalDIDLogKey(didBytes)
 
-	// identify keys of existing operations for this DID (if any)
-	var prevOpKeys [][]byte
-	logOperations, err := tree.Get(logKey)
+	localHistory, _, err := t.AuditLog(tree, did, false)
 	if err != nil {
 		return stacktrace.Propagate(err, "")
 	}
-	prevOpKeys = make([][]byte, 0, len(logOperations)/8)
-	for ts := range slices.Chunk(logOperations, 8) {
-		prevOpKeys = append(prevOpKeys, timestampBytesToDIDOperationKey(ts, didBytes))
+
+	// if the first operations are equal to what we already have, keep them untouched to minimize the turmoil
+	keepLocalBeforeIdx := 0
+	for i, localEntry := range localHistory {
+		if i >= len(remoteHistory) {
+			break
+		}
+		remoteEntry := remoteHistory[i]
+
+		// stop looping once we find a difference
+		// we trust that the authoritative source computes CIDs properly (i.e. that two operations having the same CID are indeed equal)
+		if localEntry.Nullified != remoteEntry.Nullified || localEntry.CID.String() != remoteEntry.CID {
+			break
+		}
+
+		remoteDatetime, err := syntax.ParseDatetime(remoteEntry.CreatedAt)
+		if err != nil {
+			return stacktrace.Propagate(err, "invalid CreatedAt")
+		}
+
+		if !localEntry.CreatedAt.Equal(remoteDatetime.Time()) {
+			break
+		}
+
+		keepLocalBeforeIdx++
 	}
 
-	// remove existing operations for this DID (if any)
-	for _, key := range prevOpKeys {
+	// all replaced/added operations get new sequence IDs.
+	// Get the highest sequence ID before removing any keys to ensure the sequence IDs actually change
+	seq, err := getNextSeqID(tree)
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+
+	// remove existing conflicting operations for this DID (if any)
+	logOperations, err := tree.Get(logKey)
+	if err != nil {
+		return stacktrace.Propagate(err, "")
+	}
+	logOperationsToDelete := logOperations[8*keepLocalBeforeIdx:]
+	for seqBytes := range slices.Chunk(logOperationsToDelete, 8) {
+		key := sequenceBytesToOperationKey(seqBytes)
+
 		_, _, err = tree.Remove(key)
 		if err != nil {
 			return stacktrace.Propagate(err, "")
 		}
 	}
 
-	// add new list of operations
-	logOperations = make([]byte, 0, len(history)*8)
-	for _, entry := range history {
+	// add just the operations past the point they weren't kept
+	remoteHistory = remoteHistory[keepLocalBeforeIdx:]
+
+	// keep the operations log up until the point we've kept the history
+	// clone just to make sure we avoid issues since we got this slice from the tree, it is not meant to be modified
+	logOperations = slices.Clone(logOperations[0 : 8*keepLocalBeforeIdx])
+
+	for _, entry := range remoteHistory {
 		opDatetime, err := syntax.ParseDatetime(entry.CreatedAt)
 		if err != nil {
 			return stacktrace.Propagate(err, "invalid CreatedAt")
 		}
 
 		operation := entry.Operation.AsOperation()
-		opKey := marshalOperationKey(opDatetime.Time(), didBytes)
-		opValue := marshalOperationValue(entry.Nullified, operation)
+		opKey := marshalOperationKey(seq)
+		seq++
+		opValue := marshalOperationValue(entry.Nullified, didBytes, opDatetime.Time(), operation)
 
 		_, err = tree.Set(opKey, opValue)
 		if err != nil {
···
 	return nil
 }
 
+var minOperationKey = marshalOperationKey(0)
+var maxOperationKey = marshalOperationKey(math.MaxInt64)
+
+func getNextSeqID(tree *iavl.MutableTree) (uint64, error) {
+	seq := uint64(0)
+	var err error
+	tree.IterateRange(minOperationKey, maxOperationKey, false, func(key, value []byte) bool {
+		seq, err = unmarshalOperationKey(key)
+		return true
+	})
+
+	return seq + 1, stacktrace.Propagate(err, "")
+}
+
 func didToBytes(did string) ([]byte, error) {
 	if !strings.HasPrefix(did, "did:plc:") {
 		return nil, stacktrace.NewError("invalid did:plc")
···
 	return key
 }
 
-func timestampBytesToDIDOperationKey(timestamp []byte, didBytes []byte) []byte {
-	key := make([]byte, 1+8+15)
+func sequenceBytesToOperationKey(sequenceBytes []byte) []byte {
+	key := make([]byte, 1+8)
 	key[0] = 'o'
-	copy(key[1:9], timestamp)
-	copy(key[9:], didBytes)
+	copy(key[1:9], sequenceBytes)
 	return key
 }
 
-func marshalOperationKey(createdAt time.Time, didBytes []byte) []byte {
-	key := make([]byte, 1+8+15)
+func marshalOperationKey(sequence uint64) []byte {
+	key := make([]byte, 1+8)
 	key[0] = 'o'
 
-	ts := uint64(createdAt.Truncate(1 * time.Millisecond).UTC().UnixNano())
-	binary.BigEndian.PutUint64(key[1:], ts)
+	binary.BigEndian.PutUint64(key[1:], sequence)
 
-	copy(key[9:], didBytes)
 	return key
 }
 
-func unmarshalOperationKey(key []byte) (time.Time, string, error) {
-	createdAtUnixNano := binary.BigEndian.Uint64(key[1:9])
-	createdAt := time.Unix(0, int64(createdAtUnixNano)).UTC()
-	did, err := bytesToDID(key[9:])
-	return createdAt, did, stacktrace.Propagate(err, "")
+func unmarshalOperationKey(key []byte) (uint64, error) {
+	return binary.BigEndian.Uint64(key[1:9]), nil
 }
 
-func marshalOperationValue(nullified bool, operation didplc.Operation) []byte {
-	o := []byte{lo.Ternary[byte](nullified, 1, 0)}
-	o = append(o, operation.SignedCBORBytes()...)
+func marshalOperationValue(nullified bool, didBytes []byte, createdAt time.Time, operation didplc.Operation) []byte {
+	opAsBytes := operation.SignedCBORBytes()
+	o := make([]byte, 1+15+8+len(opAsBytes))
+
+	o[0] = lo.Ternary[byte](nullified, 1, 0)
+
+	copy(o[1:16], didBytes)
+
+	ts := uint64(createdAt.Truncate(1 * time.Millisecond).UTC().UnixNano())
+	binary.BigEndian.PutUint64(o[16:24], ts)
+	copy(o[24:], opAsBytes)
+
 	return o
 }
 
-func unmarshalOperationValue(value []byte) (bool, didplc.OpEnum, error) {
+func unmarshalOperationValue(value []byte) (bool, string, time.Time, didplc.OpEnum, error) {
 	nullified := value[0] != 0
+
+	did, err := bytesToDID(value[1:16])
+	if err != nil {
+		return false, "", time.Time{}, didplc.OpEnum{}, stacktrace.Propagate(err, "")
+	}
+
+	createdAtUnixNano := binary.BigEndian.Uint64(value[16:24])
+	createdAt := time.Unix(0, int64(createdAtUnixNano)).UTC()
+
 	var opEnum didplc.OpEnum
-	err := cbornode.DecodeInto(value[1:], &opEnum)
+	err = cbornode.DecodeInto(value[24:], &opEnum)
+	if err != nil {
+		return false, "", time.Time{}, didplc.OpEnum{}, stacktrace.Propagate(err, "")
+	}
+	return nullified, did, createdAt, opEnum, nil
+}
+
+func unmarshalLogEntry(operationKey, operationValue []byte) (types.SequencedLogEntry, error) {
+	nullified, actualDID, timestamp, operation, err := unmarshalOperationValue(operationValue)
+	if err != nil {
+		return types.SequencedLogEntry{}, stacktrace.Propagate(err, "")
+	}
+
+	seq, err := unmarshalOperationKey(operationKey)
 	if err != nil {
-		return false, didplc.OpEnum{}, stacktrace.Propagate(err, "")
+		return types.SequencedLogEntry{}, stacktrace.Propagate(err, "")
 	}
-	return nullified, opEnum, nil
+
+	return types.SequencedLogEntry{
+		Seq:       seq,
+		DID:       actualDID,
+		Operation: operation,
+		CID:       operation.AsOperation().CID(),
+		Nullified: nullified,
+		CreatedAt: timestamp,
+	}, nil
 }
 
 func init() {

types/log_entry.go

···
+package types
+
+import (
+	"time"
+
+	"github.com/did-method-plc/go-didplc"
+	"github.com/ipfs/go-cid"
+)
+
+type SequencedLogEntry struct {
+	Seq       uint64
+	DID       string
+	Operation didplc.OpEnum
+	CID       cid.Cid
+	Nullified bool
+	CreatedAt time.Time
+}
+
+func (l SequencedLogEntry) ToDIDPLCLogEntry() didplc.LogEntry {
+	return didplc.LogEntry{
+		DID:       l.DID,
+		Operation: l.Operation,
+		CID:       l.CID.String(),
+		Nullified: l.Nullified,
+		CreatedAt: l.CreatedAt.Format(ActualAtprotoDatetimeLayout),
+	}
+}
+
+// ActualAtprotoDatetimeLayout is the format for CreatedAt timestamps
+// AtprotoDatetimeLayout as defined by github.com/bluesky-social/indigo/atproto/syntax omits trailing zeros in the milliseconds
+// This doesn't match how the official plc.directory implementation formats them, so we define that format here with trailing zeros included
+const ActualAtprotoDatetimeLayout = "2006-01-02T15:04:05.000Z"